cirq-core 1.5.0.dev20250403060241__py3-none-any.whl → 1.5.0.dev20250403142851__py3-none-any.whl

cirq/protocols/measurement_key_protocol_test.py

@@ -104,7 +104,7 @@ def test_is_measurement():
 
         @property
         def qubits(self):
-            return cirq.LineQubit.range(2)
+            return cirq.LineQubit.range(2)  # pragma: no cover
 
     assert not cirq.is_measurement(NotImplementedOperation())
 
@@ -123,27 +123,27 @@ def test_measurement_without_key():
 def test_non_measurement_with_key():
     class NonMeasurementGate(cirq.Gate):
         def _is_measurement_(self):
-            return False
+            return False  # pragma: no cover
 
         def _decompose_(self, qubits):
             # Decompose should not be called by `is_measurement`
-            assert False
+            assert False  # pragma: no cover
 
         def _measurement_key_name_(self):
             # `measurement_key_name`` should not be called by `is_measurement`
-            assert False
+            assert False  # pragma: no cover
 
         def _measurement_key_names_(self):
             # `measurement_key_names`` should not be called by `is_measurement`
-            assert False
+            assert False  # pragma: no cover
 
         def _measurement_key_obj_(self):
             # `measurement_key_obj`` should not be called by `is_measurement`
-            assert False
+            assert False  # pragma: no cover
 
         def _measurement_key_objs_(self):
             # `measurement_key_objs`` should not be called by `is_measurement`
-            assert False
+            assert False  # pragma: no cover
 
         def num_qubits(self) -> int:
             return 2  # pragma: no cover

cirq/protocols/unitary_protocol_test.py

@@ -286,7 +286,7 @@ def test_unitary_from_apply_unitary():
 
     class UnknownType:
         def _apply_unitary_(self, args):
-            assert False
+            assert False  # pragma: no cover
 
     class ApplyGateNotUnitary(cirq.Gate):
         def num_qubits(self):

cirq/qis/channels_test.py

@@ -51,15 +51,6 @@ def compute_choi(channel: cirq.SupportsKraus) -> np.ndarray:
     return c
 
 
-def compute_superoperator(channel: cirq.SupportsKraus) -> np.ndarray:
-    ks = cirq.kraus(channel)
-    d_out, d_in = ks[0].shape
-    m = np.zeros((d_out * d_out, d_in * d_in), dtype=np.complex128)
-    for k, e_in in enumerate(generate_standard_operator_basis(d_in, d_in)):
-        m[:, k] = np.reshape(apply_channel(channel, e_in), d_out * d_out)
-    return m
-
-
 @pytest.mark.parametrize(
     'kraus_operators, expected_choi',
     (

cirq/qis/measures.py

@@ -247,7 +247,8 @@ def _fidelity_state_vectors_or_density_matrices(state1: np.ndarray, state2: np.n
         eigs = linalg.eigvalsh(state1_sqrt @ state2 @ state1_sqrt)
         trace = np.sum(np.sqrt(np.abs(eigs)))
         return trace**2
-    raise ValueError(
+    # matrix is reshaped before this point
+    raise ValueError(  # pragma: no cover
         'The given arrays must be one- or two-dimensional. '
         f'Got shapes {state1.shape} and {state2.shape}.'
     )

cirq/qis/measures_test.py

@@ -34,6 +34,13 @@ def test_fidelity_symmetric():
     )
 
 
+def test_bad_fidelity():
+    arr = np.asarray([[[1j, 0], [0, 0]], [[0, 0], [0, 0]]])
+    assert arr.ndim > 2
+    assert arr.dtype.kind == 'c'
+    _ = cirq.fidelity(arr, arr)
+
+
 def test_fidelity_between_zero_and_one():
     assert 0 <= cirq.fidelity(VEC1, VEC2) <= 1
     assert 0 <= cirq.fidelity(VEC1, MAT1) <= 1

cirq/qis/states.py

@@ -845,7 +845,7 @@ def _qudit_values_to_state_tensor(
             )
 
     if state_vector.dtype.kind[0] not in '?bBiu':
-        raise ValueError(
+        raise ValueError(  # pragma: no cover
             f'Expected a bool or int entry for each qudit in '
             f'`state`, because len(state) == len(qid_shape), '
             f'but got dtype {state_vector.dtype}.'

cirq/sim/clifford/clifford_simulator.py

@@ -90,7 +90,8 @@ class CliffordSimulator(
             StabilizerChFormSimulationState for the circuit.
         """
         if isinstance(initial_state, clifford.StabilizerChFormSimulationState):
-            return initial_state
+            # Instances of SimulationStateBase usually returned before this point
+            return initial_state  # pragma: no cover
 
         return clifford.StabilizerChFormSimulationState(
             prng=self._prng,

cirq/sim/clifford/clifford_simulator_test.py

@@ -1,4 +1,16 @@
-# pylint: disable=wrong-or-nonexistent-copyright-notice
+# Copyright 2025 The Cirq Developers
+#
+# 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.
 import itertools
 
 import numpy as np
@@ -91,12 +103,17 @@ def test_simulate_initial_state():
                 circuit.append(cirq.X(q1))
             circuit.append(cirq.measure(q0, q1))
 
-            result = simulator.simulate(circuit, initial_state=1)
-            expected_state = np.zeros(shape=(2, 2))
-            expected_state[b0][1 - b1] = 1.0
-            np.testing.assert_almost_equal(
-                result.final_state.to_numpy(), np.reshape(expected_state, 4)
-            )
+            for initial_state in [
+                cirq.StabilizerChFormSimulationState(
+                    qubits=cirq.LineQubit.range(2), initial_state=1
+                )
+            ]:
+                result = simulator.simulate(circuit, initial_state=initial_state)
+                expected_state = np.zeros(shape=(2, 2))
+                expected_state[b0][1 - b1] = 1.0
+                np.testing.assert_almost_equal(
+                    result.final_state.to_numpy(), np.reshape(expected_state, 4)
+                )
 
 
 def test_simulation_state():
@@ -208,6 +225,8 @@ def test_clifford_state_initial_state():
     state = cirq.CliffordState(qubit_map={q0: 0}, initial_state=1)
     np.testing.assert_allclose(state.state_vector(), [0, 1])
 
+    assert state.copy() == state
+
 
 def test_clifford_trial_result_repr():
     q0 = cirq.LineQubit(0)
@@ -476,10 +495,10 @@ def test_is_supported_operation():
             raise NotImplementedError()
 
         def _has_unitary_(self):
-            return True
+            return True  # pragma: no cover
 
         def _unitary_(self):
-            assert False
+            assert False  # pragma: no cover
 
     q1, q2 = cirq.LineQubit.range(2)
     assert cirq.CliffordSimulator.is_supported_operation(cirq.X(q1))
@@ -548,6 +567,10 @@ def test_valid_apply_measurement():
     q0 = cirq.LineQubit(0)
     state = cirq.CliffordState(qubit_map={q0: 0}, initial_state=1)
     measurements = {}
+    _ = state.apply_measurement(
+        cirq.measure(q0), measurements, np.random.RandomState(), collapse_state_vector=False
+    )
+    assert measurements == {'q(0)': [1]}
     state.apply_measurement(cirq.measure(q0), measurements, np.random.RandomState())
     assert measurements == {'q(0)': [1]}
 

cirq/sim/density_matrix_simulator.py

@@ -168,7 +168,8 @@ class DensityMatrixSimulator(
             DensityMatrixSimulationState for the circuit.
         """
         if isinstance(initial_state, density_matrix_simulation_state.DensityMatrixSimulationState):
-            return initial_state
+            # Instances of SimulationStateBase usually returned before this point
+            return initial_state  # pragma: no cover
 
         return density_matrix_simulation_state.DensityMatrixSimulationState(
             qubits=qubits,

cirq/sim/density_matrix_simulator_test.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 import itertools
 import random
-from typing import Type
+from typing import Type, Union
 from unittest import mock
 
 import numpy as np
@@ -584,7 +584,15 @@ def test_simulate_qudit_increments(dtype: Type[np.complexfloating], split: bool)
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_simulate_initial_state(dtype: Type[np.complexfloating], split: bool):
+@pytest.mark.parametrize(
+    'initial_state',
+    [1, cirq.DensityMatrixSimulationState(initial_state=1, qubits=cirq.LineQubit.range(2))],
+)
+def test_simulate_initial_state(
+    dtype: Type[np.complexfloating],
+    split: bool,
+    initial_state: Union[int, cirq.DensityMatrixSimulationState],
+):
     q0, q1 = cirq.LineQubit.range(2)
     simulator = cirq.DensityMatrixSimulator(dtype=dtype, split_untangled_states=split)
     for b0 in [0, 1]:

cirq/sim/simulation_state.py

@@ -336,7 +336,7 @@ def strat_act_on_from_apply_decompose(
         curr_ancilla = tuple(q for q in operation.qubits if q not in args.qubits)
         args = args.add_qubits(curr_ancilla)
         if args is NotImplemented:
-            return NotImplemented
+            return NotImplemented  # pragma: no cover
         all_ancilla.update(curr_ancilla)
         protocols.act_on(operation, args)
     args = args.remove_qubits(tuple(all_ancilla))

cirq/sim/simulation_state_test.py

@@ -66,7 +66,7 @@ class DelegatingAncillaZ(cirq.Gate):
 
 class Composite(cirq.Gate):
     def num_qubits(self) -> int:
-        return 1
+        return 1  # pragma: no cover
 
     def _decompose_(self, qubits):
         yield cirq.X(*qubits)

cirq/sim/simulator_test.py

@@ -50,7 +50,7 @@ class FakeStepResult(cirq.StepResult):
         self._final_state = final_state
 
     def _simulator_state(self):
-        return self._final_state
+        return self._final_state  # pragma: no cover
 
     def state_vector(self):
         pass

cirq/sim/sparse_simulator.py

@@ -171,7 +171,8 @@ class Simulator(
             StateVectorSimulationState for the circuit.
         """
         if isinstance(initial_state, state_vector_simulation_state.StateVectorSimulationState):
-            return initial_state
+            # Instances of SimulationStateBase usually returned before this point
+            return initial_state  # pragma: no cover
 
         return state_vector_simulation_state.StateVectorSimulationState(
             qubits=qubits,

cirq/sim/sparse_simulator_test.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 import itertools
 import random
-from typing import Type
+from typing import Type, Union
 from unittest import mock
 
 import numpy as np
@@ -446,7 +446,15 @@ def test_simulate_bit_flips(dtype: Type[np.complexfloating], split: bool):
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_simulate_initial_state(dtype: Type[np.complexfloating], split: bool):
+@pytest.mark.parametrize(
+    'initial_state',
+    [1, cirq.StateVectorSimulationState(initial_state=1, qubits=cirq.LineQubit.range(2))],
+)
+def test_simulate_initial_state(
+    dtype: Type[np.complexfloating],
+    split: bool,
+    initial_state: Union[int, cirq.StateVectorSimulationState],
+):
     q0, q1 = cirq.LineQubit.range(2)
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split)
     for b0 in [0, 1]:

cirq/sim/state_vector_simulation_state_test.py

@@ -63,7 +63,7 @@ def test_shallow_copy_buffers():
 def test_decomposed_fallback():
     class Composite(cirq.Gate):
         def num_qubits(self) -> int:
-            return 1
+            return 1  # pragma: no cover
 
         def _decompose_(self, qubits):
             yield cirq.X(*qubits)

cirq/study/resolver.py

@@ -44,10 +44,6 @@ _NOT_FOUND = object()
 _RECURSION_FLAG = object()
 
 
-def _is_param_resolver_or_similar_type(obj: Any):
-    return obj is None or isinstance(obj, (ParamResolver, dict))
-
-
 class ParamResolver:
     """Resolves parameters to actual values.
 

cirq/study/resolver_test.py

@@ -84,7 +84,7 @@ def _assert_consistent_resolution(v, resolved):
 
         # note: super().subs() doesn't resolve based on the param_dict properly
         # for some reason, that's why a delegate (self.symbol) is used instead
-        def subs(self, *args, **kwargs):
+        def subs(self, *args, **kwargs):  # pragma: no cover
             self.called = True
             return self.symbol.subs(*args, **kwargs)
 
@@ -93,6 +93,7 @@ def _assert_consistent_resolution(v, resolved):
     # symbol based resolution
     s = SubsAwareSymbol('a')
     assert r.value_of(s) == resolved, f"expected {resolved}, got {r.value_of(s)}"
+    assert r[s] == resolved, f"expected {resolved}, got {r.value_of(s)}"
     assert not s.called, f"For pass-through type {type(v)} sympy.subs shouldn't have been called."
     assert isinstance(
         r.value_of(s), type(resolved)
@@ -183,6 +184,14 @@ def test_recursive_evaluation():
     assert sympy.Eq(r.value_of(e), 0)
 
 
+def test_resolution_of_unknown_formulas():
+    a = sympy.Symbol('a')
+    b = sympy.Symbol('b')
+
+    r = cirq.ParamResolver({a: b - 2})
+    assert r.value_of(sympy.sin(a), recursive=False) == sympy.sin(b - 2)
+
+
 def test_unbound_recursion_halted():
     a = sympy.Symbol('a')
     b = sympy.Symbol('b')

cirq/study/sweeps_test.py

@@ -111,7 +111,9 @@ def test_zip_longest_compatibility():
 
 
 def test_empty_zip():
+    assert len(cirq.Zip()) == 0
     assert len(cirq.ZipLongest()) == 0
+    assert str(cirq.Zip()) == 'Zip()'
     with pytest.raises(ValueError, match='non-empty'):
         _ = cirq.ZipLongest(cirq.Points('e', []), cirq.Points('a', [1, 2, 3]))
 
@@ -142,10 +144,26 @@ def test_product():
     assert _values(sweep, 'a') == [1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3]
     assert _values(sweep, 'b') == [4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7]
 
+    sweep = cirq.Points('a', [1, 2]) * (cirq.Points('b', [3, 4]) * cirq.Points('c', [5, 6]))
+    assert len(sweep) == 8
+    assert _values(sweep, 'a') == [1, 1, 1, 1, 2, 2, 2, 2]
+    assert _values(sweep, 'b') == [3, 3, 4, 4, 3, 3, 4, 4]
+    assert _values(sweep, 'c') == [5, 6, 5, 6, 5, 6, 5, 6]
+
+
+def test_zip_addition():
+    zip_sweep = cirq.Zip(cirq.Points('a', [1, 2]), cirq.Points('b', [3, 4]))
+    zip_sweep2 = cirq.Points('c', [5, 6]) + zip_sweep
+    assert len(zip_sweep2) == 2
+    assert _values(zip_sweep2, 'a') == [1, 2]
+    assert _values(zip_sweep2, 'b') == [3, 4]
+    assert _values(zip_sweep2, 'c') == [5, 6]
+
 
 def test_empty_product():
     sweep = cirq.Product()
     assert len(sweep) == len(list(sweep)) == 1
+    assert str(sweep) == 'Product()'
 
 
 def test_slice_access_error():

cirq/testing/circuit_compare_test.py

@@ -333,7 +333,7 @@ def test_assert_has_consistent_apply_unitary():
             return args.available_buffer
 
         def _unitary_(self):
-            return np.eye(2)
+            return np.eye(2)  # pragma: no cover
 
         def _num_qubits_(self):
             return 1
@@ -366,7 +366,7 @@ def test_assert_has_consistent_apply_unitary():
             return args.available_buffer
 
         def _unitary_(self):
-            return np.array([[0, 1], [1, 0]])
+            return np.array([[0, 1], [1, 0]])  # pragma: no cover
 
         def _num_qubits_(self):
             return 1
@@ -483,7 +483,7 @@ def test_assert_has_consistent_qid_shape():
 
     class ConsistentOp(cirq.Operation):
         def with_qubits(self, *qubits):
-            raise NotImplementedError  # pragma: no cover
+            raise NotImplementedError
 
         @property
         def qubits(self):
@@ -500,7 +500,7 @@ def test_assert_has_consistent_qid_shape():
     # the three methods before finding an inconsistency and throwing an error.
     class InconsistentOp1(cirq.Operation):
         def with_qubits(self, *qubits):
-            raise NotImplementedError  # pragma: no cover
+            raise NotImplementedError
 
         @property
         def qubits(self):
@@ -514,7 +514,7 @@ def test_assert_has_consistent_qid_shape():
 
     class InconsistentOp2(cirq.Operation):
         def with_qubits(self, *qubits):
-            raise NotImplementedError  # pragma: no cover
+            raise NotImplementedError
 
         @property
         def qubits(self):
@@ -528,7 +528,7 @@ def test_assert_has_consistent_qid_shape():
 
     class InconsistentOp3(cirq.Operation):
         def with_qubits(self, *qubits):
-            raise NotImplementedError  # pragma: no cover
+            raise NotImplementedError
 
         @property
         def qubits(self):

cirq/testing/consistent_pauli_expansion_test.py

@@ -32,7 +32,7 @@ class GoodGateExplicitPauliExpansion(cirq.testing.SingleQubitGate):
 
 class GoodGateNoPauliExpansion(cirq.Gate):
     def num_qubits(self) -> int:
-        return 4
+        return 4  # pragma: no cover
 
 
 class GoodGateNoUnitary(cirq.testing.SingleQubitGate):

cirq/testing/consistent_qasm.py

@@ -47,7 +47,7 @@ def assert_qasm_is_consistent_with_unitary(val: Any):
         qid_shape = protocols.qid_shape(val)
         remaining_shape = list(qid_shape)
         controls = getattr(val, 'control_qubits', None)
-        if controls is not None:
+        if controls is not None:  # pragma: no cover
             for i, q in zip(reversed(range(len(controls))), reversed(controls)):
                 if q is not None:
                     remaining_shape.pop(i)

cirq/testing/equals_tester.py

@@ -141,7 +141,7 @@ class _ClassUnknownToSubjects:
         return not self == other
 
     def __hash__(self):
-        return hash(_ClassUnknownToSubjects)
+        return hash(_ClassUnknownToSubjects)  # pragma: no cover
 
 
 class _TestsForNotImplemented:

cirq/testing/equals_tester_test.py

@@ -118,7 +118,7 @@ def test_fails_when_forgot_type_check():
             return not self == other
 
         def __hash__(self):
-            return hash(self.x)
+            return hash(self.x)  # pragma: no cover
 
     with pytest.raises(AttributeError, match="has no attribute 'x'"):
         eq.add_equality_group(NoTypeCheckEqualImplementation())
@@ -194,14 +194,14 @@ def test_fails_when_ne_is_inconsistent_due_to_not_implemented():
 
         def __eq__(self, other):
             if not isinstance(other, type(self)):
-                return NotImplemented
+                return NotImplemented  # pragma: no cover
             return self.x == other.x
 
         def __ne__(self, other):
             return NotImplemented
 
         def __hash__(self):
-            return hash(self.x)
+            return hash(self.x)  # pragma: no cover
 
     with pytest.raises(AssertionError, match='inconsistent'):
         eq.make_equality_group(InconsistentNeImplementation)
@@ -216,7 +216,7 @@ def test_fails_when_not_reflexive():
 
         def __eq__(self, other):
             if other is not self:
-                return NotImplemented
+                return NotImplemented  # pragma: no cover
             return False
 
         def __ne__(self, other):
@@ -235,7 +235,7 @@ def test_fails_when_not_commutative():
 
         def __eq__(self, other):
             if not isinstance(other, type(self)):
-                return NotImplemented
+                return NotImplemented  # pragma: no cover
             return self.x <= other.x
 
         def __ne__(self, other):

cirq/testing/gate_features_test.py

@@ -78,3 +78,8 @@ def test_three_qubit_gate_validate():
         g.validate_args([a, b])
     with pytest.raises(ValueError):
         g.validate_args([a, b, c, d])
+
+
+def test_does_not_support_serialization_gate():
+    g = cirq.testing.DoesNotSupportSerializationGate(n_qubits=4)
+    assert g.num_qubits() == 4

cirq/transformers/analytical_decompositions/two_qubit_to_sqrt_iswap.py

@@ -426,7 +426,7 @@ def _single_qubit_matrices_with_sqrt_iswap(
     for can_decompose, decomposer in decomposers:
         if can_decompose(kak.interaction_coefficients, weyl_tol=atol / 10):
             return decomposer(kak, atol)
-    assert False, 'The final can_decompose should always returns True'
+    assert False, 'The final can_decompose should always returns True'  # pragma: no cover
 
 
 def _in_0_region(

cirq/transformers/gauge_compiling/gauge_compiling_test_utils_test.py

@@ -31,7 +31,7 @@ class ExampleSweepGate(cirq.testing.TwoQubitGate):
     unitary = cirq.unitary(cirq.CZ)
 
     def _unitary_(self) -> np.ndarray:
-        return self.unitary
+        return self.unitary  # pragma: no cover
 
 
 _EXAMPLE_TARGET = ExampleGate()

cirq/transformers/qubit_management_transformers.py

@@ -169,7 +169,7 @@ def map_clean_and_borrowable_qubits(
                     # one from the original system qubits.
                     allocated_map[q] = qm.qborrow(1)[0]
             else:
-                assert False, f"Unknown temporary qubit type {q}"
+                assert False, f"Unknown temporary qubit type {q}"  # pragma: no cover
 
         # Return the transformed operation / decomposed op-tree.
         return op.transform_qubits({**allocated_map, **trivial_map})

cirq/transformers/transformer_api_test.py

@@ -257,6 +257,14 @@ def test_transformer_stats_logger_show_levels(capfd):
     assert all(line not in out for line in [info_line, debug_line, warning_line])
 
 
+def test_noop_logger():
+    logger = cirq.transformers.transformer_api.NoOpTransformerLogger()
+    logger.register_initial(cirq.Circuit(), "test")
+    logger.log("stuff")
+    logger.register_final(cirq.Circuit(), "test")
+    logger.show()
+
+
 def test_transformer_stats_logger_linear_and_nested(capfd):
     q = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(cirq.H.on_each(*q), cirq.CNOT(*q))

cirq/transformers/transformer_primitives_test.py

@@ -586,7 +586,7 @@ def test_merge_moments_empty_moment_as_intermediate_step():
 
 def test_merge_moments_empty_circuit():
     def fail_if_called_func(*_):
-        assert False
+        assert False  # pragma: no cover
 
     c = cirq.Circuit()
     assert cirq.merge_moments(c, fail_if_called_func) is c
@@ -601,7 +601,7 @@ def test_merge_operations_raises():
 
 def test_merge_operations_nothing_to_merge():
     def fail_if_called_func(*_):
-        assert False
+        assert False  # pragma: no cover
 
     # Empty Circuit.
     c = cirq.Circuit()

cirq/value/condition.py

@@ -239,7 +239,7 @@ class BitMaskKeyCondition(Condition):
 
     @property
     def qasm(self):
-        raise NotImplementedError()  # pragma: no cover
+        raise NotImplementedError()
 
 
 @dataclasses.dataclass(frozen=True)

cirq/value/duration.py

@@ -165,7 +165,7 @@ class Duration:
         if other_duration is not None:
             return self.total_picos() / other_duration.total_picos()
 
-        return NotImplemented
+        return NotImplemented  # pragma: no cover
 
     def __eq__(self, other):
         other = _attempt_duration_like_to_duration(other)

cirq/value/periodic_value_test.py

@@ -42,6 +42,11 @@ def test_periodic_value_approx_eq_basic():
     assert not cirq.approx_eq(cirq.PeriodicValue(1.0, 2.0), cirq.PeriodicValue(1.0, 2.2), atol=0.1)
     assert not cirq.approx_eq(cirq.PeriodicValue(1.0, 2.0), cirq.PeriodicValue(1.2, 2.2), atol=0.3)
     assert not cirq.approx_eq(cirq.PeriodicValue(1.0, 2.0), cirq.PeriodicValue(1.2, 2.2), atol=0.1)
+    assert cirq.approx_eq(
+        cirq.PeriodicValue(sympy.Symbol('t'), 2.0),
+        cirq.PeriodicValue(sympy.Symbol('t'), 2.0),
+        atol=0.1,
+    )
 
 
 def test_periodic_value_approx_eq_normalized():

cirq/value/value_equality_attr_test.py

@@ -94,7 +94,7 @@ class UnhashableD:
         self.x = x
 
     def _value_equality_values_(self):
-        return self.x
+        return self.x  # pragma: no cover
 
 
 class UnhashableCa(UnhashableC):

cirq/vis/heatmap_test.py

@@ -245,7 +245,7 @@ def test_non_float_values(ax, format_string):
     for artist in ax.get_children():
         if isinstance(artist, mpl.text.Text):
             col, row = artist.get_position()
-            if (row, col) in test_value_map:
+            if (row, col) in test_value_map:  # pragma: no cover
                 foo = test_value_map[(row, col)]
                 actual_text = artist.get_text()
                 expected_text = format(foo, format_string)

cirq/work/observable_settings.py

@@ -149,7 +149,8 @@ def _fix_precision(val: Union[value.Scalar, sympy.Expr], precision) -> Union[int
         raise ValueError(f'Cannot convert {val} to fixed precision in observable settings')
     if isinstance(val, (complex, numbers.Complex)):
         return int(val.real * precision), int(val.imag * precision)
-    return int(val * precision)
+    # Pretty much all numbers are instances of numbers.Complex
+    return int(val * precision)  # pragma: no cover
 
 
 def _hashable_param(