blob: 03109d5814dd189b3b902cd2f27364960136046c [file] [log] [blame]
# 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 public import ir_pb2
from 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_pb2.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_pb2.Location(start=ir_pb2.Position(line=1,
column=2),
end=ir_pb2.Position(line=3,
column=4),
is_synthetic=False),
parser_types.make_location((1, 2), (3, 4)))
self.assertEqual(
ir_pb2.Location(start=ir_pb2.Position(line=1,
column=2),
end=ir_pb2.Position(line=3,
column=4),
is_synthetic=False),
parser_types.make_location(ir_pb2.Position(line=1,
column=2),
ir_pb2.Position(line=3,
column=4)))
def test_make_synthetic_location(self):
self.assertEqual(
ir_pb2.Location(start=ir_pb2.Position(line=1, column=2),
end=ir_pb2.Position(line=3, column=4),
is_synthetic=True),
parser_types.make_location((1, 2), (3, 4), True))
self.assertEqual(
ir_pb2.Location(start=ir_pb2.Position(line=1, column=2),
end=ir_pb2.Position(line=3, column=4),
is_synthetic=True),
parser_types.make_location(ir_pb2.Position(line=1, column=2),
ir_pb2.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()