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

cirq/sim/state_vector_simulation_state_test.py

@@ -21,7 +21,7 @@ import pytest
 import cirq
 
 
-def test_default_parameter():
+def test_default_parameter() -> None:
     dtype = np.complex64
     tensor = cirq.one_hot(shape=(2, 2, 2), dtype=np.complex64)
     qubits = cirq.LineQubit.range(3)
@@ -33,7 +33,7 @@ def test_default_parameter():
     assert args.available_buffer.dtype == tensor.dtype
 
 
-def test_infer_target_tensor():
+def test_infer_target_tensor() -> None:
     dtype = np.complex64
     args = cirq.StateVectorSimulationState(
         qubits=cirq.LineQubit.range(2),
@@ -54,13 +54,13 @@ def test_infer_target_tensor():
     )
 
 
-def test_shallow_copy_buffers():
+def test_shallow_copy_buffers() -> None:
     args = cirq.StateVectorSimulationState(qubits=cirq.LineQubit.range(1), initial_state=0)
     copy = args.copy(deep_copy_buffers=False)
     assert copy.available_buffer is args.available_buffer
 
 
-def test_decomposed_fallback():
+def test_decomposed_fallback() -> None:
     class Composite(cirq.Gate):
         def num_qubits(self) -> int:
             return 1  # pragma: no cover
@@ -82,7 +82,7 @@ def test_decomposed_fallback():
     )
 
 
-def test_cannot_act():
+def test_cannot_act() -> None:
     class NoDetails:
         pass
 
@@ -98,7 +98,7 @@ def test_cannot_act():
         cirq.act_on(NoDetails(), args, qubits=())
 
 
-def test_act_using_probabilistic_single_qubit_channel():
+def test_act_using_probabilistic_single_qubit_channel() -> None:
     class ProbabilisticSorX(cirq.Gate):
         def num_qubits(self) -> int:
             return 1
@@ -148,7 +148,7 @@ def test_act_using_probabilistic_single_qubit_channel():
     )
 
 
-def test_act_using_adaptive_two_qubit_channel():
+def test_act_using_adaptive_two_qubit_channel() -> None:
     class Decay11(cirq.Gate):
         def num_qubits(self) -> int:
             return 2
@@ -210,7 +210,7 @@ def test_act_using_adaptive_two_qubit_channel():
         assert_not_affected(projected_state, sample=3 / 4 + 1e-8)
 
 
-def test_probability_comes_up_short_results_in_fallback():
+def test_probability_comes_up_short_results_in_fallback() -> None:
     class Short(cirq.Gate):
         def num_qubits(self) -> int:
             return 1
@@ -234,7 +234,7 @@ def test_probability_comes_up_short_results_in_fallback():
     np.testing.assert_allclose(args.target_tensor, np.array([0, 1]))
 
 
-def test_random_channel_has_random_behavior():
+def test_random_channel_has_random_behavior() -> None:
     q = cirq.LineQubit(0)
     s = cirq.Simulator().sample(
         cirq.Circuit(cirq.X(q), cirq.amplitude_damp(0.4).on(q), cirq.measure(q, key='out')),
@@ -245,7 +245,7 @@ def test_random_channel_has_random_behavior():
     assert v[1] > 1
 
 
-def test_measured_channel():
+def test_measured_channel() -> None:
     # This behaves like an X-basis measurement.
     kc = cirq.KrausChannel(
         kraus_ops=(np.array([[1, 1], [1, 1]]) * 0.5, np.array([[1, -1], [-1, 1]]) * 0.5), key='m'
@@ -257,7 +257,7 @@ def test_measured_channel():
     assert results.histogram(key='m') == {0: 100}
 
 
-def test_measured_mixture():
+def test_measured_mixture() -> None:
     # This behaves like an X-basis measurement.
     mm = cirq.MixedUnitaryChannel(
         mixture=((0.5, np.array([[1, 0], [0, 1]])), (0.5, np.array([[0, 1], [1, 0]]))), key='flip'
@@ -269,6 +269,6 @@ def test_measured_mixture():
     assert results.histogram(key='flip') == results.histogram(key='m')
 
 
-def test_qid_shape_error():
+def test_qid_shape_error() -> None:
     with pytest.raises(ValueError, match="qid_shape must be provided"):
         cirq.sim.state_vector_simulation_state._BufferedStateVector.create(initial_state=0)

cirq/study/flatten_expressions_test.py

@@ -23,14 +23,14 @@ from cirq.study import flatten_expressions
 # factor, is not consistent between sympy versions <1.4 and >=1.4.
 
 
-def test_expr_map_names():
+def test_expr_map_names() -> None:
     flattener = flatten_expressions._ParamFlattener({'collision': '<x + 2>'})
     expressions = [sympy.Symbol('x') + i for i in range(3)]
     syms = flattener.flatten(expressions)
     assert syms == [sympy.Symbol(name) for name in ('x', '<x + 1>', '<x + 2>_1')]
 
 
-def test_flattener_value_of():
+def test_flattener_value_of() -> None:
     flattener = flatten_expressions._ParamFlattener({'c': 5, 'x1': 'x1'})
     assert flattener.value_of(9) == 9
     assert flattener.value_of('c') == 5
@@ -54,18 +54,18 @@ def test_flattener_value_of():
     ]
 
 
-def test_flattener_repr():
+def test_flattener_repr() -> None:
     assert repr(flatten_expressions._ParamFlattener({'a': 1})) == ("_ParamFlattener({a: 1})")
     assert repr(
         flatten_expressions._ParamFlattener({'a': 1}, get_param_name=lambda expr: 'x')
     ).startswith("_ParamFlattener({a: 1}, get_param_name=<function ")
 
 
-def test_expression_map_repr():
+def test_expression_map_repr() -> None:
     cirq.testing.assert_equivalent_repr(cirq.ExpressionMap({'a': 'b'}))
 
 
-def test_flatten_circuit():
+def test_flatten_circuit() -> None:
     qubit = cirq.LineQubit(0)
     a = sympy.Symbol('a')
     circuit = cirq.Circuit(cirq.X(qubit) ** a, cirq.X(qubit) ** (1 + a / 2))
@@ -78,7 +78,7 @@ def test_flatten_circuit():
     assert expr_map == {a: a, 1 + a / 2: sympy.Symbol('<a/2 + 1>')}
 
 
-def test_transform_params():
+def test_transform_params() -> None:
     qubit = cirq.LineQubit(0)
     a = sympy.Symbol('a')
     circuit = cirq.Circuit(cirq.X(qubit) ** (a / 4), cirq.X(qubit) ** (1 + a / 2))
@@ -90,7 +90,7 @@ def test_transform_params():
     assert new_params == expected_params
 
 
-def test_transform_sweep():
+def test_transform_sweep() -> None:
     qubit = cirq.LineQubit(0)
     a = sympy.Symbol('a')
     circuit = cirq.Circuit(cirq.X(qubit) ** (a / 4), cirq.X(qubit) ** (1 + a / 2))
@@ -109,20 +109,20 @@ def test_transform_sweep():
     assert resolvers == expected_resolvers
 
 
-def test_flattener_new():
+def test_flattener_new() -> None:
     flattener = flatten_expressions._ParamFlattener({'a': 'b'})
     flattener2 = flatten_expressions._ParamFlattener(flattener)
     assert isinstance(flattener2, flatten_expressions._ParamFlattener)
     assert flattener2.param_dict == flattener.param_dict
 
 
-def test_resolver_new():
+def test_resolver_new() -> None:
     flattener = flatten_expressions._ParamFlattener({'a': 'b'})
     flattener2 = cirq.ParamResolver(flattener)
     assert flattener2 is flattener
 
 
-def test_transformed_sweep():
+def test_transformed_sweep() -> None:
     a = sympy.Symbol('a')
     sweep = cirq.Linspace('a', start=0, stop=3, length=4)
     expr_map = cirq.ExpressionMap({a / 4: 'x0', 1 - a / 2: 'x1'})
@@ -134,7 +134,7 @@ def test_transformed_sweep():
     assert params[1] == (('x0', 1 / 4), ('x1', 1 - 1 / 2))
 
 
-def test_transformed_sweep_equality():
+def test_transformed_sweep_equality() -> None:
     a = sympy.Symbol('a')
     sweep = cirq.Linspace('a', start=0, stop=3, length=4)
     expr_map = cirq.ExpressionMap({a / 4: 'x0', 1 - a / 4: 'x1'})

cirq/study/resolver_test.py

@@ -39,7 +39,7 @@ import cirq
         fractions.Fraction(3, 2),
     ],
 )
-def test_value_of_pass_through_types(val):
+def test_value_of_pass_through_types(val) -> None:
     _assert_consistent_resolution(val, val)
 
 
@@ -47,12 +47,12 @@ def test_value_of_pass_through_types(val):
     'val,resolved',
     [(sympy.pi, np.pi), (sympy.S.NegativeOne, -1), (sympy.S.Half, 0.5), (sympy.S.One, 1)],
 )
-def test_value_of_transformed_types(val, resolved):
+def test_value_of_transformed_types(val, resolved) -> None:
     _assert_consistent_resolution(val, resolved)
 
 
 @pytest.mark.parametrize('val,resolved', [(sympy.I, 1j)])
-def test_value_of_substituted_types(val, resolved):
+def test_value_of_substituted_types(val, resolved) -> None:
     _assert_consistent_resolution(val, resolved)
 
 
@@ -112,11 +112,11 @@ def _assert_consistent_resolution(v, resolved):
     ), f"expected {type(resolved)} got {type(r.value_of(v))}"
 
 
-def test_value_of_strings():
+def test_value_of_strings() -> None:
     assert cirq.ParamResolver().value_of('x') == sympy.Symbol('x')
 
 
-def test_value_of_calculations():
+def test_value_of_calculations() -> None:
     assert not bool(cirq.ParamResolver())
 
     r = cirq.ParamResolver({'a': 0.5, 'b': 0.1, 'c': 1 + 1j})
@@ -129,34 +129,34 @@ def test_value_of_calculations():
     assert r.value_of(sympy.Symbol('b') / 0.1 - sympy.Symbol('a')) == 0.5
 
 
-def test_resolve_integer_division():
+def test_resolve_integer_division() -> None:
     r = cirq.ParamResolver({'a': 1, 'b': 2})
     resolved = r.value_of(sympy.Symbol('a') / sympy.Symbol('b'))
     assert resolved == 0.5
 
 
-def test_resolve_symbol_division():
+def test_resolve_symbol_division() -> None:
     B = sympy.Symbol('B')
     r = cirq.ParamResolver({'a': 1, 'b': B})
     resolved = r.value_of(sympy.Symbol('a') / sympy.Symbol('b'))
     assert resolved == sympy.core.power.Pow(B, -1)
 
 
-def test_param_dict():
+def test_param_dict() -> None:
     r = cirq.ParamResolver({'a': 0.5, 'b': 0.1})
     r2 = cirq.ParamResolver(r)
     assert r2 is r
     assert r.param_dict == {'a': 0.5, 'b': 0.1}
 
 
-def test_param_dict_iter():
+def test_param_dict_iter() -> None:
     r = cirq.ParamResolver({'a': 0.5, 'b': 0.1})
     assert [key for key in r] == ['a', 'b']
     assert [r.value_of(key) for key in r] == [0.5, 0.1]
     assert list(r) == ['a', 'b']
 
 
-def test_formulas_in_param_dict():
+def test_formulas_in_param_dict() -> None:
     """Tests that formula keys are rejected in a `param_dict`."""
     a = sympy.Symbol('a')
     b = sympy.Symbol('b')
@@ -166,7 +166,7 @@ def test_formulas_in_param_dict():
         _ = cirq.ParamResolver({a: b + 1, b: 2, b + c: 101, 'd': 2 * e})
 
 
-def test_recursive_evaluation():
+def test_recursive_evaluation() -> None:
     a = sympy.Symbol('a')
     b = sympy.Symbol('b')
     c = sympy.Symbol('c')
@@ -184,7 +184,7 @@ def test_recursive_evaluation():
     assert sympy.Eq(r.value_of(e), 0)
 
 
-def test_resolution_of_unknown_formulas():
+def test_resolution_of_unknown_formulas() -> None:
     a = sympy.Symbol('a')
     b = sympy.Symbol('b')
 
@@ -192,7 +192,7 @@ def test_resolution_of_unknown_formulas():
     assert r.value_of(sympy.sin(a), recursive=False) == sympy.sin(b - 2)
 
 
-def test_unbound_recursion_halted():
+def test_unbound_recursion_halted() -> None:
     a = sympy.Symbol('a')
     b = sympy.Symbol('b')
     c = sympy.Symbol('c')
@@ -223,14 +223,14 @@ def test_unbound_recursion_halted():
         _ = r.value_of(a)
 
 
-def test_resolve_unknown_type():
+def test_resolve_unknown_type() -> None:
     a = sympy.Symbol('a')
     b = sympy.Symbol('b')
     r = cirq.ParamResolver({a: b})
     assert r.value_of(cirq.X) == cirq.X
 
 
-def test_custom_resolved_value():
+def test_custom_resolved_value() -> None:
     class Foo:
         def _resolved_value_(self):
             return self
@@ -249,7 +249,7 @@ def test_custom_resolved_value():
     assert r.value_of(b) == 'Baz'
 
 
-def test_custom_value_not_implemented():
+def test_custom_value_not_implemented() -> None:
     class BarImplicit:
         pass
 
@@ -264,7 +264,7 @@ def test_custom_value_not_implemented():
         assert r.value_of(b) == b
 
 
-def test_compose():
+def test_compose() -> None:
     """Tests that cirq.resolve_parameters on a ParamResolver composes."""
     a = sympy.Symbol('a')
     b = sympy.Symbol('b')
@@ -301,7 +301,7 @@ def test_compose():
     ],
 )
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_compose_associative(p1, p2, p3, resolve_fn):
+def test_compose_associative(p1, p2, p3, resolve_fn) -> None:
     r1, r2, r3 = [
         cirq.ParamResolver(
             {sympy.Symbol(k): (sympy.Symbol(v) if isinstance(v, str) else v) for k, v in pd.items()}
@@ -313,7 +313,7 @@ def test_compose_associative(p1, p2, p3, resolve_fn):
     )
 
 
-def test_equals():
+def test_equals() -> None:
     et = cirq.testing.EqualsTester()
     et.add_equality_group(
         cirq.ParamResolver(),
@@ -329,7 +329,7 @@ def test_equals():
     et.add_equality_group(cirq.ParamResolver({'c': 0.1}))
 
 
-def test_repr():
+def test_repr() -> None:
     cirq.testing.assert_equivalent_repr(cirq.ParamResolver())
     cirq.testing.assert_equivalent_repr(cirq.ParamResolver({'a': 2.0}))
     cirq.testing.assert_equivalent_repr(cirq.ParamResolver({'a': sympy.Symbol('a')}))

cirq/testing/consistent_act_on_test.py

@@ -55,7 +55,7 @@ class UnimplementedUnitaryGate(cirq.testing.TwoQubitGate):
         return np.array([[0, 0, 0, 1], [0, 0, 1, 0], [0, 1, 0, 0], [1, 0, 0, 0]])
 
 
-def test_assert_act_on_clifford_tableau_effect_matches_unitary():
+def test_assert_act_on_clifford_tableau_effect_matches_unitary() -> None:
     cirq.testing.assert_all_implemented_act_on_effects_match_unitary(GoodGate())
     cirq.testing.assert_all_implemented_act_on_effects_match_unitary(
         GoodGate().on(cirq.LineQubit(1))

cirq/testing/consistent_channels_test.py

@@ -18,12 +18,12 @@ import pytest
 import cirq
 
 
-def test_assert_consistent_channel_valid():
+def test_assert_consistent_channel_valid() -> None:
     channel = cirq.KrausChannel(kraus_ops=(np.array([[0, 1], [0, 0]]), np.array([[1, 0], [0, 0]])))
     cirq.testing.assert_consistent_channel(channel)
 
 
-def test_assert_consistent_channel_tolerances():
+def test_assert_consistent_channel_tolerances() -> None:
     # This channel is off by 1e-5 from the identity matrix in the consistency condition.
     channel = cirq.KrausChannel(
         kraus_ops=(np.array([[0, np.sqrt(1 - 1e-5)], [0, 0]]), np.array([[1, 0], [0, 0]]))
@@ -37,23 +37,23 @@ def test_assert_consistent_channel_tolerances():
         cirq.testing.assert_consistent_channel(channel, rtol=0, atol=1e-6)
 
 
-def test_assert_consistent_channel_invalid():
+def test_assert_consistent_channel_invalid() -> None:
     channel = cirq.KrausChannel(kraus_ops=(np.array([[1, 1], [0, 0]]), np.array([[1, 0], [0, 0]])))
     with pytest.raises(AssertionError, match=r"cirq.KrausChannel.*2 1"):
         cirq.testing.assert_consistent_channel(channel)
 
 
-def test_assert_consistent_channel_not_kraus():
+def test_assert_consistent_channel_not_kraus() -> None:
     with pytest.raises(AssertionError, match="12.*has_kraus"):
         cirq.testing.assert_consistent_channel(12)
 
 
-def test_assert_consistent_mixture_valid():
+def test_assert_consistent_mixture_valid() -> None:
     mixture = cirq.X.with_probability(0.1)
     cirq.testing.assert_consistent_mixture(mixture)
 
 
-def test_assert_consistent_mixture_not_mixture():
+def test_assert_consistent_mixture_not_mixture() -> None:
     not_mixture = cirq.amplitude_damp(0.1)
     with pytest.raises(AssertionError, match="has_mixture"):
         cirq.testing.assert_consistent_mixture(not_mixture)
@@ -69,7 +69,7 @@ class _MixtureGate(cirq.testing.SingleQubitGate):
         return (self._p, cirq.unitary(cirq.I)), (self._q, cirq.unitary(cirq.X))
 
 
-def test_assert_consistent_mixture_not_normalized():
+def test_assert_consistent_mixture_not_normalized() -> None:
     mixture = _MixtureGate(0.1, 0.85)
     with pytest.raises(AssertionError, match="sum to 1"):
         cirq.testing.assert_consistent_mixture(mixture)
@@ -79,7 +79,7 @@ def test_assert_consistent_mixture_not_normalized():
         cirq.testing.assert_consistent_mixture(mixture)
 
 
-def test_assert_consistent_mixture_tolerances():
+def test_assert_consistent_mixture_tolerances() -> None:
 
     # This gate is 1e-5 off being properly normalized.
     mixture = _MixtureGate(0.1, 0.9 - 1e-5)

cirq/testing/consistent_controlled_gate_op_test.py

@@ -62,7 +62,7 @@ class BadGate(cirq.EigenGate, cirq.testing.SingleQubitGate):
         return ret
 
 
-def test_assert_controlled_and_controlled_by_identical():
+def test_assert_controlled_and_controlled_by_identical() -> None:
     cirq.testing.assert_controlled_and_controlled_by_identical(GoodGate())
 
     with pytest.raises(AssertionError):
@@ -79,7 +79,7 @@ def test_assert_controlled_and_controlled_by_identical():
         )
 
 
-def test_assert_controlled_unitary_consistent():
+def test_assert_controlled_unitary_consistent() -> None:
     cirq.testing.assert_controlled_and_controlled_by_identical(
         GoodGate(exponent=0.5, global_shift=1 / 3)
     )

cirq/testing/consistent_decomposition_test.py

@@ -35,7 +35,7 @@ class BadGateDecompose(cirq.testing.SingleQubitGate):
         return np.array([[0, 1], [1, 0]])
 
 
-def test_assert_decompose_is_consistent_with_unitary():
+def test_assert_decompose_is_consistent_with_unitary() -> None:
     cirq.testing.assert_decompose_is_consistent_with_unitary(GoodGateDecompose())
 
     cirq.testing.assert_decompose_is_consistent_with_unitary(
@@ -89,7 +89,7 @@ class ParameterizedGate(cirq.Gate):
         yield cirq.Y(qubits[1]) ** sympy.Symbol("y")
 
 
-def test_assert_decompose_ends_at_default_gateset():
+def test_assert_decompose_ends_at_default_gateset() -> None:
     cirq.testing.assert_decompose_ends_at_default_gateset(GateDecomposesToDefaultGateset())
     cirq.testing.assert_decompose_ends_at_default_gateset(
         GateDecomposesToDefaultGateset().on(*cirq.LineQubit.range(2))

cirq/testing/consistent_pauli_expansion_test.py

@@ -52,7 +52,7 @@ class BadGateInconsistentPauliExpansion(cirq.testing.SingleQubitGate):
         return cirq.LinearDict({'X': np.sqrt(1 / 6), 'Y': np.sqrt(1 / 3), 'Z': np.sqrt(1 / 2)})
 
 
-def test_assert_pauli_expansion_is_consistent_with_unitary():
+def test_assert_pauli_expansion_is_consistent_with_unitary() -> None:
     cirq.testing.assert_pauli_expansion_is_consistent_with_unitary(GoodGateExplicitPauliExpansion())
     cirq.testing.assert_pauli_expansion_is_consistent_with_unitary(GoodGateNoPauliExpansion())
     cirq.testing.assert_pauli_expansion_is_consistent_with_unitary(GoodGateNoUnitary())

cirq/testing/consistent_phase_by_test.py

@@ -89,7 +89,7 @@ class SemiBadPhaser:
         return SemiBadPhaser([resolver.value_of(val, recursive) for val in self.e])
 
 
-def test_assert_phase_by_is_consistent_with_unitary():
+def test_assert_phase_by_is_consistent_with_unitary() -> None:
     cirq.testing.assert_phase_by_is_consistent_with_unitary(GoodPhaser(0.5))
 
     cirq.testing.assert_phase_by_is_consistent_with_unitary(GoodQuditPhaser(0.5))

cirq/testing/consistent_qasm_test.py

@@ -51,7 +51,7 @@ class QuditGate(cirq.Gate):
         return NotImplemented
 
 
-def test_assert_qasm_is_consistent_with_unitary():
+def test_assert_qasm_is_consistent_with_unitary() -> None:
     try:
         import qiskit as _
     except ImportError:  # pragma: no cover

cirq/testing/consistent_specified_has_unitary_test.py

@@ -18,7 +18,7 @@ import pytest
 import cirq
 
 
-def test_assert_specifies_has_unitary_if_unitary_from_matrix():
+def test_assert_specifies_has_unitary_if_unitary_from_matrix() -> None:
     class Bad:
         def _unitary_(self):
             return np.array([[1]])
@@ -28,7 +28,7 @@ def test_assert_specifies_has_unitary_if_unitary_from_matrix():
         cirq.testing.assert_specifies_has_unitary_if_unitary(Bad())
 
 
-def test_assert_specifies_has_unitary_if_unitary_from_apply():
+def test_assert_specifies_has_unitary_if_unitary_from_apply() -> None:
     class Bad(cirq.Operation):
         @property
         def qubits(self):
@@ -45,7 +45,7 @@ def test_assert_specifies_has_unitary_if_unitary_from_apply():
         cirq.testing.assert_specifies_has_unitary_if_unitary(Bad())
 
 
-def test_assert_specifies_has_unitary_if_unitary_from_decompose():
+def test_assert_specifies_has_unitary_if_unitary_from_decompose() -> None:
     class Bad:
         def _decompose_(self):
             return []
@@ -70,7 +70,7 @@ def test_assert_specifies_has_unitary_if_unitary_from_decompose():
     cirq.testing.assert_specifies_has_unitary_if_unitary(Okay())
 
 
-def test_assert_specifies_has_unitary_if_unitary_pass():
+def test_assert_specifies_has_unitary_if_unitary_pass() -> None:
     class Good:
         def _has_unitary_(self):
             return True

cirq/testing/consistent_unitary_test.py

@@ -78,7 +78,7 @@ class CleanCorrectButBorrowableIncorrectGate(cirq.Gate):
         (CleanCorrectButBorrowableIncorrectGate(use_clean_ancilla=False), False),
     ],
 )
-def test_assert_unitary_is_consistent(g, ignore_phase, is_consistent):
+def test_assert_unitary_is_consistent(g, ignore_phase, is_consistent) -> None:
     if is_consistent:
         cirq.testing.assert_unitary_is_consistent(g, ignore_phase)
         cirq.testing.assert_unitary_is_consistent(g.on(*cirq.LineQid.for_gate(g)), ignore_phase)
@@ -89,7 +89,7 @@ def test_assert_unitary_is_consistent(g, ignore_phase, is_consistent):
             cirq.testing.assert_unitary_is_consistent(g.on(*cirq.LineQid.for_gate(g)), ignore_phase)
 
 
-def test_failed_decomposition():
+def test_failed_decomposition() -> None:
     with pytest.raises(ValueError):
         cirq.testing.assert_unitary_is_consistent(FailsOnDecompostion())
 

cirq/testing/deprecation_test.py

@@ -18,14 +18,14 @@ import pytest
 from cirq.testing import assert_deprecated
 
 
-def test_nested_assert_deprecation():
+def test_nested_assert_deprecation() -> None:
     with assert_deprecated(deadline="v1.2", count=1):
         with assert_deprecated(deadline="v1.2", count=1):
             with assert_deprecated(deadline="v1.2", count=1):
                 warnings.warn("hello, this is deprecated in v1.2")
 
 
-def test_assert_deprecated_log_handling():
+def test_assert_deprecated_log_handling() -> None:
     # correct deprecation message
     with assert_deprecated("hello", deadline="v1.2"):
         warnings.warn("hello, this is deprecated in v1.2")

cirq/testing/devices_test.py

@@ -17,7 +17,7 @@ import cirq
 from cirq.testing.devices import ValidatingTestDevice
 
 
-def test_validating_types_and_qubits():
+def test_validating_types_and_qubits() -> None:
     dev = ValidatingTestDevice(
         allowed_qubit_types=(cirq.GridQubit,),
         allowed_gates=(cirq.XPowGate,),
@@ -37,7 +37,7 @@ def test_validating_types_and_qubits():
         dev.validate_operation(cirq.Y(cirq.GridQubit(0, 0)))
 
 
-def test_validating_locality():
+def test_validating_locality() -> None:
     dev = ValidatingTestDevice(
         allowed_qubit_types=(cirq.GridQubit,),
         allowed_gates=(cirq.CZPowGate, cirq.MeasurementGate),
@@ -62,7 +62,7 @@ def test_validating_locality():
         )
 
 
-def test_repr():
+def test_repr() -> None:
     dev = ValidatingTestDevice(
         allowed_qubit_types=(cirq.GridQubit,),
         allowed_gates=(cirq.CZPowGate, cirq.MeasurementGate),
@@ -73,7 +73,7 @@ def test_repr():
     assert repr(dev) == 'test'
 
 
-def test_defaults():
+def test_defaults() -> None:
     dev = ValidatingTestDevice(qubits={cirq.GridQubit(0, 0)})
     assert repr(dev) == 'ValidatingTestDevice'
     assert dev.allowed_qubit_types == (cirq.GridQubit,)

cirq/testing/equivalent_basis_map_test.py

@@ -17,7 +17,7 @@ import cirq
 from cirq import circuits
 
 
-def test_correct_mappings():
+def test_correct_mappings() -> None:
     a, b, c = cirq.LineQubit.range(3)
     cirq.testing.assert_equivalent_computational_basis_map(
         maps={0b01: 0b01, 0b10: 0b10},
@@ -30,7 +30,7 @@ def test_correct_mappings():
     )
 
 
-def test_incorrect_mappings():
+def test_incorrect_mappings() -> None:
     a, b, c = cirq.LineQubit.range(3)
     with pytest.raises(
         AssertionError,

cirq/testing/equivalent_repr_eval_test.py

@@ -18,7 +18,7 @@ import pytest
 import cirq
 
 
-def test_external():
+def test_external() -> None:
     for t in ['a', 1j]:
         cirq.testing.assert_equivalent_repr(t)
         cirq.testing.assert_equivalent_repr(t, setup_code='')
@@ -29,7 +29,7 @@ def test_external():
         cirq.testing.assert_equivalent_repr(np.array([5]))
 
 
-def test_custom_class_repr():
+def test_custom_class_repr() -> None:
     class CustomRepr:  # pragma: no cover
         setup_code = """class CustomRepr:
             def __init__(self, eq_val):
@@ -81,5 +81,5 @@ def test_custom_class_repr():
         )
 
 
-def test_imports_cirq_by_default():
+def test_imports_cirq_by_default() -> None:
     cirq.testing.assert_equivalent_repr(cirq.NamedQubit('a'))