Fix all tests

qupulse/_program/tabor.py

@@ -53,21 +53,21 @@ class TaborSegment:
     __slots__ = ('_data', '_hash')
 
     @staticmethod
-    def _data_a_view(data: np.ndarray) -> np.ndarray:
+    def _data_a_view(data: np.ndarray, writable: bool) -> np.ndarray:
         view = data[:, 1, :]
-        assert view.base is data
+        assert not writable or view.base is data
         return view
 
     @staticmethod
-    def _data_b_view(data: np.ndarray) -> np.ndarray:
+    def _data_b_view(data: np.ndarray, writable: bool) -> np.ndarray:
         view = data[:, 0, :]
-        assert view.base is data
+        assert not writable or view.base is data
         return view
 
     @staticmethod
-    def _marker_data_view(data: np.ndarray) -> np.ndarray:
+    def _marker_data_view(data: np.ndarray, writable: bool) -> np.ndarray:
         view = data.reshape((-1, 2, 2, 8))[:, 1, 1, :]
-        assert view.base is data
+        assert not writable or view.base is data
         return view
 
     def __init__(self, *,
@@ -94,11 +94,11 @@ def native(self) -> np.ndarray:
 
     @property
     def data_a(self) -> np.ndarray:
-        return self._data_a_view(self._data).reshape(-1)
+        return self._data_a_view(self._data, writable=False).reshape(-1)
 
     @property
     def data_b(self) -> np.ndarray:
-        return self._data_b_view(self._data).reshape(-1)
+        return self._data_b_view(self._data, writable=False).reshape(-1)
 
     @classmethod
     def from_sampled(cls,
@@ -133,9 +133,9 @@ def from_sampled(cls,
         assert num_points % cls.QUANTUM == 0
 
         data = np.full((num_points // cls.QUANTUM, 2, cls.QUANTUM), cls.ZERO_VAL, dtype=np.uint16)
-        data_a = cls._data_a_view(data)
-        data_b = cls._data_b_view(data)
-        marker_view = cls._marker_data_view(data)
+        data_a = cls._data_a_view(data, writable=True)
+        data_b = cls._data_b_view(data, writable=True)
+        marker_view = cls._marker_data_view(data, writable=True)
 
         if ch_a is not None:
             data_a[:] = ch_a.reshape((-1, cls.QUANTUM))
@@ -165,12 +165,12 @@ def ch_b(self):
 
     @property
     def marker_a(self) -> np.ndarray:
-        marker_data = self._marker_data_view(self._data)
+        marker_data = self._marker_data_view(self._data, writable=False)
         return np.bitwise_and(marker_data, self.MARKER_A_MASK).astype(bool).reshape(-1)
 
     @property
     def marker_b(self) -> np.ndarray:
-        marker_data = self._marker_data_view(self._data)
+        marker_data = self._marker_data_view(self._data, writable=False)
         return np.bitwise_and(marker_data, self.MARKER_B_MASK).astype(bool).reshape(-1)
 
     @classmethod
@@ -180,8 +180,8 @@ def from_binary_data(cls, data_a: np.ndarray, data_b: np.ndarray) -> 'TaborSegme
         assert data_a.size % 16 == 0
 
         data = np.empty((data_a.size // 16, 2, 16), dtype=np.uint16)
-        cls._data_a_view(data)[:] = data_a.reshape((-1, 16))
-        cls._data_b_view(data)[:] = data_b.reshape((-1, 16))
+        cls._data_a_view(data, writable=True)[:] = data_a.reshape((-1, 16))
+        cls._data_b_view(data, writable=True)[:] = data_b.reshape((-1, 16))
 
         return cls(data=data)
 

tests/_program/tabor_tests.py

@@ -173,23 +173,24 @@ def root_loop(self):
                                                          duration_generator=itertools.repeat(1)))
 
     def test_init(self):
-        prog = MultiChannelProgram(MultiChannelTests().root_block)
-        tabor_program = TaborProgram(prog['A'], self.instr_props, ('A', None), (None, None), **self.program_entry_kwargs)
+        prog = self.root_loop
+        tabor_program = TaborProgram(prog, self.instr_props, ('A', None), (None, None), **self.program_entry_kwargs)
 
         self.assertEqual(tabor_program.channels, ('A', None))
         self.assertEqual(tabor_program.markers, (None, None))
-        self.assertIs(prog['A'], tabor_program.program)
+        self.assertIs(prog, tabor_program.program)
         self.assertIs(self.instr_props, tabor_program._device_properties)
         self.assertEqual(frozenset('A'), tabor_program._used_channels)
         self.assertEqual(TaborSequencing.ADVANCED, tabor_program._mode)
 
         with self.assertRaises(KeyError):
-            TaborProgram(prog['A'], self.instr_props, ('A', 'B'), (None, None), **self.program_entry_kwargs)
+            # C not in prog
+            TaborProgram(prog, self.instr_props, ('A', 'C'), (None, None), **self.program_entry_kwargs)
 
         with self.assertRaises(TaborException):
-            TaborProgram(prog['A'], self.instr_props, ('A', 'B'), (None, None, None), **self.program_entry_kwargs)
+            TaborProgram(prog, self.instr_props, ('A', 'B'), (None, None, None), **self.program_entry_kwargs)
         with self.assertRaises(TaborException):
-            TaborProgram(prog['A'], self.instr_props, ('A', 'B', 'C'), (None, None), **self.program_entry_kwargs)
+            TaborProgram(prog, self.instr_props, ('A', 'B', 'C'), (None, None), **self.program_entry_kwargs)
 
     def test_depth_0_single_waveform(self):
         program = Loop(waveform=DummyWaveform(defined_channels={'A'}, duration=1), repetition_count=3)
@@ -333,18 +334,13 @@ def my_gen(gen):
                 duration_generator=itertools.repeat(1/200),
                 num_channels=4))
 
-            mcp = MultiChannelProgram(InstructionBlock(), tuple())
-            mcp.programs[frozenset(('A', 'B', 'C', 'D'))] = root_loop
             TaborProgram(root_loop, self.instr_props, ('A', 'B'), (None, None), **self.program_entry_kwargs)
 
         root_loop = LoopTests.get_test_loop(WaveformGenerator(
             waveform_data_generator=my_gen(self.waveform_data_generator),
             duration_generator=itertools.repeat(1),
             num_channels=4))
 
-        mcp = MultiChannelProgram(InstructionBlock(), tuple())
-        mcp.programs[frozenset(('A', 'B', 'C', 'D'))] = root_loop
-
         prog = TaborProgram(root_loop, self.instr_props, ('A', 'B'), (None, None), **self.program_entry_kwargs)
 
         sampled, sampled_length = prog.get_sampled_segments()