compiler/util/parser_types_test.py

# Copyright 2019 Google LLC
#
# Licensed 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
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""Tests for parser_types."""

import unittest
from compiler.util import ir_data
from compiler.util import parser_types


class PositionTest(unittest.TestCase):
    """Tests for Position-related functions in parser_types."""

    def test_format_position(self):
        self.assertEqual(
            "1:2", parser_types.format_position(ir_data.Position(line=1, column=2))
        )


class LocationTest(unittest.TestCase):
    """Tests for Location-related functions in parser_types."""

    def test_make_location(self):
        self.assertEqual(
            ir_data.Location(
                start=ir_data.Position(line=1, column=2),
                end=ir_data.Position(line=3, column=4),
                is_synthetic=False,
            ),
            parser_types.make_location((1, 2), (3, 4)),
        )
        self.assertEqual(
            ir_data.Location(
                start=ir_data.Position(line=1, column=2),
                end=ir_data.Position(line=3, column=4),
                is_synthetic=False,
            ),
            parser_types.make_location(
                ir_data.Position(line=1, column=2), ir_data.Position(line=3, column=4)
            ),
        )

    def test_make_synthetic_location(self):
        self.assertEqual(
            ir_data.Location(
                start=ir_data.Position(line=1, column=2),
                end=ir_data.Position(line=3, column=4),
                is_synthetic=True,
            ),
            parser_types.make_location((1, 2), (3, 4), True),
        )
        self.assertEqual(
            ir_data.Location(
                start=ir_data.Position(line=1, column=2),
                end=ir_data.Position(line=3, column=4),
                is_synthetic=True,
            ),
            parser_types.make_location(
                ir_data.Position(line=1, column=2),
                ir_data.Position(line=3, column=4),
                True,
            ),
        )

    def test_make_location_type_checks(self):
        self.assertRaises(ValueError, parser_types.make_location, [1, 2], (1, 2))
        self.assertRaises(ValueError, parser_types.make_location, (1, 2), [1, 2])

    def test_make_location_logic_checks(self):
        self.assertRaises(ValueError, parser_types.make_location, (3, 4), (1, 2))
        self.assertRaises(ValueError, parser_types.make_location, (1, 3), (1, 2))
        self.assertTrue(parser_types.make_location((1, 2), (1, 2)))

    def test_format_location(self):
        self.assertEqual(
            "1:2-3:4",
            parser_types.format_location(parser_types.make_location((1, 2), (3, 4))),
        )

    def test_parse_location(self):
        self.assertEqual(
            parser_types.make_location((1, 2), (3, 4)),
            parser_types.parse_location("1:2-3:4"),
        )
        self.assertEqual(
            parser_types.make_location((1, 2), (3, 4)),
            parser_types.parse_location("  1  :  2  -    3 :   4  "),
        )


class TokenTest(unittest.TestCase):
    """Tests for parser_types.Token."""

    def test_str(self):
        self.assertEqual(
            "FOO 'bar' 1:2-3:4",
            str(
                parser_types.Token(
                    "FOO", "bar", parser_types.make_location((1, 2), (3, 4))
                )
            ),
        )


class ProductionTest(unittest.TestCase):
    """Tests for parser_types.Production."""

    def test_parse(self):
        self.assertEqual(
            parser_types.Production(lhs="A", rhs=("B", "C")),
            parser_types.Production.parse("A -> B C"),
        )
        self.assertEqual(
            parser_types.Production(lhs="A", rhs=("B",)),
            parser_types.Production.parse("A -> B"),
        )
        self.assertEqual(
            parser_types.Production(lhs="A", rhs=("B", "C")),
            parser_types.Production.parse("  A   ->   B   C  "),
        )
        self.assertEqual(
            parser_types.Production(lhs="A", rhs=tuple()),
            parser_types.Production.parse("A ->"),
        )
        self.assertEqual(
            parser_types.Production(lhs="A", rhs=tuple()),
            parser_types.Production.parse("A ->  "),
        )
        self.assertEqual(
            parser_types.Production(lhs="FOO", rhs=('"B"', "x*")),
            parser_types.Production.parse('FOO -> "B" x*'),
        )
        self.assertRaises(SyntaxError, parser_types.Production.parse, "F-> A B")
        self.assertRaises(SyntaxError, parser_types.Production.parse, "F B -> A B")
        self.assertRaises(SyntaxError, parser_types.Production.parse, "-> A B")

    def test_str(self):
        self.assertEqual(
            str(parser_types.Production(lhs="A", rhs=("B", "C"))), "A -> B C"
        )
        self.assertEqual(str(parser_types.Production(lhs="A", rhs=("B",))), "A -> B")
        self.assertEqual(str(parser_types.Production(lhs="A", rhs=tuple())), "A -> ")
        self.assertEqual(
            str(parser_types.Production(lhs="FOO", rhs=('"B"', "x*"))), 'FOO -> "B" x*'
        )


if __name__ == "__main__":
    unittest.main()