From e0788e65d57de8db0a605f6bf74336574b444de3 Mon Sep 17 00:00:00 2001 From: Marquess Valdez Date: Wed, 21 Feb 2024 13:26:09 -0800 Subject: [PATCH] update tests --- pyquil/quilbase.py | 4 + test/unit/test_quilbase.py | 155 ++++++++++++++++++++++++++++++++----- 2 files changed, 141 insertions(+), 18 deletions(-) diff --git a/pyquil/quilbase.py b/pyquil/quilbase.py index b802429b5..281aff2af 100644 --- a/pyquil/quilbase.py +++ b/pyquil/quilbase.py @@ -145,6 +145,8 @@ def _convert_to_rs_instruction(instr: Union[AbstractInstruction, quil_rs.Instruc return quil_rs.Instruction.from_gate_definition(instr) if isinstance(instr, Halt): return quil_rs.Instruction.new_halt() + if isinstance(instr, Include): + return quil_rs.Instruction.from_include(instr) if isinstance(instr, quil_rs.Load): return quil_rs.Instruction.from_load(instr) if isinstance(instr, quil_rs.MeasureCalibrationDefinition): @@ -211,6 +213,8 @@ def _convert_to_py_instruction(instr: Any) -> AbstractInstruction: return _convert_to_py_instruction(instr.inner()) if isinstance(instr, quil_rs.Arithmetic): return ArithmeticBinaryOp._from_rs_arithmetic(instr) + if isinstance(instr, quil_rs.BinaryLogic): + return LogicalBinaryOp._from_rs_binary_logic(instr) if isinstance(instr, quil_rs.Calibration): return DefCalibration._from_rs_calibration(instr) if isinstance(instr, quil_rs.Capture): diff --git a/test/unit/test_quilbase.py b/test/unit/test_quilbase.py index b6064c82d..f1c7fcdbf 100644 --- a/test/unit/test_quilbase.py +++ b/test/unit/test_quilbase.py @@ -11,6 +11,8 @@ from pyquil.gates import X from pyquil.quil import Program from pyquil.quilbase import ( + _convert_to_rs_instruction, + _convert_to_py_instruction, AbstractInstruction, ArithmeticBinaryOp, Capture, @@ -160,6 +162,10 @@ def test_eq(self, gate: Gate, name: str, params: List[ParameterDesignator], qubi assert not (gate == not_eq_gate) assert gate != not_eq_gate + def test_convert(self, gate: Gate): + rs_gate = _convert_to_rs_instruction(gate) + assert gate == _convert_to_py_instruction(rs_gate) + def test_copy(self, gate: Gate): assert isinstance(copy.copy(gate), Gate) assert isinstance(copy.deepcopy(gate), Gate) @@ -399,6 +405,10 @@ def test_copy(self, calibration: DefCalibration): assert isinstance(copy.copy(calibration), DefCalibration) assert isinstance(copy.deepcopy(calibration), DefCalibration) + def test_convert(self, calibration: DefCalibration): + rs_calibration = _convert_to_rs_instruction(calibration) + assert calibration == _convert_to_py_instruction(rs_calibration) + @pytest.mark.parametrize( ("qubit", "memory_reference", "instrs"), @@ -433,6 +443,10 @@ def test_copy(self, measure_calibration: DefMeasureCalibration): assert isinstance(copy.copy(measure_calibration), DefMeasureCalibration) assert isinstance(copy.deepcopy(measure_calibration), DefMeasureCalibration) + def test_convert(self, measure_calibration: DefMeasureCalibration): + rs_measure_calibration = _convert_to_rs_instruction(measure_calibration) + assert measure_calibration == _convert_to_py_instruction(rs_measure_calibration) + @pytest.mark.parametrize( ("qubit", "classical_reg"), @@ -472,6 +486,10 @@ def test_copy(self, measurement: Measurement): assert isinstance(copy.copy(measurement), Measurement) assert isinstance(copy.deepcopy(measurement), Measurement) + def test_convert(self, measurement: Measurement): + rs_measurement = _convert_to_rs_instruction(measurement) + assert measurement == _convert_to_py_instruction(rs_measurement) + @pytest.mark.parametrize( ("frame", "direction", "initial_frequency", "hardware_object", "sample_rate", "center_frequency", "channel_delay"), @@ -560,6 +578,10 @@ def test_copy(self, def_frame: DefFrame): assert isinstance(copy.copy(def_frame), DefFrame) assert isinstance(copy.deepcopy(def_frame), DefFrame) + def test_convert(self, def_frame: DefFrame): + rs_def_frame = _convert_to_rs_instruction(def_frame) + assert def_frame == _convert_to_py_instruction(rs_def_frame) + @pytest.mark.parametrize( ("name", "memory_type", "memory_size", "shared_region", "offsets"), @@ -626,6 +648,10 @@ def test_copy(self, declare: Declare): assert isinstance(copy.copy(declare), Declare) assert isinstance(copy.deepcopy(declare), Declare) + def test_convert(self, declare: Declare): + rs_declare = _convert_to_rs_instruction(declare) + assert declare == _convert_to_py_instruction(rs_declare) + @pytest.mark.parametrize( ("command", "args", "freeform_string"), @@ -667,6 +693,10 @@ def test_copy(self, pragma: Pragma): assert isinstance(copy.copy(pragma), Pragma) assert isinstance(copy.deepcopy(pragma), Pragma) + def test_convert(self, pragma: Pragma): + rs_pragma = _convert_to_rs_instruction(pragma) + assert pragma == _convert_to_py_instruction(rs_pragma) + @pytest.mark.parametrize( ("qubit"), @@ -710,6 +740,10 @@ def test_copy(self, reset_qubit: Union[Reset, ResetQubit]): assert isinstance(copy.copy(reset_qubit), type(reset_qubit)) assert isinstance(copy.deepcopy(reset_qubit), type(reset_qubit)) + def test_convert(self, reset_qubit: Reset): + rs_reset_qubit = _convert_to_rs_instruction(reset_qubit) + assert reset_qubit == _convert_to_py_instruction(rs_reset_qubit) + @pytest.mark.parametrize( ("frames", "duration"), @@ -739,6 +773,10 @@ def test_copy(self, delay_frames: DelayFrames): assert isinstance(copy.copy(delay_frames), DelayFrames) assert isinstance(copy.deepcopy(delay_frames), DelayFrames) + def test_convert(self, delay_frames: DelayFrames): + rs_delay_frames = _convert_to_rs_instruction(delay_frames) + assert delay_frames == _convert_to_py_instruction(rs_delay_frames) + @pytest.mark.parametrize( ("qubits", "duration"), @@ -770,6 +808,10 @@ def test_copy(self, delay_qubits: DelayQubits): assert isinstance(copy.copy(delay_qubits), DelayQubits) assert isinstance(copy.deepcopy(delay_qubits), DelayQubits) + def test_convert(self, delay_qubits: DelayQubits): + rs_delay_qubits = _convert_to_rs_instruction(delay_qubits) + assert delay_qubits == _convert_to_py_instruction(rs_delay_qubits) + @pytest.mark.parametrize( ("qubits"), @@ -796,6 +838,10 @@ def test_copy(self, fence: Fence): assert isinstance(copy.copy(fence), Fence) assert isinstance(copy.deepcopy(fence), Fence) + def test_convert(self, fence: Fence): + rs_fence = _convert_to_rs_instruction(fence) + assert fence == _convert_to_py_instruction(rs_fence) + def test_fence_all(): fa = FenceAll() @@ -843,6 +889,10 @@ def test_copy(self, def_waveform: DefWaveform): assert isinstance(copy.copy(def_waveform), DefWaveform) assert isinstance(copy.deepcopy(def_waveform), DefWaveform) + def test_convert(self, def_waveform: DefWaveform): + rs_def_waveform = _convert_to_rs_instruction(def_waveform) + assert def_waveform == _convert_to_py_instruction(rs_def_waveform) + @pytest.mark.parametrize( ("name", "parameters", "qubit_variables", "instructions"), @@ -899,6 +949,10 @@ def test_copy(self, def_circuit: DefCircuit): assert isinstance(copy.copy(def_circuit), DefCircuit) assert isinstance(copy.deepcopy(def_circuit), DefCircuit) + def test_convert(self, def_circuit: DefCircuit): + rs_def_circuit = _convert_to_rs_instruction(def_circuit) + assert def_circuit == _convert_to_py_instruction(rs_def_circuit) + @pytest.mark.parametrize( ("frame", "kernel", "memory_region", "nonblocking"), @@ -956,6 +1010,10 @@ def test_copy(self, capture: Capture): assert isinstance(copy.copy(capture), Capture) assert isinstance(copy.deepcopy(capture), Capture) + def test_convert(self, capture: Capture): + rs_capture = _convert_to_rs_instruction(capture) + assert capture == _convert_to_py_instruction(rs_capture) + @pytest.mark.parametrize( ("frame", "waveform", "nonblocking"), @@ -1042,6 +1100,10 @@ def test_copy(self, pulse: Pulse): assert isinstance(copy.copy(pulse), Pulse) assert isinstance(copy.deepcopy(pulse), Pulse) + def test_convert(self, pulse: Pulse): + rs_pulse = _convert_to_rs_instruction(pulse) + assert pulse == _convert_to_py_instruction(rs_pulse) + @pytest.mark.parametrize( ("frame", "duration", "memory_region", "nonblocking"), @@ -1099,6 +1161,10 @@ def test_copy(self, raw_capture: RawCapture): assert isinstance(copy.copy(raw_capture), RawCapture) assert isinstance(copy.deepcopy(raw_capture), RawCapture) + def test_convert(self, raw_capture: RawCapture): + rs_raw_capture = _convert_to_rs_instruction(raw_capture) + assert raw_capture == _convert_to_py_instruction(rs_raw_capture) + @pytest.mark.parametrize( ("frame", "expression"), @@ -1161,6 +1227,11 @@ def test_copy(self, frame_mutation_instructions): assert isinstance(copy.copy(instr), type(instr)) assert isinstance(copy.deepcopy(instr), type(instr)) + def test_convert(self, frame_mutation_instructions): + for instr in frame_mutation_instructions: + rs_instr = _convert_to_rs_instruction(instr) + assert instr == _convert_to_py_instruction(rs_instr) + @pytest.mark.parametrize( ("frame_a", "frame_b"), @@ -1191,6 +1262,10 @@ def test_copy(self, swap_phase: SwapPhases): assert isinstance(copy.copy(swap_phase), SwapPhases) assert isinstance(copy.deepcopy(swap_phase), SwapPhases) + def test_convert(self, swap_phase: SwapPhases): + rs_swap_phase = _convert_to_rs_instruction(swap_phase) + assert swap_phase == _convert_to_py_instruction(rs_swap_phase) + @pytest.mark.parametrize( ("left", "right"), @@ -1222,6 +1297,10 @@ def test_copy(self, move: ClassicalMove): assert isinstance(copy.copy(move), ClassicalMove) assert isinstance(copy.deepcopy(move), ClassicalMove) + def test_convert(self, move: ClassicalMove): + rs_classical_move = _convert_to_rs_instruction(move) + assert move == _convert_to_py_instruction(rs_classical_move) + @pytest.mark.parametrize( ("left", "right"), @@ -1249,6 +1328,10 @@ def test_copy(self, exchange: ClassicalExchange): assert isinstance(copy.copy(exchange), ClassicalExchange) assert isinstance(copy.deepcopy(exchange), ClassicalExchange) + def test_convert(self, exchange: ClassicalExchange): + rs_classical_exchange = _convert_to_rs_instruction(exchange) + assert exchange == _convert_to_py_instruction(rs_classical_exchange) + @pytest.mark.parametrize( ("left", "right"), @@ -1276,6 +1359,10 @@ def test_copy(self, convert: ClassicalConvert): assert isinstance(copy.copy(convert), ClassicalConvert) assert isinstance(copy.deepcopy(convert), ClassicalConvert) + def test_convert(self, convert: ClassicalConvert): + rs_classical_convert = _convert_to_rs_instruction(convert) + assert convert == _convert_to_py_instruction(rs_classical_convert) + @pytest.mark.parametrize( ("target", "left", "right"), @@ -1308,6 +1395,10 @@ def test_copy(self, load: ClassicalLoad): assert isinstance(copy.copy(load), ClassicalLoad) assert isinstance(copy.deepcopy(load), ClassicalLoad) + def test_convert(self, load: ClassicalLoad): + rs_classical_load = _convert_to_rs_instruction(load) + assert load == _convert_to_py_instruction(rs_classical_load) + @pytest.mark.parametrize( ("target", "left", "right"), @@ -1319,30 +1410,34 @@ def test_copy(self, load: ClassicalLoad): ) class TestClassicalStore: @pytest.fixture - def load(self, target: str, left: MemoryReference, right: MemoryReference) -> ClassicalStore: + def store(self, target: str, left: MemoryReference, right: MemoryReference) -> ClassicalStore: return ClassicalStore(target, left, right) - def test_out(self, load: ClassicalStore, snapshot: SnapshotAssertion): - assert load.out() == snapshot + def test_out(self, store: ClassicalStore, snapshot: SnapshotAssertion): + assert store.out() == snapshot - def test_target(self, load: ClassicalStore, target: str): - assert load.target == target - load.target = "new-target" - assert load.target == "new-target" + def test_target(self, store: ClassicalStore, target: str): + assert store.target == target + store.target = "new-target" + assert store.target == "new-target" - def test_left(self, load: ClassicalStore, left: MemoryReference): - assert load.left == left - load.left = MemoryReference("new-memory-reference") - assert load.left == MemoryReference("new-memory-reference") + def test_left(self, store: ClassicalStore, left: MemoryReference): + assert store.left == left + store.left = MemoryReference("new-memory-reference") + assert store.left == MemoryReference("new-memory-reference") - def test_right(self, load: ClassicalStore, right: Union[MemoryReference, int, float]): - assert load.right == right - load.right = MemoryReference("new-memory-reference") - assert load.right == MemoryReference("new-memory-reference") + def test_right(self, store: ClassicalStore, right: Union[MemoryReference, int, float]): + assert store.right == right + store.right = MemoryReference("new-memory-reference") + assert store.right == MemoryReference("new-memory-reference") + + def test_copy(self, store: ClassicalStore): + assert isinstance(copy.copy(store), ClassicalStore) + assert isinstance(copy.deepcopy(store), ClassicalStore) - def test_copy(self, load: ClassicalStore): - assert isinstance(copy.copy(load), ClassicalStore) - assert isinstance(copy.deepcopy(load), ClassicalStore) + def test_convert(self, store: ClassicalStore): + rs_classical_store = _convert_to_rs_instruction(store) + assert store == _convert_to_py_instruction(rs_classical_store) @pytest.mark.parametrize( @@ -1392,6 +1487,10 @@ def test_copy(self, comparison: ClassicalComparison): assert isinstance(copy.copy(comparison), type(comparison)) assert isinstance(copy.deepcopy(comparison), type(comparison)) + def test_convert(self, comparison: ClassicalComparison): + rs_classical_comparison = _convert_to_rs_instruction(comparison) + assert comparison == _convert_to_py_instruction(rs_classical_comparison) + @pytest.mark.parametrize( ("op", "target"), @@ -1420,6 +1519,10 @@ def test_copy(self, unary: UnaryClassicalInstruction): assert isinstance(copy.copy(unary), type(unary)) assert isinstance(copy.deepcopy(unary), type(unary)) + def test_convert(self, unary: UnaryClassicalInstruction): + rs_classical_unary = _convert_to_rs_instruction(unary) + assert unary == _convert_to_py_instruction(rs_classical_unary) + @pytest.mark.parametrize( ("op", "left", "right"), @@ -1467,6 +1570,10 @@ def valid_in_program(self, arithmetic): except Exception: pytest.fail("ArithmeticBinaryOp not valid in Program") + def test_convert(self, arithmetic: UnaryClassicalInstruction): + rs_classical_arithmetic = _convert_to_rs_instruction(arithmetic) + assert arithmetic == _convert_to_py_instruction(rs_classical_arithmetic) + @pytest.mark.parametrize( ("op", "left", "right"), @@ -1502,21 +1609,33 @@ def test_copy(self, logical: LogicalBinaryOp): assert isinstance(copy.copy(logical), type(logical)) assert isinstance(copy.deepcopy(logical), type(logical)) + def test_convert(self, logical: LogicalBinaryOp): + rs_classical_logical = _convert_to_rs_instruction(logical) + assert logical == _convert_to_py_instruction(rs_classical_logical) + def test_include(): include = Include("my-cool-file.quil") assert include.out() == 'INCLUDE "my-cool-file.quil"' include.filename = "my-other-file.quil" assert include.filename == "my-other-file.quil" + rs_include = _convert_to_rs_instruction(include) + assert include == _convert_to_py_instruction(rs_include) def test_wait(): assert Wait().out() == str(Wait()) == "WAIT" + rs_wait = _convert_to_rs_instruction(Wait()) + assert Wait() == _convert_to_py_instruction(rs_wait) def test_halt(): assert Halt().out() == str(Halt()) == "HALT" + rs_halt = _convert_to_rs_instruction(Halt()) + assert Halt() == _convert_to_py_instruction(rs_halt) def test_nop(): assert Nop().out() == str(Nop()) == "NOP" + rs_nop = _convert_to_rs_instruction(Nop()) + assert Nop() == _convert_to_py_instruction(rs_nop)