| # 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. |
| |
| """Utilities for test code.""" |
| |
| from compiler.util import ir_data_utils |
| |
| |
| def proto_is_superset(proto, expected_values, path=""): |
| """Returns true if every value in expected_values is set in proto. |
| |
| This is intended to be used in assertTrue in a unit test, like so: |
| |
| self.assertTrue(*proto_is_superset(proto, expected)) |
| |
| Arguments: |
| proto: The proto to check. |
| expected_values: The reference proto. |
| path: The path to the elements being compared. Clients can generally leave |
| this at default. |
| |
| Returns: |
| A tuple; the first element is True if the fields set in proto are a strict |
| superset of the fields set in expected_values. The second element is an |
| informational string specifying the path of a value found in expected_values |
| but not in proto. |
| |
| Every atomic field that is set in expected_values must be set to the same |
| value in proto; every message field set in expected_values must have a |
| matching field in proto, such that proto_is_superset(proto.field, |
| expected_values.field) is true. |
| |
| For repeated fields in expected_values, each element in the expected_values |
| proto must have a corresponding element at the same index in proto; proto |
| may have additional elements. |
| """ |
| if path: |
| path += "." |
| for spec, expected_value in ir_data_utils.get_set_fields(expected_values): |
| name = spec.name |
| field_path = "{}{}".format(path, name) |
| value = getattr(proto, name) |
| if spec.is_dataclass: |
| if spec.is_sequence: |
| if len(expected_value) > len(value): |
| return False, "{}[{}] missing".format(field_path, |
| len(getattr(proto, name))) |
| for i in range(len(expected_value)): |
| result = proto_is_superset(value[i], expected_value[i], |
| "{}[{}]".format(field_path, i)) |
| if not result[0]: |
| return result |
| else: |
| if (expected_values.HasField(name) and |
| not proto.HasField(name)): |
| return False, "{} missing".format(field_path) |
| result = proto_is_superset(value, expected_value, field_path) |
| if not result[0]: |
| return result |
| else: |
| # Zero-length repeated fields and not-there repeated fields are "the |
| # same." |
| if (expected_value != value and |
| (not spec.is_sequence or |
| len(expected_value))): |
| if spec.is_sequence: |
| return False, "{} differs: found {}, expected {}".format( |
| field_path, list(value), list(expected_value)) |
| else: |
| return False, "{} differs: found {}, expected {}".format( |
| field_path, value, expected_value) |
| return True, "" |
| |
| |
| def dict_file_reader(file_dict): |
| """Returns a callable that retrieves entries from file_dict as files. |
| |
| This can be used to call glue.parse_emboss_file with file text declared |
| inline. |
| |
| Arguments: |
| file_dict: A dictionary from "file names" to "contents." |
| |
| Returns: |
| A callable that can be passed to glue.parse_emboss_file in place of the |
| "read" builtin. |
| """ |
| |
| def read(file_name): |
| try: |
| return file_dict[file_name], None |
| except KeyError: |
| return None, ["File '{}' not found.".format(file_name)] |
| |
| return read |