e0808a1f84
+ Upper-case for Delete Index + User-Defined amended with Index Change-Id: I972ee22fa3681a0f1159426836a0ec1b83fa5e3f Reviewed-on: https://gerrit.libreoffice.org/c/core/+/173849 Reviewed-by: Heiko Tietze <heiko.tietze@documentfoundation.org> Tested-by: Jenkins
3507 lines
132 KiB
Python
3507 lines
132 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
'''
|
|
This file is part of the LibreOffice project.
|
|
|
|
This Source Code Form is subject to the terms of the Mozilla Public
|
|
License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
|
|
This file incorporates work covered by the following license notice:
|
|
|
|
Licensed to the Apache Software Foundation (ASF) under one or more
|
|
contributor license agreements. See the NOTICE file distributed
|
|
with this work for additional information regarding copyright
|
|
ownership. The ASF licenses this file to you under the Apache
|
|
License, Version 2.0 (the "License"); you may not use this file
|
|
except in compliance with the License. You may obtain a copy of
|
|
the License at http://www.apache.org/licenses/LICENSE-2.0 .
|
|
'''
|
|
import uno
|
|
import unittest
|
|
import os.path
|
|
from org.libreoffice.unotest import UnoInProcess
|
|
from tempfile import TemporaryDirectory
|
|
from com.sun.star.uno import RuntimeException
|
|
from com.sun.star.lang import IllegalArgumentException, NoSupportException
|
|
from com.sun.star.beans import StringPair
|
|
from com.sun.star.rdf.URIs import ODF_PREFIX, ODF_SUFFIX
|
|
from com.sun.star.i18n.NumberFormatIndex import NUMBER_INT
|
|
from com.sun.star.text.ControlCharacter import PARAGRAPH_BREAK, HARD_HYPHEN
|
|
from com.sun.star.text.TextContentAnchorType import (
|
|
AT_CHARACTER, AS_CHARACTER, AT_PARAGRAPH, AT_PAGE, AT_FRAME)
|
|
|
|
|
|
class TreeNode():
|
|
'''base class for tree nodes. only instance: root of tree.'''
|
|
|
|
def __init__(self, content=None):
|
|
self.content = content
|
|
self._children = []
|
|
self.nodetype = "__ROOT__"
|
|
self.isnesting = False
|
|
|
|
def __str__(self):
|
|
return "<{}>".format(self.nodetype)
|
|
|
|
def __eq__(self, other):
|
|
return type(self) is type(other)
|
|
|
|
def __ne__(self, other):
|
|
return not self == other
|
|
|
|
def _dup(self, nodetype, *args):
|
|
try:
|
|
return nodetype(*args)
|
|
except Exception as e:
|
|
raise RuntimeError("TreeNode.dup") from e
|
|
|
|
def createenumeration(self):
|
|
return iter(self._children)
|
|
|
|
def appendchild(self, child):
|
|
self._children.append(child)
|
|
return self
|
|
|
|
|
|
class ContentNode(TreeNode):
|
|
|
|
def __init__(self, content):
|
|
super().__init__(content)
|
|
|
|
def __str__(self):
|
|
return "{}\tcontent: {}".format(super().__str__(), self.content)
|
|
|
|
def __eq__(self, other):
|
|
try:
|
|
return other.content == self.content and super().__eq__(other)
|
|
except AttributeError:
|
|
return False
|
|
|
|
def appendchild(self, child):
|
|
try:
|
|
self._children.append(child)
|
|
return self
|
|
except Exception as e:
|
|
raise RuntimeError("ContentNode.appendchild") from e
|
|
|
|
|
|
class TextNode(ContentNode):
|
|
|
|
def __init__(self, content):
|
|
super().__init__(content)
|
|
self.nodetype = "Text"
|
|
|
|
def dup(self):
|
|
return self._dup(TextNode, self.content)
|
|
|
|
|
|
class TextFieldNode(ContentNode):
|
|
|
|
def __init__(self, content):
|
|
super().__init__(content)
|
|
self.nodetype = "TextField"
|
|
|
|
def dup(self):
|
|
return self._dup(TextFieldNode, self.content)
|
|
|
|
|
|
class ControlCharacterNode(TreeNode):
|
|
def __init__(self, char):
|
|
super().__init__()
|
|
self.char = char
|
|
self.nodetype = "ControlCharacter"
|
|
|
|
def __str__(self):
|
|
return "{}\tcontent: {}".format(super().__str__(), self.char)
|
|
|
|
def __eq__(self, other):
|
|
try:
|
|
return other.char == self.char and super().__eq__(other)
|
|
except AttributeError:
|
|
return False
|
|
|
|
def dup(self):
|
|
return self._dup(ControlCharacterNode, self.char)
|
|
|
|
|
|
class FootnoteNode(TreeNode):
|
|
|
|
def __init__(self, label):
|
|
super().__init__()
|
|
self.label = label
|
|
self.nodetype = "Footnote"
|
|
|
|
def __str__(self):
|
|
return "{}\tlabel: {}".format(super().__str__(), self.label)
|
|
|
|
def __eq__(self, other):
|
|
try:
|
|
return other.label == self.label and super().__eq__(other)
|
|
except AttributeError:
|
|
return False
|
|
|
|
def dup(self):
|
|
return self._dup(FootnoteNode, self.label)
|
|
|
|
|
|
class FrameNode(TreeNode):
|
|
def __init__(self, name, anchor):
|
|
super().__init__()
|
|
self.name = name
|
|
self.anchor = anchor
|
|
self.nodetype = "Frame"
|
|
|
|
def __str__(self):
|
|
return "{}\tname: {}\tanchor: {}".format(
|
|
super().__str__(),self.name, self.str_anchor(self.anchor))
|
|
|
|
def __eq__(self, other):
|
|
try:
|
|
return (other.name == self.name and
|
|
other.anchor == self.anchor and
|
|
super().__eq__(other))
|
|
except AttributeError:
|
|
return False
|
|
|
|
def dup(self):
|
|
return self._dup(FrameNode, self.name, self.anchor)
|
|
|
|
def str_anchor(self, anchor):
|
|
anchors = {str(AS_CHARACTER): "AS_CHARACTER",
|
|
str(AT_CHARACTER): "AT_CHARACTER",
|
|
str(AT_PARAGRAPH): "AT_PARAGRAPH",
|
|
str(AT_PAGE): "AT_PAGE",
|
|
str(AT_FRAME): "AT_FRAME"}
|
|
try:
|
|
return anchors[str(anchor)]
|
|
except KeyError:
|
|
raise RuntimeError("unknown anchor")
|
|
|
|
|
|
class MetaNode(TreeNode):
|
|
def __init__(self, xmlid):
|
|
super().__init__()
|
|
self.xmlid = xmlid
|
|
self.nodetype = "InContentMetadata"
|
|
self.isnesting = True
|
|
|
|
def __str__(self):
|
|
return "{}\txmlid: {}#{}".format(
|
|
super().__str__(), self.xmlid.First, self.xmlid.Second)
|
|
|
|
def __eq__(self, other):
|
|
try:
|
|
return (type(other) is type(self) and
|
|
MetaNode.eq(other.xmlid, self.xmlid))
|
|
except AttributeError:
|
|
return False
|
|
|
|
@classmethod
|
|
def eq(cls, left, right):
|
|
return left.First == right.First and left.Second == right.Second
|
|
|
|
def dup(self):
|
|
return self._dup(MetaNode, self.xmlid)
|
|
|
|
|
|
class MarkNode(TreeNode):
|
|
def __init__(self, name, ispoint=True):
|
|
super().__init__()
|
|
self.name = name
|
|
self.ispoint = ispoint
|
|
self.isstart = False
|
|
|
|
def __str__(self):
|
|
return "{}\tisPoint: {}\tisStart: {}".format(
|
|
super().__str__(), self.ispoint, self.isstart)
|
|
|
|
def __eq__(self, other):
|
|
try:
|
|
return (other.name == self.name and
|
|
other.ispoint == self.ispoint and
|
|
other.isstart == self.isstart)
|
|
except AttributeError:
|
|
return False
|
|
|
|
|
|
class BookmarkNode(MarkNode):
|
|
def __init__(self, name, xmlid=StringPair()):
|
|
super().__init__(name)
|
|
self.xmlid = xmlid
|
|
self.nodetype = "Bookmark"
|
|
|
|
def __str__(self):
|
|
return "{}\txmlid: {}#{}".format(
|
|
super().__str__(), self.xmlid.First, self.xmlid.Second)
|
|
|
|
def __eq__(self, other):
|
|
try:
|
|
return (type(other) is type(self) and
|
|
super().__eq__(other) and
|
|
MetaNode.eq(other.xmlid, self.xmlid))
|
|
except AttributeError:
|
|
return False
|
|
|
|
def dup(self):
|
|
return self._dup(BookmarkNode, self.name, self.xmlid)
|
|
|
|
|
|
class BookmarkStartNode(BookmarkNode):
|
|
|
|
def __init__(self, name, xmlid=StringPair()):
|
|
super().__init__(name, xmlid)
|
|
self.ispoint = False
|
|
self.isstart = True
|
|
|
|
def dup(self):
|
|
return self._dup(BookmarkStartNode, self.name)
|
|
|
|
|
|
class BookmarkEndNode(BookmarkNode):
|
|
|
|
def __init__(self, name, xmlid=StringPair()):
|
|
super().__init__(name, xmlid)
|
|
self.ispoint = False
|
|
self.isstart = False
|
|
|
|
def dup(self):
|
|
return self._dup(BookmarkEndNode, self.name)
|
|
|
|
|
|
class ReferenceMarkNode(MarkNode):
|
|
def __init__(self, name):
|
|
super().__init__(name)
|
|
self.nodetype = "ReferenceMark"
|
|
|
|
def __eq__(self, other):
|
|
return (type(other) is type(self) and super().__eq__(other))
|
|
|
|
def dup(self):
|
|
return self._dup(ReferenceMarkNode, self.name)
|
|
|
|
|
|
class ReferenceMarkStartNode(ReferenceMarkNode):
|
|
def __init__(self, name):
|
|
super().__init__(name)
|
|
self.ispoint = False
|
|
self.isstart = True
|
|
|
|
def dup(self):
|
|
return self._dup(ReferenceMarkStartNode, self.name)
|
|
|
|
|
|
class ReferenceMarkEndNode(ReferenceMarkNode):
|
|
def __init__(self, name):
|
|
super().__init__(name)
|
|
self.ispoint = False
|
|
self.isstart = False
|
|
|
|
def dup(self):
|
|
return self._dup(ReferenceMarkEndNode, self.name)
|
|
|
|
|
|
class DocumentIndexMarkNode(MarkNode):
|
|
def __init__(self, name):
|
|
super().__init__(name)
|
|
self.nodetype = "DocumentIndexMark"
|
|
|
|
def __eq__(self, other):
|
|
return (type(other) is type(self) and super().__eq__(other))
|
|
|
|
def dup(self):
|
|
return self._dup(DocumentIndexMarkNode, self.name)
|
|
|
|
|
|
class DocumentIndexMarkStartNode(DocumentIndexMarkNode):
|
|
def __init__(self, name):
|
|
super().__init__(name)
|
|
self.ispoint = False
|
|
self.isstart = True
|
|
|
|
def dup(self):
|
|
return self._dup(DocumentIndexMarkStartNode, self.name)
|
|
|
|
|
|
class DocumentIndexMarkEndNode(DocumentIndexMarkNode):
|
|
def __init__(self, name):
|
|
super().__init__(name)
|
|
self.ispoint = False
|
|
self.isstart = False
|
|
|
|
def dup(self):
|
|
return self._dup(DocumentIndexMarkEndNode, self.name)
|
|
|
|
|
|
class HyperlinkNode(TreeNode):
|
|
def __init__(self, url):
|
|
super().__init__()
|
|
self.nodetype = "Hyperlink"
|
|
self.isnesting = True
|
|
if url:
|
|
self.url = url
|
|
else:
|
|
raise RuntimeError("HyperlinkNode")
|
|
|
|
def __str__(self):
|
|
return "{}\turl: {}".format(super().__str__(), self.url)
|
|
|
|
def __eq__(self, other):
|
|
try:
|
|
return other.url == self.url and super().__eq__(other)
|
|
except AttributeError:
|
|
return False
|
|
|
|
def dup(self):
|
|
return self._dup(HyperlinkNode, self.url)
|
|
|
|
|
|
class RubyNode(TreeNode):
|
|
def __init__(self, ruby):
|
|
super().__init__()
|
|
self.nodetype = "Ruby"
|
|
self.isnesting = True
|
|
if ruby:
|
|
self.ruby = ruby
|
|
else:
|
|
raise RuntimeError("RubyNode")
|
|
|
|
def __str__(self):
|
|
return "{}\trubytext: {}".format(super().__str__(), self.ruby)
|
|
|
|
def __eq__(self, other):
|
|
try:
|
|
return other.ruby == self.ruby and super().__eq__(other)
|
|
except AttributeError:
|
|
return False
|
|
|
|
def dup(self):
|
|
return self._dup(RubyNode, self.ruby)
|
|
|
|
|
|
class MetaFieldNode(MetaNode):
|
|
def __init__(self, xmlid):
|
|
super().__init__(xmlid)
|
|
self.nodetype = "MetadataField"
|
|
|
|
def dup(self):
|
|
return self._dup(MetaFieldNode, self.xmlid)
|
|
|
|
|
|
class Range():
|
|
def __init__(self, start, end, node):
|
|
self.start = start
|
|
self.end = end
|
|
self.node = node
|
|
self.extent = end - start
|
|
|
|
|
|
class Inserter():
|
|
|
|
def __init__(self, xDoc):
|
|
self.xDoc = xDoc
|
|
self.xText = xDoc.getText()
|
|
self.xCursor = self.xText.createTextCursor()
|
|
|
|
def initparagraph(self):
|
|
## we split the first (empty) paragraph, and then insert into the
|
|
## second (empty) paragraph; this ensures first is always empty!
|
|
self.xCursor.gotoStartOfParagraph(False)
|
|
self.xText.insertControlCharacter(self.xCursor, PARAGRAPH_BREAK, False)
|
|
|
|
def inserttext(self, xCursor, text):
|
|
xCursor.setString(text)
|
|
|
|
def inserttextfield(self, xCursor, content):
|
|
xContent = self.maketextfield(content)
|
|
xContent.attach(xCursor)
|
|
|
|
def maketextfield(self, content):
|
|
xField = self.xDoc.createInstance("com.sun.star.text.textfield.Author")
|
|
xField.IsFixed = True
|
|
xField.FullName = False
|
|
xField.Content = content
|
|
return xField
|
|
|
|
def insertcontrolcharacter(self, xCursor, cchar):
|
|
self.xText.insertControlCharacter(xCursor, cchar, False)
|
|
|
|
def insertframe(self, xCursor, name, anchor):
|
|
xContent = self.makeframe(name, anchor)
|
|
xContent.attach(xCursor)
|
|
|
|
def makeframe(self, name, anchor):
|
|
xFrame = self.xDoc.createInstance("com.sun.star.text.TextFrame")
|
|
xFrame.AnchorType = anchor
|
|
xFrame.setName(name)
|
|
return xFrame
|
|
|
|
def insertfootnote(self, xCursor, label):
|
|
xContent = self.makefootnote(label)
|
|
xContent.attach(xCursor)
|
|
|
|
def makefootnote(self, label):
|
|
xFootNote = self.xDoc.createInstance("com.sun.star.text.Footnote")
|
|
xFootNote.setLabel(label)
|
|
return xFootNote
|
|
|
|
def insertbookmark(self, xCursor, name, xmlid):
|
|
xContent = self.makebookmark(name)
|
|
xContent.attach(xCursor)
|
|
if xmlid.First != "":
|
|
xContent.MetadataReference = xmlid
|
|
|
|
def makebookmark(self, name):
|
|
xBookmark = self.xDoc.createInstance("com.sun.star.text.Bookmark")
|
|
xBookmark.setName(name)
|
|
return xBookmark
|
|
|
|
def insertreferencemark(self, xCursor, name):
|
|
xContent = self.makereferencemark(name)
|
|
xContent.attach(xCursor)
|
|
|
|
def makereferencemark(self, name):
|
|
xMark = self.xDoc.createInstance("com.sun.star.text.ReferenceMark")
|
|
xMark.setName(name)
|
|
return xMark
|
|
|
|
def insertdocumentindexmark(self, xCursor, key):
|
|
xContent = self.makedocumentindexmark(key)
|
|
xContent.attach(xCursor)
|
|
|
|
def makedocumentindexmark(self, key):
|
|
xMark = self.xDoc.createInstance("com.sun.star.text.DocumentIndexMark")
|
|
xMark.PrimaryKey = key
|
|
return xMark
|
|
|
|
def inserthyperlink(self, xCursor, url):
|
|
xCursor.HyperLinkURL = url
|
|
|
|
def insertruby(self, xCursor, rubytext):
|
|
xCursor.RubyText = rubytext
|
|
|
|
def insertmeta(self, xCursor, xmlid):
|
|
xContent = self.makemeta()
|
|
xContent.attach(xCursor)
|
|
xContent.MetadataReference = xmlid
|
|
return xContent
|
|
|
|
def makemeta(self):
|
|
xMeta = self.xDoc.createInstance("com.sun.star.text.InContentMetadata")
|
|
return xMeta
|
|
|
|
def insertmetafield(self, xCursor, xmlid):
|
|
xContent = self.makemetafield()
|
|
xContent.attach(xCursor)
|
|
xContent.MetadataReference = xmlid
|
|
return xContent
|
|
|
|
def makemetafield(self):
|
|
xMeta = self.xDoc.createInstance(
|
|
"com.sun.star.text.textfield.MetadataField")
|
|
return xMeta
|
|
|
|
|
|
class TreeInserter(Inserter):
|
|
|
|
def __init__(self, xDoc):
|
|
super().__init__(xDoc)
|
|
self._bookmarkstarts = {}
|
|
self._referencemarkstarts = {}
|
|
self._documentindexmarkstarts = {}
|
|
self._framehints = []
|
|
|
|
def inserttree(self, tree):
|
|
if tree.nodetype != "__ROOT__":
|
|
raise RuntimeError("insertTree: test error: no root")
|
|
self.initparagraph()
|
|
self.insertchildren(tree.createenumeration())
|
|
for p in self._framehints:
|
|
self.insertframe(p[0], p[1].name, p[1].anchor)
|
|
|
|
def insertchildren(self, children):
|
|
xCursor = self.xCursor
|
|
for node in children:
|
|
xCursor.gotoEndOfParagraph(False)
|
|
type_ = node.nodetype
|
|
if type_ == "Text":
|
|
self.inserttext(xCursor, node.content)
|
|
elif type_ == "TextField":
|
|
self.inserttextfield(xCursor, node.content)
|
|
elif type_ == "ControlCharacter":
|
|
self.insertcontrolcharacter(xCursor, node.char)
|
|
elif type_ == "Footnote":
|
|
self.insertfootnote(xCursor, node.label)
|
|
elif type_ == "Frame":
|
|
if node.anchor == AT_CHARACTER:
|
|
self._framehints.append((xCursor.getStart(), node))
|
|
else:
|
|
self.insertframe(xCursor, node.name, node.anchor)
|
|
elif type_ == "Bookmark":
|
|
name = node.name
|
|
id_ = node.xmlid
|
|
if node.ispoint:
|
|
self.insertbookmark(xCursor, name, id_)
|
|
elif node.isstart:
|
|
self._bookmarkstarts[name] = xCursor.getStart()
|
|
else:
|
|
xRange = self._bookmarkstarts[name]
|
|
xParaCursor = self.mkcursor(xRange)
|
|
self.insertbookmark(xParaCursor, name, id_)
|
|
elif type_ == "ReferenceMark":
|
|
name = node.name
|
|
if node.ispoint:
|
|
self.insertreferencemark(xCursor, name)
|
|
elif node.isstart:
|
|
self._referencemarkstarts[name] = xCursor.getStart()
|
|
else:
|
|
xRange = self._referencemarkstarts[name]
|
|
xParaCursor = self.mkcursor(xRange)
|
|
self.insertreferencemark(xParaCursor, name)
|
|
elif type_ == "DocumentIndexMark":
|
|
name = node.name
|
|
if node.ispoint:
|
|
self.insertdocumentindexmark(xCursor, name)
|
|
elif node.isstart:
|
|
self._documentindexmarkstarts[name] = xCursor.getStart()
|
|
else:
|
|
xRange = self._documentindexmarkstarts[name]
|
|
xParaCursor = self.mkcursor(xRange)
|
|
self.insertdocumentindexmark(xParaCursor, name)
|
|
elif type_ == "Hyperlink":
|
|
xRange = xCursor.getStart()
|
|
self.insertchildren(node.createenumeration())
|
|
xParaCursor = self.mkcursor(xRange)
|
|
self.inserthyperlink(xParaCursor, node.url)
|
|
elif type_ == "Ruby":
|
|
xRange = xCursor.getStart()
|
|
self.insertchildren(node.createenumeration())
|
|
xParaCursor = self.mkcursor(xRange)
|
|
self.insertruby(xParaCursor, node.ruby)
|
|
elif type_ == "InContentMetadata":
|
|
xRange = xCursor.getStart()
|
|
self.insertchildren(node.createenumeration())
|
|
xParaCursor = self.mkcursor(xRange)
|
|
self.insertmeta(xParaCursor, node.xmlid)
|
|
elif type_ == "MetadataField":
|
|
xRange = xCursor.getStart()
|
|
self.insertchildren(node.createenumeration())
|
|
xParaCursor = self.mkcursor(xRange)
|
|
self.insertmetafield(xParaCursor, node.xmlid)
|
|
elif type_ == "SoftPageBreak":
|
|
raise RuntimeError("sorry, cannot test SoftPageBreak")
|
|
else:
|
|
raise RuntimeError("unexpected type: {}".format(type_))
|
|
|
|
def mkcursor(self, xRange):
|
|
xCursor = self.xText.createTextCursorByRange(xRange)
|
|
xCursor.gotoEndOfParagraph(True)
|
|
return xCursor
|
|
|
|
|
|
# FIXME: this does not account for inserted dummy characters!
|
|
class RangeInserter(Inserter):
|
|
def __init__(self, xDoc):
|
|
super().__init__(xDoc)
|
|
self.initparagraph()
|
|
|
|
# def inserttext(self, pos, text):
|
|
# self.xCursor.gotoStartOfParagraph(False)
|
|
# self.xCursor.goRight(pos, False)
|
|
# self.inserttext(self.xCursor, text)
|
|
|
|
def insertrange(self, range):
|
|
self.xCursor.gotoStartOfParagraph(False)
|
|
self.xCursor.goRight(range.start, False)
|
|
self.xCursor.goRight(range.extent, True)
|
|
return self.insertnode(self.xCursor, range.node)
|
|
|
|
def insertnode(self, xParaCursor, node):
|
|
nodetype = node.nodetype
|
|
if nodetype == "Text":
|
|
text = node
|
|
self.inserttext(xParaCursor, text.content)
|
|
elif nodetype == "Hyperlink":
|
|
href = node
|
|
self.inserthyperlink(xParaCursor, href.url)
|
|
elif nodetype == "Ruby":
|
|
ruby = node
|
|
self.insertruby(xParaCursor, ruby.ruby)
|
|
elif nodetype == "InContentMetadata":
|
|
meta = node
|
|
return self.insertmeta(xParaCursor, meta.xmlid)
|
|
elif nodetype == "MetadataField":
|
|
meta = node
|
|
return self.insertmetafield(xParaCursor, meta.xmlid)
|
|
elif nodetype == "Bookmark":
|
|
bkmk = node
|
|
if bkmk.ispoint:
|
|
raise RuntimeError("range only")
|
|
self.insertbookmark(xParaCursor, bkmk.name, bkmk.xmlid)
|
|
elif nodetype == "ReferenceMark":
|
|
mark = node
|
|
if mark.ispoint:
|
|
raise RuntimeError("range only")
|
|
self.insertreferencemark(xParaCursor, mark.name)
|
|
elif nodetype == "DocumentIndexMark":
|
|
mark = node
|
|
if mark.ispoint:
|
|
raise RuntimeError("range only")
|
|
self.insertdocumentindexmark(xParaCursor, mark.name)
|
|
elif nodetype == "TextField":
|
|
field = node
|
|
self.inserttextfield(self.xCursor, field.content)
|
|
elif nodetype == "Footnote":
|
|
note = node
|
|
self.insertfootnote(self.xCursor, note.label)
|
|
elif nodetype == "Frame":
|
|
frame = node
|
|
self.insertframe(xParaCursor, frame.name, frame.anchor)
|
|
elif nodetype == "ControlCharacter":
|
|
cchar = node
|
|
self.insertcontrolcharacter(self.xCursor, cchar.char)
|
|
elif nodetype == "SoftPageBreak":
|
|
raise RuntimeError("sorry, cannot test SoftPageBreak")
|
|
else:
|
|
raise RuntimeError("unexpected nodetype: {}".format(nodetype))
|
|
return None
|
|
|
|
|
|
class EnumConverter():
|
|
|
|
def __init__(self):
|
|
self._stack = []
|
|
|
|
def convert(self, xEnum):
|
|
root = TreeNode()
|
|
self._stack.append(root)
|
|
ret = self.convertchildren(xEnum)
|
|
assert (len(self._stack)==0), "EnumConverter.convert: stack is not empty"
|
|
return ret
|
|
|
|
def convertchildren(self, xEnum):
|
|
for xPortion in xEnum:
|
|
type_ = xPortion.TextPortionType
|
|
if type_ == "Text":
|
|
text = xPortion.getString()
|
|
node = TextNode(text)
|
|
url = xPortion.HyperLinkURL
|
|
if len(url) > 0:
|
|
temp = node
|
|
node = HyperlinkNode(url)
|
|
node.appendchild(temp)
|
|
elif type_ == "TextField":
|
|
xField = xPortion.TextField
|
|
if xField.supportsService("com.sun.star.text.textfield.MetadataField"):
|
|
xmlid = xField.MetadataReference
|
|
node = MetaFieldNode(xmlid)
|
|
self._stack.append(node)
|
|
xEnumChildren = xField.createEnumeration()
|
|
node2 = self.convertchildren(xEnumChildren)
|
|
print(node)
|
|
print(node2)
|
|
assert (node2 is node), "stack error: meta-field"
|
|
else:
|
|
content = xField.Content
|
|
isFixed = xField.IsFixed
|
|
assert isFixed, "field not fixed?"
|
|
node = TextFieldNode(content)
|
|
elif type_ == "ControlCharacter":
|
|
c = xPortion.ControlCharacter
|
|
node = ControlCharacterNode(c)
|
|
elif type_ == "Footnote":
|
|
xFootnote = xPortion.Footnote
|
|
label = xFootnote.getLabel()
|
|
node = FootnoteNode(label)
|
|
elif type_ == "Frame":
|
|
xCEA = xPortion.createContentEnumeration('')
|
|
while xCEA.hasMoreElements():
|
|
xFrame = xCEA.nextElement()
|
|
anchor = xFrame.AnchorType
|
|
name = xFrame.getName()
|
|
node = FrameNode(name, anchor)
|
|
self._stack[-1].appendchild(node)
|
|
continue
|
|
elif type_ == "Bookmark":
|
|
xMark = xPortion.Bookmark
|
|
name = xMark.getName()
|
|
xmlid = xMark.MetadataReference
|
|
isCollapsed = xPortion.IsCollapsed
|
|
if isCollapsed:
|
|
node = BookmarkNode(name, xmlid)
|
|
else:
|
|
isStart = xPortion.IsStart
|
|
if isStart:
|
|
node = BookmarkStartNode(name, xmlid)
|
|
else:
|
|
node = BookmarkEndNode(name, xmlid)
|
|
elif type_ == "ReferenceMark":
|
|
xMark = xPortion.ReferenceMark
|
|
name = xMark.getName()
|
|
isCollapsed = xPortion.IsCollapsed
|
|
if isCollapsed:
|
|
node = ReferenceMarkNode(name)
|
|
else:
|
|
isStart = xPortion.IsStart
|
|
if isStart:
|
|
node = ReferenceMarkStartNode(name)
|
|
else:
|
|
node = ReferenceMarkEndNode(name)
|
|
elif type_ == "DocumentIndexMark":
|
|
xMark = xPortion.DocumentIndexMark
|
|
name = xMark.PrimaryKey
|
|
isCollapsed = xPortion.IsCollapsed
|
|
if isCollapsed:
|
|
node = DocumentIndexMarkNode(name)
|
|
else:
|
|
isStart = xPortion.IsStart
|
|
if isStart:
|
|
node = DocumentIndexMarkStartNode(name)
|
|
else:
|
|
node = DocumentIndexMarkEndNode(name)
|
|
elif type_ == "Ruby":
|
|
isStart = xPortion.IsStart
|
|
if isStart:
|
|
# ARRGH!!! stupid api...
|
|
# the text is ONLY at the start!
|
|
ruby = xPortion.RubyText
|
|
node = RubyNode(ruby)
|
|
self._stack.append(node)
|
|
continue
|
|
else:
|
|
node = self._stack.pop()
|
|
assert (isinstance(node, RubyNode)), "stack error: Ruby expected; is: {}".format(str(node))
|
|
elif type_ == "InContentMetadata":
|
|
xMeta = xPortion.InContentMetadata
|
|
xmlid = xMeta.MetadataReference
|
|
node = MetaNode(xmlid)
|
|
self._stack.append(node)
|
|
xEnumChildren = xMeta.createEnumeration()
|
|
node2 = self.convertchildren(xEnumChildren)
|
|
assert (node2 is node), "stack error: meta"
|
|
elif type_ == "SoftPageBreak":
|
|
node = SoftPageBreakNode()
|
|
else:
|
|
raise RuntimeError("unexpected type: {}".format(type_))
|
|
self._stack[-1].appendchild(node)
|
|
ret = self._stack.pop()
|
|
return ret
|
|
|
|
|
|
class FuzzyTester():
|
|
'''this is where we nail the pudding to the wall'''
|
|
def __init__(self):
|
|
self.diffcontent = 0
|
|
self.diffmissing = 0
|
|
self.diffnesting = 0
|
|
self.diffspuriousemptytext = 0
|
|
self.diffsequence = 0 # ignored?
|
|
self.stackexpected = []
|
|
self.stackactual = []
|
|
self.bufferexpected = []
|
|
self.bufferactual = []
|
|
|
|
def dotest(self, expected, actual):
|
|
'''idea: traverse both trees, enumerate nodes, stopping at content nodes.
|
|
then compare buffers.'''
|
|
assert "__ROOT__" == expected.nodetype
|
|
assert "__ROOT__" == actual.nodetype
|
|
self.stackexpected.append((expected, expected.createenumeration()))
|
|
self.stackactual.append((actual, actual.createenumeration()))
|
|
while self.stackexpected or self.stackactual:
|
|
self.traverse(self.stackexpected, self.bufferexpected)
|
|
self.traverse(self.stackactual, self.bufferactual)
|
|
self.testbuffer()
|
|
if self.diffsequence:
|
|
print("warning: {} differences in sequence".format(
|
|
self.diffsequence))
|
|
if self.diffspuriousemptytext:
|
|
print("warning: {} spurious empty text nodes".format(
|
|
self.diffspuriousemptytext))
|
|
if self.diffnesting:
|
|
print("WARNING: {} differences in nesting".format(
|
|
self.diffnesting))
|
|
assert self.diffcontent == 0
|
|
assert self.diffmissing == 0
|
|
|
|
def traverse(self, stack, buffer):
|
|
while stack:
|
|
topenum = stack[-1][1]
|
|
try:
|
|
node = next(topenum)
|
|
buffer.append(node)
|
|
if node._children:
|
|
node_enum = node.createenumeration()
|
|
stack.append((node, node_enum))
|
|
if node.content:
|
|
if not (isinstance(node, TextNode) and # spurious empty text?
|
|
len(node.content) == 0):
|
|
return # break here
|
|
except StopIteration:
|
|
buffer.append(stack[-1][0])
|
|
stack.pop()
|
|
|
|
def testterminatingnode(self):
|
|
lenexpected = len(self.bufferexpected)
|
|
lenactual = len(self.bufferactual)
|
|
if lenexpected == 0 or lenactual == 0:
|
|
return
|
|
expected = self.bufferexpected[-1]
|
|
actual = self.bufferactual[-1]
|
|
eroot = expected.nodetype == "__ROOT__"
|
|
aroot = actual.nodetype == "__ROOT__"
|
|
if eroot or aroot:
|
|
if not (eroot and aroot):
|
|
if aroot:
|
|
self.printmissing(expected)
|
|
else:
|
|
self.printunexpected(actual)
|
|
self.diffmissing += 1
|
|
return
|
|
self.testcontentnode(expected, actual)
|
|
self.bufferexpected[-1] = None
|
|
self.bufferactual[-1] = None
|
|
|
|
def testcontentnode(self, expected, actual):
|
|
contentexpected = expected.content
|
|
contentactual = actual.content
|
|
if expected != actual:
|
|
self.printdiff("text content differs", contentexpected, contentactual)
|
|
self.diffcontent += 1
|
|
|
|
def testbuffer(self):
|
|
lenactual = len(self.bufferactual)
|
|
tmp_bufferactual = self.bufferactual[:]
|
|
for i, node in enumerate(self.bufferexpected):
|
|
try:
|
|
j = tmp_bufferactual.index(node)
|
|
if j != i:
|
|
# FIXME how bad is this?
|
|
self.printdiff("position differs", i, j)
|
|
# a hacky hack
|
|
min_ = min(i,j)
|
|
max_ = max(min(lenactual-1, i),j)
|
|
for k in range(min_, max_):
|
|
tmp = tmp_bufferactual[k]
|
|
if tmp and tmp.isnesting:
|
|
self.printnesting(node, tmp)
|
|
self.diffnesting += 1
|
|
self.diffsequence += 1
|
|
tmp_bufferactual[j] = None
|
|
except ValueError:
|
|
print('perdrix')
|
|
self.printmissing(node)
|
|
self.diffmissing += 1
|
|
for j, node in enumerate(tmp_bufferactual):
|
|
if node:
|
|
self.printunexpected(node)
|
|
if isinstance(node, TextNode) and len(node.content) == 0:
|
|
self.diffspuriousemptytext += 1
|
|
else:
|
|
print('renard')
|
|
self.diffmissing += 1
|
|
self.testterminatingnode()
|
|
self.bufferexpected[:] = []
|
|
self.bufferactual[:] = []
|
|
|
|
def printdiff(self, prefix, expected, actual):
|
|
print("{}:\texpected: {}\tactual: {}".format(prefix, expected, actual))
|
|
|
|
def printnesting(self, node, nesting):
|
|
print("node: {} possibly moved across nesting {}".format(
|
|
str(node), str(nesting)))
|
|
|
|
def printmissing(self, node):
|
|
print(" missing node: {}".format(str(node)))
|
|
|
|
def printunexpected(self, node):
|
|
print("unexpected node: {}".format(str(node)))
|
|
|
|
|
|
def SoftPageBreakNode():
|
|
raise NotImplementedError("todo")
|
|
|
|
|
|
class TextPortionEnumerationTest(unittest.TestCase):
|
|
|
|
xMSF = None
|
|
xContext = None
|
|
tempdir = None
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls._uno = UnoInProcess()
|
|
cls._uno.setUp()
|
|
cls.xDoc = cls._uno.openEmptyWriterDoc()
|
|
cls.count = 0
|
|
|
|
@classmethod
|
|
def tearDownClass(cls):
|
|
cls.xDoc.close(True)
|
|
cls._uno.tearDown()
|
|
# HACK in case cls.xDoc holds a UNO proxy to an SwXTextDocument (whose dtor calls
|
|
# Application::GetSolarMutex via sw::UnoImplPtrDeleter), which would potentially only be
|
|
# garbage-collected after VCL has already been deinitialized:
|
|
cls.xDoc = None
|
|
|
|
def test_text(self):
|
|
root = TreeNode()
|
|
text = TextNode("abc")
|
|
root.appendchild(text)
|
|
self.dotest(root)
|
|
|
|
def test_text_field(self):
|
|
self.mkname("ruby")
|
|
root = TreeNode()
|
|
txtf = TextFieldNode("abc")
|
|
root.appendchild(txtf)
|
|
self.dotest(root)
|
|
|
|
@unittest.skip("FIXME this is converted to a text portion: ControlCharacter is obsolete")
|
|
def test_control_char(self):
|
|
root = TreeNode()
|
|
cchr = ControlCharacterNode(HARD_HYPHEN)
|
|
root.appendchild(cchr)
|
|
self.dotest(root)
|
|
|
|
@unittest.skip("FIXME: insert a soft page break: not done")
|
|
def test_soft_page_break(self):
|
|
root = TreeNode()
|
|
spbk = SoftPageBreakNode()
|
|
text = TextNode("abc")
|
|
root.appendchild(spbk)
|
|
root.appendchild(text)
|
|
self.dotest(root)
|
|
|
|
def test_footnote(self):
|
|
name = self.mkname("ftn")
|
|
root = TreeNode()
|
|
ftnd = FootnoteNode(name)
|
|
root.appendchild(ftnd)
|
|
self.dotest(root)
|
|
|
|
def test_frame_as(self):
|
|
name = self.mkname("frame")
|
|
root = TreeNode()
|
|
fram = FrameNode(name, AS_CHARACTER)
|
|
root.appendchild(fram)
|
|
self.dotest(root)
|
|
|
|
def test_frame_at(self):
|
|
name = self.mkname("frame")
|
|
root = TreeNode()
|
|
fram = FrameNode(name, AT_CHARACTER)
|
|
root.appendchild(fram)
|
|
self.dotest(root)
|
|
|
|
def test_bookmark_point(self):
|
|
name = self.mkname("mark")
|
|
root = TreeNode()
|
|
bkmk = BookmarkNode(name)
|
|
text = TextNode("abc")
|
|
root.appendchild(bkmk)
|
|
root.appendchild(text)
|
|
self.dotest(root)
|
|
|
|
def test_bookmark(self):
|
|
name = self.mkname("mark")
|
|
root = TreeNode()
|
|
bkm1 = BookmarkStartNode(name)
|
|
text = TextNode("abc")
|
|
bkm2 = BookmarkEndNode(name)
|
|
root.appendchild(bkm1)
|
|
root.appendchild(text)
|
|
root.appendchild(bkm2)
|
|
self.dotest(root)
|
|
|
|
def test_bookmark_point_xmlid(self):
|
|
name = self.mkname("mark")
|
|
id = self.mkid("id")
|
|
root = TreeNode()
|
|
bkmk = BookmarkNode(name, id)
|
|
text = TextNode("abc")
|
|
root.appendchild(bkmk)
|
|
root.appendchild(text)
|
|
self.dotest(root)
|
|
|
|
def test_bookmark_xmlid(self):
|
|
name = self.mkname("mark")
|
|
id = self.mkid("id")
|
|
root = TreeNode()
|
|
bkm1 = BookmarkStartNode(name, id)
|
|
text = TextNode("abc")
|
|
bkm2 = BookmarkEndNode(name, id)
|
|
root.appendchild(bkm1)
|
|
root.appendchild(text)
|
|
root.appendchild(bkm2)
|
|
self.dotest(root)
|
|
|
|
def test_refmark_point(self):
|
|
name = self.mkname("refmark")
|
|
root = TreeNode()
|
|
rfmk = ReferenceMarkNode(name)
|
|
text = TextNode("abc")
|
|
root.appendchild(rfmk)
|
|
root.appendchild(text)
|
|
self.dotest(root)
|
|
|
|
def test_refmark(self):
|
|
name = self.mkname("refmark")
|
|
root = TreeNode()
|
|
rfm1 = ReferenceMarkStartNode(name)
|
|
text = TextNode("abc")
|
|
rfm2 = ReferenceMarkEndNode(name)
|
|
root.appendchild(rfm1)
|
|
root.appendchild(text)
|
|
root.appendchild(rfm2)
|
|
self.dotest(root)
|
|
|
|
def test_toxmark_point(self):
|
|
name = self.mkname("toxmark")
|
|
root = TreeNode()
|
|
txmk = DocumentIndexMarkNode(name)
|
|
text = TextNode("abc")
|
|
root.appendchild(txmk)
|
|
root.appendchild(text)
|
|
self.dotest(root)
|
|
|
|
def test_toxmark(self):
|
|
name = self.mkname("toxmark")
|
|
root = TreeNode()
|
|
txm1 = DocumentIndexMarkStartNode(name)
|
|
text = TextNode("abc")
|
|
txm2 = DocumentIndexMarkEndNode(name)
|
|
root.appendchild(txm1)
|
|
root.appendchild(text)
|
|
root.appendchild(txm2)
|
|
self.dotest(root)
|
|
|
|
def test_hyperlink(self):
|
|
name = self.mkname("url")
|
|
root = TreeNode()
|
|
href = HyperlinkNode(name)
|
|
text = TextNode("abc")
|
|
href.appendchild(text)
|
|
root.appendchild(href)
|
|
self.dotest(root)
|
|
|
|
def test_hyperlink_empty(self):
|
|
name = self.mkname("url")
|
|
root = TreeNode()
|
|
href = HyperlinkNode(name)
|
|
text = TextNode("")
|
|
href.appendchild(text)
|
|
root.appendchild(href)
|
|
self.dotest(root)
|
|
|
|
def test_ruby(self):
|
|
name = self.mkname("ruby")
|
|
root = TreeNode()
|
|
ruby = RubyNode(name)
|
|
text = TextNode("abc")
|
|
ruby.appendchild(text)
|
|
root.appendchild(ruby)
|
|
self.dotest(root)
|
|
|
|
def test_ruby_empty(self):
|
|
# BUG: #i91534#
|
|
name = self.mkname("ruby")
|
|
root = TreeNode()
|
|
ruby = RubyNode(name)
|
|
root.appendchild(ruby)
|
|
self.dotest(root)
|
|
|
|
def test_meta(self):
|
|
id = StringPair("content.xml", self.mkname("id"))
|
|
root = TreeNode()
|
|
meta = MetaNode(id)
|
|
text = TextNode("abc")
|
|
root.appendchild(TextNode("123"))
|
|
meta.appendchild(text)
|
|
root.appendchild(meta)
|
|
self.dotest(root)
|
|
|
|
def test_meta_empty(self):
|
|
id = StringPair("content.xml", self.mkname("id"))
|
|
root = TreeNode()
|
|
meta = MetaNode(id)
|
|
root.appendchild(meta)
|
|
self.dotest(root)
|
|
|
|
def test_meta_field(self):
|
|
id = StringPair("content.xml", self.mkname("id"))
|
|
root = TreeNode()
|
|
meta = MetaFieldNode(id)
|
|
text = TextNode("abc")
|
|
root.appendchild(TextNode("123"))
|
|
meta.appendchild(text)
|
|
root.appendchild(meta)
|
|
self.dotest(root)
|
|
|
|
def test_meta_field_empty(self):
|
|
id = StringPair("content.xml", self.mkname("id"))
|
|
root = TreeNode()
|
|
meta = MetaFieldNode(id)
|
|
root.appendchild(meta)
|
|
self.dotest(root)
|
|
|
|
def test_bookmark1(self):
|
|
name1 = self.mkname("mark")
|
|
name2 = self.mkname("mark")
|
|
name3 = self.mkname("mark")
|
|
root = TreeNode()
|
|
root.appendchild(BookmarkStartNode(name1))
|
|
root.appendchild(BookmarkNode(name2))
|
|
root.appendchild(BookmarkStartNode(name3))
|
|
root.appendchild(TextNode("abc"))
|
|
root.appendchild(BookmarkEndNode(name1))
|
|
root.appendchild(TextNode("de"))
|
|
root.appendchild(BookmarkEndNode(name3))
|
|
self.dotest(root)
|
|
|
|
def test_bookmark2(self):
|
|
name1 = self.mkname("mark")
|
|
name2 = self.mkname("mark")
|
|
name3 = self.mkname("mark")
|
|
root = TreeNode()
|
|
root.appendchild(BookmarkStartNode(name1))
|
|
root.appendchild(TextNode("abc"))
|
|
root.appendchild(BookmarkNode(name2))
|
|
root.appendchild(BookmarkStartNode(name3))
|
|
root.appendchild(BookmarkEndNode(name1))
|
|
root.appendchild(TextNode("de"))
|
|
root.appendchild(BookmarkEndNode(name3))
|
|
self.dotest(root)
|
|
|
|
def test_refmark2(self):
|
|
name1 = self.mkname("refmark")
|
|
root = TreeNode()
|
|
root.appendchild(ReferenceMarkStartNode(name1))
|
|
root.appendchild(TextNode("abc"))
|
|
# BUG: #i102541# (this is actually not unoportenum's fault)
|
|
root.appendchild(ReferenceMarkEndNode(name1))
|
|
root.appendchild(TextNode("de"))
|
|
self.dotest(root)
|
|
|
|
def test_refmark3(self):
|
|
# BUG: #i107672# (non-deterministic; depends on pointer ordering)
|
|
name1 = self.mkname("refmark")
|
|
name2 = self.mkname("refmark")
|
|
name3 = self.mkname("refmark")
|
|
name4 = self.mkname("refmark")
|
|
name5 = self.mkname("refmark")
|
|
name6 = self.mkname("refmark")
|
|
name7 = self.mkname("refmark")
|
|
root = TreeNode()
|
|
root.appendchild(ReferenceMarkStartNode(name1))
|
|
root.appendchild(ReferenceMarkStartNode(name2))
|
|
root.appendchild(ReferenceMarkStartNode(name3))
|
|
root.appendchild(ReferenceMarkStartNode(name4))
|
|
root.appendchild(ReferenceMarkStartNode(name5))
|
|
root.appendchild(ReferenceMarkStartNode(name6))
|
|
root.appendchild(ReferenceMarkStartNode(name7))
|
|
root.appendchild(TextNode("abc"))
|
|
root.appendchild(ReferenceMarkEndNode(name7))
|
|
root.appendchild(ReferenceMarkEndNode(name6))
|
|
root.appendchild(ReferenceMarkEndNode(name5))
|
|
root.appendchild(ReferenceMarkEndNode(name4))
|
|
root.appendchild(ReferenceMarkEndNode(name3))
|
|
root.appendchild(ReferenceMarkEndNode(name2))
|
|
root.appendchild(ReferenceMarkEndNode(name1))
|
|
root.appendchild(TextNode("de"))
|
|
self.dotest(root)
|
|
|
|
def test_toxmark2(self):
|
|
name1 = self.mkname("toxmark")
|
|
root = TreeNode()
|
|
root.appendchild(DocumentIndexMarkStartNode(name1))
|
|
root.appendchild(TextNode("abc"))
|
|
root.appendchild(DocumentIndexMarkEndNode(name1))
|
|
root.appendchild(TextNode("de"))
|
|
self.dotest(root)
|
|
|
|
def test_toxmark3(self):
|
|
# BUG: #i107672# (non-deterministic; depends on pointer ordering)
|
|
name1 = self.mkname("toxmark")
|
|
name2 = self.mkname("toxmark")
|
|
name3 = self.mkname("toxmark")
|
|
name4 = self.mkname("toxmark")
|
|
name5 = self.mkname("toxmark")
|
|
name6 = self.mkname("toxmark")
|
|
name7 = self.mkname("toxmark")
|
|
root = TreeNode()
|
|
root.appendchild(DocumentIndexMarkStartNode(name1))
|
|
root.appendchild(DocumentIndexMarkStartNode(name2))
|
|
root.appendchild(DocumentIndexMarkStartNode(name3))
|
|
root.appendchild(DocumentIndexMarkStartNode(name4))
|
|
root.appendchild(DocumentIndexMarkStartNode(name5))
|
|
root.appendchild(DocumentIndexMarkStartNode(name6))
|
|
root.appendchild(DocumentIndexMarkStartNode(name7))
|
|
root.appendchild(TextNode("abc"))
|
|
root.appendchild(DocumentIndexMarkEndNode(name7))
|
|
root.appendchild(DocumentIndexMarkEndNode(name6))
|
|
root.appendchild(DocumentIndexMarkEndNode(name5))
|
|
root.appendchild(DocumentIndexMarkEndNode(name4))
|
|
root.appendchild(DocumentIndexMarkEndNode(name3))
|
|
root.appendchild(DocumentIndexMarkEndNode(name2))
|
|
root.appendchild(DocumentIndexMarkEndNode(name1))
|
|
root.appendchild(TextNode("de"))
|
|
self.dotest(root)
|
|
|
|
def test_marks1(self):
|
|
name1 = self.mkname("bookmark")
|
|
name2 = self.mkname("toxmark")
|
|
name3 = self.mkname("refmark")
|
|
name4 = self.mkname("toxmark")
|
|
root = TreeNode()
|
|
root.appendchild(BookmarkStartNode(name1))
|
|
root.appendchild(DocumentIndexMarkNode(name2))
|
|
root.appendchild(ReferenceMarkStartNode(name3))
|
|
root.appendchild(TextNode("abc"))
|
|
root.appendchild(BookmarkEndNode(name1))
|
|
root.appendchild(DocumentIndexMarkStartNode(name4))
|
|
root.appendchild(TextNode("de"))
|
|
root.appendchild(DocumentIndexMarkEndNode(name4))
|
|
root.appendchild(ReferenceMarkEndNode(name3))
|
|
self.dotest(root)
|
|
|
|
def test_marks2(self):
|
|
name1 = self.mkname("bookmark")
|
|
name2 = self.mkname("refmark")
|
|
name3 = self.mkname("refmark")
|
|
name4 = self.mkname("toxmark")
|
|
name5 = self.mkname("refmark")
|
|
root = TreeNode()
|
|
root.appendchild(BookmarkStartNode(name1))
|
|
root.appendchild(ReferenceMarkNode(name2))
|
|
root.appendchild(ReferenceMarkStartNode(name3))
|
|
root.appendchild(TextNode("abc"))
|
|
root.appendchild(DocumentIndexMarkStartNode(name4))
|
|
root.appendchild(ReferenceMarkStartNode(name5))
|
|
# BUG: #i102541# (this is actually not unoportenum's fault)
|
|
root.appendchild(ReferenceMarkEndNode(name3))
|
|
root.appendchild(TextNode("de"))
|
|
root.appendchild(DocumentIndexMarkEndNode(name4))
|
|
root.appendchild(BookmarkEndNode(name1))
|
|
root.appendchild(ReferenceMarkEndNode(name5))
|
|
self.dotest(root)
|
|
|
|
def test_marks3(self):
|
|
name1 = self.mkname("bookmark")
|
|
name2 = self.mkname("refmark")
|
|
name3 = self.mkname("refmark")
|
|
name4 = self.mkname("toxmark")
|
|
name5 = self.mkname("refmark")
|
|
root = TreeNode()
|
|
root.appendchild(BookmarkStartNode(name1))
|
|
root.appendchild(DocumentIndexMarkNode(name2))
|
|
root.appendchild(DocumentIndexMarkStartNode(name3))
|
|
root.appendchild(TextNode("abc"))
|
|
root.appendchild(ReferenceMarkStartNode(name4))
|
|
root.appendchild(DocumentIndexMarkStartNode(name5))
|
|
root.appendchild(DocumentIndexMarkEndNode(name3))
|
|
root.appendchild(TextNode("de"))
|
|
root.appendchild(ReferenceMarkEndNode(name4))
|
|
root.appendchild(BookmarkEndNode(name1))
|
|
root.appendchild(DocumentIndexMarkEndNode(name5))
|
|
self.dotest(root)
|
|
|
|
def test_frame_mark1(self):
|
|
name1 = self.mkname("bookmark")
|
|
name2 = self.mkname("frame")
|
|
root = TreeNode()
|
|
root.appendchild(TextNode("abc"))
|
|
root.appendchild(BookmarkNode(name1))
|
|
root.appendchild(TextNode("de"))
|
|
root.appendchild(FrameNode(name2, AS_CHARACTER))
|
|
self.dotest(root)
|
|
|
|
def test_frame_mark2(self):
|
|
# BUG: #i98530#
|
|
name1 = self.mkname("bookmark")
|
|
name2 = self.mkname("frame")
|
|
root = TreeNode()
|
|
root.appendchild(TextNode("abc"))
|
|
root.appendchild(BookmarkNode(name1))
|
|
root.appendchild(TextNode("de"))
|
|
root.appendchild(FrameNode(name2, AT_CHARACTER))
|
|
self.dotest(root)
|
|
|
|
def test_frame_mark3(self):
|
|
name1 = self.mkname("frame")
|
|
name2 = self.mkname("bookmark")
|
|
root = TreeNode()
|
|
root.appendchild(TextNode("abc"))
|
|
root.appendchild(FrameNode(name1, AS_CHARACTER))
|
|
root.appendchild(TextNode("de"))
|
|
root.appendchild(BookmarkNode(name2))
|
|
self.dotest(root)
|
|
|
|
def test_frame_mark4(self):
|
|
name1 = self.mkname("frame")
|
|
name2 = self.mkname("bookmark")
|
|
root = TreeNode()
|
|
root.appendchild(TextNode("abc"))
|
|
root.appendchild(FrameNode(name1, AT_CHARACTER))
|
|
root.appendchild(TextNode("de"))
|
|
root.appendchild(BookmarkNode(name2))
|
|
self.dotest(root)
|
|
|
|
def test_frames1(self):
|
|
name1 = self.mkname("frame")
|
|
name2 = self.mkname("frame")
|
|
name3 = self.mkname("frame")
|
|
root = TreeNode()
|
|
root.appendchild(FrameNode(name1, AT_CHARACTER))
|
|
root.appendchild(FrameNode(name2, AT_CHARACTER))
|
|
root.appendchild(FrameNode(name3, AT_CHARACTER))
|
|
self.dotest(root)
|
|
|
|
def test_frames2(self):
|
|
name1 = self.mkname("frame")
|
|
name2 = self.mkname("frame")
|
|
name3 = self.mkname("frame")
|
|
root = TreeNode()
|
|
root.appendchild(FrameNode(name1, AS_CHARACTER))
|
|
root.appendchild(FrameNode(name2, AS_CHARACTER))
|
|
root.appendchild(FrameNode(name3, AS_CHARACTER))
|
|
self.dotest(root)
|
|
|
|
def test_frames3(self):
|
|
name1 = self.mkname("frame")
|
|
name2 = self.mkname("frame")
|
|
name3 = self.mkname("frame")
|
|
root = TreeNode()
|
|
root.appendchild(FrameNode(name1, AT_CHARACTER))
|
|
root.appendchild(FrameNode(name2, AS_CHARACTER))
|
|
root.appendchild(FrameNode(name3, AT_CHARACTER))
|
|
self.dotest(root)
|
|
|
|
def test_frames4(self):
|
|
name1 = self.mkname("frame")
|
|
name2 = self.mkname("frame")
|
|
name3 = self.mkname("frame")
|
|
root = TreeNode()
|
|
root.appendchild(FrameNode(name1, AT_CHARACTER))
|
|
root.appendchild(FrameNode(name2, AT_CHARACTER))
|
|
root.appendchild(FrameNode(name3, AS_CHARACTER))
|
|
self.dotest(root)
|
|
|
|
def test_frames5(self):
|
|
name1 = self.mkname("frame")
|
|
name2 = self.mkname("frame")
|
|
name3 = self.mkname("frame")
|
|
root = TreeNode()
|
|
root.appendchild(FrameNode(name1, AS_CHARACTER))
|
|
root.appendchild(FrameNode(name2, AT_CHARACTER))
|
|
root.appendchild(FrameNode(name3, AT_CHARACTER))
|
|
self.dotest(root)
|
|
|
|
def test_ruby_hyperlink1(self):
|
|
name1 = self.mkname("ruby")
|
|
name2 = self.mkname("url")
|
|
root = TreeNode()
|
|
ruby = RubyNode(name1)
|
|
href = HyperlinkNode(name2)
|
|
href.appendchild(TextNode("abc"))
|
|
ruby.appendchild(href)
|
|
root.appendchild(ruby)
|
|
self.dotest(root)
|
|
|
|
def test_ruby_hyperlink2(self):
|
|
name1 = self.mkname("url")
|
|
name2 = self.mkname("ruby")
|
|
root = TreeNode()
|
|
href = HyperlinkNode(name1)
|
|
ruby = RubyNode(name2)
|
|
ruby.appendchild(TextNode("abc"))
|
|
href.appendchild(ruby)
|
|
root.appendchild(href)
|
|
self.dotest(root)
|
|
|
|
def test_end1(self):
|
|
name1 = self.mkname("bookmark")
|
|
name2 = self.mkname("toxmark")
|
|
name3 = self.mkname("refmark")
|
|
root = TreeNode()
|
|
root.appendchild(TextNode("abc"))
|
|
root.appendchild(BookmarkNode(name1))
|
|
root.appendchild(DocumentIndexMarkNode(name2))
|
|
root.appendchild(ReferenceMarkNode(name3))
|
|
self.dotest(root)
|
|
|
|
def test_end2(self):
|
|
name1 = self.mkname("bookmark")
|
|
name2 = self.mkname("frame")
|
|
name3 = self.mkname("refmark")
|
|
name4 = self.mkname("frame")
|
|
name5 = self.mkname("frame")
|
|
root = TreeNode()
|
|
root.appendchild(TextNode("abc"))
|
|
root.appendchild(BookmarkStartNode(name1))
|
|
root.appendchild(FrameNode(name2, AT_CHARACTER))
|
|
root.appendchild(BookmarkEndNode(name1))
|
|
root.appendchild(ReferenceMarkNode(name3))
|
|
root.appendchild(FrameNode(name4, AT_CHARACTER))
|
|
root.appendchild(FrameNode(name5, AT_CHARACTER))
|
|
self.dotest(root)
|
|
|
|
def test_end3(self):
|
|
name1 = self.mkname("ftn")
|
|
name2 = self.mkname("toxmark")
|
|
root = TreeNode()
|
|
root.appendchild(TextNode("abc"))
|
|
root.appendchild(FootnoteNode(name1))
|
|
root.appendchild(DocumentIndexMarkNode(name2))
|
|
self.dotest(root)
|
|
|
|
def test_end4(self):
|
|
name1 = self.mkname("bookmark")
|
|
name2 = self.mkname("frame")
|
|
root = TreeNode()
|
|
root.appendchild(BookmarkStartNode(name1))
|
|
root.appendchild(TextNode("abc"))
|
|
root.appendchild(FrameNode(name2, AS_CHARACTER))
|
|
root.appendchild(BookmarkEndNode(name1))
|
|
self.dotest(root)
|
|
|
|
def test_end5(self):
|
|
name1 = self.mkname("refmark")
|
|
name2 = self.mkname("ruby")
|
|
root = TreeNode()
|
|
root.appendchild(ReferenceMarkStartNode(name1))
|
|
root.appendchild(TextNode("abc"))
|
|
ruby = RubyNode(name2)
|
|
ruby.appendchild(TextFieldNode("de"))
|
|
root.appendchild(ruby)
|
|
root.appendchild(ReferenceMarkEndNode(name1))
|
|
self.dotest(root)
|
|
|
|
def test_empty1(self):
|
|
name1 = self.mkname("refmark")
|
|
name2 = self.mkname("toxmark")
|
|
name3 = self.mkname("bookmark")
|
|
name4 = self.mkname("frame")
|
|
name7 = self.mkname("refmark")
|
|
name8 = self.mkname("toxmark")
|
|
name9 = self.mkname("bookmark")
|
|
nameA = self.mkname("frame")
|
|
root = TreeNode()
|
|
root.appendchild(ReferenceMarkNode(name1))
|
|
root.appendchild(DocumentIndexMarkNode(name2))
|
|
root.appendchild(BookmarkStartNode(name3))
|
|
root.appendchild(FrameNode(name4, AT_CHARACTER))
|
|
root.appendchild(BookmarkEndNode(name3))
|
|
root.appendchild(ReferenceMarkNode(name7))
|
|
root.appendchild(DocumentIndexMarkNode(name8))
|
|
root.appendchild(BookmarkStartNode(name9))
|
|
root.appendchild(FrameNode(nameA, AT_CHARACTER))
|
|
root.appendchild(BookmarkEndNode(name9))
|
|
self.dotest(root)
|
|
|
|
def test_empty2(self):
|
|
name3 = self.mkname("bookmark")
|
|
name4 = self.mkname("frame")
|
|
name9 = self.mkname("bookmark")
|
|
nameA = self.mkname("frame")
|
|
root = TreeNode()
|
|
root.appendchild(BookmarkStartNode(name3))
|
|
root.appendchild(FrameNode(name4, AT_CHARACTER))
|
|
root.appendchild(BookmarkEndNode(name3))
|
|
root.appendchild(BookmarkStartNode(name9))
|
|
root.appendchild(FrameNode(nameA, AT_CHARACTER))
|
|
root.appendchild(BookmarkEndNode(name9))
|
|
self.dotest(root)
|
|
|
|
def test_empty3(self):
|
|
name1 = self.mkname("refmark")
|
|
name2 = self.mkname("toxmark")
|
|
name3 = self.mkname("bookmark")
|
|
name4 = self.mkname("frame")
|
|
# name5 = self.mkname("url")
|
|
name6 = self.mkname("ruby")
|
|
name7 = self.mkname("refmark")
|
|
name8 = self.mkname("toxmark")
|
|
name9 = self.mkname("bookmark")
|
|
nameA = self.mkname("frame")
|
|
root = TreeNode()
|
|
root.appendchild(ReferenceMarkNode(name1))
|
|
root.appendchild(DocumentIndexMarkNode(name2))
|
|
root.appendchild(BookmarkStartNode(name3))
|
|
root.appendchild(FrameNode(name4, AT_CHARACTER))
|
|
root.appendchild(BookmarkEndNode(name3))
|
|
## currently empty hyperlinks may get eaten...
|
|
# href = HyperlinkNode(name5)
|
|
# href.appendchild(TextNode(""))
|
|
# root.appendchild(href)
|
|
ruby = RubyNode(name6)
|
|
root.appendchild(ruby)
|
|
root.appendchild(ReferenceMarkNode(name7))
|
|
root.appendchild(DocumentIndexMarkNode(name8))
|
|
root.appendchild(BookmarkStartNode(name9))
|
|
root.appendchild(FrameNode(nameA, AT_CHARACTER))
|
|
root.appendchild(BookmarkEndNode(name9))
|
|
self.dotest(root)
|
|
|
|
def test1(self):
|
|
name1 = self.mkname("frame")
|
|
name2 = self.mkname("bookmark")
|
|
name3 = self.mkname("ruby")
|
|
name4 = self.mkname("ftn")
|
|
name5 = self.mkname("frame")
|
|
root = TreeNode()
|
|
root.appendchild(FrameNode(name1, AT_CHARACTER))
|
|
root.appendchild(BookmarkStartNode(name2))
|
|
root.appendchild(TextNode("abc"))
|
|
ruby = RubyNode(name3)
|
|
ruby.appendchild(TextNode("de"))
|
|
ruby.appendchild(FootnoteNode(name4))
|
|
ruby.appendchild(BookmarkEndNode(name2))
|
|
root.appendchild(ruby)
|
|
root.appendchild(TextNode("fg"))
|
|
root.appendchild(FrameNode(name5, AT_CHARACTER))
|
|
root.appendchild(TextFieldNode("h"))
|
|
self.dotest(root)
|
|
|
|
# some range tests for the insertion: these are for the current
|
|
# API which treats hyperlinks and rubys not as entities, but as formatting
|
|
# attributes; if these ever become entities, they should not be split!'''
|
|
|
|
def test_range1(self):
|
|
name1 = self.mkname("url")
|
|
inserter = RangeInserter(self.__class__.xDoc)
|
|
text = TextNode("12345")
|
|
inserter.insertrange(Range(0, 0, text))
|
|
url1 = HyperlinkNode(name1)
|
|
range1 = Range(0, 5, url1)
|
|
inserter.insertrange(range1)
|
|
root = TreeNode()
|
|
root.appendchild(url1)
|
|
url1.appendchild(text)
|
|
self.dotest(root, False)
|
|
|
|
def test_range_hyperlink_hyperlink(self):
|
|
inserter = RangeInserter(self.__class__.xDoc)
|
|
text = TextNode("123456789")
|
|
inserter.insertrange(Range(0, 0, text))
|
|
url1 = HyperlinkNode(self.mkname("url"))
|
|
inserter.insertrange(Range(1, 4, url1))
|
|
## overlap left
|
|
url2 = HyperlinkNode(self.mkname("url"))
|
|
inserter.insertrange(Range(0, 2, url2))
|
|
root = TreeNode()
|
|
root.appendchild(url2.dup().appendchild(TextNode("12")))
|
|
root.appendchild(url1.dup().appendchild(TextNode("34")))
|
|
root.appendchild(TextNode("56789"))
|
|
self.dotest(root, False)
|
|
## overlap right
|
|
url3 = HyperlinkNode(self.mkname("url"))
|
|
inserter.insertrange(Range(3, 7, url3))
|
|
root = TreeNode()
|
|
root.appendchild(url2.dup().appendchild(TextNode("12")))
|
|
root.appendchild(url1.dup().appendchild(TextNode("3")))
|
|
root.appendchild(url3.dup().appendchild(TextNode("4567")))
|
|
root.appendchild(TextNode("89"))
|
|
self.dotest(root, False)
|
|
## around
|
|
url4 = HyperlinkNode(self.mkname("url"))
|
|
inserter.insertrange(Range(3, 7, url4))
|
|
root = TreeNode()
|
|
root.appendchild(url2.dup().appendchild(TextNode("12")))
|
|
root.appendchild(url1.dup().appendchild(TextNode("3")))
|
|
root.appendchild(url4.dup().appendchild(TextNode("4567")))
|
|
root.appendchild(TextNode("89"))
|
|
self.dotest(root, False)
|
|
## inside
|
|
url5 = HyperlinkNode(self.mkname("url"))
|
|
inserter.insertrange(Range(4, 6, url5))
|
|
root = TreeNode()
|
|
root.appendchild(url2.dup().appendchild(TextNode("12")))
|
|
root.appendchild(url1.dup().appendchild(TextNode("3")))
|
|
root.appendchild(url4.dup().appendchild(TextNode("4")))
|
|
root.appendchild(url5.dup().appendchild(TextNode("56")))
|
|
root.appendchild(url4.dup().appendchild(TextNode("7")))
|
|
root.appendchild(TextNode("89"))
|
|
self.dotest(root, False)
|
|
## empty
|
|
url6 = HyperlinkNode(self.mkname("url"))
|
|
inserter.insertrange(Range(7, 7, url6))
|
|
root = TreeNode()
|
|
root.appendchild(url2.dup().appendchild(TextNode("12")))
|
|
root.appendchild(url1.dup().appendchild(TextNode("3")))
|
|
root.appendchild(url4.dup().appendchild(TextNode("4")))
|
|
root.appendchild(url5.dup().appendchild(TextNode("56")))
|
|
root.appendchild(url4.dup().appendchild(TextNode("7")))
|
|
## this one gets eaten, but we still need to test inserting it (#i106930#)
|
|
# root.appendchild(url6.dup().appendchild(TextNode("")))
|
|
root.appendchild(TextNode("89"))
|
|
## inside (left-edge)
|
|
url7 = HyperlinkNode(self.mkname("url"))
|
|
inserter.insertrange(Range(0, 1, url7))
|
|
root = TreeNode()
|
|
root.appendchild(url7.dup().appendchild(TextNode("1")))
|
|
root.appendchild(url2.dup().appendchild(TextNode("2")))
|
|
root.appendchild(url1.dup().appendchild(TextNode("3")))
|
|
root.appendchild(url4.dup().appendchild(TextNode("4")))
|
|
root.appendchild(url5.dup().appendchild(TextNode("56")))
|
|
root.appendchild(url4.dup().appendchild(TextNode("7")))
|
|
root.appendchild(TextNode("89"))
|
|
## inside (right-edge)
|
|
url8 = HyperlinkNode(self.mkname("url"))
|
|
inserter.insertrange(Range(5, 6, url8))
|
|
root = TreeNode()
|
|
root.appendchild(url7.dup().appendchild(TextNode("1")))
|
|
root.appendchild(url2.dup().appendchild(TextNode("2")))
|
|
root.appendchild(url1.dup().appendchild(TextNode("3")))
|
|
root.appendchild(url4.dup().appendchild(TextNode("4")))
|
|
root.appendchild(url5.dup().appendchild(TextNode("5")))
|
|
root.appendchild(url8.dup().appendchild(TextNode("6")))
|
|
root.appendchild(url4.dup().appendchild(TextNode("7")))
|
|
root.appendchild(TextNode("89"))
|
|
self.dotest(root, False)
|
|
|
|
def test_range_hyperlink_ruby(self):
|
|
inserter = RangeInserter(self.__class__.xDoc)
|
|
text = TextNode("123456789")
|
|
inserter.insertrange(Range(0, 0, text))
|
|
url1 = HyperlinkNode(self.mkname("url"))
|
|
inserter.insertrange(Range(1, 4, url1))
|
|
# overlap left
|
|
rby2 = RubyNode(self.mkname("ruby"))
|
|
inserter.insertrange(Range(0, 2, rby2))
|
|
root = TreeNode()
|
|
root.appendchild(rby2.dup()
|
|
.appendchild(TextNode("1"))
|
|
.appendchild(url1.dup().appendchild(TextNode("2"))))
|
|
root.appendchild(url1.dup().appendchild(TextNode("34")))
|
|
root.appendchild(TextNode("56789"))
|
|
self.dotest(root, False)
|
|
# overlap right
|
|
rby3 = RubyNode(self.mkname("ruby"))
|
|
inserter.insertrange(Range(3, 5, rby3))
|
|
root = TreeNode()
|
|
root.appendchild(rby2.dup()
|
|
.appendchild(TextNode("1"))
|
|
.appendchild(url1.dup().appendchild(TextNode("2"))))
|
|
root.appendchild(url1.dup().appendchild(TextNode("3")))
|
|
root.appendchild(rby3.dup()
|
|
.appendchild(url1.dup().appendchild(TextNode("4")))
|
|
.appendchild(TextNode("5")))
|
|
root.appendchild(TextNode("6789"))
|
|
self.dotest(root, False)
|
|
# around
|
|
rby4 = RubyNode(self.mkname("ruby"))
|
|
inserter.insertrange(Range(2, 3, rby4))
|
|
root = TreeNode()
|
|
root.appendchild(rby2.dup()
|
|
.appendchild(TextNode("1"))
|
|
.appendchild(url1.dup().appendchild(TextNode("2"))))
|
|
root.appendchild(rby4.dup()
|
|
.appendchild(url1.dup().appendchild(TextNode("3"))))
|
|
root.appendchild(rby3.dup()
|
|
.appendchild(url1.dup().appendchild(TextNode("4")))
|
|
.appendchild(TextNode("5")))
|
|
root.appendchild(TextNode("6789"))
|
|
self.dotest(root, False)
|
|
# inside
|
|
url5 = HyperlinkNode(self.mkname("url"))
|
|
inserter.insertrange(Range(6, 9, url5))
|
|
rby6 = RubyNode(self.mkname("ruby"))
|
|
inserter.insertrange(Range(7, 8, rby6))
|
|
root = TreeNode()
|
|
root.appendchild(rby2.dup()
|
|
.appendchild(TextNode("1"))
|
|
.appendchild(url1.dup().appendchild(TextNode("2"))))
|
|
root.appendchild(rby4.dup()
|
|
.appendchild(url1.dup().appendchild(TextNode("3"))))
|
|
root.appendchild(rby3.dup()
|
|
.appendchild(url1.dup().appendchild(TextNode("4")))
|
|
.appendchild(TextNode("5")))
|
|
root.appendchild(TextNode("6"))
|
|
root.appendchild(url5.dup().appendchild(TextNode("7")))
|
|
root.appendchild(rby6.dup()
|
|
.appendchild(url5.dup().appendchild(TextNode("8"))))
|
|
root.appendchild(url5.dup().appendchild(TextNode("9")))
|
|
self.dotest(root, False)
|
|
|
|
def test_range_ruby_hyperlink(self):
|
|
inserter = RangeInserter(self.__class__.xDoc)
|
|
text = TextNode("123456789")
|
|
inserter.insertrange(Range(0, 0, text))
|
|
rby1 = RubyNode(self.mkname("ruby"))
|
|
inserter.insertrange(Range(1, 6, rby1))
|
|
## overlap left
|
|
url2 = HyperlinkNode(self.mkname("url"))
|
|
inserter.insertrange(Range(0, 3, url2))
|
|
root = TreeNode()
|
|
root.appendchild(url2.dup().appendchild(TextNode("1")))
|
|
root.appendchild(rby1.dup()
|
|
.appendchild(url2.dup().appendchild(TextNode("23")))
|
|
.appendchild(TextNode("456")))
|
|
root.appendchild(TextNode("789"))
|
|
self.dotest(root, False)
|
|
## overlap right
|
|
url3 = HyperlinkNode(self.mkname("url"))
|
|
inserter.insertrange(Range(5, 7, url3))
|
|
root = TreeNode()
|
|
root.appendchild(url2.dup().appendchild(TextNode("1")))
|
|
root.appendchild(rby1.dup()
|
|
.appendchild(url2.dup().appendchild(TextNode("23")))
|
|
.appendchild(TextNode("45"))
|
|
.appendchild(url3.dup().appendchild(TextNode("6"))))
|
|
root.appendchild(url3.dup().appendchild(TextNode("7")))
|
|
root.appendchild(TextNode("89"))
|
|
self.dotest(root, False)
|
|
## around (not quite, due to API)
|
|
url4 = HyperlinkNode(self.mkname("url"))
|
|
inserter.insertrange(Range(1, 8, url4))
|
|
root = TreeNode()
|
|
root.appendchild(url2.dup().appendchild(TextNode("1")))
|
|
root.appendchild(rby1.dup()
|
|
.appendchild(url4.dup()
|
|
.appendchild(TextNode("23456"))))
|
|
root.appendchild(url4.dup().appendchild(TextNode("78")))
|
|
root.appendchild(TextNode("9"))
|
|
self.dotest(root, False)
|
|
## inside
|
|
url5 = HyperlinkNode(self.mkname("url"))
|
|
inserter.insertrange(Range(3, 5, url5))
|
|
root = TreeNode()
|
|
root.appendchild(url2.dup().appendchild(TextNode("1")))
|
|
root.appendchild(rby1.dup()
|
|
.appendchild(url4.dup()
|
|
.appendchild(TextNode("23")))
|
|
.appendchild(url5.dup()
|
|
.appendchild(TextNode("45")))
|
|
.appendchild(url4.dup()
|
|
.appendchild(TextNode("6"))))
|
|
root.appendchild(url4.dup().appendchild(TextNode("78")))
|
|
root.appendchild(TextNode("9"))
|
|
self.dotest(root, False)
|
|
|
|
def test_range_ruby_ruby(self):
|
|
inserter = RangeInserter(self.__class__.xDoc)
|
|
text = TextNode("123456789")
|
|
inserter.insertrange(Range(0, 0, text))
|
|
rby1 = RubyNode(self.mkname("ruby"))
|
|
inserter.insertrange(Range(1, 4, rby1))
|
|
## overlap left
|
|
rby2 = RubyNode(self.mkname("ruby"))
|
|
inserter.insertrange(Range(0, 2, rby2))
|
|
root = TreeNode()
|
|
root.appendchild(rby2.dup().appendchild(TextNode("12")))
|
|
root.appendchild(rby1.dup().appendchild(TextNode("34")))
|
|
root.appendchild(TextNode("56789"))
|
|
self.dotest(root, False)
|
|
## overlap right
|
|
rby3 = RubyNode(self.mkname("ruby"))
|
|
inserter.insertrange(Range(3, 7, rby3))
|
|
root = TreeNode()
|
|
root.appendchild(rby2.dup().appendchild(TextNode("12")))
|
|
root.appendchild(rby1.dup().appendchild(TextNode("3")))
|
|
root.appendchild(rby3.dup().appendchild(TextNode("4567")))
|
|
root.appendchild(TextNode("89"))
|
|
self.dotest(root, False)
|
|
## around
|
|
rby4 = RubyNode(self.mkname("ruby"))
|
|
inserter.insertrange(Range(3, 7, rby4))
|
|
root = TreeNode()
|
|
root.appendchild(rby2.dup().appendchild(TextNode("12")))
|
|
root.appendchild(rby1.dup().appendchild(TextNode("3")))
|
|
root.appendchild(rby4.dup().appendchild(TextNode("4567")))
|
|
root.appendchild(TextNode("89"))
|
|
self.dotest(root, False)
|
|
## inside
|
|
rby5 = RubyNode(self.mkname("ruby"))
|
|
inserter.insertrange(Range(4, 6, rby5))
|
|
root = TreeNode()
|
|
root.appendchild(rby2.dup().appendchild(TextNode("12")))
|
|
root.appendchild(rby1.dup().appendchild(TextNode("3")))
|
|
root.appendchild(rby4.dup().appendchild(TextNode("4")))
|
|
root.appendchild(rby5.dup().appendchild(TextNode("56")))
|
|
root.appendchild(rby4.dup().appendchild(TextNode("7")))
|
|
root.appendchild(TextNode("89"))
|
|
self.dotest(root, False)
|
|
|
|
def test_range_hyperlink_meta(self):
|
|
inserter = RangeInserter(self.__class__.xDoc)
|
|
text = TextNode("123456789")
|
|
inserter.insertrange(Range(0, 0, text))
|
|
url1 = HyperlinkNode(self.mkname("url"))
|
|
inserter.insertrange(Range(1, 4, url1))
|
|
## overlap left
|
|
met2 = MetaNode(self.mkid("id"))
|
|
inserter.insertrange(Range(0, 2, met2))
|
|
root = TreeNode()
|
|
root.appendchild(met2.dup()
|
|
.appendchild(TextNode("1"))
|
|
.appendchild(url1.dup().appendchild(TextNode("2"))))
|
|
root.appendchild(url1.dup().appendchild(TextNode("34")))
|
|
root.appendchild(TextNode("56789"))
|
|
self.dotest(root, False)
|
|
## overlap right
|
|
met3 = MetaNode(self.mkid("id"))
|
|
# inserter.insertrange(Range(4-1, 6-1, met3))
|
|
inserter.insertrange(Range(4, 6, met3))
|
|
root = TreeNode()
|
|
root.appendchild(met2.dup()
|
|
.appendchild(TextNode("1"))
|
|
.appendchild(url1.dup().appendchild(TextNode("2"))))
|
|
root.appendchild(url1.dup().appendchild(TextNode("3")))
|
|
root.appendchild(met3.dup()
|
|
.appendchild(url1.dup().appendchild(TextNode("4")))
|
|
.appendchild(TextNode("5")))
|
|
root.appendchild(TextNode("6789"))
|
|
self.dotest(root, False)
|
|
## around
|
|
met4 = MetaNode(self.mkid("id"))
|
|
# inserter.insertrange(Range(3-1, 4-1, met4))
|
|
inserter.insertrange(Range(3, 4, met4))
|
|
root = TreeNode()
|
|
root.appendchild(met2.dup()
|
|
.appendchild(TextNode("1"))
|
|
.appendchild(url1.dup().appendchild(TextNode("2"))))
|
|
root.appendchild(met4.dup()
|
|
.appendchild(url1.dup().appendchild(TextNode("3"))))
|
|
root.appendchild(met3.dup()
|
|
.appendchild(url1.dup().appendchild(TextNode("4")))
|
|
.appendchild(TextNode("5")))
|
|
root.appendchild(TextNode("6789"))
|
|
self.dotest(root, False)
|
|
## inside
|
|
url5 = HyperlinkNode(self.mkname("url"))
|
|
# inserter.insertrange(Range(9-3, 12-3, url5))
|
|
inserter.insertrange(Range(9, 12, url5))
|
|
met6 = MetaNode(self.mkid("id"))
|
|
# inserter.insertrange(Range(10-3, 11-3, met6))
|
|
inserter.insertrange(Range(10, 11, met6))
|
|
root = TreeNode()
|
|
root.appendchild(met2.dup()
|
|
.appendchild(TextNode("1"))
|
|
.appendchild(url1.dup().appendchild(TextNode("2"))))
|
|
root.appendchild(met4.dup()
|
|
.appendchild(url1.dup().appendchild(TextNode("3"))))
|
|
root.appendchild(met3.dup()
|
|
.appendchild(url1.dup().appendchild(TextNode("4")))
|
|
.appendchild(TextNode("5")))
|
|
root.appendchild(TextNode("6"))
|
|
root.appendchild(url5.dup().appendchild(TextNode("7")))
|
|
root.appendchild(met6.dup()
|
|
.appendchild(url5.dup().appendchild(TextNode("8"))))
|
|
root.appendchild(url5.dup().appendchild(TextNode("9")))
|
|
self.dotest(root, False)
|
|
|
|
def test_range_ruby_meta(self):
|
|
inserter = RangeInserter(self.__class__.xDoc)
|
|
text = TextNode("123456789")
|
|
inserter.insertrange(Range(0, 0, text))
|
|
rby1 = RubyNode(self.mkname("ruby"))
|
|
inserter.insertrange(Range(1, 4, rby1))
|
|
## overlap left
|
|
met2 = MetaNode(self.mkid("id"))
|
|
inserter.insertrange(Range(0, 2, met2))
|
|
root = TreeNode()
|
|
root.appendchild(met2.dup()
|
|
.appendchild(TextNode("1"))
|
|
.appendchild(rby1.dup().appendchild(TextNode("2"))))
|
|
root.appendchild(rby1.dup().appendchild(TextNode("34")))
|
|
root.appendchild(TextNode("56789"))
|
|
self.dotest(root, False)
|
|
## overlap right
|
|
met3 = MetaNode(self.mkid("id"))
|
|
# inserter.insertrange(Range(4-1, 6-1, met3))
|
|
inserter.insertrange(Range(4, 6, met3))
|
|
root = TreeNode()
|
|
root.appendchild(met2.dup()
|
|
.appendchild(TextNode("1"))
|
|
.appendchild(rby1.dup().appendchild(TextNode("2"))))
|
|
root.appendchild(rby1.dup().appendchild(TextNode("3")))
|
|
root.appendchild(met3.dup()
|
|
.appendchild(rby1.dup().appendchild(TextNode("4")))
|
|
.appendchild(TextNode("5")))
|
|
root.appendchild(TextNode("6789"))
|
|
self.dotest(root, False)
|
|
## around
|
|
met4 = MetaNode(self.mkid("id"))
|
|
# inserter.insertrange(Range(3-1, 4-1, met4))
|
|
inserter.insertrange(Range(3, 4, met4))
|
|
root = TreeNode()
|
|
root.appendchild(met2.dup()
|
|
.appendchild(TextNode("1"))
|
|
.appendchild(rby1.dup().appendchild(TextNode("2"))))
|
|
root.appendchild(met4.dup()
|
|
.appendchild(rby1.dup().appendchild(TextNode("3"))))
|
|
root.appendchild(met3.dup()
|
|
.appendchild(rby1.dup().appendchild(TextNode("4")))
|
|
.appendchild(TextNode("5")))
|
|
root.appendchild(TextNode("6789"))
|
|
self.dotest(root, False)
|
|
## inside
|
|
rby5 = RubyNode(self.mkname("ruby"))
|
|
# inserter.insertrange(Range(9-3, 12-3, rby5))
|
|
inserter.insertrange(Range(9, 12, rby5))
|
|
met6 = MetaNode(self.mkid("id"))
|
|
# inserter.insertrange(Range(10-3, 11-3, met6))
|
|
inserter.insertrange(Range(10, 11, met6))
|
|
root = TreeNode()
|
|
root.appendchild(met2.dup()
|
|
.appendchild(TextNode("1"))
|
|
.appendchild(rby1.dup().appendchild(TextNode("2"))))
|
|
root.appendchild(met4.dup()
|
|
.appendchild(rby1.dup().appendchild(TextNode("3"))))
|
|
root.appendchild(met3.dup()
|
|
.appendchild(rby1.dup().appendchild(TextNode("4")))
|
|
.appendchild(TextNode("5")))
|
|
root.appendchild(TextNode("6"))
|
|
root.appendchild(rby5.dup()
|
|
.appendchild(TextNode("7"))
|
|
.appendchild(met6.dup()
|
|
.appendchild(TextNode("8")))
|
|
.appendchild(TextNode("9")))
|
|
self.dotest(root, False)
|
|
|
|
def test_range_meta_hyperlink(self):
|
|
inserter = RangeInserter(self.__class__.xDoc)
|
|
text = TextNode("123456789")
|
|
inserter.insertrange(Range(0, 0, text))
|
|
met1 = MetaNode(self.mkid("id"))
|
|
inserter.insertrange(Range(1, 6, met1))
|
|
## overlap left
|
|
url2 = HyperlinkNode(self.mkname("url"))
|
|
# inserter.insertrange(Range(0, 4-1, url2))
|
|
inserter.insertrange(Range(0, 4, url2))
|
|
root = TreeNode()
|
|
root.appendchild(url2.dup().appendchild(TextNode("1")))
|
|
root.appendchild(met1.dup()
|
|
.appendchild(url2.dup().appendchild(TextNode("23")))
|
|
.appendchild(TextNode("456")))
|
|
root.appendchild(TextNode("789"))
|
|
self.dotest(root, False)
|
|
## overlap right
|
|
url3 = HyperlinkNode(self.mkname("url"))
|
|
# inserter.insertrange(Range(6-1, 8-1, url3))
|
|
inserter.insertrange(Range(6, 8, url3))
|
|
root = TreeNode()
|
|
root.appendchild(url2.dup().appendchild(TextNode("1")))
|
|
root.appendchild(met1.dup()
|
|
.appendchild(url2.dup().appendchild(TextNode("23")))
|
|
.appendchild(TextNode("45"))
|
|
.appendchild(url3.dup().appendchild(TextNode("6"))))
|
|
root.appendchild(url3.dup().appendchild(TextNode("7")))
|
|
root.appendchild(TextNode("89"))
|
|
self.dotest(root, False)
|
|
## around (not quite, due to API)
|
|
url4 = HyperlinkNode(self.mkname("url"))
|
|
# inserter.insertrange(Range(1, 9-1, url4))
|
|
inserter.insertrange(Range(1, 9, url4))
|
|
root = TreeNode()
|
|
root.appendchild(url2.dup().appendchild(TextNode("1")))
|
|
root.appendchild(met1.dup()
|
|
.appendchild(url4.dup()
|
|
.appendchild(TextNode("23456"))))
|
|
root.appendchild(url4.dup().appendchild(TextNode("78")))
|
|
root.appendchild(TextNode("9"))
|
|
self.dotest(root, False)
|
|
## inside
|
|
url5 = HyperlinkNode(self.mkname("url"))
|
|
# inserter.insertrange(Range(4-1, 6-1, url5))
|
|
inserter.insertrange(Range(4, 6, url5))
|
|
root = TreeNode()
|
|
root.appendchild(url2.dup().appendchild(TextNode("1")))
|
|
root.appendchild(met1.dup()
|
|
.appendchild(url4.dup()
|
|
.appendchild(TextNode("23")))
|
|
.appendchild(url5.dup()
|
|
.appendchild(TextNode("45")))
|
|
.appendchild(url4.dup()
|
|
.appendchild(TextNode("6"))))
|
|
root.appendchild(url4.dup().appendchild(TextNode("78")))
|
|
root.appendchild(TextNode("9"))
|
|
self.dotest(root, False)
|
|
|
|
def test_range_meta_ruby(self):
|
|
inserter = RangeInserter(self.__class__.xDoc)
|
|
text = TextNode("123456789")
|
|
inserter.insertrange(Range(0, 0, text))
|
|
met1 = MetaNode(self.mkid("id"))
|
|
inserter.insertrange(Range(1, 5, met1))
|
|
## overlap left
|
|
rby2 = RubyNode(self.mkname("ruby"))
|
|
# inserter.insertrange(Range(0, 3-1, rby2))
|
|
inserter.insertrange(Range(0, 3, rby2))
|
|
root = TreeNode()
|
|
root.appendchild(rby2.dup().appendchild(TextNode("1")))
|
|
root.appendchild(met1.dup()
|
|
.appendchild(rby2.dup().appendchild(TextNode("2")))
|
|
.appendchild(TextNode("345")))
|
|
root.appendchild(TextNode("6789"))
|
|
self.dotest(root, False)
|
|
## overlap right
|
|
rby3 = RubyNode(self.mkname("ruby"))
|
|
# inserter.insertrange(Range(5-1, 7-1, rby3))
|
|
inserter.insertrange(Range(5, 7, rby3))
|
|
root = TreeNode()
|
|
root.appendchild(rby2.dup().appendchild(TextNode("1")))
|
|
root.appendchild(met1.dup()
|
|
.appendchild(rby2.dup().appendchild(TextNode("2")))
|
|
.appendchild(TextNode("34"))
|
|
.appendchild(rby3.dup().appendchild(TextNode("5"))))
|
|
root.appendchild(rby3.dup().appendchild(TextNode("6")))
|
|
root.appendchild(TextNode("789"))
|
|
self.dotest(root, False)
|
|
## // around
|
|
rby4 = RubyNode(self.mkname("ruby"))
|
|
# inserter.insertrange(Range(1, 7-1, rby4))
|
|
inserter.insertrange(Range(1, 7, rby4))
|
|
root = TreeNode()
|
|
root.appendchild(rby2.dup().appendchild(TextNode("1")))
|
|
root.appendchild(rby4.dup()
|
|
.appendchild(met1.dup()
|
|
.appendchild(TextNode("2345")))
|
|
.appendchild(TextNode("6")))
|
|
root.appendchild(TextNode("789"))
|
|
self.dotest(root, False)
|
|
## inside
|
|
met5 = MetaNode(self.mkid("id"))
|
|
# inserter.insertrange(Range(7-1, 9-1, met5))
|
|
inserter.insertrange(Range(7, 9, met5))
|
|
rby6 = RubyNode(self.mkname("ruby"))
|
|
# inserter.insertrange(Range(9-2, 10/-2, rby6))
|
|
inserter.insertrange(Range(9, 10, rby6))
|
|
root = TreeNode()
|
|
root.appendchild(rby2.dup().appendchild(TextNode("1")))
|
|
root.appendchild(rby4.dup()
|
|
.appendchild(met1.dup()
|
|
.appendchild(TextNode("2345")))
|
|
.appendchild(TextNode("6")))
|
|
root.appendchild(met5.dup()
|
|
.appendchild(TextNode("7"))
|
|
.appendchild(rby6.dup()
|
|
.appendchild(TextNode("8"))))
|
|
root.appendchild(TextNode("9"))
|
|
self.dotest(root, False)
|
|
## inside, with invalid range that includes the dummy char
|
|
rby7 = RubyNode(self.mkname("ruby"))
|
|
# inserter.insertrange(Range(7-1, 9-2, rby7))
|
|
inserter.insertrange(Range(7, 9, rby7))
|
|
root = TreeNode()
|
|
root.appendchild(rby2.dup().appendchild(TextNode("1")))
|
|
root.appendchild(rby4.dup()
|
|
.appendchild(met1.dup()
|
|
.appendchild(TextNode("2345")))
|
|
.appendchild(TextNode("6")))
|
|
root.appendchild(met5.dup()
|
|
.appendchild(rby7.dup()
|
|
.appendchild(TextNode("7")))
|
|
.appendchild(rby6.dup()
|
|
.appendchild(TextNode("8"))))
|
|
root.appendchild(TextNode("9"))
|
|
self.dotest(root, False)
|
|
## around, at same position as meta
|
|
rby8 = RubyNode(self.mkname("ruby"))
|
|
# inserter.insertrange(Range(7-1, 10-2, rby8))
|
|
inserter.insertrange(Range(7, 10, rby8))
|
|
root = TreeNode()
|
|
root.appendchild(rby2.dup().appendchild(TextNode("1")))
|
|
root.appendchild(rby4.dup()
|
|
.appendchild(met1.dup()
|
|
.appendchild(TextNode("2345")))
|
|
.appendchild(TextNode("6")))
|
|
root.appendchild(rby8.dup()
|
|
.appendchild(met5.dup()
|
|
.appendchild(TextNode("78"))))
|
|
root.appendchild(TextNode("9"))
|
|
self.dotest(root, False)
|
|
|
|
def test_range_meta_meta(self):
|
|
inserter = RangeInserter(self.__class__.xDoc)
|
|
text = TextNode("123456789")
|
|
inserter.insertrange(Range(0, 0, text))
|
|
met1 = MetaNode(self.mkid("id"))
|
|
inserter.insertrange(Range(3, 6, met1))
|
|
## overlap left
|
|
met2 = MetaNode(self.mkid("id"))
|
|
try:
|
|
inserter.insertrange(Range(0, 4, met2))
|
|
self.fail("testRangeMetaMeta: overlap left allowed")
|
|
except IllegalArgumentException:
|
|
pass
|
|
root = TreeNode()
|
|
root.appendchild(TextNode("123"))
|
|
root.appendchild(met1.dup().appendchild(TextNode("456")))
|
|
root.appendchild(TextNode("789"))
|
|
self.dotest(root, False)
|
|
## overlap right
|
|
met3 = MetaNode(self.mkid("id"))
|
|
|
|
try:
|
|
# inserter.insertrange(Range(5-1, 8-1, met3))
|
|
inserter.insertrange(Range(5, 8, met3))
|
|
self.fail("testRangeMetaMeta: overlap right allowed")
|
|
except IllegalArgumentException:
|
|
pass
|
|
|
|
root = TreeNode()
|
|
root.appendchild(TextNode("123"))
|
|
root.appendchild(met1.dup().appendchild(TextNode("456")))
|
|
root.appendchild(TextNode("789"))
|
|
self.dotest(root, False)
|
|
## around
|
|
met4 = MetaNode(self.mkid("id"))
|
|
# inserter.insertrange(Range(3, 7-1, met4))
|
|
inserter.insertrange(Range(3, 7, met4))
|
|
root = TreeNode()
|
|
root.appendchild(TextNode("123"))
|
|
root.appendchild(met4.dup()
|
|
.appendchild(met1.dup().appendchild(TextNode("456"))))
|
|
root.appendchild(TextNode("789"))
|
|
self.dotest(root, False)
|
|
## inside
|
|
met5 = MetaNode(self.mkid("id"))
|
|
# inserter.insertrange(Range(6-2, 8-2, met5))
|
|
inserter.insertrange(Range(6, 8, met5))
|
|
root = TreeNode()
|
|
root.appendchild(TextNode("123"))
|
|
root.appendchild(met4.dup()
|
|
.appendchild(met1.dup()
|
|
.appendchild(TextNode("4"))
|
|
.appendchild(met5.dup()
|
|
.appendchild(TextNode("56")))))
|
|
root.appendchild(TextNode("789"))
|
|
self.dotest(root, False)
|
|
|
|
def test_range2(self):
|
|
inserter = RangeInserter(self.__class__.xDoc)
|
|
text = TextNode("123456789")
|
|
inserter.insertrange(Range(0, 0, text))
|
|
met1 = MetaNode(self.mkid("id"))
|
|
inserter.insertrange(Range(1, 8, met1))
|
|
met2 = MetaNode(self.mkid("id"))
|
|
# inserter.insertrange(Range(3-1, 8-1, met2))
|
|
inserter.insertrange(Range(3, 8, met2))
|
|
met3 = MetaNode(self.mkid("id"))
|
|
# inserter.insertrange(Range(5-2, 8-2, met3))
|
|
inserter.insertrange(Range(5, 8, met3))
|
|
root = TreeNode()
|
|
root.appendchild(TextNode("1"))
|
|
root.appendchild(met1.dup()
|
|
.appendchild(TextNode("2"))
|
|
.appendchild(met2.dup()
|
|
.appendchild(TextNode("3"))
|
|
.appendchild(met3.dup()
|
|
.appendchild(TextNode("456")))
|
|
.appendchild(TextNode("7")))
|
|
.appendchild(TextNode("8")))
|
|
root.appendchild(TextNode("9"))
|
|
self.dotest(root, False)
|
|
## split ruby at every meta start!
|
|
rby4 = RubyNode(self.mkname("ruby"))
|
|
# inserter.insertrange(Range(0, 7-3, rby4))
|
|
inserter.insertrange(Range(0, 7, rby4))
|
|
root = TreeNode()
|
|
root.appendchild(rby4.dup()
|
|
.appendchild(TextNode("1")))
|
|
root.appendchild(met1.dup()
|
|
.appendchild(rby4.dup()
|
|
.appendchild(TextNode("2")))
|
|
.appendchild(met2.dup()
|
|
.appendchild(rby4.dup()
|
|
.appendchild(TextNode("3")))
|
|
.appendchild(met3.dup()
|
|
.appendchild(rby4.dup()
|
|
.appendchild(TextNode("4")))
|
|
.appendchild(TextNode("56")))
|
|
.appendchild(TextNode("7")))
|
|
.appendchild(TextNode("8")))
|
|
root.appendchild(TextNode("9"))
|
|
self.dotest(root, False)
|
|
## split ruby at every meta end!
|
|
rby5 = RubyNode(self.mkname("ruby"))
|
|
# inserter.insertrange(Range(8-3, 12-3, rby5))
|
|
inserter.insertrange(Range(8, 12, rby5))
|
|
root = TreeNode()
|
|
root.appendchild(rby4.dup()
|
|
.appendchild(TextNode("1")))
|
|
root.appendchild(met1.dup()
|
|
.appendchild(rby4.dup()
|
|
.appendchild(TextNode("2")))
|
|
.appendchild(met2.dup()
|
|
.appendchild(rby4.dup()
|
|
.appendchild(TextNode("3")))
|
|
.appendchild(met3.dup()
|
|
.appendchild(rby4.dup()
|
|
.appendchild(TextNode("4")))
|
|
.appendchild(TextNode("5"))
|
|
.appendchild(rby5.dup()
|
|
.appendchild(TextNode("6"))))
|
|
.appendchild(rby5.dup()
|
|
.appendchild(TextNode("7"))))
|
|
.appendchild(rby5.dup()
|
|
.appendchild(TextNode("8"))))
|
|
root.appendchild(rby5.dup()
|
|
.appendchild(TextNode("9")))
|
|
self.dotest(root, False)
|
|
|
|
def test_range3(self):
|
|
inserter = RangeInserter(self.__class__.xDoc)
|
|
text = TextNode("123456789")
|
|
inserter.insertrange(Range(0, 0, text))
|
|
rby1 = RubyNode(self.mkname("ruby"))
|
|
inserter.insertrange(Range(0, 9, rby1))
|
|
met2 = MetaNode(self.mkid("id"))
|
|
inserter.insertrange(Range(2, 7, met2))
|
|
root = TreeNode()
|
|
root.appendchild(rby1.dup()
|
|
.appendchild(TextNode("12"))
|
|
.appendchild(met2.dup()
|
|
.appendchild(TextNode("34567")))
|
|
.appendchild(TextNode("89")))
|
|
self.dotest(root, False)
|
|
## overwrite outer ruby, split remains at inner meta!
|
|
rby3 = RubyNode(self.mkname("ruby"))
|
|
# inserter.insertrange(Range(5-1, 6-1, rby3))
|
|
inserter.insertrange(Range(5, 6, rby3))
|
|
root = TreeNode()
|
|
root.appendchild(rby1.dup()
|
|
.appendchild(TextNode("12")))
|
|
root.appendchild(met2.dup()
|
|
.appendchild(rby1.dup()
|
|
.appendchild(TextNode("34")))
|
|
.appendchild(rby3.dup()
|
|
.appendchild(TextNode("5")))
|
|
.appendchild(rby1.dup()
|
|
.appendchild(TextNode("67"))))
|
|
root.appendchild(rby1.dup()
|
|
.appendchild(TextNode("89")))
|
|
self.dotest(root, False)
|
|
|
|
def test_range4(self):
|
|
inserter = RangeInserter(self.__class__.xDoc)
|
|
text = TextNode("123456789")
|
|
inserter.insertrange(Range(0, 0, text))
|
|
rby1 = RubyNode(self.mkname("ruby"))
|
|
inserter.insertrange(Range(0, 9, rby1))
|
|
met2 = MetaNode(self.mkid("id"))
|
|
inserter.insertrange(Range(1, 8, met2))
|
|
met3 = MetaNode(self.mkid("id"))
|
|
# inserter.insertrange(Range(3-1, 8-1, met3))
|
|
inserter.insertrange(Range(3, 8, met3))
|
|
met4 = MetaNode(self.mkid("id"))
|
|
# inserter.insertrange(Range(5-2, 8-2, met4))
|
|
inserter.insertrange(Range(5, 8, met4))
|
|
root = TreeNode()
|
|
root.appendchild(rby1.dup()
|
|
.appendchild(TextNode("1"))
|
|
.appendchild(met2.dup()
|
|
.appendchild(TextNode("2"))
|
|
.appendchild(met3.dup()
|
|
.appendchild(TextNode("3"))
|
|
.appendchild(met4.dup()
|
|
.appendchild(TextNode("456")))
|
|
.appendchild(TextNode("7")))
|
|
.appendchild(TextNode("8")))
|
|
.appendchild(TextNode("9")))
|
|
self.dotest(root, False)
|
|
## overwrite outer ruby, split remains at every inner meta!
|
|
rby5 = RubyNode(self.mkname("ruby"))
|
|
# inserter.insertrange(Range(7-3, 8-3, rby5))
|
|
inserter.insertrange(Range(7, 8, rby5))
|
|
root = TreeNode()
|
|
root.appendchild(rby1.dup()
|
|
.appendchild(TextNode("1")))
|
|
root.appendchild(met2.dup()
|
|
.appendchild(rby1.dup()
|
|
.appendchild(TextNode("2")))
|
|
.appendchild(met3.dup()
|
|
.appendchild(rby1.dup()
|
|
.appendchild(TextNode("3")))
|
|
.appendchild(met4.dup()
|
|
.appendchild(rby1.dup()
|
|
.appendchild(TextNode("4")))
|
|
.appendchild(rby5.dup()
|
|
.appendchild(TextNode("5")))
|
|
.appendchild(rby1.dup()
|
|
.appendchild(TextNode("6"))))
|
|
.appendchild(rby1.dup()
|
|
.appendchild(TextNode("7"))))
|
|
.appendchild(rby1.dup()
|
|
.appendchild(TextNode("8"))))
|
|
root.appendchild(rby1.dup()
|
|
.appendchild(TextNode("9")))
|
|
self.dotest(root, False)
|
|
|
|
def test_range5(self):
|
|
inserter = RangeInserter(self.__class__.xDoc)
|
|
text = TextNode("123456789")
|
|
inserter.insertrange(Range(0, 0, text))
|
|
rby1 = RubyNode(self.mkname("ruby"))
|
|
inserter.insertrange(Range(0, 9, rby1))
|
|
met2 = MetaNode(self.mkid("id"))
|
|
inserter.insertrange(Range(1, 3, met2))
|
|
met3 = MetaNode(self.mkid("id"))
|
|
# inserter.insertrange(Range(5-1, 6-1, met3))
|
|
inserter.insertrange(Range(5, 6, met3))
|
|
met4 = MetaNode(self.mkid("id"))
|
|
# inserter.insertrange(Range(8-2, 10-2, met4))
|
|
inserter.insertrange(Range(8, 10, met4))
|
|
root = TreeNode()
|
|
root.appendchild(rby1.dup()
|
|
.appendchild(TextNode("1"))
|
|
.appendchild(met2.dup().appendchild(TextNode("23")))
|
|
.appendchild(TextNode("4"))
|
|
.appendchild(met3.dup().appendchild(TextNode("5")))
|
|
.appendchild(TextNode("6"))
|
|
.appendchild(met4.dup().appendchild(TextNode("78")))
|
|
.appendchild(TextNode("9")))
|
|
self.dotest(root, False)
|
|
## overwrite outer ruby, but split at inner metas!
|
|
rby5 = RubyNode(self.mkname("ruby"))
|
|
# inserter.insertrange(Range(3-1, 10-3, rby5))
|
|
inserter.insertrange(Range(3, 10, rby5))
|
|
root = TreeNode()
|
|
root.appendchild(rby1.dup()
|
|
.appendchild(TextNode("1")))
|
|
root.appendchild(met2.dup()
|
|
.appendchild(rby1.dup()
|
|
.appendchild(TextNode("2")))
|
|
.appendchild(rby5.dup()
|
|
.appendchild(TextNode("3"))))
|
|
root.appendchild(rby5.dup()
|
|
.appendchild(TextNode("4"))
|
|
.appendchild(met3.dup()
|
|
.appendchild(TextNode("5")))
|
|
.appendchild(TextNode("6")))
|
|
root.appendchild(met4.dup()
|
|
.appendchild(rby5.dup()
|
|
.appendchild(TextNode("7")))
|
|
.appendchild(rby1.dup()
|
|
.appendchild(TextNode("8"))))
|
|
root.appendchild(rby1.dup()
|
|
.appendchild(TextNode("9")))
|
|
self.dotest(root, False)
|
|
|
|
def test_range6(self):
|
|
inserter = RangeInserter(self.__class__.xDoc)
|
|
text = TextNode("123456789")
|
|
inserter.insertrange(Range(0, 0, text))
|
|
met1 = MetaNode(self.mkid("id"))
|
|
inserter.insertrange(Range(1, 5, met1))
|
|
met2 = MetaNode(self.mkid("id"))
|
|
# inserter.insertrange(Range(3-1, 6-1, met2))
|
|
inserter.insertrange(Range(3, 6, met2))
|
|
met3 = MetaNode(self.mkid("id"))
|
|
# inserter.insertrange(Range(5-2, 7-2, met3))
|
|
inserter.insertrange(Range(5, 7, met3))
|
|
root = TreeNode()
|
|
root.appendchild(TextNode("1"))
|
|
root.appendchild(met1.dup()
|
|
.appendchild(TextNode("2"))
|
|
.appendchild(met2.dup()
|
|
.appendchild(TextNode("3"))
|
|
.appendchild(met3.dup()
|
|
.appendchild(TextNode("45")))))
|
|
root.appendchild(TextNode("6789"))
|
|
self.dotest(root, False)
|
|
## split at 3 metas, all at same position
|
|
rby4 = RubyNode(self.mkname("ruby"))
|
|
# inserter.insertrange(Range(7-3, 10-3, rby4))
|
|
inserter.insertrange(Range(7, 10, rby4))
|
|
root = TreeNode()
|
|
root.appendchild(TextNode("1"))
|
|
root.appendchild(met1.dup()
|
|
.appendchild(TextNode("2"))
|
|
.appendchild(met2.dup()
|
|
.appendchild(TextNode("3"))
|
|
.appendchild(met3.dup()
|
|
.appendchild(TextNode("4"))
|
|
.appendchild(rby4.dup()
|
|
.appendchild(TextNode("5"))))))
|
|
root.appendchild(rby4.dup()
|
|
.appendchild(TextNode("67")))
|
|
root.appendchild(TextNode("89"))
|
|
self.dotest(root, False)
|
|
|
|
def test_range7(self):
|
|
inserter = RangeInserter(self.__class__.xDoc)
|
|
text = TextNode("123456789")
|
|
inserter.insertrange(Range(0, 0, text))
|
|
url1 = HyperlinkNode(self.mkname("url"))
|
|
inserter.insertrange(Range(1, 5, url1))
|
|
met2 = MetaNode(self.mkid("id"))
|
|
inserter.insertrange(Range(3, 5, met2))
|
|
root = TreeNode()
|
|
root.appendchild(TextNode("1"))
|
|
root.appendchild(url1.dup()
|
|
.appendchild(TextNode("23")))
|
|
root.appendchild(met2.dup()
|
|
.appendchild(url1.dup()
|
|
.appendchild(TextNode("45"))))
|
|
root.appendchild(TextNode("6789"))
|
|
self.dotest(root, False)
|
|
## this should result in not splitting the hyperlink, but due to API
|
|
## we can't tell :(
|
|
rby3 = RubyNode(self.mkname("ruby"))
|
|
# inserter.insertrange(Range(5-1, 8-1, rby3))
|
|
inserter.insertrange(Range(5, 8, rby3))
|
|
root = TreeNode()
|
|
root.appendchild(TextNode("1"))
|
|
root.appendchild(url1.dup()
|
|
.appendchild(TextNode("23")))
|
|
root.appendchild(met2.dup()
|
|
.appendchild(url1.dup()
|
|
.appendchild(TextNode("4")))
|
|
.appendchild(rby3.dup()
|
|
.appendchild(url1.dup()
|
|
.appendchild(TextNode("5")))))
|
|
root.appendchild(rby3.dup()
|
|
.appendchild(TextNode("67")))
|
|
root.appendchild(TextNode("89"))
|
|
self.dotest(root, False)
|
|
|
|
# TODO: test partial selection, test UNDO/REDO
|
|
|
|
##i109601# NestedTextContent and XChild
|
|
def test_meta_xchild(self):
|
|
xDoc = self.__class__.xDoc
|
|
id1 = StringPair("content.xml", self.mkname("id"))
|
|
id2 = StringPair("content.xml", self.mkname("id"))
|
|
id3 = StringPair("content.xml", self.mkname("id"))
|
|
id4 = StringPair("content.xml", self.mkname("id"))
|
|
id5 = StringPair("content.xml", self.mkname("id"))
|
|
id6 = StringPair("content.xml", self.mkname("id"))
|
|
meta1 = MetaNode(id1)
|
|
meta2 = MetaNode(id2)
|
|
meta3 = MetaFieldNode(id3)
|
|
meta4 = MetaNode(id4)
|
|
meta5 = MetaNode(id5)
|
|
meta6 = MetaFieldNode(id6)
|
|
root = TreeNode()
|
|
root.appendchild(meta1.dup()
|
|
.appendchild(TextNode("1")))
|
|
root.appendchild(TextNode("2"))
|
|
root.appendchild(meta2.dup()
|
|
.appendchild(meta3.dup()
|
|
.appendchild(TextNode("34"))
|
|
.appendchild(meta4.dup()
|
|
.appendchild(TextNode("56")))
|
|
.appendchild(meta5.dup())
|
|
.appendchild(TextNode("7"))))
|
|
root.appendchild(TextNode("8"))
|
|
root.appendchild(meta6.dup()
|
|
.appendchild(TextNode("9")))
|
|
|
|
inserter = RangeInserter(xDoc)
|
|
text = TextNode("123456789")
|
|
inserter.insertrange(Range(0, 0, text))
|
|
xMeta1 = inserter.insertrange(Range(0, 1, meta1))
|
|
xMeta2 = inserter.insertrange(Range(3, 8, meta2))
|
|
xMeta3 = inserter.insertrange(Range(4, 9, meta3))
|
|
xMeta4 = inserter.insertrange(Range(7, 9, meta4))
|
|
xMeta5 = inserter.insertrange(Range(10, 10, meta5))
|
|
xMeta6 = inserter.insertrange(Range(13, 14, meta6))
|
|
|
|
self.dotest(root, False)
|
|
|
|
xDocText = xDoc.getText()
|
|
xDocTextCursor = xDocText.createTextCursor()
|
|
xDocTextCursor.gotoNextParagraph(False) # second paragraph
|
|
# X12XX34X56X78X9
|
|
# 1 23 4 5 6
|
|
# 1 452 6
|
|
# 3
|
|
nestedTextContent = (
|
|
None,
|
|
id1,
|
|
id1,
|
|
None,
|
|
id2,
|
|
id3,
|
|
id3,
|
|
id3,
|
|
id4,
|
|
id4,
|
|
id4,
|
|
id5,
|
|
id3,
|
|
None,
|
|
id6,
|
|
id6)
|
|
for i, ntc in enumerate(nestedTextContent):
|
|
oNTC = xDocTextCursor.NestedTextContent
|
|
if ntc is None:
|
|
self.assertIsNone(oNTC,
|
|
"unexpected NestedTextContent at: {}".format(i))
|
|
else:
|
|
xmlid = oNTC.MetadataReference
|
|
self.assertTrue(MetaNode.eq(ntc, xmlid),
|
|
"wrong NestedTextContent at: {}".format(i))
|
|
xDocTextCursor.goRight(1, False)
|
|
|
|
try:
|
|
xMeta1.setParent(xMeta4)
|
|
self.fail("setParent(): allowed?")
|
|
except NoSupportException:
|
|
pass
|
|
self.assertIsNone(xMeta1.getParent(), "getParent(): not None")
|
|
self.assertIsNone(xMeta2.getParent(), "getParent(): not None")
|
|
self.assertIsNone(xMeta6.getParent(), "getParent(): not None")
|
|
|
|
xParent3 = xMeta3.getParent()
|
|
self.assertIsNotNone(xParent3, "getParent(): None")
|
|
xmlid = xParent3.MetadataReference
|
|
self.assertTrue(MetaNode.eq(xmlid, id2), "getParent(): wrong")
|
|
|
|
xParent4 = xMeta4.getParent()
|
|
self.assertIsNotNone(xParent4, "getParent(): None")
|
|
xmlid = xParent4.MetadataReference
|
|
self. assertTrue(MetaNode.eq(xmlid, id3), "getParent(): wrong")
|
|
|
|
xParent5 = xMeta5.getParent()
|
|
self.assertIsNotNone(xParent5, "getParent(): None")
|
|
xmlid = xParent5.MetadataReference
|
|
self.assertTrue(MetaNode.eq(xmlid, id3), "getParent(): wrong")
|
|
|
|
# test SwXMeta XText interface
|
|
def test_meta_xtext(self):
|
|
xDoc = self.__class__.xDoc
|
|
inserter = RangeInserter(xDoc)
|
|
text = TextNode("12AB6789")
|
|
inserter.insertrange(Range(0, 0, text))
|
|
meta = MetaNode(self.mkid("id"))
|
|
xMeta = inserter.makemeta()
|
|
|
|
xDocText = xDoc.getText()
|
|
xDocTextCursor = xDocText.createTextCursor()
|
|
xDocTextCursor.goRight(3, False)
|
|
xDocTextCursor.goRight(2, True)
|
|
xDocText.insertTextContent(xDocTextCursor, xMeta, True)
|
|
|
|
xMeta.MetadataReference = meta.xmlid
|
|
xParentText = xMeta.getText()
|
|
self.assertIsNotNone(xParentText, "getText(): no parent")
|
|
|
|
xStart = xMeta.getStart()
|
|
self.assertIsNotNone(xStart, "getStart(): no start")
|
|
|
|
xEnd = xMeta.getEnd()
|
|
self.assertIsNotNone(xEnd, "getEnd(): no end")
|
|
|
|
xMeta.setString("45")
|
|
|
|
string = xMeta.getString()
|
|
self.assertEqual("45", string, "getString(): invalid string returned")
|
|
|
|
xTextCursor = xMeta.createTextCursor()
|
|
self.assertIsNotNone(xTextCursor, "createTextCursor(): failed")
|
|
|
|
try:
|
|
xMeta.createTextCursorByRange(None)
|
|
self.fail("createTextCursorByRange(): None allowed?")
|
|
except RuntimeException:
|
|
pass
|
|
|
|
xTextCursorStart = xMeta.createTextCursorByRange(xStart)
|
|
self.assertIsNotNone(xTextCursorStart,
|
|
"createTextCursorByRange(): failed for start")
|
|
|
|
xTextCursorEnd = xMeta.createTextCursorByRange(xEnd)
|
|
self.assertIsNotNone(xTextCursorEnd,
|
|
"createTextCursorByRange(): failed for end")
|
|
|
|
## move outside meta
|
|
xDocTextCursor.gotoStart(False)
|
|
|
|
try:
|
|
xMeta.insertString(None, "foo", False)
|
|
self.fail("insertString(): None allowed?")
|
|
except RuntimeException:
|
|
pass
|
|
|
|
try:
|
|
xMeta.insertString(xDocTextCursor, "foo", False)
|
|
self.fail("insertString(): cursor outside allowed?")
|
|
except RuntimeException:
|
|
pass
|
|
|
|
xStart = xMeta.getStart()
|
|
xMeta.insertString(xStart, "A", False)
|
|
string = xMeta.getString()
|
|
self.assertEqual("A45", string, "getString(): invalid string returned")
|
|
|
|
xMeta.insertString(xEnd, "B", False)
|
|
string = xMeta.getString()
|
|
self.assertEqual("A45B", string, "getString(): invalid string returned")
|
|
|
|
try:
|
|
xMeta.insertControlCharacter(None, HARD_HYPHEN, False)
|
|
self.fail("insertControlCharacter(): None allowed?")
|
|
except IllegalArgumentException:
|
|
pass
|
|
|
|
xStart = xMeta.getStart()
|
|
try:
|
|
xMeta.insertControlCharacter(xDocTextCursor, HARD_HYPHEN, False)
|
|
self.fail("insertControlCharacter(): cursor outside allowed?")
|
|
except IllegalArgumentException:
|
|
pass
|
|
|
|
xMeta.insertControlCharacter(xStart, HARD_HYPHEN, False)
|
|
string = xMeta.getString()
|
|
self.assertEqual('\u2011' + 'A45B', string,
|
|
"getString(): invalid string returned")
|
|
|
|
xMeta.insertControlCharacter(xEnd, HARD_HYPHEN, False)
|
|
string = xMeta.getString()
|
|
self.assertEqual('\u2011' + 'A45B' + '\u2011', string,
|
|
"getString(): invalid string returned")
|
|
|
|
xMeta.setString("45")
|
|
try:
|
|
xMeta.insertTextContent(None, xMeta, False)
|
|
self.fail("insertTextContent(): None range allowed?")
|
|
except IllegalArgumentException:
|
|
pass
|
|
|
|
try:
|
|
xMeta.insertTextContent(xStart, None, False)
|
|
self.fail("insertTextContent(): None content allowed?")
|
|
except IllegalArgumentException:
|
|
pass
|
|
|
|
try:
|
|
xMeta.insertTextContent(xDocTextCursor, xMeta, False)
|
|
self.fail("insertTextContent(): cursor outside allowed?")
|
|
except IllegalArgumentException:
|
|
pass
|
|
|
|
field1 = TextFieldNode("f1")
|
|
field2 = TextFieldNode("f2")
|
|
xField1 = inserter.maketextfield(field1.content)
|
|
xField2 = inserter.maketextfield(field2.content)
|
|
|
|
xStart = xMeta.getStart()
|
|
xMeta.insertTextContent(xStart, xField1, False)
|
|
|
|
root = TreeNode()
|
|
root.appendchild(TextNode("12"))
|
|
root.appendchild(meta.dup()
|
|
.appendchild(field1.dup())
|
|
.appendchild(TextNode("45")))
|
|
root.appendchild(TextNode("6789"))
|
|
self.dotest(root, False)
|
|
|
|
xMeta.insertTextContent(xEnd, xField2, False)
|
|
|
|
root = TreeNode()
|
|
root.appendchild(TextNode("12"))
|
|
root.appendchild(meta.dup()
|
|
.appendchild(field1.dup())
|
|
.appendchild(TextNode("45"))
|
|
.appendchild(field2.dup()))
|
|
root.appendchild(TextNode("6789"))
|
|
self.dotest(root, False)
|
|
|
|
try:
|
|
xMeta.removeTextContent(None)
|
|
self.fail("removeTextContent(): None content allowed?")
|
|
except RuntimeException:
|
|
pass
|
|
|
|
xMeta.removeTextContent(xField1)
|
|
|
|
xAnchor = xMeta.getAnchor()
|
|
self.assertIsNotNone(xAnchor, "getAnchor(): None")
|
|
|
|
## evil test case: insert ruby around meta
|
|
ruby = RubyNode(self.mkname("ruby"))
|
|
inserter.insertrange(Range(2, 6, ruby))
|
|
|
|
## prevent caching...
|
|
# root = TreeNode()
|
|
# root.appendchild(TextNode("12"))
|
|
# root.appendchild(ruby.dup()
|
|
# .appendchild(meta.dup()
|
|
# .appendchild(TextNode("45"))
|
|
# .appendchild(field2.dup())))
|
|
# root.appendchild(TextNode("6789"))
|
|
# self.dotest(root, False)
|
|
|
|
xEnum = xMeta.createEnumeration()
|
|
self.assertIsNotNone("createEnumeration(): returns None", xEnum)
|
|
|
|
self.assertTrue(xEnum.hasMoreElements(),"hasNext(): first missing")
|
|
xPortion = xEnum.nextElement()
|
|
type_ = xPortion.TextPortionType
|
|
self.assertEqual("Text", type_, "first: not text")
|
|
txt = xPortion.getString()
|
|
self.assertEqual("45", txt, "first: text differs")
|
|
|
|
self.assertTrue(xEnum.hasMoreElements(),"hasNext(): second missing")
|
|
xPortion = xEnum.nextElement()
|
|
type_ = xPortion.TextPortionType
|
|
self.assertEqual("TextField", type_, "second: not text")
|
|
|
|
## no ruby end here!!!
|
|
self.assertFalse(xEnum.hasMoreElements(), "hasNext(): more elements?")
|
|
|
|
xMeta.dispose()
|
|
|
|
try:
|
|
xCursor = xMeta.createTextCursor()
|
|
self.assertIsNone(xCursor,
|
|
"createTextCursor(): succeeds on disposed object?")
|
|
except RuntimeException:
|
|
pass
|
|
|
|
# check that cursor move methods move to positions in the meta,
|
|
# but do not move to positions outside the meta.
|
|
def test_meta_xtextcursor(self):
|
|
xDoc = self.__class__.xDoc
|
|
inserter = RangeInserter(xDoc)
|
|
text = TextNode("Text. 12 More text here.")
|
|
inserter.insertrange(Range(0, 0, text))
|
|
met1 = MetaNode(self.mkid("id"))
|
|
xMeta = inserter.makemeta()
|
|
|
|
xDocText = xDoc.getText()
|
|
xDocTextCursor = xDocText.createTextCursor()
|
|
xDocTextCursor.goRight(7, False)
|
|
xDocTextCursor.goRight(2, True)
|
|
xDocText.insertTextContent(xDocTextCursor, xMeta, True)
|
|
xDocTextCursor.gotoStart(True)
|
|
|
|
xMeta.MetadataReference = met1.xmlid
|
|
xStart = xMeta.getStart()
|
|
self.assertIsNotNone(xStart, "getStart(): no start")
|
|
xEnd = xMeta.getEnd()
|
|
self.assertIsNotNone(xEnd, "getEnd(): no end")
|
|
|
|
## XTextCursor
|
|
xMetaCursor = xMeta.createTextCursor()
|
|
self.assertIsNotNone(xMetaCursor, "createTextCursor(): no cursor")
|
|
xMetaCursor.gotoStart(False)
|
|
xMetaCursor.gotoEnd(False)
|
|
bSuccess = xMetaCursor.goLeft(1, False)
|
|
self.assertTrue(bSuccess, "goLeft(): failed")
|
|
bSuccess = xMetaCursor.goLeft(1000, False)
|
|
self.assertFalse(bSuccess, "goLeft(): succeeded")
|
|
bSuccess = xMetaCursor.goRight(1, False)
|
|
self.assertTrue(bSuccess, "goRight(): failed")
|
|
bSuccess = xMetaCursor.goRight(1000, False)
|
|
self.assertFalse(bSuccess, "goRight(): succeeded")
|
|
xMetaCursor.gotoRange(xStart, False)
|
|
xMetaCursor.gotoRange(xEnd, False)
|
|
try:
|
|
xMetaCursor.gotoRange(xDocTextCursor, False)
|
|
self.fail("gotoRange(): succeeded")
|
|
except RuntimeException:
|
|
pass
|
|
|
|
## XWordCursor
|
|
xMeta.setString("Two words")
|
|
xMetaCursor.gotoStart(False)
|
|
|
|
bSuccess = xMetaCursor.gotoNextWord(True) # at start of "words"
|
|
self.assertTrue(bSuccess, "gotoNextWord(): failed")
|
|
|
|
string = xMetaCursor.getString()
|
|
self.assertEqual("Two ", string, "gotoNextWord(): wrong string")
|
|
|
|
bSuccess = xMetaCursor.gotoNextWord(False) # at end of "words", cannot leave metafield
|
|
self.assertFalse(bSuccess,"gotoNextWord(): succeeded")
|
|
xMetaCursor.collapseToEnd()
|
|
bSuccess = xMetaCursor.gotoPreviousWord(True) # at start of "words"
|
|
self.assertTrue(bSuccess, "gotoPreviousWord(): failed")
|
|
|
|
string = xMetaCursor.getString()
|
|
self.assertEqual("words", string, "gotoPreviousWord(): wrong string")
|
|
|
|
bSuccess = xMetaCursor.gotoPreviousWord(False) # at start of "Two"
|
|
self.assertTrue(bSuccess, "gotoPreviousWord(): failed")
|
|
|
|
bSuccess = xMetaCursor.gotoPreviousWord(False) # cannot leave metafield
|
|
self.assertFalse(bSuccess, "gotoPreviousWord(): succeeded")
|
|
|
|
bSuccess = xMetaCursor.gotoEndOfWord(True) # at end of "Two"
|
|
self.assertTrue(bSuccess, "gotoEndOfWord(): failed")
|
|
|
|
string = xMetaCursor.getString()
|
|
self.assertEqual("Two", string, "gotoEndOfWord(): wrong string")
|
|
|
|
xMetaCursor.gotoEnd(False)
|
|
bSuccess = xMetaCursor.gotoStartOfWord(True)
|
|
self.assertTrue(bSuccess, "gotoStartOfWord(): failed")
|
|
|
|
string = xMetaCursor.getString()
|
|
self.assertEqual("words", string, "gotoStartOfWord(): wrong string")
|
|
|
|
xMeta.setString("")
|
|
bSuccess = xMetaCursor.gotoEndOfWord(False)
|
|
self.assertFalse(bSuccess, "gotoEndOfWord(): succeeded")
|
|
bSuccess = xMetaCursor.gotoStartOfWord(False)
|
|
self.assertFalse(bSuccess, "gotoStartOfWord(): succeeded")
|
|
|
|
## XSentenceCursor
|
|
xMeta.setString("This is a sentence. Another sentence.")
|
|
xMetaCursor.gotoStart(False)
|
|
|
|
bSuccess = xMetaCursor.gotoNextSentence(True)
|
|
self.assertTrue(bSuccess,"gotoNextSentence(): failed")
|
|
|
|
string = xMetaCursor.getString()
|
|
self.assertEqual("This is a sentence. ", string,
|
|
"gotoNextSentence(): wrong string")
|
|
|
|
bSuccess = xMetaCursor.gotoNextSentence(False)
|
|
self.assertFalse(bSuccess, "gotoNextSentence(): succeeded")
|
|
## FIXME:
|
|
## the sentence cursor seems to work differently than the word cursor
|
|
xMeta.setString("This is a sentence. Another sentence. Sentence 3.")
|
|
xMetaCursor.gotoEnd(False)
|
|
bSuccess = xMetaCursor.gotoPreviousSentence(True)
|
|
self.assertTrue(bSuccess, "gotoPreviousSentence(): failed")
|
|
|
|
string = xMetaCursor.getString()
|
|
self.assertEqual("Another sentence. Sentence 3.", string,
|
|
"gotoPreviousSentence(): wrong string")
|
|
|
|
bSuccess = xMetaCursor.gotoPreviousSentence(False)
|
|
self.assertFalse(bSuccess, "gotoPreviousSentence(): succeeded")
|
|
bSuccess = xMetaCursor.gotoEndOfSentence(True)
|
|
self.assertTrue(bSuccess, "gotoEndOfSentence(): failed")
|
|
|
|
string = xMetaCursor.getString()
|
|
self.assertEqual("This is a sentence.", string,
|
|
"gotoEndOfSentence(): wrong string")
|
|
|
|
xMetaCursor.gotoEnd(False)
|
|
bSuccess = xMetaCursor.gotoStartOfSentence(True)
|
|
self.assertTrue(bSuccess,"gotoStartOfSentence(): failed")
|
|
|
|
string = xMetaCursor.getString()
|
|
self.assertEqual("Sentence 3.", string,
|
|
"gotoStartOfSentence(): wrong string")
|
|
|
|
xMeta.setString("")
|
|
bSuccess = xMetaCursor.gotoEndOfSentence(False)
|
|
self.assertFalse(bSuccess, "gotoEndOfSentence(): succeeded")
|
|
bSuccess = xMetaCursor.gotoStartOfSentence(False)
|
|
self.assertFalse(bSuccess, "gotoStartOfSentence(): succeeded")
|
|
|
|
## XParagraphCursor (does not make sense)
|
|
bSuccess = xMetaCursor.gotoNextParagraph(False)
|
|
self.assertFalse(bSuccess, "gotoNextParagraph(): succeeded")
|
|
bSuccess = xMetaCursor.gotoPreviousParagraph(False)
|
|
self.assertFalse(bSuccess, "gotoPreviousParagraph(): succeeded")
|
|
bSuccess = xMetaCursor.gotoStartOfParagraph(False)
|
|
self.assertFalse(bSuccess, "gotoStartOfParagraph(): succeeded")
|
|
bSuccess = xMetaCursor.gotoEndOfParagraph(False)
|
|
self.assertFalse(bSuccess, "gotoEndOfParagraph(): succeeded")
|
|
|
|
# See https://bugs.libreoffice.org/show_bug.cgi?id=49629
|
|
# ensure that gotoEndOfWord does not fail when footnote is at word end
|
|
def test_xtextcursor(self):
|
|
xDoc = self.__class__.xDoc
|
|
inserter = RangeInserter(xDoc)
|
|
xDocText = xDoc.getText()
|
|
xDocTextCursor = xDocText.createTextCursor()
|
|
xDocTextCursor.gotoNextParagraph(False)
|
|
inserter.inserttext(xDocTextCursor, "Text")
|
|
xDocTextCursor.gotoEndOfWord(False)
|
|
inserter.insertfootnote(xDocTextCursor, "footnote")
|
|
xDocTextCursor.gotoStartOfParagraph(False)
|
|
bSuccess = xDocTextCursor.gotoEndOfWord(True)
|
|
self.assertTrue(bSuccess, "gotoEndOfWord(): failed")
|
|
string = xDocTextCursor.getString()
|
|
self.assertEqual("Text", string, "gotoEndOfWord(): wrong string")
|
|
self.assertNotEqual("a","b")
|
|
|
|
class AttachHelper():
|
|
def isattribute(self): pass
|
|
def mktreenode(self): pass
|
|
def mktextcontent(self, inserter, node): pass
|
|
def postinserted(self, node, xContent): pass
|
|
|
|
def test_meta_xtextattach_toxmark(self):
|
|
class Helper(self.AttachHelper):
|
|
def isattribute(_):
|
|
return True
|
|
def mktreenode(_):
|
|
return DocumentIndexMarkNode(self.mkname("toxmark"))
|
|
def mktextcontent(_, inserter, node):
|
|
return inserter.makedocumentindexmark(node.name)
|
|
self.do_meta_xtextattach(Helper())
|
|
|
|
def test_meta_xtextattach_refmark(self):
|
|
class Helper(self.AttachHelper):
|
|
def isattribute(_):
|
|
return True
|
|
def mktreenode(_):
|
|
return ReferenceMarkNode(self.mkname("refmark"))
|
|
def mktextcontent(_, inserter, node):
|
|
return inserter.makereferencemark(node.name)
|
|
self.do_meta_xtextattach(Helper())
|
|
|
|
def test_meta_xtextattach_textfield(self):
|
|
class Helper(self.AttachHelper):
|
|
def isattribute(_):
|
|
return False
|
|
def mktreenode(_):
|
|
return TextFieldNode(self.mkname("field"))
|
|
def mktextcontent(_, inserter, node):
|
|
return inserter.maketextfield(node.content)
|
|
self.do_meta_xtextattach(Helper())
|
|
|
|
def test_meta_xtextattach_footnote(self):
|
|
class Helper(self.AttachHelper):
|
|
def isattribute(_):
|
|
return False
|
|
def mktreenode(_):
|
|
return FootnoteNode(self.mkname("ftn"))
|
|
def mktextcontent(_, inserter, node):
|
|
return inserter.makefootnote(node.label)
|
|
self.do_meta_xtextattach(Helper())
|
|
|
|
def test_meta_xtextattach_meta(self):
|
|
class Helper(self.AttachHelper):
|
|
def isattribute(_):
|
|
return True
|
|
def mktreenode(_):
|
|
return MetaNode(self.mkid("id"))
|
|
def mktextcontent(_, inserter, node):
|
|
return inserter.makemeta()
|
|
def postinserted(_, node, xContent):
|
|
xContent.MetadataReference = node.xmlid
|
|
self.do_meta_xtextattach(Helper())
|
|
|
|
def do_meta_xtextattach(self, helper):
|
|
xDoc = self.__class__.xDoc
|
|
inserter = RangeInserter(xDoc)
|
|
text = TextNode("12AB6789")
|
|
inserter.insertrange(Range(0, 0, text))
|
|
met1 = MetaNode(self.mkid("id"))
|
|
xMeta = inserter.makemeta()
|
|
|
|
xDocText = xDoc.getText()
|
|
xDocTextCursor = xDocText.createTextCursor()
|
|
xDocTextCursor.goRight(3, False)
|
|
xDocTextCursor.goRight(2, True)
|
|
xDocText.insertTextContent(xDocTextCursor, xMeta, True)
|
|
|
|
xMeta.MetadataReference = met1.xmlid
|
|
xStart = None
|
|
xEnd = None
|
|
|
|
xStart = xMeta.getStart()
|
|
xEnd = xMeta.getEnd()
|
|
|
|
nod1 = helper.mktreenode()
|
|
nod2 = helper.mktreenode()
|
|
xContent1 = helper.mktextcontent(inserter, nod1)
|
|
xContent2 = helper.mktextcontent(inserter, nod2)
|
|
|
|
## insertTextContent with meta getStart()/getEnd()
|
|
xMeta.insertTextContent(xStart, xContent1, False)
|
|
xMeta.insertTextContent(xEnd, xContent2, False)
|
|
|
|
helper.postinserted(nod1, xContent1)
|
|
helper.postinserted(nod2, xContent2)
|
|
|
|
root = TreeNode()
|
|
root.appendchild(TextNode("12"))
|
|
root.appendchild(met1.dup()
|
|
.appendchild(nod1.dup())
|
|
.appendchild(TextNode("AB"))
|
|
.appendchild(nod2.dup()))
|
|
root.appendchild(TextNode("6789"))
|
|
self.dotest(root, False)
|
|
|
|
xMeta.setString("AB")
|
|
xStart = xMeta.getStart()
|
|
xEnd = xMeta.getEnd()
|
|
|
|
nod1 = helper.mktreenode()
|
|
nod2 = helper.mktreenode()
|
|
xContent1 = helper.mktextcontent(inserter, nod1)
|
|
xContent2 = helper.mktextcontent(inserter, nod2)
|
|
|
|
xTextCursor = xMeta.createTextCursor()
|
|
xTextCursor.gotoStart(False)
|
|
|
|
## insertTextContent with meta cursor
|
|
xMeta.insertTextContent(xTextCursor, xContent1, False)
|
|
xTextCursor.gotoEnd(False)
|
|
xMeta.insertTextContent(xTextCursor, xContent2, False)
|
|
|
|
helper.postinserted(nod1, xContent1)
|
|
helper.postinserted(nod2, xContent2)
|
|
|
|
root = TreeNode()
|
|
root.appendchild(TextNode("12"))
|
|
root.appendchild(met1.dup()
|
|
.appendchild(nod1.dup())
|
|
.appendchild(TextNode("AB"))
|
|
.appendchild(nod2.dup()))
|
|
root.appendchild(TextNode("6789"))
|
|
self.dotest(root, False)
|
|
|
|
if not helper.isattribute():
|
|
# xMeta.setString("AB")
|
|
xStart = xMeta.getStart()
|
|
xEnd = xMeta.getEnd()
|
|
|
|
nod1 = helper.mktreenode()
|
|
nod2 = helper.mktreenode()
|
|
xContent1 = helper.mktextcontent(inserter, nod1)
|
|
xContent2 = helper.mktextcontent(inserter, nod2)
|
|
|
|
xTextCursor = xMeta.createTextCursor()
|
|
xTextCursor.gotoStart(False)
|
|
xTextCursor.goRight(1, True)
|
|
|
|
## insertTextContent with meta cursor and absorb
|
|
xMeta.insertTextContent(xTextCursor, xContent1, True)
|
|
xTextCursor.gotoEnd(False)
|
|
xTextCursor.goLeft(1, True)
|
|
xMeta.insertTextContent(xTextCursor, xContent2, True)
|
|
|
|
helper.postinserted(nod1, xContent1)
|
|
helper.postinserted(nod2, xContent2)
|
|
|
|
root = TreeNode()
|
|
root.appendchild(TextNode("12"))
|
|
root.appendchild(met1.dup()
|
|
.appendchild(nod1.dup())
|
|
.appendchild(TextNode("AB"))
|
|
.appendchild(nod2.dup()))
|
|
root.appendchild(TextNode("6789"))
|
|
self.dotest(root, False)
|
|
|
|
xMeta.setString("AB")
|
|
xStart = xMeta.getStart()
|
|
xEnd = xMeta.getEnd()
|
|
|
|
nod1 = helper.mktreenode()
|
|
nod2 = helper.mktreenode()
|
|
xContent1 = helper.mktextcontent(inserter, nod1)
|
|
xContent2 = helper.mktextcontent(inserter, nod2)
|
|
|
|
xDocTextCursor.gotoRange(xStart, False)
|
|
|
|
## insertTextContent with document cursor
|
|
xMeta.insertTextContent(xDocTextCursor, xContent1, False)
|
|
xDocTextCursor.gotoRange(xEnd, False)
|
|
xMeta.insertTextContent(xDocTextCursor, xContent2, False)
|
|
|
|
helper.postinserted(nod1, xContent1)
|
|
helper.postinserted(nod2, xContent2)
|
|
|
|
root = TreeNode()
|
|
root.appendchild(TextNode("12"))
|
|
root.appendchild(met1.dup()
|
|
.appendchild(nod1.dup())
|
|
.appendchild(TextNode("AB"))
|
|
.appendchild(nod2.dup()))
|
|
root.appendchild(TextNode("6789"))
|
|
self.dotest(root, False)
|
|
|
|
if not helper.isattribute():
|
|
xStart = xMeta.getStart()
|
|
xEnd = xMeta.getEnd()
|
|
|
|
nod1 = helper.mktreenode()
|
|
nod2 = helper.mktreenode()
|
|
xContent1 = helper.mktextcontent(inserter, nod1)
|
|
xContent2 = helper.mktextcontent(inserter, nod2)
|
|
|
|
xDocTextCursor.gotoRange(xStart, False)
|
|
xDocTextCursor.goRight(1, True)
|
|
|
|
## insertTextContent with document cursor and absorb
|
|
xMeta.insertTextContent(xDocTextCursor, xContent1, True)
|
|
xDocTextCursor.gotoRange(xEnd, False)
|
|
xDocTextCursor.goLeft(1, True)
|
|
xMeta.insertTextContent(xDocTextCursor, xContent2, True)
|
|
|
|
helper.postinserted(nod1, xContent1)
|
|
helper.postinserted(nod2, xContent2)
|
|
|
|
root = TreeNode()
|
|
root.appendchild(TextNode("12"))
|
|
root.appendchild(met1.dup()
|
|
.appendchild(nod1.dup())
|
|
.appendchild(TextNode("AB"))
|
|
.appendchild(nod2.dup()))
|
|
root.appendchild(TextNode("6789"))
|
|
self.dotest(root, False)
|
|
|
|
xMeta.setString("AB")
|
|
xStart = xMeta.getStart()
|
|
xEnd = xMeta.getEnd()
|
|
|
|
nod1 = helper.mktreenode()
|
|
nod2 = helper.mktreenode()
|
|
xContent1 = helper.mktextcontent(inserter, nod1)
|
|
xContent2 = helper.mktextcontent(inserter, nod2)
|
|
|
|
## attach to range from meta getStart()/getEnd()
|
|
xContent1.attach(xStart)
|
|
xContent2.attach(xEnd)
|
|
|
|
helper.postinserted(nod1, xContent1)
|
|
helper.postinserted(nod2, xContent2)
|
|
|
|
root = TreeNode()
|
|
root.appendchild(TextNode("12"))
|
|
root.appendchild(met1.dup()
|
|
.appendchild(nod1.dup())
|
|
.appendchild(TextNode("AB"))
|
|
.appendchild(nod2.dup()))
|
|
root.appendchild(TextNode("6789"))
|
|
self.dotest(root, False)
|
|
|
|
xMeta.setString("AB")
|
|
xStart = xMeta.getStart()
|
|
xEnd = xMeta.getEnd()
|
|
|
|
nod1 = helper.mktreenode()
|
|
nod2 = helper.mktreenode()
|
|
xContent1 = helper.mktextcontent(inserter, nod1)
|
|
xContent2 = helper.mktextcontent(inserter, nod2)
|
|
|
|
xTextCursor = xMeta.createTextCursor()
|
|
xTextCursor.gotoStart(False)
|
|
|
|
## attach to cursor from meta XText
|
|
xContent1.attach(xTextCursor)
|
|
xTextCursor.gotoEnd(False)
|
|
xContent2.attach(xTextCursor)
|
|
|
|
helper.postinserted(nod1, xContent1)
|
|
helper.postinserted(nod2, xContent2)
|
|
|
|
root = TreeNode()
|
|
root.appendchild(TextNode("12"))
|
|
root.appendchild(met1.dup()
|
|
.appendchild(nod1.dup())
|
|
.appendchild(TextNode("AB"))
|
|
.appendchild(nod2.dup()))
|
|
root.appendchild(TextNode("6789"))
|
|
self.dotest(root, False)
|
|
|
|
def test_metafield_xtextfield(self):
|
|
xDoc = self.__class__.xDoc
|
|
smgr = self.__class__._uno.xContext.ServiceManager
|
|
xRepo = xDoc.getRDFRepository()
|
|
## for testing just add it to the first graph
|
|
Graphs = xRepo.getGraphNames()
|
|
xGraph = xRepo.getGraph(Graphs[0])
|
|
xOdfPrefix = smgr.createInstance("com.sun.star.rdf.URI")
|
|
xOdfPrefix.initialize((ODF_PREFIX,))
|
|
xOdfSuffix = smgr.createInstance("com.sun.star.rdf.URI")
|
|
xOdfSuffix.initialize((ODF_SUFFIX,))
|
|
|
|
xPrefix = smgr.createInstance("com.sun.star.rdf.Literal")
|
|
xPrefix.initialize(("foo",))
|
|
xSuffix = smgr.createInstance("com.sun.star.rdf.Literal")
|
|
xSuffix.initialize(("bar",))
|
|
|
|
inserter = RangeInserter(xDoc)
|
|
text = TextNode("abc")
|
|
inserter.insertrange(Range(0, 0, text))
|
|
xDocText = xDoc.getText()
|
|
xDocTextCursor = xDocText.createTextCursor()
|
|
xDocTextCursor.goRight(1, False)
|
|
xDocTextCursor.goRight(3, True)
|
|
|
|
xMetaField = inserter.makemetafield()
|
|
|
|
xDocText.insertTextContent(xDocTextCursor, xMetaField, True)
|
|
|
|
xMetaField.ensureMetadataReference
|
|
|
|
xGraph.addStatement(xMetaField, xOdfPrefix, xPrefix)
|
|
xGraph.addStatement(xMetaField, xOdfSuffix, xSuffix)
|
|
self.assertEqual("fooabcbar", xMetaField.getPresentation(False),
|
|
"getPresentation(): wrong")
|
|
inserter.insertrange(Range(0, 0, text))
|
|
|
|
def test_metafield_xpropertyset(self):
|
|
xDoc = self.__class__.xDoc
|
|
inserter = RangeInserter(xDoc)
|
|
text = TextNode("123")
|
|
inserter.insertrange(Range(0, 0, text))
|
|
xDocText = xDoc.getText()
|
|
xDocTextCursor = xDocText.createTextCursor()
|
|
xDocTextCursor.goRight(1, False)
|
|
xDocTextCursor.goRight(3, True)
|
|
|
|
xMetaField = inserter.makemetafield()
|
|
|
|
xDocText.insertTextContent(xDocTextCursor, xMetaField, True)
|
|
|
|
self.assertIsNotNone(xMetaField, "PropertySet: not supported?")
|
|
xPropertySetInfo = xMetaField.getPropertySetInfo()
|
|
self.assertTrue(xPropertySetInfo.hasPropertyByName("NumberFormat"),
|
|
'hasPropertyByName("NumberFormat"):')
|
|
self.assertTrue(xPropertySetInfo.hasPropertyByName("IsFixedLanguage"),
|
|
'hasPropertyByName("IsFixedLanguage"):')
|
|
|
|
def_ = xMetaField.NumberFormat
|
|
print("NumberFormat: default is {}".format(def_))
|
|
xMetaField.NumberFormat = NUMBER_INT
|
|
xMetaField.IsFixedLanguage = True
|
|
format = xMetaField.NumberFormat
|
|
self.assertEqual(NUMBER_INT, format, "NumberFormat: failed")
|
|
isfixed = xMetaField.IsFixedLanguage
|
|
self.assertTrue(isfixed, "IsFixedLanguage: failed")
|
|
|
|
def dostore(self, xComp, file):
|
|
print("Storing test document...")
|
|
file = uno.systemPathToFileUrl(file)
|
|
xComp.storeToURL(file, ())
|
|
print("...done")
|
|
|
|
def doload(self, file):
|
|
xComp = None
|
|
print("Loading test document...")
|
|
xComp = self.__class__._uno.openDocFromAbsolutePath(file)
|
|
self.assertIsNotNone(xComp, "cannot load: {}".format(file))
|
|
print("...done")
|
|
return xComp
|
|
|
|
def close(self, i_comp):
|
|
try:
|
|
if i_comp:
|
|
i_comp.close(True)
|
|
except Exception:
|
|
pass
|
|
|
|
def test_load_store(self):
|
|
xComp = None
|
|
filename = "TESTMETA.odt"
|
|
try:
|
|
xComp = self.__class__._uno.openDocFromTDOC(filename)
|
|
if xComp:
|
|
self.checkloadmeta(xComp)
|
|
with TemporaryDirectory() as tempdir:
|
|
file = os.path.join(tempdir, filename)
|
|
self.dostore(xComp, file)
|
|
self.close(xComp)
|
|
xComp2 = None
|
|
try:
|
|
xComp2 = self.doload(file)
|
|
self.checkloadmeta(xComp2)
|
|
finally:
|
|
self.close(xComp2)
|
|
finally:
|
|
self.close(xComp)
|
|
|
|
def checkloadmeta(self, xTextDoc):
|
|
print("Checking meta(-field)s in loaded test document...")
|
|
root = TreeNode()
|
|
root.appendchild(RubyNode("ruby1")
|
|
.appendchild(TextNode("1")))
|
|
root.appendchild(MetaNode(self.mkid_("id1"))
|
|
.appendchild(TextNode("2")))
|
|
root.appendchild(MetaFieldNode(self.mkid_("id2"))
|
|
.appendchild(TextNode("3")))
|
|
root.appendchild(RubyNode("ruby2")
|
|
.appendchild(MetaNode(self.mkid_("id3"))
|
|
.appendchild(TextNode("4"))))
|
|
root.appendchild(RubyNode("ruby3")
|
|
.appendchild(MetaFieldNode(self.mkid_("id4"))
|
|
.appendchild(TextNode("5"))))
|
|
root.appendchild(MetaNode(self.mkid_("id5"))
|
|
.appendchild(RubyNode("ruby4")
|
|
.appendchild(TextNode("6"))))
|
|
root.appendchild(MetaFieldNode(self.mkid_("id6"))
|
|
.appendchild(RubyNode("ruby5")
|
|
.appendchild(TextNode("7"))))
|
|
root.appendchild(MetaNode(self.mkid_("id7"))
|
|
.appendchild(MetaNode(self.mkid_("id8"))
|
|
.appendchild(TextNode("8"))))
|
|
root.appendchild(MetaNode(self.mkid_("id9"))
|
|
.appendchild(MetaFieldNode(self.mkid_("id10"))
|
|
.appendchild(TextNode("9"))))
|
|
root.appendchild(MetaFieldNode(self.mkid_("id11"))
|
|
.appendchild(MetaNode(self.mkid_("id12"))
|
|
.appendchild(TextNode("10"))))
|
|
root.appendchild(MetaFieldNode(self.mkid_("id13"))
|
|
.appendchild(MetaFieldNode(self.mkid_("id14"))
|
|
.appendchild(TextNode("11"))))
|
|
root.appendchild(MetaNode(self.mkid_("id15"))
|
|
.appendchild(RubyNode("ruby6")
|
|
.appendchild(MetaFieldNode(self.mkid_("id16"))
|
|
.appendchild(TextNode("12")))))
|
|
|
|
class MetaNode_(MetaNode):
|
|
def __init__(self, id):
|
|
super().__init__(id)
|
|
def __eq__(self, other):
|
|
return isinstance(other, MetaNode)
|
|
root.appendchild(MetaNode_(self.mkid_(""))
|
|
.appendchild(TextNode("13")))
|
|
root.appendchild(TextNode(" X X "))
|
|
self._dotest(xTextDoc, root, False)
|
|
print("...done")
|
|
|
|
def test_load_store_xmlid(self):
|
|
xComp = None
|
|
filename = "TESTXMLID.odt"
|
|
try:
|
|
xComp = self.__class__._uno.openDocFromTDOC(filename)
|
|
if xComp:
|
|
self.checkloadxmlid(xComp)
|
|
with TemporaryDirectory() as tempdir:
|
|
file = os.path.join(tempdir, filename)
|
|
self.dostore(xComp, file)
|
|
self.close(xComp)
|
|
xComp2 = None
|
|
try:
|
|
xComp2 = self.doload(file)
|
|
self.checkloadxmlid(xComp2)
|
|
finally:
|
|
self.close(xComp2)
|
|
finally:
|
|
self.close(xComp)
|
|
|
|
def checkloadxmlid(self, xTextDoc):
|
|
xRepo = xTextDoc.getRDFRepository()
|
|
|
|
print("Checking bookmarks in loaded test document...")
|
|
xBookmarks = xTextDoc.getBookmarks()
|
|
xMark1 = xBookmarks["mk1"]
|
|
self.assertTrue(self.eq(xMark1.MetadataReference,
|
|
StringPair("content.xml", "id90")), "mark1")
|
|
xMark2 = xBookmarks["mk2"]
|
|
result = xRepo.getStatementRDFa(xMark2)
|
|
self.assertTrue(len(result.First) == 1 and
|
|
result.First[0].Subject.StringValue == "uri:foo" and
|
|
result.First[0].Predicate.StringValue == "uri:bar" and
|
|
result.First[0].Object.Value == "a fooish bar",
|
|
"mark2")
|
|
xMark3 = xBookmarks["mk3"]
|
|
self.assertTrue(self.eq(xMark3.MetadataReference,
|
|
StringPair("content.xml", "id91")), "mark3")
|
|
print("...done")
|
|
|
|
print("Checking sections in loaded test document...")
|
|
xSections = xTextDoc.getTextSections()
|
|
xSection1 = xSections["Section 1"]
|
|
self.assertTrue(self.eq(xSection1.MetadataReference,
|
|
StringPair("content.xml", "idSection1")), "idsection1")
|
|
xSection2 = xSections["Section 2"]
|
|
self.assertTrue(self.eq(xSection2.MetadataReference,
|
|
StringPair("content.xml", "idSection2")),"idSection2")
|
|
xSection3 = xSections["Table of Contents1_Head"]
|
|
self.assertTrue(self.eq(xSection3.MetadataReference,
|
|
StringPair("content.xml", "idTOCTitle")), "idTOCTitle")
|
|
xSection4 = xSections["Alphabetical Index1_Head"]
|
|
self.assertTrue(self.eq(xSection4.MetadataReference,
|
|
StringPair("content.xml", "idAITitle")), "idAITitle")
|
|
xSection5 = xSections["Illustration Index1_Head"]
|
|
self.assertTrue(self.eq(xSection5.MetadataReference,
|
|
StringPair("content.xml", "idIITitle")), "idIITitle")
|
|
xSection6 = xSections["Index of Tables1_Head"]
|
|
self.assertTrue(self.eq(xSection6.MetadataReference,
|
|
StringPair("content.xml", "idIOTTitle")), "idIOTTitle")
|
|
xSection7 = xSections["User-Defined1_Head"]
|
|
self.assertTrue(self.eq(xSection7.MetadataReference,
|
|
StringPair("content.xml", "idUDTitle")), "idUDTitle")
|
|
xSection8 = xSections["Table of Objects1_Head"]
|
|
self.assertTrue(self.eq(xSection8.MetadataReference,
|
|
StringPair("content.xml", "idTOOTitle")), "idTOOTitle")
|
|
xSection9 = xSections["Bibliography1_Head"]
|
|
self.assertTrue(self.eq(xSection9.MetadataReference,
|
|
StringPair("content.xml", "idBibTitle")), "idBibTitle")
|
|
print("...done")
|
|
|
|
print("Checking indexes in loaded test document...")
|
|
xIndexes = xTextDoc.getDocumentIndexes()
|
|
xIndex1 = xIndexes["Table of Contents1"]
|
|
self.assertTrue(self.eq(xIndex1.MetadataReference,
|
|
StringPair("content.xml", "idTOC")), "idTOC")
|
|
xIndex1s = xSections["Table of Contents1"]
|
|
self.assertTrue(self.eq(xIndex1s.MetadataReference,
|
|
StringPair("content.xml", "idTOC")), "idTOC")
|
|
xIndex2 = xIndexes["Alphabetical Index1"]
|
|
self.assertTrue(self.eq(xIndex2.MetadataReference,
|
|
StringPair("content.xml", "idAI")), "idAI")
|
|
xIndex2s = xSections["Alphabetical Index1"]
|
|
self.assertTrue(self.eq(xIndex2s.MetadataReference,
|
|
StringPair("content.xml", "idAI")), "idAI")
|
|
xIndex3 = xIndexes["Illustration Index1"]
|
|
self.assertTrue(self.eq(xIndex3.MetadataReference,
|
|
StringPair("content.xml", "idII")), "idII")
|
|
xIndex3s = xSections["Table of Figures1"]
|
|
self.assertTrue(self.eq(xIndex3s.MetadataReference,
|
|
StringPair("content.xml", "idII")), "idII")
|
|
xIndex4 = xIndexes["Index of Tables1"]
|
|
self.assertTrue(self.eq(xIndex4.MetadataReference,
|
|
StringPair("content.xml", "idIOT")), "idIOT")
|
|
xIndex4s = xSections["Index of Tables1"]
|
|
self.assertTrue(self.eq(xIndex4s.MetadataReference,
|
|
StringPair("content.xml", "idIOT")), "idIOT")
|
|
xIndex5 = xIndexes["User-Defined1"]
|
|
self.assertTrue(self.eq(xIndex5.MetadataReference,
|
|
StringPair("content.xml", "idUD")), "idUD")
|
|
xIndex5s = xSections["User-Defined Index1"] # User-Defined => User-Defined Index, tdf#161574
|
|
self.assertTrue(self.eq(xIndex5s.MetadataReference,
|
|
StringPair("content.xml", "idUD")), "idUD")
|
|
xIndex6 = xIndexes["Table of Objects1"]
|
|
self.assertTrue(self.eq(xIndex6.MetadataReference,
|
|
StringPair("content.xml", "idTOO")), "idTOO")
|
|
xIndex6s = xSections["Table of Objects1"]
|
|
self.assertTrue(self.eq(xIndex6s.MetadataReference,
|
|
StringPair("content.xml", "idTOO")), "idTOO")
|
|
xIndex7 = xIndexes["Bibliography1"]
|
|
self.assertTrue(self.eq(xIndex7.MetadataReference,
|
|
StringPair("content.xml", "idBib")), "idBib")
|
|
xIndex7s = xSections["Bibliography1"]
|
|
self.assertTrue(self.eq(xIndex7s.MetadataReference,
|
|
StringPair("content.xml", "idBib")), "idBib")
|
|
print("...done")
|
|
|
|
def dotest(self, intree, insert=True):
|
|
xDoc = self.__class__.xDoc
|
|
self._dotest(xDoc, intree, insert)
|
|
|
|
def _dotest(self, xDoc, intree, insert):
|
|
self._dumptree(intree, "I: ")
|
|
if insert:
|
|
TreeInserter(xDoc).inserttree(intree)
|
|
xText = xDoc.getText()
|
|
xTextEnum = xText.createEnumeration()
|
|
## skip to right paragraph
|
|
xTextEnum.nextElement() # skip first -- always empty!
|
|
xElement = xTextEnum.nextElement() # second contains test case
|
|
xEnum = xElement.createEnumeration()
|
|
outtree = EnumConverter().convert(xEnum)
|
|
self._dumptree(outtree, "O: ")
|
|
FuzzyTester().dotest(intree, outtree)
|
|
|
|
def _dumptree(self, tree, prefix):
|
|
print('{}{}'.format(prefix, str(tree)))
|
|
children = tree.createenumeration()
|
|
for node in children:
|
|
self._dumptree(node, "{} ".format(prefix))
|
|
|
|
def mkname(self, prefix):
|
|
self.__class__.count += 1
|
|
return "{}{}".format(prefix, self.__class__.count)
|
|
|
|
def mkid(self, prefix):
|
|
self.mkname(prefix)
|
|
return StringPair("content.xml", self.mkname(prefix))
|
|
|
|
def mkid_(self, id):
|
|
return StringPair("content.xml", id)
|
|
|
|
def eq(self, left, right):
|
|
return (left.First == right.First and
|
|
left.Second == right.Second)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|