def testGarbage(self):
gc.collect()
source = []
parser = _syck.Parser(source)
source.append(parser)
del source, parser
self.assertEqual(gc.collect(), 2)
class TestValuesAndSources(unittest.TestCase, EqualStructure):
def testValues1(self):
self._testValues(COMPARE1)
def testValues2(self):
self._testValues(COMPARE2)
def testValues3(self):
self._testValues(COMPARE3)
def testFileValues1(self):
self._testFileValues(COMPARE1)
def testFileValues2(self):
self._testFileValues(COMPARE2)
def testFileValues3(self):
self._testFileValues(COMPARE3)
def testNonsense(self):
parser = _syck.Parser(None)
self.assertRaises(AttributeError, lambda: parser.parse())
def testCallMeNot(self):
class Source:
def __init__(self):
self.parser = None
def read(self, size=None):
if self.parser:
self.parser.parse()
return
source = Source()
parser = _syck.Parser(source)
source.parser = parser
self.assertRaises(RuntimeError, lambda: parser.parse())
def testAbsoluteHorror(self):
class Source:
def __init__(self):
self.parser = None
def read(self, size=None):
if self.parser:
self.parser = None
return ''
source = Source()
parser = _syck.Parser(source)
source.parser = parser
del parser
self.assertEqual(None, source.parser.parse())
def _testValues(self, (source, structure)):
parser = _syck.Parser(source)
document = parser.parse()
self.assertEqualStructure(document, structure)
def testErrorLocation(self):
source, line, column = INVALID
parser = _syck.Parser(source)
try:
parser.parse()
raise Exception
except _syck.error, e:
self.assertEqual(e.args[1], line)
self.assertEqual(e.args[2], column)
def testSyckBugWithComplexKeys(self):
broken = 0
for key in COMPLEX_ITEMS:
for value in COMPLEX_ITEMS:
node = _syck.Map({key: value})
emitter = _syck.Emitter(StringIO.StringIO())
emitter.emit(node)
parser = _syck.Parser(emitter.output.getvalue())
self.assertEqual(strip(node), strip(parser.parse()))
def _testTyping(self, implicit_typing, taguri_expansion):
parser = _syck.Parser(IMPLICIT_TYPING[0], implicit_typing,
taguri_expansion)
for node, (tag, explicit) in zip(parser.parse().value,
IMPLICIT_TYPING[1]):
if tag is not None and taguri_expansion:
tag = 'tag:yaml.org,2002:%s' % tag
if implicit_typing or explicit:
self.assertEqual(node.tag, tag)
else:
self.assertEqual(node.tag, None)
def testDocuments(self):
emitter = _syck.Emitter(StringIO.StringIO())
emitter.emit(EXAMPLE)
emitter.emit(EXAMPLE)
emitter.emit(EXAMPLE)
parser = _syck.Parser(emitter.output.getvalue())
self.assertEqual(strip(EXAMPLE), strip(parser.parse()))
self.assertEqual(strip(EXAMPLE), strip(parser.parse()))
self.assertEqual(strip(EXAMPLE), strip(parser.parse()))
self.assert_(not parser.eof)
parser.parse()
self.assert_(parser.eof)
def testTags(self):
document = _syck.Seq()
for tag in TAGS:
document.value.append(_syck.Scalar('foo', tag=tag))
emitter = _syck.Emitter(StringIO.StringIO())
emitter.emit(document)
parser = _syck.Parser(emitter.output.getvalue())
document = parser.parse()
self.assertEqual(len(document.value), len(TAGS))
for index in range(len(document.value)):
node = document.value[index]
self.assertEqual(node.tag, TAGS[index])
def testCallMeNot(self):
class Source:
def __init__(self):
self.parser = None
def read(self, size=None):
if self.parser:
self.parser.parse()
return
source = Source()
parser = _syck.Parser(source)
source.parser = parser
self.assertRaises(RuntimeError, lambda: parser.parse())
def testAttributes(self):
parser = _syck.Parser(EXAMPLE)
self.assertEqual(type(parser), _syck.Parser)
self.assertEqual(parser.source, EXAMPLE)
self.assertEqual(parser.implicit_typing, True)
self.assertEqual(parser.taguri_expansion, True)
self.assertEqual(parser.eof, False)
node = parser.parse()
self.assert_(isinstance(node, _syck.Node))
self.assertEqual(parser.source, EXAMPLE)
self.assertEqual(parser.implicit_typing, True)
self.assertEqual(parser.taguri_expansion, True)
self.assertEqual(parser.eof, False)
self.assertEqual(parser.parse(), None)
self.assertEqual(parser.eof, True)
def _testDocuments(self, source, length):
parser = _syck.Parser(source)
actual_length = 0
while True:
document = parser.parse()
if parser.eof:
self.assertEqual(document, None)
break
actual_length += 1
self.assertEqual(actual_length, length)
self.assertEqual(parser.parse(), None)
self.assert_(parser.eof)
self.assertEqual(parser.parse(), None)
self.assert_(parser.eof)
self.assert_(parser.eof)
def testAbsoluteHorror(self):
class Source:
def __init__(self):
self.parser = None
def read(self, size=None):
if self.parser:
self.parser = None
return ''
source = Source()
parser = _syck.Parser(source)
source.parser = parser
del parser
self.assertEqual(None, source.parser.parse())
def testSyckBugWithTrailingSpace(self):
emitter = _syck.Emitter(StringIO.StringIO())
emitter.emit(_syck.Scalar('foo ', tag="tag:yaml.org,2002:str"))
parser = _syck.Parser(emitter.output.getvalue())
self.assertEqual(parser.parse().value, 'foo ')
def testAliases(self):
emitter = _syck.Emitter(StringIO.StringIO())
emitter.emit(ALIASES)
parser = _syck.Parser(emitter.output.getvalue())
node = parser.parse()
self.assert_(node.value[0] is node.value[1])
def testComplexExample(self):
emitter = _syck.Emitter(StringIO.StringIO())
emitter.emit(COMPLEX_EXAMPLE)
parser = _syck.Parser(emitter.output.getvalue())
node = parser.parse()
self.assertEqual(strip(COMPLEX_EXAMPLE), strip(node))
def testPairs(self):
emitter = _syck.Emitter(StringIO.StringIO())
emitter.emit(PAIRS)
parser = _syck.Parser(emitter.output.getvalue())
node = parser.parse()
self.assertEqual(strip(PAIRS), strip(node))
def testLeaks(self):
parser = _syck.Parser(LEAKS)
node = parser.parse()
dummy = []
self.checkLeaks(node, dummy)
def testAliases(self):
parser = _syck.Parser(ALIASES)
node = parser.parse()
self.assert_(node.value[0] is node.value[1])
def testRecursive(self):
parser = _syck.Parser(RECURSIVE)
self.assertRaises(TypeError, lambda: parser.parse())
def _testTree(self, tree):
emitter = _syck.Emitter(StringIO.StringIO())
emitter.emit(tree)
#print emitter.output.getvalue()
parser = _syck.Parser(emitter.output.getvalue())
self.assertEqual(strip(tree), strip(parser.parse()))
def testNonsense(self):
parser = _syck.Parser(None)
self.assertRaises(AttributeError, lambda: parser.parse())
def testError(self):
parser = _syck.Parser(INVALID[0])
self.assertRaises(_syck.error, lambda: parser.parse())
def testExplicitTyping(self):
parser = _syck.Parser(EXPLICIT_TYPING[0])
for node, tag in zip(parser.parse().value, EXPLICIT_TYPING[1]):
self.assertEqual(node.tag, tag)
self.parser = None
return ''
source = Source()
parser = _syck.Parser(source)
source.parser = parser
del parser
self.assertEqual(None, source.parser.parse())
def _testValues(self, (source, structure)):
parser = _syck.Parser(source)
document = parser.parse()
self.assertEqualStructure(document, structure)
def _testFileValues(self, (source, structure)):
parser = _syck.Parser(StringIO.StringIO(source))
document = parser.parse()
self.assertEqualStructure(document, structure)
class TestDocuments(unittest.TestCase):
def testDocuments0(self):
self._testDocuments(DOCUMENTS0, 0)
def testDocuments1(self):
self._testDocuments(DOCUMENTS1, 1)
def testDocuments2(self):
self._testDocuments(DOCUMENTS2, 2)
def testDocuments3(self):
