def testEndStringParsing(self):
        stream = 'some meaningful "spaced value1"'

        start = len('some meaningful ')
        self.assertTrue(StringValueParser.is_applicable(stream[start]), 'Should be parsable.')
        _, value, _ = StringValueParser.parse(start, stream)
        self.assertEqual(value, 'spaced value1')
Beispiel #2
0
    def testEndStringParsing(self):
        stream = 'some meaningful "spaced value1"'

        start = len('some meaningful ')
        self.assertTrue(StringValueParser.is_applicable(stream[start]),
                        'Should be parsable.')
        _, value, _ = StringValueParser.parse(start, stream)
        self.assertEqual(value, 'spaced value1')
    def testIncompleteStringParsing(self):
        stream = 'some meaningful "spaced .'

        start = len('some meaningful ')
        self.assertTrue(StringValueParser.is_applicable(stream[start]), 'Should be parsable.')
        try:
            StringValueParser.parse(start, stream)
            self.assertTrue(False, 'Parsing failure expected.')
        except content.ParseException:
            self.assertTrue(True)
Beispiel #4
0
    def testIncompleteStringParsing(self):
        stream = 'some meaningful "spaced .'

        start = len('some meaningful ')
        self.assertTrue(StringValueParser.is_applicable(stream[start]),
                        'Should be parsable.')
        try:
            StringValueParser.parse(start, stream)
            self.assertTrue(False, 'Parsing failure expected.')
        except content.ParseException:
            self.assertTrue(True)
    def testEscapedStringParsing(self):
        stream = 'some meaningful "spaced \\"value1" something else skippable ' \
                 '"double spaced value2" still more skip.'

        start = len('some meaningful ')
        self.assertTrue(StringValueParser.is_applicable(stream[start]), 'Should be parsable.')
        _, value, _ = StringValueParser.parse(start, stream)
        self.assertEqual(value, 'spaced \\"value1')

        start = len('some meaningful "spaced \\"value1" something else skippable ')
        self.assertTrue(StringValueParser.is_applicable(stream[start]), 'Should be parsable.')
        _, value, _ = StringValueParser.parse(start, stream)
        self.assertEqual(value, 'double spaced value2')

        start = len(stream) - 2
        self.assertFalse(StringValueParser.is_applicable(stream[start]), 'Should not be parsable.')
Beispiel #6
0
    def testEscapedStringParsing(self):
        stream = 'some meaningful "spaced \\"value1" something else skippable ' \
                 '"double spaced value2" still more skip.'

        start = len('some meaningful ')
        self.assertTrue(StringValueParser.is_applicable(stream[start]),
                        'Should be parsable.')
        _, value, _ = StringValueParser.parse(start, stream)
        self.assertEqual(value, 'spaced \\"value1')

        start = len(
            'some meaningful "spaced \\"value1" something else skippable ')
        self.assertTrue(StringValueParser.is_applicable(stream[start]),
                        'Should be parsable.')
        _, value, _ = StringValueParser.parse(start, stream)
        self.assertEqual(value, 'double spaced value2')

        start = len(stream) - 2
        self.assertFalse(StringValueParser.is_applicable(stream[start]),
                         'Should not be parsable.')
Beispiel #7
0
        self.assertTrue(DefaultParser.is_applicable(stream[start]),
                        'Should be parsable.')
        _, value, _ = DefaultParser.parse(start, stream)
        self.assertEqual(value, 'value2')

    def testEndStringParsing(self):
        stream = 'some meaningful value1'

        start = len('some meaningful ')
        self.assertTrue(DefaultParser.is_applicable(stream[start]),
                        'Should be parsable.')
        _, value, _ = DefaultParser.parse(start, stream)
        self.assertEqual(value, 'value1')


STR_DOUBLE_QUOTE_PARSER = StringValueParser(start='"', end='"', escape='\\')


class Test_DQ_StringValueParser(TestCase):
    def testStringParsing(self):
        stream = 'some meaningful "spaced value1" something else skippable "double spaced value2"' \
                 'still more skip.'

        start = len('some meaningful ')
        self.assertTrue(STR_DOUBLE_QUOTE_PARSER.is_applicable(stream[start]),
                        'Should be parsable.')
        _, value, _ = STR_DOUBLE_QUOTE_PARSER.parse(start, stream)
        self.assertEqual(value, 'spaced value1')

        start = len(
            'some meaningful "spaced value1" something else skippable ')