Handle failing tests

Author: ElePT

qiskit/circuit/quantumcircuit.py

@@ -1420,8 +1420,8 @@ def reverse_ops(self) -> "QuantumCircuit":
         for instruction in reversed(self.data):
             reverse_circ._append(instruction.replace(operation=instruction.operation.reverse_ops()))
 
-        reverse_circ.duration = self.duration
-        reverse_circ.unit = self.unit
+        reverse_circ._duration = self._duration
+        reverse_circ._unit = self._unit
         return reverse_circ
 
     def reverse_bits(self) -> "QuantumCircuit":
@@ -2559,8 +2559,8 @@ def _append(self, instruction, qargs=(), cargs=(), *, _standard_gate: bool = Fal
         """
         if _standard_gate:
             self._data.append(instruction)
-            self.duration = None
-            self.unit = "dt"
+            self._duration = None
+            self._unit = "dt"
             return instruction
 
         old_style = not isinstance(instruction, CircuitInstruction)
@@ -2582,8 +2582,8 @@ def _append(self, instruction, qargs=(), cargs=(), *, _standard_gate: bool = Fal
             self._data.append_manual_params(instruction, params)
 
         # Invalidate whole circuit duration if an instruction is added
-        self.duration = None
-        self.unit = "dt"
+        self._duration = None
+        self._unit = "dt"
         return instruction.operation if old_style else instruction
 
     @typing.overload
@@ -6951,7 +6951,7 @@ def qubit_start_time(self, *qubits: Union[Qubit, int]) -> float:
         Raises:
             CircuitError: if ``self`` is a not-yet scheduled circuit.
         """
-        if self.duration is None:
+        if self._duration is None:
             # circuit has only delays, this is kind of scheduled
             for instruction in self._data:
                 if not isinstance(instruction.operation, Delay):
@@ -6993,7 +6993,7 @@ def qubit_stop_time(self, *qubits: Union[Qubit, int]) -> float:
         Raises:
             CircuitError: if ``self`` is a not-yet scheduled circuit.
         """
-        if self.duration is None:
+        if self._duration is None:
             # circuit has only delays, this is kind of scheduled
             for instruction in self._data:
                 if not isinstance(instruction.operation, Delay):
@@ -7004,7 +7004,7 @@ def qubit_stop_time(self, *qubits: Union[Qubit, int]) -> float:
 
         qubits = [self.qubits[q] if isinstance(q, int) else q for q in qubits]
 
-        stops = {q: self.duration for q in qubits}
+        stops = {q: self._duration for q in qubits}
         dones = {q: False for q in qubits}
         for instruction in reversed(self._data):
             for q in qubits:

qiskit/transpiler/passes/scheduling/padding/base_padding.py

@@ -124,7 +124,7 @@ def run(self, dag: DAGCircuit):
 
         new_dag.name = dag.name
         new_dag.metadata = dag.metadata
-        new_dag.unit = self.property_set["time_unit"]
+        new_dag._unit = self.property_set["time_unit"]
         new_dag.global_phase = dag.global_phase
 
         idle_after = {bit: 0 for bit in dag.qubits}

test/python/circuit/test_scheduled_circuit.py

@@ -51,8 +51,9 @@ def test_schedule_circuit_when_backend_tells_dt(self):
         backend = GenericBackendV2(2, seed=42)
 
         sc = transpile(qc, backend, scheduling_method="alap", layout_method="trivial")
-        self.assertEqual(sc.duration, 451095)
-        self.assertEqual(sc.unit, "dt")
+        with self.assertRaises(DeprecationWarning):
+            self.assertEqual(sc.duration, 451095)
+            self.assertEqual(sc.unit, "dt")
         self.assertEqual(sc.data[0].operation.name, "delay")
         self.assertEqual(sc.data[0].operation.duration, 450900)
         self.assertEqual(sc.data[0].operation.unit, "dt")
@@ -77,8 +78,9 @@ def test_schedule_circuit_when_transpile_option_tells_dt(self):
             seed_transpiler=20,
         )
         target_durations = self.backend_with_dt.target.durations()
-        self.assertAlmostEqual(sc.duration, (450450 + target_durations.get("sx", 0)))
-        self.assertEqual(sc.unit, "dt")
+        with self.assertRaises(DeprecationWarning):
+            self.assertAlmostEqual(sc.duration, (450450 + target_durations.get("sx", 0)))
+            self.assertEqual(sc.unit, "dt")
         self.assertEqual(sc.data[0].operation.name, "delay")
         self.assertEqual(sc.data[0].operation.duration, 450450)
         self.assertEqual(sc.data[0].operation.unit, "dt")
@@ -101,8 +103,10 @@ def test_schedule_circuit_in_sec_when_no_one_tells_dt(self):
             qc, self.backend_without_dt, scheduling_method="alap", layout_method="trivial"
         )
         target_durations = self.backend_with_dt.target.durations()
-        self.assertAlmostEqual(sc.duration, (450450 + target_durations.get("sx", 0)) * self.dt)
-        self.assertEqual(sc.unit, "s")
+
+        with self.assertRaises(DeprecationWarning):
+            self.assertAlmostEqual(sc.duration, (450450 + target_durations.get("sx", 0)) * self.dt)
+            self.assertEqual(sc.unit, "s")
         self.assertEqual(sc.data[0].operation.name, "delay")
         self.assertAlmostEqual(sc.data[0].operation.duration, 1.0e-4 + 1.0e-7)
         self.assertEqual(sc.data[0].operation.unit, "s")
@@ -125,7 +129,8 @@ def test_transpile_single_delay_circuit(self):
         qc = QuantumCircuit(1)
         qc.delay(1234, 0)
         sc = transpile(qc, backend=self.backend_with_dt, scheduling_method="alap")
-        self.assertEqual(sc.duration, 1234)
+        with self.assertRaises(DeprecationWarning):
+            self.assertEqual(sc.duration, 1234)
         self.assertEqual(sc.data[0].operation.name, "delay")
         self.assertEqual(sc.data[0].operation.duration, 1234)
         self.assertEqual(sc.data[0].operation.unit, "dt")
@@ -141,7 +146,8 @@ def test_transpile_t1_circuit(self):
         expected_scheduled = (
             target_durations.get("x", 1) + 4500 + target_durations.get("measure", 1)
         )
-        self.assertEqual(scheduled.duration, expected_scheduled)
+        with self.assertRaises(DeprecationWarning):
+            self.assertEqual(scheduled.duration, expected_scheduled)
 
     def test_transpile_delay_circuit_with_backend(self):
         qc = QuantumCircuit(2)
@@ -152,7 +158,8 @@ def test_transpile_delay_circuit_with_backend(self):
             qc, backend=self.backend_with_dt, scheduling_method="alap", layout_method="trivial"
         )
         target_durations = self.backend_with_dt.target.durations()
-        self.assertEqual(scheduled.duration, target_durations.get("cx", (0, 1)) + 450)
+        with self.assertRaises(DeprecationWarning):
+            self.assertEqual(scheduled.duration, target_durations.get("cx", (0, 1)) + 450)
 
     def test_transpile_circuit_with_custom_instruction(self):
         """See: https://github.com/Qiskit/qiskit-terra/issues/5154"""
@@ -184,13 +191,15 @@ def test_transpile_circuit_with_custom_instruction(self):
             target=target,
             dt=1e-2,
         )
-        self.assertEqual(scheduled.duration, 1500)
+        with self.assertRaises(DeprecationWarning):
+            self.assertEqual(scheduled.duration, 1500)
 
     def test_transpile_delay_circuit_with_dt_but_without_scheduling_method(self):
         qc = QuantumCircuit(1)
         qc.delay(100, 0, unit="ns")
         transpiled = transpile(qc, backend=self.backend_with_dt)
-        self.assertEqual(transpiled.duration, None)  # not scheduled
+        with self.assertRaises(DeprecationWarning):
+            self.assertEqual(transpiled.duration, None)  # not scheduled
         self.assertEqual(transpiled.data[0].operation.duration, 450)  # unit is converted ns -> dt
 
     def test_transpile_delay_circuit_without_scheduling_method_or_durs(self):
@@ -199,7 +208,8 @@ def test_transpile_delay_circuit_without_scheduling_method_or_durs(self):
         qc.delay(500, 1)
         qc.cx(0, 1)
         not_scheduled = transpile(qc)
-        self.assertEqual(not_scheduled.duration, None)
+        with self.assertRaises(DeprecationWarning):
+            self.assertEqual(not_scheduled.duration, None)
 
     def test_raise_error_if_transpile_with_scheduling_method_but_without_durations(self):
         qc = QuantumCircuit(2)
@@ -217,7 +227,8 @@ def test_invalidate_schedule_circuit_if_new_instruction_is_appended(self):
         scheduled = transpile(qc, backend=self.backend_with_dt, scheduling_method="alap")
         # append a gate to a scheduled circuit
         scheduled.h(0)
-        self.assertEqual(scheduled.duration, None)
+        with self.assertRaises(DeprecationWarning):
+            self.assertEqual(scheduled.duration, None)
 
     def test_unit_seconds_when_using_backend_durations(self):
         qc = QuantumCircuit(2)
@@ -229,7 +240,8 @@ def test_unit_seconds_when_using_backend_durations(self):
             qc, backend=self.backend_with_dt, scheduling_method="alap", layout_method="trivial"
         )
         target_durations = self.backend_with_dt.target.durations()
-        self.assertEqual(scheduled.duration, target_durations.get("cx", (0, 1)) + 500)
+        with self.assertRaises(DeprecationWarning):
+            self.assertEqual(scheduled.duration, target_durations.get("cx", (0, 1)) + 500)
 
     def test_per_qubit_durations(self):
         """Test target with custom instruction_durations"""
@@ -288,29 +300,32 @@ def test_convert_duration_to_dt(self):
         circ.measure_all()
 
         circuit_dt = transpile(circ, backend, scheduling_method="asap")
-        # reference duration and unit in dt
-        ref_duration = circuit_dt.duration
-        ref_unit = circuit_dt.unit
-
-        circuit_s = circuit_dt.copy()
-        circuit_s.duration *= backend.dt
-        circuit_s.unit = "s"
-
-        circuit_ms = circuit_s.copy()
-        circuit_ms.duration *= 1000
-        circuit_ms.unit = "ms"
-
-        for circuit in [circuit_dt, circuit_s, circuit_ms]:
-            with self.subTest(circuit=circuit):
-                converted_circ = convert_durations_to_dt(circuit, dt_in_sec=2.22e-10, inplace=False)
-                self.assertEqual(
-                    converted_circ.duration,
-                    ref_duration,
-                )
-                self.assertEqual(
-                    converted_circ.unit,
-                    ref_unit,
-                )
+        with self.assertRaises(DeprecationWarning):
+            # reference duration and unit in dt
+            ref_duration = circuit_dt.duration
+            ref_unit = circuit_dt.unit
+
+            circuit_s = circuit_dt.copy()
+            circuit_s.duration *= backend.dt
+            circuit_s.unit = "s"
+
+            circuit_ms = circuit_s.copy()
+            circuit_ms.duration *= 1000
+            circuit_ms.unit = "ms"
+
+            for circuit in [circuit_dt, circuit_s, circuit_ms]:
+                with self.subTest(circuit=circuit):
+                    converted_circ = convert_durations_to_dt(
+                        circuit, dt_in_sec=2.22e-10, inplace=False
+                    )
+                    self.assertEqual(
+                        converted_circ.duration,
+                        ref_duration,
+                    )
+                    self.assertEqual(
+                        converted_circ.unit,
+                        ref_unit,
+                    )
 
     @data("s", "dt", "f", "p", "n", "u", "µ", "m", "k", "M", "G", "T", "P")
     def test_estimate_duration(self, unit):
@@ -475,15 +490,17 @@ def test_change_dt_in_transpile(self):
             backend=GenericBackendV2(1, basis_gates=["x"], seed=2, dt=self.dt),
             scheduling_method="asap",
         )
-        org_duration = scheduled.duration
+        with self.assertRaises(DeprecationWarning):
+            org_duration = scheduled.duration
         # halve dt in sec = double duration in dt
         scheduled = transpile(
             qc,
             backend=GenericBackendV2(1, basis_gates=["x"], seed=2, dt=self.dt),
             scheduling_method="asap",
             dt=self.dt / 2,
         )
-        self.assertEqual(scheduled.duration, org_duration * 2)
+        with self.assertRaises(DeprecationWarning):
+            self.assertEqual(scheduled.duration, org_duration * 2)
 
     @data("asap", "alap")
     def test_duration_on_same_instruction_instance(self, scheduling_method):
@@ -509,7 +526,8 @@ def test_can_transpile_circuits_after_assigning_parameters(self):
         qc.measure(0, 0)
         qc = qc.assign_parameters({idle_dur: 0.1})
         circ = transpile(qc, self.backend_with_dt)
-        self.assertEqual(circ.duration, None)  # not scheduled
+        with self.assertRaises(DeprecationWarning):
+            self.assertEqual(circ.duration, None)  # not scheduled
         self.assertEqual(circ.data[1].operation.duration, 450)  # converted in dt
 
     def test_can_transpile_circuits_with_assigning_parameters_inbetween(self):
@@ -531,7 +549,8 @@ def test_can_transpile_circuits_with_unbounded_parameters(self):
         qc.measure(0, 0)
         # not assign parameter
         circ = transpile(qc, self.backend_with_dt)
-        self.assertEqual(circ.duration, None)  # not scheduled
+        with self.assertRaises(DeprecationWarning):
+            self.assertEqual(circ.duration, None)  # not scheduled
         self.assertEqual(circ.data[1].operation.unit, "dt")  # converted in dt
         self.assertEqual(
             circ.data[1].operation.duration, idle_dur * 1e-6 / self.dt
@@ -546,7 +565,8 @@ def test_can_schedule_circuits_with_bounded_parameters(self, scheduling_method):
         qc.measure(0, 0)
         qc = qc.assign_parameters({idle_dur: 0.1})
         circ = transpile(qc, self.backend_with_dt, scheduling_method=scheduling_method)
-        self.assertIsNotNone(circ.duration)  # scheduled
+        with self.assertRaises(DeprecationWarning):
+            self.assertIsNotNone(circ.duration)  # scheduled
 
     @data("asap", "alap")
     def test_fail_to_schedule_circuits_with_unbounded_parameters(self, scheduling_method):

test/python/compiler/test_transpiler.py

@@ -1318,8 +1318,9 @@ def test_circuit_with_delay(self, optimization_level):
             seed_transpiler=42,
         )
 
-        self.assertEqual(out.unit, "dt")
-        self.assertEqual(out.duration, 1200)
+        with self.assertRaises(DeprecationWarning):
+            self.assertEqual(out.unit, "dt")
+            self.assertEqual(out.duration, 1200)
 
     @data(0, 1, 2, 3)
     def test_circuit_with_delay_expr_duration(self, optimization_level):
@@ -1355,8 +1356,9 @@ def test_circuit_with_delay_expr_duration(self, optimization_level):
             seed_transpiler=42,
         )
 
-        self.assertEqual(out.unit, "dt")
-        self.assertEqual(out.duration, 1200)
+        with self.assertRaises(DeprecationWarning):
+            self.assertEqual(out.unit, "dt")
+            self.assertEqual(out.duration, 1200)
 
     def test_delay_converts_to_dt(self):
         """Test that a delay instruction is converted to units of dt given a backend."""
@@ -1647,7 +1649,8 @@ def test_scheduling_instruction_constraints_backend(self):
             scheduling_method="alap",
             layout_method="trivial",
         )
-        self.assertEqual(scheduled.duration, 9010)
+        with self.assertRaises(DeprecationWarning):
+            self.assertEqual(scheduled.duration, 9010)
 
     def test_scheduling_instruction_constraints(self):
         """Test that scheduling-related loose transpile constraints work with target."""
@@ -1671,7 +1674,8 @@ def test_scheduling_instruction_constraints(self):
             scheduling_method="alap",
             layout_method="trivial",
         )
-        self.assertEqual(scheduled.duration, 9010)
+        with self.assertRaises(DeprecationWarning):
+            self.assertEqual(scheduled.duration, 9010)
 
     def test_scheduling_dt_constraints(self):
         """Test that scheduling-related loose transpile constraints
@@ -1683,11 +1687,13 @@ def test_scheduling_dt_constraints(self):
         qc.x(0)
         qc.measure(0, 0)
         scheduled = transpile(qc, backend=backend_v2, scheduling_method="asap")
-        original_duration = scheduled.duration
+        with self.assertRaises(DeprecationWarning):
+            original_duration = scheduled.duration
 
         # halve dt in sec = double duration in dt
         scheduled = transpile(qc, backend=backend_v2, scheduling_method="asap", dt=original_dt / 2)
-        self.assertEqual(scheduled.duration, original_duration * 2)
+        with self.assertRaises(DeprecationWarning):
+            self.assertEqual(scheduled.duration, original_duration * 2)
 
     @data(1, 2, 3)
     def test_no_infinite_loop(self, optimization_level):

test/python/dagcircuit/test_dagcircuit.py

@@ -498,8 +498,9 @@ def test_copy_empty_like(self):
         self.assertEqual(self.dag.qubits, result_dag.qubits)
         self.assertEqual(self.dag.cregs, result_dag.cregs)
         self.assertEqual(self.dag.qregs, result_dag.qregs)
-        self.assertEqual(self.dag.duration, result_dag.duration)
-        self.assertEqual(self.dag.unit, result_dag.unit)
+        with self.assertRaises(DeprecationWarning):
+            self.assertEqual(self.dag.duration, result_dag.duration)
+            self.assertEqual(self.dag.unit, result_dag.unit)
 
     def test_copy_empty_like_vars(self):
         """Variables should be part of the empty copy."""