cirq-core 1.6.0.dev20250509215532__py3-none-any.whl → 1.6.0.dev20250512192405__py3-none-any.whl

cirq/ops/uniform_superposition_gate_test.py

@@ -65,18 +65,18 @@ def test_incompatible_m_value_and_qubit_args(m: int, n: int) -> None:
             cirq.UniformSuperpositionGate(m, n)
 
 
-def test_repr():
+def test_repr() -> None:
     assert (
         repr(cirq.UniformSuperpositionGate(7, 3))
         == 'UniformSuperpositionGate(m_value=7, num_qubits=3)'
     )
 
 
-def test_uniform_superposition_gate_json_dict():
+def test_uniform_superposition_gate_json_dict() -> None:
     assert cirq.UniformSuperpositionGate(7, 3)._json_dict_() == {'m_value': 7, 'num_qubits': 3}
 
 
-def test_str():
+def test_str() -> None:
     assert (
         str(cirq.UniformSuperpositionGate(7, 3))
         == 'UniformSuperpositionGate(m_value=7, num_qubits=3)'

cirq/protocols/act_on_protocol_test.py

@@ -45,24 +45,24 @@ class ExampleSimulationState(cirq.SimulationState):
 op = cirq.X(cirq.LineQubit(0))
 
 
-def test_act_on_fallback_succeeds():
+def test_act_on_fallback_succeeds() -> None:
     state = ExampleSimulationState(fallback_result=True)
     cirq.act_on(op, state)
 
 
-def test_act_on_fallback_fails():
+def test_act_on_fallback_fails() -> None:
     state = ExampleSimulationState(fallback_result=NotImplemented)
     with pytest.raises(TypeError, match='Failed to act'):
         cirq.act_on(op, state)
 
 
-def test_act_on_fallback_errors():
+def test_act_on_fallback_errors() -> None:
     state = ExampleSimulationState(fallback_result=False)
     with pytest.raises(ValueError, match='_act_on_fallback_ must return True or NotImplemented'):
         cirq.act_on(op, state)
 
 
-def test_act_on_errors():
+def test_act_on_errors() -> None:
     class Op(cirq.Operation):
         @property
         def qubits(self) -> Tuple[cirq.Qid, ...]:  # type: ignore[empty-body]
@@ -79,7 +79,7 @@ def test_act_on_errors():
         cirq.act_on(Op(), state)
 
 
-def test_qubits_not_allowed_for_operations():
+def test_qubits_not_allowed_for_operations() -> None:
     class Op(cirq.Operation):
         @property
         def qubits(self) -> Tuple[cirq.Qid, ...]:  # type: ignore[empty-body]
@@ -95,7 +95,7 @@ def test_qubits_not_allowed_for_operations():
         cirq.act_on(Op(), state, qubits=[])
 
 
-def test_qubits_should_be_defined_for_operations():
+def test_qubits_should_be_defined_for_operations() -> None:
     state = ExampleSimulationState()
     with pytest.raises(ValueError, match='Calls to act_on should'):
         cirq.act_on(cirq.KrausChannel([np.array([[1, 0], [0, 0]])]), state, qubits=None)

cirq/protocols/circuit_diagram_info_protocol_test.py

@@ -18,7 +18,7 @@ import sympy
 import cirq
 
 
-def test_circuit_diagram_info_value_wrapping():
+def test_circuit_diagram_info_value_wrapping() -> None:
     single_info = cirq.CircuitDiagramInfo(('Single',))
 
     class ReturnInfo:
@@ -67,20 +67,20 @@ def test_circuit_diagram_info_value_wrapping():
     )
 
 
-def test_circuit_diagram_info_init():
+def test_circuit_diagram_info_init() -> None:
     assert cirq.CircuitDiagramInfo(['a', 'b']).wire_symbols == ('a', 'b')
 
 
-def test_circuit_diagram_info_validate():
+def test_circuit_diagram_info_validate() -> None:
     with pytest.raises(ValueError):
         _ = cirq.CircuitDiagramInfo('X')
 
 
-def test_circuit_diagram_info_repr():
+def test_circuit_diagram_info_repr() -> None:
     cirq.testing.assert_equivalent_repr(cirq.CircuitDiagramInfo(('X', 'Y'), 2))
 
 
-def test_circuit_diagram_info_eq():
+def test_circuit_diagram_info_eq() -> None:
     eq = cirq.testing.EqualsTester()
     eq.make_equality_group(lambda: cirq.CircuitDiagramInfo(('X',)))
     eq.add_equality_group(
@@ -92,7 +92,7 @@ def test_circuit_diagram_info_eq():
     eq.add_equality_group(cirq.CircuitDiagramInfo(('Z',), 3, auto_exponent_parens=False))
 
 
-def test_circuit_diagram_info_pass_fail():
+def test_circuit_diagram_info_pass_fail() -> None:
     class C:
         pass
 
@@ -115,14 +115,14 @@ def test_circuit_diagram_info_pass_fail():
     assert cirq.circuit_diagram_info(E()) == cirq.CircuitDiagramInfo(('X',))
 
 
-def test_controlled_1x1_matrixgate_diagram_error():
+def test_controlled_1x1_matrixgate_diagram_error() -> None:
     q = cirq.LineQubit(0)
     g = cirq.MatrixGate(np.array([[1j]])).controlled()
     c = cirq.Circuit(g(q))
     assert str(c) == "0: ───C[[0.+1.j]]───"
 
 
-def test_circuit_diagram_info_args_eq():
+def test_circuit_diagram_info_args_eq() -> None:
     eq = cirq.testing.EqualsTester()
     eq.add_equality_group(cirq.CircuitDiagramInfoArgs.UNINFORMED_DEFAULT)
     eq.add_equality_group(
@@ -192,7 +192,7 @@ def test_circuit_diagram_info_args_eq():
     )
 
 
-def test_circuit_diagram_info_args_repr():
+def test_circuit_diagram_info_args_repr() -> None:
     cirq.testing.assert_equivalent_repr(
         cirq.CircuitDiagramInfoArgs(
             known_qubits=cirq.LineQubit.range(2),
@@ -206,7 +206,7 @@ def test_circuit_diagram_info_args_repr():
     )
 
 
-def test_format_real():
+def test_format_real() -> None:
     args = cirq.CircuitDiagramInfoArgs.UNINFORMED_DEFAULT.copy()
     assert args.format_real(1) == '1'
     assert args.format_real(1.1) == '1.1'
@@ -227,7 +227,7 @@ def test_format_real():
     assert args.format_real(sympy.Symbol('t') * 2 + 1) == '2*t + 1'
 
 
-def test_format_complex():
+def test_format_complex() -> None:
     args = cirq.CircuitDiagramInfoArgs.UNINFORMED_DEFAULT.copy()
     assert args.format_complex(1) == '1+0i'
     assert args.format_complex(1.1) == '1.1+0i'
@@ -250,7 +250,7 @@ def test_format_complex():
     assert args.format_complex(sympy.Symbol('t') * 2 + 1) == '2*t + 1'
 
 
-def test_format_radians_without_precision():
+def test_format_radians_without_precision() -> None:
     args = cirq.CircuitDiagramInfoArgs(
         known_qubits=None,
         known_qubit_count=None,
@@ -278,7 +278,7 @@ def test_format_radians_without_precision():
     assert args.format_radians(sympy.Symbol('t') * 2 + 1) == '2*t + 1'
 
 
-def test_format_radians_with_precision():
+def test_format_radians_with_precision() -> None:
     args = cirq.CircuitDiagramInfoArgs(
         known_qubits=None,
         known_qubit_count=None,

cirq/protocols/control_key_protocol_test.py

@@ -15,7 +15,7 @@
 import cirq
 
 
-def test_control_key():
+def test_control_key() -> None:
     class Named:
         def _control_keys_(self):
             return frozenset([cirq.MeasurementKey('key')])

cirq/protocols/decompose_protocol_test.py

@@ -64,7 +64,7 @@ class DecomposeQuditGate:
         yield cirq.identity_each(*qids)
 
 
-def test_decompose_once():
+def test_decompose_once() -> None:
     # No default value results in descriptive error.
     with pytest.raises(TypeError, match='no _decompose_with_context_ or _decompose_ method'):
         _ = cirq.decompose_once(NoMethod())
@@ -91,7 +91,7 @@ def test_decompose_once():
     ]
 
 
-def test_decompose_once_with_qubits():
+def test_decompose_once_with_qubits() -> None:
     qs = cirq.LineQubit.range(3)
 
     # No default value results in descriptive error.
@@ -137,7 +137,7 @@ def test_decompose_once_with_qubits():
     ) == list(cirq.X.on_each(*qs)) + list(cirq.Y.on_each(*qs))
 
 
-def test_decompose_general():
+def test_decompose_general() -> None:
     a, b, c = cirq.LineQubit.range(3)
     no_method = NoMethod()
     assert cirq.decompose(no_method) == [no_method]
@@ -152,7 +152,7 @@ def test_decompose_general():
     )
 
 
-def test_decompose_keep():
+def test_decompose_keep() -> None:
     a, b = cirq.LineQubit.range(2)
 
     # Recursion can be stopped.
@@ -180,7 +180,7 @@ def test_decompose_keep():
     assert cirq.decompose([[[cirq.SWAP(a, b)]]], keep=lambda _: True) == [cirq.SWAP(a, b)]
 
 
-def test_decompose_on_stuck_raise():
+def test_decompose_on_stuck_raise() -> None:
     a, b = cirq.LineQubit.range(2)
     no_method = NoMethod()
 
@@ -210,7 +210,7 @@ def test_decompose_on_stuck_raise():
         assert cirq.decompose([], on_stuck_raise=TypeError('x'))
 
 
-def test_decompose_intercept():
+def test_decompose_intercept() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -247,7 +247,7 @@ def test_decompose_intercept():
     assert actual == [cirq.X(a), cirq.X(cirq.ops.CleanQubit(0)), cirq.X(b)]
 
 
-def test_decompose_preserving_structure():
+def test_decompose_preserving_structure() -> None:
     a, b = cirq.LineQubit.range(2)
     fc1 = cirq.FrozenCircuit(cirq.SWAP(a, b), cirq.FSimGate(0.1, 0.2).on(a, b))
     cop1_1 = cirq.CircuitOperation(fc1).with_tags('test_tag')
@@ -275,7 +275,7 @@ def test_decompose_preserving_structure():
 
 # Test both intercepting and fallback decomposers.
 @pytest.mark.parametrize('decompose_mode', ['intercept', 'fallback'])
-def test_decompose_preserving_structure_forwards_args(decompose_mode):
+def test_decompose_preserving_structure_forwards_args(decompose_mode) -> None:
     a, b = cirq.LineQubit.range(2)
     fc1 = cirq.FrozenCircuit(cirq.SWAP(a, b), cirq.FSimGate(0.1, 0.2).on(a, b))
     cop1_1 = cirq.CircuitOperation(fc1).with_tags('test_tag')
@@ -322,7 +322,7 @@ def test_decompose_preserving_structure_forwards_args(decompose_mode):
     assert actual == expected
 
 
-def test_decompose_tagged_operation():
+def test_decompose_tagged_operation() -> None:
     op = cirq.TaggedOperation(
         cirq.CircuitOperation(
             circuit=cirq.FrozenCircuit(
@@ -377,7 +377,7 @@ class RecursiveDecompose(cirq.Gate):
 
 
 @pytest.mark.parametrize('with_context', [True, False])
-def test_decompose_recursive_dfs(with_context: bool):
+def test_decompose_recursive_dfs(with_context: bool) -> None:
     expected_calls = [
         mock.call.qalloc(True),
         mock.call.qalloc(False),
@@ -426,7 +426,7 @@ class G2(cirq.Gate):
 
 
 @mock.patch('cirq.protocols.decompose_protocol._CONTEXT_COUNTER', itertools.count())
-def test_successive_decompose_once_succeed():
+def test_successive_decompose_once_succeed() -> None:
     op = G2()(cirq.NamedQubit('q'))
     d1 = cirq.decompose_once(op)
     d2 = cirq.decompose_once(d1[0])
@@ -438,7 +438,7 @@ def test_successive_decompose_once_succeed():
     ]
 
 
-def test_decompose_without_context_succeed():
+def test_decompose_without_context_succeed() -> None:
     op = G2()(cirq.NamedQubit('q'))
     assert cirq.decompose(op, keep=lambda op: op.gate is cirq.CNOT) == [
         cirq.CNOT(

cirq/protocols/equal_up_to_global_phase_protocol_test.py

@@ -16,7 +16,7 @@ import numpy as np
 import cirq
 
 
-def test_equal_up_to_global_phase_primitives():
+def test_equal_up_to_global_phase_primitives() -> None:
     assert cirq.equal_up_to_global_phase(1.0 + 1j, 1.0 + 1j, atol=1e-9)
     assert not cirq.equal_up_to_global_phase(2.0, 1.0 + 1j, atol=1e-9)
     assert cirq.equal_up_to_global_phase(1.0 + 1j, 1.0 - 1j, atol=1e-9)
@@ -34,7 +34,7 @@ def test_equal_up_to_global_phase_primitives():
     assert cirq.equal_up_to_global_phase(1.0 + 1e-10j, 1.0, atol=1e-15)
 
 
-def test_equal_up_to_global_numeric_iterables():
+def test_equal_up_to_global_numeric_iterables() -> None:
     assert cirq.equal_up_to_global_phase([], [], atol=1e-9)
     assert cirq.equal_up_to_global_phase([[]], [[]], atol=1e-9)
     assert cirq.equal_up_to_global_phase([1j, 1], [1j, 1], atol=1e-9)
@@ -49,7 +49,7 @@ def test_equal_up_to_global_numeric_iterables():
     assert not cirq.equal_up_to_global_phase((1j, 1), (1, 1j), atol=1e-09)
 
 
-def test_equal_up_to_global_numpy_array():
+def test_equal_up_to_global_numpy_array() -> None:
     assert cirq.equal_up_to_global_phase(
         np.asarray([1j, 1j]), np.asarray([1, 1], dtype=np.complex64)
     )
@@ -60,7 +60,7 @@ def test_equal_up_to_global_numpy_array():
     assert cirq.equal_up_to_global_phase(np.asarray([[]]), np.asarray([[]]))
 
 
-def test_equal_up_to_global_mixed_array_types():
+def test_equal_up_to_global_mixed_array_types() -> None:
     a = [1j, 1, -1j, -1]
     b = [-1, 1j, 1, -1j]
     c = [-1, 1, -1, 1]
@@ -108,7 +108,7 @@ class B:
         return cirq.equal_up_to_global_phase(self.val[0], other, atol=atol)
 
 
-def test_equal_up_to_global_phase_eq_supported():
+def test_equal_up_to_global_phase_eq_supported() -> None:
     assert cirq.equal_up_to_global_phase(A(0.1 + 0j), A(0.1j), atol=1e-2)
     assert not cirq.equal_up_to_global_phase(A(0.0 + 0j), A(0.1j), atol=0.0)
     assert not cirq.equal_up_to_global_phase(A(0.0 + 0j), 0.1j, atol=0.0)
@@ -120,7 +120,7 @@ def test_equal_up_to_global_phase_eq_supported():
     assert not cirq.equal_up_to_global_phase(1e-8j, B(0.0), atol=1e-10)
 
 
-def test_equal_up_to_global_phase_non_eigen_gates():
+def test_equal_up_to_global_phase_non_eigen_gates() -> None:
     gate1 = cirq.PhasedXPowGate(phase_exponent=1.5, exponent=1.0)
     gate2 = cirq.PhasedXPowGate(phase_exponent=0.5, exponent=1.0)
     assert cirq.equal_up_to_global_phase(gate1, gate2)

cirq/protocols/has_stabilizer_effect_protocol_test.py

@@ -105,7 +105,7 @@ class GateDecomposes(cirq.Gate):
         yield YesOp(*qubits)
 
 
-def test_inconclusive():
+def test_inconclusive() -> None:
     assert not cirq.has_stabilizer_effect(object())
     assert not cirq.has_stabilizer_effect('boo')
     assert not cirq.has_stabilizer_effect(cirq.testing.SingleQubitGate())
@@ -113,21 +113,21 @@ def test_inconclusive():
     assert not cirq.has_stabilizer_effect(NoOp())
 
 
-def test_via_has_stabilizer_effect_method():
+def test_via_has_stabilizer_effect_method() -> None:
     assert not cirq.has_stabilizer_effect(No1())
     assert not cirq.has_stabilizer_effect(No2())
     assert not cirq.has_stabilizer_effect(No3())
     assert cirq.has_stabilizer_effect(Yes())
 
 
-def test_via_gate_of_op():
+def test_via_gate_of_op() -> None:
     assert cirq.has_stabilizer_effect(YesOp())
     assert not cirq.has_stabilizer_effect(NoOp1())
     assert not cirq.has_stabilizer_effect(NoOp2())
     assert not cirq.has_stabilizer_effect(NoOp3())
 
 
-def test_via_unitary():
+def test_via_unitary() -> None:
     op1 = OpWithUnitary(np.array([[0, 1], [1, 0]]))
     assert cirq.has_stabilizer_effect(op1)
 
@@ -148,7 +148,7 @@ def test_via_unitary():
     assert not cirq.has_stabilizer_effect(cirq.CCZ)
 
 
-def test_via_decompose():
+def test_via_decompose() -> None:
     assert cirq.has_stabilizer_effect(cirq.Circuit(cirq.H.on_each(cirq.LineQubit.range(4))))
     assert not cirq.has_stabilizer_effect(cirq.Circuit(cirq.T.on_each(cirq.LineQubit.range(4))))
     assert not cirq.has_stabilizer_effect(

cirq/protocols/has_unitary_protocol_test.py

@@ -18,7 +18,7 @@ import pytest
 import cirq
 
 
-def test_inconclusive():
+def test_inconclusive() -> None:
     class No:
         pass
 
@@ -30,7 +30,7 @@ def test_inconclusive():
 @pytest.mark.parametrize(
     'measurement_gate', (cirq.MeasurementGate(1, 'a'), cirq.PauliMeasurementGate([cirq.X], 'a'))
 )
-def test_fail_fast_measure(measurement_gate):
+def test_fail_fast_measure(measurement_gate) -> None:
     assert not cirq.has_unitary(measurement_gate)
 
     qubit = cirq.NamedQubit('q0')
@@ -40,13 +40,13 @@ def test_fail_fast_measure(measurement_gate):
     assert not cirq.has_unitary(circuit)
 
 
-def test_fail_fast_measure_large_memory():
+def test_fail_fast_measure_large_memory() -> None:
     num_qubits = 100
     measurement_op = cirq.MeasurementGate(num_qubits, 'a').on(*cirq.LineQubit.range(num_qubits))
     assert not cirq.has_unitary(measurement_op)
 
 
-def test_via_unitary():
+def test_via_unitary() -> None:
     class No1:
         def _unitary_(self):
             return NotImplemented
@@ -65,7 +65,7 @@ def test_via_unitary():
     assert cirq.has_unitary(Yes(), allow_decompose=False)
 
 
-def test_via_apply_unitary():
+def test_via_apply_unitary() -> None:
     class No1(EmptyOp):
         def _apply_unitary_(self, args):
             return None
@@ -100,7 +100,7 @@ def test_via_apply_unitary():
     assert not cirq.has_unitary(No4())
 
 
-def test_via_decompose():
+def test_via_decompose() -> None:
     class Yes1:
         def _decompose_(self):
             return []
@@ -132,7 +132,7 @@ def test_via_decompose():
     assert not cirq.has_unitary(No1(), allow_decompose=False)
 
 
-def test_via_has_unitary():
+def test_via_has_unitary() -> None:
     class No1:
         def _has_unitary_(self):
             return NotImplemented
@@ -150,7 +150,7 @@ def test_via_has_unitary():
     assert cirq.has_unitary(Yes())
 
 
-def test_order():
+def test_order() -> None:
     class Yes1(EmptyOp):
         def _has_unitary_(self):
             return True

cirq/protocols/hash_from_pickle_test.py

@@ -105,7 +105,7 @@ def test_exclude_json_files_has_valid_entries() -> None:
         if _is_included(f"{abs_path}.json")
     ],
 )
-def test_hash_from_pickle(json_filename: str, pool: multiprocessing.pool.Pool):
+def test_hash_from_pickle(json_filename: str, pool: multiprocessing.pool.Pool) -> None:
     obj_local = _read_json(json_filename)
     if not isinstance(obj_local, Hashable):
         return

cirq/protocols/inverse_protocol_test.py

@@ -50,7 +50,7 @@ class IsIterable:
 @pytest.mark.parametrize(
     'val', (NoMethod(), 'text', object(), ReturnsNotImplemented(), [NoMethod(), 5])
 )
-def test_objects_with_no_inverse(val):
+def test_objects_with_no_inverse(val) -> None:
     with pytest.raises(TypeError, match="isn't invertible"):
         _ = cirq.inverse(val)
     assert cirq.inverse(val, None) is None
@@ -76,6 +76,6 @@ def test_objects_with_no_inverse(val):
         (IsIterable(), (0.5, 1)),
     ),
 )
-def test_objects_with_inverse(val, inv):
+def test_objects_with_inverse(val, inv) -> None:
     assert cirq.inverse(val) == inv
     assert cirq.inverse(val, 0) == inv

cirq/protocols/kraus_protocol_test.py

@@ -24,7 +24,7 @@ import cirq
 LOCAL_DEFAULT: List[np.ndarray] = [np.array([])]
 
 
-def test_kraus_no_methods():
+def test_kraus_no_methods() -> None:
     class NoMethod:
         pass
 
@@ -51,7 +51,7 @@ def assert_not_implemented(val):
     assert not cirq.has_kraus(val)
 
 
-def test_kraus_returns_not_implemented():
+def test_kraus_returns_not_implemented() -> None:
     class ReturnsNotImplemented:
         def _kraus_(self):
             return NotImplemented
@@ -59,7 +59,7 @@ def test_kraus_returns_not_implemented():
     assert_not_implemented(ReturnsNotImplemented())
 
 
-def test_mixture_returns_not_implemented():
+def test_mixture_returns_not_implemented() -> None:
     class ReturnsNotImplemented:
         def _mixture_(self):
             return NotImplemented
@@ -67,7 +67,7 @@ def test_mixture_returns_not_implemented():
     assert_not_implemented(ReturnsNotImplemented())
 
 
-def test_unitary_returns_not_implemented():
+def test_unitary_returns_not_implemented() -> None:
     class ReturnsNotImplemented:
         def _unitary_(self):
             return NotImplemented
@@ -80,7 +80,7 @@ def test_unitary_returns_not_implemented():
     assert cirq.kraus(ReturnsNotImplemented(), LOCAL_DEFAULT) is LOCAL_DEFAULT
 
 
-def test_explicit_kraus():
+def test_explicit_kraus() -> None:
     a0 = np.array([[0, 0], [1, 0]])
     a1 = np.array([[1, 0], [0, 0]])
     c = (a0, a1)
@@ -98,7 +98,7 @@ def test_explicit_kraus():
     assert cirq.has_kraus(ReturnsKraus())
 
 
-def test_kraus_fallback_to_mixture():
+def test_kraus_fallback_to_mixture() -> None:
     m = ((0.3, cirq.unitary(cirq.X)), (0.4, cirq.unitary(cirq.Y)), (0.3, cirq.unitary(cirq.Z)))
 
     class ReturnsMixture:
@@ -120,7 +120,7 @@ def test_kraus_fallback_to_mixture():
     assert cirq.has_kraus(ReturnsMixture())
 
 
-def test_kraus_fallback_to_unitary():
+def test_kraus_fallback_to_unitary() -> None:
     u = np.array([[1, 0], [1, 0]])
 
     class ReturnsUnitary:
@@ -160,12 +160,12 @@ class HasKrausWhenDecomposed(cirq.testing.SingleQubitGate):
 
 
 @pytest.mark.parametrize('cls', [HasKraus, HasMixture, HasUnitary])
-def test_has_kraus(cls):
+def test_has_kraus(cls) -> None:
     assert cirq.has_kraus(cls())
 
 
 @pytest.mark.parametrize('decomposed_cls', [HasKraus, HasMixture, HasUnitary])
-def test_has_kraus_when_decomposed(decomposed_cls):
+def test_has_kraus_when_decomposed(decomposed_cls) -> None:
     op = HasKrausWhenDecomposed(decomposed_cls).on(cirq.NamedQubit('test'))
     assert cirq.has_kraus(op)
     assert not cirq.has_kraus(op, allow_decompose=False)

cirq/protocols/measurement_key_protocol_test.py

@@ -28,7 +28,7 @@ class ReturnsObj:
 
 
 @pytest.mark.parametrize('gate', [ReturnsStr(), ReturnsObj()])
-def test_measurement_key_name(gate):
+def test_measurement_key_name(gate) -> None:
     assert isinstance(cirq.measurement_key_name(gate), str)
     assert cirq.measurement_key_name(gate) == 'door locker'
     assert cirq.measurement_key_obj(gate) == cirq.MeasurementKey(name='door locker')
@@ -39,7 +39,7 @@ def test_measurement_key_name(gate):
 
 
 @pytest.mark.parametrize('gate', [ReturnsStr(), ReturnsObj()])
-def test_measurement_key_obj(gate):
+def test_measurement_key_obj(gate) -> None:
     assert isinstance(cirq.measurement_key_obj(gate), cirq.MeasurementKey)
     assert cirq.measurement_key_obj(gate) == cirq.MeasurementKey(name='door locker')
     assert cirq.measurement_key_obj(gate) == 'door locker'
@@ -50,7 +50,7 @@ def test_measurement_key_obj(gate):
 
 
 @pytest.mark.parametrize('key_method', [cirq.measurement_key_name, cirq.measurement_key_obj])
-def test_measurement_key_no_method(key_method):
+def test_measurement_key_no_method(key_method) -> None:
     class NoMethod:
         pass
 
@@ -73,7 +73,7 @@ def test_measurement_key_no_method(key_method):
 
 
 @pytest.mark.parametrize('key_method', [cirq.measurement_key_name, cirq.measurement_key_obj])
-def test_measurement_key_not_implemented_default_behavior(key_method):
+def test_measurement_key_not_implemented_default_behavior(key_method) -> None:
     class ReturnsNotImplemented:
         def _measurement_key_name_(self):
             return NotImplemented
@@ -89,7 +89,7 @@ def test_measurement_key_not_implemented_default_behavior(key_method):
     assert key_method(ReturnsNotImplemented(), 'a') == 'a'
 
 
-def test_is_measurement():
+def test_is_measurement() -> None:
     q = cirq.NamedQubit('q')
     assert cirq.is_measurement(cirq.measure(q))
     assert cirq.is_measurement(cirq.MeasurementGate(num_qubits=1, key='b'))
@@ -109,7 +109,7 @@ def test_is_measurement():
     assert not cirq.is_measurement(NotImplementedOperation())
 
 
-def test_measurement_without_key():
+def test_measurement_without_key() -> None:
     class MeasurementWithoutKey:
         def _is_measurement_(self):
             return True
@@ -120,7 +120,7 @@ def test_measurement_without_key():
     assert cirq.is_measurement(MeasurementWithoutKey())
 
 
-def test_non_measurement_with_key():
+def test_non_measurement_with_key() -> None:
     class NonMeasurementGate(cirq.Gate):
         def _is_measurement_(self):
             return False  # pragma: no cover
@@ -155,7 +155,7 @@ def test_non_measurement_with_key():
     ('key_method', 'keys'),
     [(cirq.measurement_key_names, {'a', 'b'}), (cirq.measurement_key_objs, {'c', 'd'})],
 )
-def test_measurement_keys(key_method, keys):
+def test_measurement_keys(key_method, keys) -> None:
     class MeasurementKeysGate(cirq.Gate):
         def _measurement_key_names_(self):
             return frozenset(['a', 'b'])
@@ -180,7 +180,7 @@ def test_measurement_keys(key_method, keys):
     assert key_method(MeasurementKeysGate().on(a)) == keys
 
 
-def test_measurement_key_mapping():
+def test_measurement_key_mapping() -> None:
     class MultiKeyGate:
         def __init__(self, keys):
             self._keys = frozenset(keys)
@@ -217,7 +217,7 @@ def test_measurement_key_mapping():
     assert cirq.measurement_key_names(mkg_cdx) == {'c', 'd'}
 
 
-def test_measurement_key_path():
+def test_measurement_key_path() -> None:
     class MultiKeyGate:
         def __init__(self, keys):
             self._keys = frozenset(cirq.MeasurementKey.parse_serialized(key) for key in keys)

cirq/protocols/pauli_expansion_protocol_test.py

@@ -54,7 +54,7 @@ class HasQuditUnitary:
 @pytest.mark.parametrize(
     'val', (NoMethod(), ReturnsNotImplemented(), HasQuditUnitary(), 123, np.eye(2), object(), cirq)
 )
-def test_raises_no_pauli_expansion(val):
+def test_raises_no_pauli_expansion(val) -> None:
     assert cirq.pauli_expansion(val, default=None) is None
     with pytest.raises(TypeError, match='No Pauli expansion'):
         cirq.pauli_expansion(val)
@@ -78,7 +78,7 @@ def test_raises_no_pauli_expansion(val):
         ),
     ),
 )
-def test_pauli_expansion(val, expected_expansion):
+def test_pauli_expansion(val, expected_expansion) -> None:
     actual_expansion = cirq.pauli_expansion(val)
     assert cirq.approx_eq(actual_expansion, expected_expansion, atol=1e-12)
     assert set(actual_expansion.keys()) == set(expected_expansion.keys())

cirq/protocols/phase_protocol_test.py

@@ -17,7 +17,7 @@ import pytest
 import cirq
 
 
-def test_phase_by():
+def test_phase_by() -> None:
     class NoMethod:
         pass