Add strict_type and numerical_precision option

Author: nkanazawa1989

test/base.py

@@ -75,7 +75,9 @@ def assertEqualExtended(
         self,
         first: Any,
         second: Any,
+        *,
         msg: Optional[str] = None,
+        strict_type: bool = False,
     ):
         """Extended equality assertion which covers Qiskit Experiments classes.
 
@@ -91,18 +93,30 @@ def assertEqualExtended(
             first: First object to compare.
             second: Second object to compare.
             msg: Optional. Custom error message issued when first and second object are not equal.
+            strict_type: Set True to enforce type check before comparison.
         """
         default_msg = f"{first} != {second}"
-        self.assertTrue(is_equivalent(first, second), msg=msg or default_msg)
 
-    def assertRoundTripSerializable(self, obj: Any, check_func: Optional[Callable] = None):
+        self.assertTrue(
+            is_equivalent(first, second, strict_type=strict_type),
+            msg=msg or default_msg,
+        )
+
+    def assertRoundTripSerializable(
+        self,
+        obj: Any,
+        *,
+        check_func: Optional[Callable] = None,
+        strict_type: bool = False,
+    ):
         """Assert that an object is round trip serializable.
 
         Args:
             obj: the object to be serialized.
             check_func: Optional, a custom function ``check_func(a, b) -> bool``
                 to check equality of the original object with the decoded
                 object. If None :meth:`.assertEqualExtended` is called.
+            strict_type: Set True to enforce type check before comparison.
         """
         try:
             encoded = json.dumps(obj, cls=ExperimentEncoder)
@@ -116,16 +130,23 @@ def assertRoundTripSerializable(self, obj: Any, check_func: Optional[Callable] =
         if check_func is not None:
             self.assertTrue(check_func(obj, decoded), msg=f"{obj} != {decoded}")
         else:
-            self.assertEqualExtended(obj, decoded)
+            self.assertEqualExtended(obj, decoded, strict_type=strict_type)
 
-    def assertRoundTripPickle(self, obj: Any, check_func: Optional[Callable] = None):
+    def assertRoundTripPickle(
+        self,
+        obj: Any,
+        *,
+        check_func: Optional[Callable] = None,
+        strict_type: bool = False,
+    ):
         """Assert that an object is round trip serializable using pickle module.
 
         Args:
             obj: the object to be serialized.
             check_func: Optional, a custom function ``check_func(a, b) -> bool``
                 to check equality of the original object with the decoded
                 object. If None :meth:`.assertEqualExtended` is called.
+            strict_type: Set True to enforce type check before comparison.
         """
         try:
             encoded = pickle.dumps(obj)
@@ -139,7 +160,7 @@ def assertRoundTripPickle(self, obj: Any, check_func: Optional[Callable] = None)
         if check_func is not None:
             self.assertTrue(check_func(obj, decoded), msg=f"{obj} != {decoded}")
         else:
-            self.assertEqualExtended(obj, decoded)
+            self.assertEqualExtended(obj, decoded, strict_type=strict_type)
 
     @classmethod
     @deprecate_func(

test/extended_equality.py

@@ -9,6 +9,9 @@
 # Any modifications or derivative works of this code must retain this
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
+
+# pylint: disable=unused-argument
+
 """
 Utility for checking equality of data of Qiskit Experiments class which doesn't
 officially implement the equality dunder method.
@@ -36,10 +39,54 @@
 from qiskit_experiments.visualization import BaseDrawer
 
 
-@multimethod
 def is_equivalent(
+    data1: Any,
+    data2: Any,
+    *,
+    strict_type: bool = True,
+    numerical_precision: float = 1e-8,
+) -> bool:
+    """Check if two input data are equivalent.
+
+    This function is used for custom equivalence evaluation only for unittest purpose.
+    Some third party class may not preserve equivalence after JSON round-trip with
+    Qiskit Experiments JSON Encoder/Decoder, or some Qiskit Experiments class doesn't
+    define the equality dunder method intentionally.
+
+    Args:
+        data1: First data to compare.
+        data2: Second data to compare.
+        strict_type: Set True to enforce type check before comparison. Note that serialization
+            and deserialization round-trip may not preserve data type.
+            If the data type doesn't matter and only behavioral equivalence is considered,
+            e.g. iterator with the same element; tuple vs list,
+            you can turn off this flag to relax the constraint for data type.
+        numerical_precision: Tolerance of difference between two real numbers.
+
+    Returns:
+        True when two objects are equivalent.
+    """
+    if strict_type and type(data1) is not type(data2):
+        return False
+    evaluated = _is_equivalent_dispatcher(
+        data1,
+        data2,
+        strict_type=strict_type,
+        numerical_precision=numerical_precision,
+    )
+    if not isinstance(evaluated, (bool, np.bool_)):
+        # When either one of input is numpy array type, it may broadcast equality check
+        # and return ndarray of dtype=bool. e.g. np.array([]) == 123
+        # The input values should not be equal in this case.
+        return False
+    return evaluated
+
+
+@multimethod
+def _is_equivalent_dispatcher(
     data1: object,
     data2: object,
+    **kwargs,
 ):
     """Equality check finally falls into this function."""
     if data1 is None and data2 is None:
@@ -50,33 +97,28 @@ def is_equivalent(
         return is_equivalent(
             data1.__dict__,
             data2.__dict__,
+            **kwargs,
         )
-    evaluated = data1 == data2
-    if not isinstance(evaluated, bool):
-        # When either one of input is numpy array type, it may broadcast equality check
-        # and return ndarray of dtype=bool. e.g. np.array([]) == 123
-        # The input values should not be equal in this case.
-        return False
+    return data1 == data2
 
-    # Return the outcome of native equivalence check.
-    return evaluated
 
-
-@is_equivalent.register
+@_is_equivalent_dispatcher.register
 def _check_dicts(
     data1: Union[dict, ThreadSafeOrderedDict],
     data2: Union[dict, ThreadSafeOrderedDict],
+    **kwargs,
 ):
     """Check equality of dictionary which may involve Qiskit Experiments classes."""
     if set(data1) != set(data2):
         return False
-    return all(is_equivalent(data1[k], data2[k]) for k in data1.keys())
+    return all(is_equivalent(data1[k], data2[k], **kwargs) for k in data1.keys())
 
 
-@is_equivalent.register
+@_is_equivalent_dispatcher.register
 def _check_floats(
     data1: Union[float, np.floating],
     data2: Union[float, np.floating],
+    **kwargs,
 ):
     """Check equality of float.
 
@@ -86,13 +128,18 @@ def _check_floats(
     if np.isnan(data1) and np.isnan(data2):
         # Special case
         return True
-    return float(data1) == float(data2)
+
+    precision = kwargs.get("numerical_precision", 0.0)
+    if precision == 0.0:
+        return float(data1) == float(data2)
+    return np.isclose(np.abs(data1-data2), 0.0, atol=precision)
 
 
-@is_equivalent.register
+@_is_equivalent_dispatcher.register
 def _check_integer(
     data1: Union[int, np.integer],
     data2: Union[int, np.integer],
+    **kwargs,
 ):
     """Check equality of integer.
 
@@ -101,59 +148,65 @@ def _check_integer(
     return int(data1) == int(data2)
 
 
-@is_equivalent.register
+@_is_equivalent_dispatcher.register
 def _check_sequences(
     data1: Union[list, tuple, np.ndarray, ThreadSafeList],
     data2: Union[list, tuple, np.ndarray, ThreadSafeList],
+    **kwargs,
 ):
     """Check equality of sequence."""
     if len(data1) != len(data2):
         return False
-    return all(is_equivalent(e1, e2) for e1, e2 in zip(data1, data2))
+    return all(is_equivalent(e1, e2, **kwargs) for e1, e2 in zip(data1, data2))
 
 
-@is_equivalent.register
+@_is_equivalent_dispatcher.register
 def _check_unordered_sequences(
     data1: set,
     data2: set,
+    **kwargs,
 ):
     """Check equality of sequence after sorting."""
     if len(data1) != len(data2):
         return False
-    return all(is_equivalent(e1, e2) for e1, e2 in zip(sorted(data1), sorted(data2)))
+    return all(is_equivalent(e1, e2, **kwargs) for e1, e2 in zip(sorted(data1), sorted(data2)))
 
 
-@is_equivalent.register
+@_is_equivalent_dispatcher.register
 def _check_ufloats(
     data1: uncertainties.UFloat,
     data2: uncertainties.UFloat,
+    **kwargs,
 ):
     """Check equality of UFloat instance. Correlations are ignored."""
-    return data1.n == data2.n and data1.s == data2.s
+    return is_equivalent(data1.n, data2.n, **kwargs) and is_equivalent(data1.s, data2.s, **kwargs)
 
 
-@is_equivalent.register
+@_is_equivalent_dispatcher.register
 def _check_lmfit_models(
     data1: Model,
     data2: Model,
+    **kwargs,
 ):
     """Check equality of LMFIT model."""
-    return is_equivalent(data1.dumps(), data2.dumps())
+    return is_equivalent(data1.dumps(), data2.dumps(), **kwargs)
 
 
-@is_equivalent.register
+@_is_equivalent_dispatcher.register
 def _check_dataprocessing_instances(
     data1: Union[DataAction, DataProcessor],
     data2: Union[DataAction, DataProcessor],
+    **kwargs,
 ):
     """Check equality of classes in the data_processing module."""
     return repr(data1) == repr(data2)
 
 
-@is_equivalent.register
+@_is_equivalent_dispatcher.register
 def _check_curvefit_results(
     data1: CurveFitResult,
     data2: CurveFitResult,
+    **kwargs,
 ):
     """Check equality of curve fit result."""
     return _check_all_attributes(
@@ -177,13 +230,15 @@ def _check_curvefit_results(
         ],
         data1=data1,
         data2=data2,
+        **kwargs,
     )
 
 
-@is_equivalent.register
+@_is_equivalent_dispatcher.register
 def _check_service_analysis_results(
     data1: AnalysisResult,
     data2: AnalysisResult,
+    **kwargs,
 ):
     """Check equality of AnalysisResult class which is payload for experiment service."""
     return _check_all_attributes(
@@ -203,22 +258,25 @@ def _check_service_analysis_results(
         ],
         data1=data1,
         data2=data2,
+        **kwargs,
     )
 
 
-@is_equivalent.register
+@_is_equivalent_dispatcher.register
 def _check_configurable_classes(
     data1: Union[BaseExperiment, BaseAnalysis, BaseDrawer],
     data2: Union[BaseExperiment, BaseAnalysis, BaseDrawer],
+    **kwargs,
 ):
     """Check equality of Qiskit Experiments class with config method."""
-    return is_equivalent(data1.config(), data2.config())
+    return is_equivalent(data1.config(), data2.config(), **kwargs)
 
 
-@is_equivalent.register
+@_is_equivalent_dispatcher.register
 def _check_experiment_data(
     data1: ExperimentData,
     data2: ExperimentData,
+    **kwargs,
 ):
     """Check equality of ExperimentData."""
     attributes_equiv = _check_all_attributes(
@@ -234,18 +292,22 @@ def _check_experiment_data(
         ],
         data1=data1,
         data2=data2,
+        **kwargs,
     )
     data_equiv = is_equivalent(
         data1.data(),
         data2.data(),
+        **kwargs,
     )
     analysis_results_equiv = is_equivalent(
         data1._analysis_results,
         data2._analysis_results,
+        **kwargs,
     )
     child_equiv = is_equivalent(
         data1.child_data(),
         data2.child_data(),
+        **kwargs,
     )
     return all([attributes_equiv, data_equiv, analysis_results_equiv, child_equiv])
 
@@ -254,6 +316,7 @@ def _check_all_attributes(
     attrs: List[str],
     data1: Any,
     data2: Any,
+    **kwargs,
 ):
     """Helper function to check all attributes."""
-    return all(is_equivalent(getattr(data1, att), getattr(data2, att)) for att in attrs)
+    return all(is_equivalent(getattr(data1, att), getattr(data2, att), **kwargs) for att in attrs)