xref: /aosp_15_r20/external/emboss/compiler/util/test_util_test.py (revision 99e0aae7469b87d12f0ad23e61142c2d74c1ef70)

# 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 front_end.test_util."""

import unittest

from compiler.util import ir_data
from compiler.util import parser_types
from compiler.util import test_util


class ProtoIsSupersetTest(unittest.TestCase):
  """Tests for test_util.proto_is_superset."""

  def test_superset_extra_optional_field(self):
    self.assertEqual(
        (True, ""),
        test_util.proto_is_superset(
            ir_data.Structure(
                field=[ir_data.Field()],
                source_location=parser_types.parse_location("1:2-3:4")),
            ir_data.Structure(field=[ir_data.Field()])))

  def test_superset_extra_repeated_field(self):
    self.assertEqual(
        (True, ""),
        test_util.proto_is_superset(
            ir_data.Structure(
                field=[ir_data.Field(), ir_data.Field()],
                source_location=parser_types.parse_location("1:2-3:4")),
            ir_data.Structure(field=[ir_data.Field()])))

  def test_superset_missing_empty_repeated_field(self):
    self.assertEqual(
        (False, "field[0] missing"),
        test_util.proto_is_superset(
            ir_data.Structure(
                field=[],
                source_location=parser_types.parse_location("1:2-3:4")),
            ir_data.Structure(field=[ir_data.Field(), ir_data.Field()])))

  def test_superset_missing_empty_optional_field(self):
    self.assertEqual((False, "source_location missing"),
                     test_util.proto_is_superset(
                         ir_data.Structure(field=[]),
                         ir_data.Structure(source_location=ir_data.Location())))

  def test_array_element_differs(self):
    self.assertEqual(
        (False,
         "field[0].source_location.start.line differs: found 1, expected 2"),
        test_util.proto_is_superset(
            ir_data.Structure(
                field=[ir_data.Field(source_location=parser_types.parse_location(
                    "1:2-3:4"))]),
            ir_data.Structure(
                field=[ir_data.Field(source_location=parser_types.parse_location(
                    "2:2-3:4"))])))

  def test_equal(self):
    self.assertEqual(
        (True, ""),
        test_util.proto_is_superset(parser_types.parse_location("1:2-3:4"),
                                    parser_types.parse_location("1:2-3:4")))

  def test_superset_missing_optional_field(self):
    self.assertEqual(
        (False, "source_location missing"),
        test_util.proto_is_superset(
            ir_data.Structure(field=[ir_data.Field()]),
            ir_data.Structure(
                field=[ir_data.Field()],
                source_location=parser_types.parse_location("1:2-3:4"))))

  def test_optional_field_differs(self):
    self.assertEqual((False, "end.line differs: found 4, expected 3"),
                     test_util.proto_is_superset(
                         parser_types.parse_location("1:2-4:4"),
                         parser_types.parse_location("1:2-3:4")))

  def test_non_message_repeated_field_equal(self):
    self.assertEqual((True, ""),
                     test_util.proto_is_superset(
                         ir_data.CanonicalName(object_path=[]),
                         ir_data.CanonicalName(object_path=[])))

  def test_non_message_repeated_field_missing_element(self):
    self.assertEqual(
        (False, "object_path differs: found {none!r}, expected {a!r}".format(
            none=[],
            a=[u"a"])),
        test_util.proto_is_superset(
            ir_data.CanonicalName(object_path=[]),
            ir_data.CanonicalName(object_path=[u"a"])))

  def test_non_message_repeated_field_element_differs(self):
    self.assertEqual(
        (False, "object_path differs: found {aa!r}, expected {ab!r}".format(
            aa=[u"a", u"a"],
            ab=[u"a", u"b"])),
        test_util.proto_is_superset(
            ir_data.CanonicalName(object_path=[u"a", u"a"]),
            ir_data.CanonicalName(object_path=[u"a", u"b"])))

  def test_non_message_repeated_field_extra_element(self):
    # For repeated fields of int/bool/str values, the entire list is treated as
    # an atomic unit, and should be equal.
    self.assertEqual(
        (False,
         "object_path differs: found {!r}, expected {!r}".format(
             [u"a", u"a"], [u"a"])),
        test_util.proto_is_superset(
            ir_data.CanonicalName(object_path=["a", "a"]),
            ir_data.CanonicalName(object_path=["a"])))

  def test_non_message_repeated_field_no_expected_value(self):
    # When a repeated field is empty, it is the same as if it were entirely
    # missing -- there is no way to differentiate those two conditions.
    self.assertEqual((True, ""),
                     test_util.proto_is_superset(
                         ir_data.CanonicalName(object_path=["a", "a"]),
                         ir_data.CanonicalName(object_path=[])))


class DictFileReaderTest(unittest.TestCase):
  """Tests for dict_file_reader."""

  def test_empty_dict(self):
    reader = test_util.dict_file_reader({})
    self.assertEqual((None, ["File 'anything' not found."]), reader("anything"))
    self.assertEqual((None, ["File '' not found."]), reader(""))

  def test_one_element_dict(self):
    reader = test_util.dict_file_reader({"m": "abc"})
    self.assertEqual((None, ["File 'not_there' not found."]),
                     reader("not_there"))
    self.assertEqual((None, ["File '' not found."]), reader(""))
    self.assertEqual(("abc", None), reader("m"))

  def test_two_element_dict(self):
    reader = test_util.dict_file_reader({"m": "abc", "n": "def"})
    self.assertEqual((None, ["File 'not_there' not found."]),
                     reader("not_there"))
    self.assertEqual((None, ["File '' not found."]), reader(""))
    self.assertEqual(("abc", None), reader("m"))
    self.assertEqual(("def", None), reader("n"))

  def test_dict_with_empty_key(self):
    reader = test_util.dict_file_reader({"m": "abc", "": "def"})
    self.assertEqual((None, ["File 'not_there' not found."]),
                     reader("not_there"))
    self.assertEqual((None, ["File 'None' not found."]), reader(None))
    self.assertEqual(("abc", None), reader("m"))
    self.assertEqual(("def", None), reader(""))


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