qubasic 0.12.0__tar.gz → 0.13.0__tar.gz

{qubasic-0.12.0 → qubasic-0.13.0}/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.13.0 (2026-06-19)
+
+Closes the remaining audit gaps in the classic-BASIC layer (conventions,
+inspection, and an agent contract). The quantum engine is unchanged.
+
+### Added
+- `qubasic --spec` emits a machine-readable JSON contract (version, commands with arg flag and one-line help, gates, functions, constants, bit order) so an agent can load the exact surface of the installed version.
+- `REDIM PRESERVE name(n)` keeps existing elements; plain `REDIM` clears to zeros (QBASIC semantics).
+- `DENSITY` shows the density matrix after a measured `SET_DENSITY` run, not only a no-MEASURE one.
+
+### Changed
+- `DIM` uses inclusive sizing: `DIM a(n)` spans indices base..n (the declared top index is valid), matching QBASIC instead of the previous C-style element count.
+- `round()` rounds half away from zero (`round(2.5)` = 3), not Python's banker's rounding.
+- `STR$(n)` reserves a leading space for non-negative numbers (`STR$(42)` = " 42").
+- A chained comparison such as `a < b < c` now raises a clear "ambiguous" error instead of silently using Python chaining; write `(a < b) AND (b < c)`.
+- `PRINT`ing a mid-circuit measurement bit (`MEAS`/`SYNDROME -> var`) shows "mid-circuit bit, resolved per shot" rather than the placeholder 0.
+
 ## 0.12.0 (2026-06-19)
 
 Correctness and robustness pass on the classic-BASIC layer, from an extended

{qubasic-0.12.0/qubasic.egg-info → qubasic-0.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qubasic
-Version: 0.12.0
+Version: 0.13.0
 Summary: Quantum BASIC Interactive Terminal
 Author-email: "Charles C. Norton" <machineelv@gmail.com>
 License-Expression: MIT
@@ -78,6 +78,7 @@ python -m qubasic_core         Same, without installing
 qubasic script.qb             Run a script file
 qubasic --quiet script         Suppress banner, output results only
 qubasic --json script          Machine-readable JSON output
+qubasic --spec                Print a JSON contract (commands, gates, functions)
 qubasic --help                Show CLI help
 ```
 
@@ -256,12 +257,13 @@ DIM data(10)            1D array
 DIM matrix(3, 3)        Multi-dimensional (flat storage)
 LET data(0) = PI
 LET names$(0) = "alice" String array (name$ elements hold strings)
-REDIM data(20)          Resize (preserves existing data)
+REDIM data(20)          Resize, clearing to zeros
+REDIM PRESERVE data(20) Resize, keeping existing data
 ERASE data              Delete array
 OPTION BASE 1           Set array index base
 ```
 
-A `DIM`med array enforces its declared bounds on write; an undimensioned array grows on first assignment.
+`DIM a(n)` is inclusive: it spans indices base..n, so the declared top index is valid. A `DIM`med array enforces its declared bounds on write; an undimensioned array grows on first assignment.
 
 ## Control flow
 

{qubasic-0.12.0 → qubasic-0.13.0}/README.md

@@ -45,6 +45,7 @@ python -m qubasic_core         Same, without installing
 qubasic script.qb             Run a script file
 qubasic --quiet script         Suppress banner, output results only
 qubasic --json script          Machine-readable JSON output
+qubasic --spec                Print a JSON contract (commands, gates, functions)
 qubasic --help                Show CLI help
 ```
 
@@ -223,12 +224,13 @@ DIM data(10)            1D array
 DIM matrix(3, 3)        Multi-dimensional (flat storage)
 LET data(0) = PI
 LET names$(0) = "alice" String array (name$ elements hold strings)
-REDIM data(20)          Resize (preserves existing data)
+REDIM data(20)          Resize, clearing to zeros
+REDIM PRESERVE data(20) Resize, keeping existing data
 ERASE data              Delete array
 OPTION BASE 1           Set array index base
 ```
 
-A `DIM`med array enforces its declared bounds on write; an undimensioned array grows on first assignment.
+`DIM a(n)` is inclusive: it spans indices base..n, so the declared top index is valid. A `DIM`med array enforces its declared bounds on write; an undimensioned array grows on first assignment.
 
 ## Control flow
 

{qubasic-0.12.0 → qubasic-0.13.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qubasic"
-version = "0.12.0"
+version = "0.13.0"
 description = "Quantum BASIC Interactive Terminal"
 readme = "README.md"
 requires-python = ">=3.10"

{qubasic-0.12.0 → qubasic-0.13.0/qubasic.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qubasic
-Version: 0.12.0
+Version: 0.13.0
 Summary: Quantum BASIC Interactive Terminal
 Author-email: "Charles C. Norton" <machineelv@gmail.com>
 License-Expression: MIT
@@ -78,6 +78,7 @@ python -m qubasic_core         Same, without installing
 qubasic script.qb             Run a script file
 qubasic --quiet script         Suppress banner, output results only
 qubasic --json script          Machine-readable JSON output
+qubasic --spec                Print a JSON contract (commands, gates, functions)
 qubasic --help                Show CLI help
 ```
 
@@ -256,12 +257,13 @@ DIM data(10)            1D array
 DIM matrix(3, 3)        Multi-dimensional (flat storage)
 LET data(0) = PI
 LET names$(0) = "alice" String array (name$ elements hold strings)
-REDIM data(20)          Resize (preserves existing data)
+REDIM data(20)          Resize, clearing to zeros
+REDIM PRESERVE data(20) Resize, keeping existing data
 ERASE data              Delete array
 OPTION BASE 1           Set array index base
 ```
 
-A `DIM`med array enforces its declared bounds on write; an undimensioned array grows on first assignment.
+`DIM a(n)` is inclusive: it spans indices base..n, so the declared top index is valid. A `DIM`med array enforces its declared bounds on write; an undimensioned array grows on first assignment.
 
 ## Control flow
 

{qubasic-0.12.0 → qubasic-0.13.0}/qubasic_core/__init__.py

@@ -28,7 +28,7 @@ __all__ = [
     'GATE_TABLE', 'GATE_ALIASES',
 ]
 
-__version__ = '0.12.0'
+__version__ = '0.13.0'
 
 def __getattr__(name):
     """Lazy import heavy modules on first access."""

{qubasic-0.12.0 → qubasic-0.13.0}/qubasic_core/cli.py

@@ -57,8 +57,9 @@ def main():
     quiet = '--quiet' in args or '-q' in args
     json_mode = '--json' in args
     agent_mode = '--agent' in args
+    spec_mode = '--spec' in args
     seed_val = None
-    for flag in ('--quiet', '-q', '--json', '--agent'):
+    for flag in ('--quiet', '-q', '--json', '--agent', '--spec'):
         args = [a for a in args if a != flag]
     # Parse --seed N
     filtered = []
@@ -93,6 +94,37 @@ def main():
         print("Type HELP inside the REPL for full command reference.")
         sys.exit(0)
 
+    if spec_mode:
+        # Machine-readable contract for agents: commands, gates, functions,
+        # constants, and conventions for the installed version.
+        from qubasic_core.engine import GATE_TABLE
+        from qubasic_core.expression import ExpressionMixin
+
+        def _help1(mname):
+            doc = (getattr(getattr(QBasicTerminal, mname, None), '__doc__', '') or '').strip()
+            return doc.split('\n')[0].strip()
+
+        cmds = []
+        for tbl, takes in ((QBasicTerminal._CMD_WITH_ARG, True),
+                           (QBasicTerminal._CMD_NO_ARG, False)):
+            for cname, mname in tbl.items():
+                cmds.append({'name': cname, 'takes_arg': takes, 'help': _help1(mname)})
+        spec = {
+            'name': 'qubasic',
+            'version': __version__,
+            'bit_order': 'little-endian (qubit 0 = rightmost bit)',
+            'commands': sorted(cmds, key=lambda c: c['name']),
+            'gates': sorted(GATE_TABLE.keys()),
+            'functions': sorted(
+                set(ExpressionMixin._SAFE_FUNCS)
+                | {'RND', 'TIMER', 'POS', 'PEEK', 'USR', 'EOF', 'FRE',
+                   'LEFT$', 'RIGHT$', 'MID$', 'CHR$', 'STR$', 'HEX$', 'BIN$',
+                   'ASC', 'VAL', 'INSTR', 'LEN'}),
+            'constants': sorted(ExpressionMixin._SAFE_CONSTS.keys()),
+        }
+        print(_json.dumps(spec, indent=2))
+        sys.exit(0)
+
     term = QBasicTerminal()
     # JSON mode implies agent use, so confine file writes to the working dir.
     term.agent_mode = agent_mode or json_mode

{qubasic-0.12.0 → qubasic-0.13.0}/qubasic_core/control_flow.py

@@ -184,6 +184,12 @@ class ControlFlowMixin:
         # Quoted literal: emit verbatim (no substitution, no SPC/TAB).
         if (item[0] == '"' and item[-1] == '"') or (item[0] == "'" and item[-1] == "'"):
             return item[1:-1]
+        # A mid-circuit measurement bit (MEAS/SYNDROME -> var) has no single
+        # value in standard mode; it is resolved per shot inside the if_test.
+        # Show that instead of the placeholder 0.
+        cb = getattr(self, '_classical_bits', None)
+        if cb and item in cb:
+            return f"<{item}: mid-circuit bit, resolved per shot>"
         text = self._substitute_vars(item, run_vars)
 
         def _spaces(m):

{qubasic-0.12.0 → qubasic-0.13.0}/qubasic_core/expression.py

@@ -124,6 +124,18 @@ def _basic_xor(a: Any, b: Any) -> int:
     return _as_int(a) ^ _as_int(b)
 
 
+def _basic_round(x: Any, ndigits: Any = None) -> float:
+    """Round half away from zero (BASIC convention), not Python's half-to-even.
+
+    round(2.5) == 3, round(-2.5) == -3, round(2.345, 2) == 2.35.
+    """
+    nd = int(ndigits) if ndigits is not None else 0
+    f = 10 ** nd
+    y = float(x) * f
+    r = math.floor(y + 0.5) if y >= 0 else math.ceil(y - 0.5)
+    return (r / f) if nd else float(r)
+
+
 class ExpressionMixin:
     """AST-based safe expression evaluation. No eval().
 
@@ -138,7 +150,7 @@ class ExpressionMixin:
         # INT floors toward negative infinity, as in QBASIC (INT(-3.2) = -4).
         # FIX truncates toward zero (FIX(-3.2) = -3) for the other convention.
         'abs': abs, 'int': math.floor, 'fix': math.trunc, 'float': float,
-        'min': min, 'max': max, 'round': round, 'len': len,
+        'min': min, 'max': max, 'round': _basic_round, 'len': len,
         'ceil': math.ceil, 'floor': math.floor,
     }
     _SAFE_CONSTS = {
@@ -203,16 +215,18 @@ class ExpressionMixin:
                 result = op(result, self._ast_eval(val, ns))
             return result
         if isinstance(node, ast.Compare):
-            left = self._ast_eval(node.left, ns)
-            for op_node, comparator in zip(node.ops, node.comparators):
-                op = self._AST_OPS.get(type(op_node))
-                if op is None:
-                    raise ValueError(f"UNSUPPORTED OP: {type(op_node).__name__}")
-                right = self._ast_eval(comparator, ns)
-                if not op(left, right):
-                    return False
-                left = right
-            return True
+            # A chained comparison (a < b < c) is ambiguous: Python reads it as
+            # (a<b) and (b<c), BASIC as the left-to-right (a<b)<c. Rather than
+            # pick one silently, require it to be written explicitly.
+            if len(node.ops) > 1:
+                raise ValueError(
+                    "AMBIGUOUS CHAINED COMPARISON: write it explicitly, "
+                    "e.g. (a < b) AND (b < c)")
+            op = self._AST_OPS.get(type(node.ops[0]))
+            if op is None:
+                raise ValueError(f"UNSUPPORTED OP: {type(node.ops[0]).__name__}")
+            return op(self._ast_eval(node.left, ns),
+                      self._ast_eval(node.comparators[0], ns))
         if isinstance(node, ast.Call):
             if not isinstance(node.func, ast.Name):
                 raise ValueError("ONLY SIMPLE FUNCTION CALLS ALLOWED")

{qubasic-0.12.0 → qubasic-0.13.0}/qubasic_core/patterns.py

@@ -18,7 +18,7 @@ RE_MEAS = re.compile(r'MEAS\s+(\S+)\s*->\s*(\w+)', re.IGNORECASE)
 RE_RESET = re.compile(r'RESET\s+(\S+)', re.IGNORECASE)
 RE_UNITARY = re.compile(r'UNITARY\s+(\w+)\s*=\s*(\[.+\])', re.IGNORECASE)
 RE_DIM = re.compile(r'DIM\s+(\w+)\((\d+)\)', re.IGNORECASE)
-RE_REDIM = re.compile(r'REDIM\s+(\w+)\((\d+)\)', re.IGNORECASE)
+RE_REDIM = re.compile(r'REDIM\s+(PRESERVE\s+)?(\w+)\((\d+)\)', re.IGNORECASE)
 RE_ERASE = re.compile(r'ERASE\s+(\w+)', re.IGNORECASE)
 RE_GET = re.compile(r'GET\s+(\w+\$?)', re.IGNORECASE)
 RE_INPUT = re.compile(r'INPUT\s+(?:"([^"]*)"\s*,\s*)?(\w+)', re.IGNORECASE)

{qubasic-0.12.0 → qubasic-0.13.0}/qubasic_core/strings.py

@@ -29,8 +29,11 @@ def _chr_fn(n: float) -> str:
     return chr(int(n))
 
 def _str_fn(n: float) -> str:
+    # BASIC reserves a leading space for the sign of a non-negative number,
+    # so STR$(42) is " 42" and STR$(-5) is "-5".
     v = float(n)
-    return str(int(v)) if v == int(v) else str(v)
+    s = str(int(v)) if v == int(v) else str(v)
+    return s if v < 0 else ' ' + s
 
 def _val_fn(s: str) -> float:
     try:

{qubasic-0.12.0 → qubasic-0.13.0}/qubasic_core/terminal.py

@@ -1255,7 +1255,25 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
         2^n statevector that cannot be displayed anyway.
         """
         if getattr(self, '_pending_set_density', None) is not None:
-            self.last_sv = None   # mixed state: no pure statevector to extract
+            # Mixed state: no pure statevector. Capture the density matrix so
+            # DENSITY works after a measured run, not just a no-MEASURE one.
+            self.last_sv = None
+            if self.num_qubits <= self._SV_EXTRACT_MAX_QUBITS:
+                try:
+                    qc_sv.save_density_matrix()
+                    dm_backend = self._make_backend('density_matrix', include_noise=True)
+                    _kw = {}
+                    if self._seed is not None:
+                        _kw['seed_simulator'] = self._seed
+                    dm_result = dm_backend.run(
+                        transpile(qc_sv, dm_backend,
+                                  optimization_level=self._transpile_opt_level),
+                        **_kw).result()
+                    data = dm_result.data(0)
+                    dm = data.get('density_matrix') if hasattr(data, 'get') else None
+                    self._last_density = np.array(dm) if dm is not None else None
+                except Exception:
+                    self._last_density = None
             return
         if self.num_qubits > self._SV_EXTRACT_MAX_QUBITS:
             self.last_sv = None
@@ -1943,13 +1961,17 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
         if not m:
             return False
         name = m.group(1)
+        base = getattr(self, '_option_base', 0)
         dims = [int(d.strip()) for d in m.group(2).split(',')]
+        # Inclusive sizing (QBASIC): DIM a(n) spans indices base..n, so the
+        # declared top index n is valid (n - base + 1 slots per dimension).
+        sizes = [max(0, d - base + 1) for d in dims]
         total = 1
-        for d in dims:
-            total *= d
+        for s in sizes:
+            total *= s
         self.arrays[name] = [0.0] * total
-        if len(dims) > 1:
-            self._array_dims[name] = dims
+        if len(sizes) > 1:
+            self._array_dims[name] = sizes
         self._dimmed_arrays.add(name)
         return True
 
@@ -1975,20 +1997,26 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
         return True
 
     def _try_exec_redim(self, stmt: str) -> bool:
-        """Handle REDIM name(size) — resize an existing array."""
+        """Handle REDIM [PRESERVE] name(size) — resize an array.
+
+        Plain REDIM clears to zeros (QBASIC semantics); REDIM PRESERVE keeps the
+        existing elements. Sizing is inclusive (REDIM a(n) spans indices base..n).
+        """
         m = RE_REDIM.match(stmt)
         if not m:
             return False
-        name = m.group(1)
-        new_size = int(m.group(2))
+        preserve = bool(m.group(1))
+        name = m.group(2)
+        base = getattr(self, '_option_base', 0)
+        new_len = max(0, int(m.group(3)) - base + 1)
         old = self.arrays.get(name, [])
-        if isinstance(old, list):
-            if new_size > len(old):
-                self.arrays[name] = old + [0.0] * (new_size - len(old))
+        if preserve and isinstance(old, list):
+            if new_len > len(old):
+                self.arrays[name] = old + [0.0] * (new_len - len(old))
             else:
-                self.arrays[name] = old[:new_size]
+                self.arrays[name] = old[:new_len]
         else:
-            self.arrays[name] = [0.0] * new_size
+            self.arrays[name] = [0.0] * new_len
         self._dimmed_arrays.add(name)
         return True
 

{qubasic-0.12.0 → qubasic-0.13.0}/tests/test_features.py

@@ -487,8 +487,9 @@ class TestStrings(unittest.TestCase):
         self.assertEqual(_instr("HELLO", "XYZ"), 0.0)
         self.assertEqual(_hex_fn(255), "FF")
         self.assertEqual(_bin_fn(5), "101")
-        self.assertEqual(_str_fn(42.0), "42")
-        self.assertEqual(_str_fn(3.14), "3.14")
+        self.assertEqual(_str_fn(42.0), " 42")    # leading space for non-negative
+        self.assertEqual(_str_fn(3.14), " 3.14")
+        self.assertEqual(_str_fn(-5.0), "-5")
         self.assertEqual(_val_fn("42"), 42.0)
         self.assertEqual(_val_fn("abc"), 0.0)
         self.assertEqual(_len_fn("HELLO"), 5.0)
@@ -1048,7 +1049,7 @@ class TestProgramManagement(unittest.TestCase):
         _, out = capture(t_dim.cmd_run)
         self.assertIn('matrix', t_dim.arrays)
         self.assertIsInstance(t_dim.arrays['matrix'], list)
-        self.assertEqual(len(t_dim.arrays['matrix']), 9)
+        self.assertEqual(len(t_dim.arrays['matrix']), 16)  # inclusive: (0..3)^2
 
         # DIM single
         t_dim2 = QBasicTerminal()
@@ -1056,7 +1057,7 @@ class TestProgramManagement(unittest.TestCase):
         t_dim2.process('20 END')
         capture(t_dim2.cmd_run)
         self.assertIn('arr', t_dim2.arrays)
-        self.assertEqual(len(t_dim2.arrays['arr']), 5)
+        self.assertEqual(len(t_dim2.arrays['arr']), 6)   # inclusive: indices 0..5
 
         # IMPORT namespace
         with tempfile.NamedTemporaryFile(mode='w', suffix='.qb', dir='.', delete=False) as f:
@@ -2305,20 +2306,26 @@ class TestGapCoverage(unittest.TestCase):
 
     # 16 REDIM
     def test_redim(self):
-        """REDIM resizes an existing array, preserving or truncating data."""
-        # DIM first
+        """REDIM resizes (inclusive sizing); plain clears, PRESERVE keeps."""
+        # DIM a(5) spans indices 0..5 -> 6 slots (inclusive sizing).
         self.t._try_exec_dim('DIM arr(5)')
-        self.assertEqual(len(self.t.arrays['arr']), 5)
-        # REDIM larger
+        self.assertEqual(len(self.t.arrays['arr']), 6)
+        self.t.arrays['arr'][2] = 99.0
+        # Plain REDIM clears to zeros.
         self.t._try_exec_redim('REDIM arr(8)')
-        self.assertEqual(len(self.t.arrays['arr']), 8)
-        self.assertEqual(self.t.arrays['arr'][:5], [0.0] * 5)
-        # REDIM smaller
-        self.t._try_exec_redim('REDIM arr(3)')
-        self.assertEqual(len(self.t.arrays['arr']), 3)
-        # REDIM non-existent array creates it
+        self.assertEqual(len(self.t.arrays['arr']), 9)
+        self.assertEqual(self.t.arrays['arr'][2], 0.0)
+        # REDIM PRESERVE keeps existing data.
+        self.t.arrays['arr'][1] = 7.0
+        self.t._try_exec_redim('REDIM PRESERVE arr(10)')
+        self.assertEqual(len(self.t.arrays['arr']), 11)
+        self.assertEqual(self.t.arrays['arr'][1], 7.0)
+        # PRESERVE smaller truncates.
+        self.t._try_exec_redim('REDIM PRESERVE arr(3)')
+        self.assertEqual(len(self.t.arrays['arr']), 4)
+        # REDIM on a non-existent array creates it.
         self.t._try_exec_redim('REDIM newary(4)')
-        self.assertEqual(len(self.t.arrays['newary']), 4)
+        self.assertEqual(len(self.t.arrays['newary']), 5)
 
 
 # =====================================================================

{qubasic-0.12.0 → qubasic-0.13.0}/tests/test_qubasic.py

@@ -2152,6 +2152,58 @@ class TestDeepFixRegressions(unittest.TestCase):
         self.assertEqual(t.eval_expr('sq(5)'), 25.0)
 
 
+class TestConventionFixesV2(unittest.TestCase):
+    """round half-away, chained-comparison guard, inclusive DIM, REDIM
+    PRESERVE, MEAS print hint, DENSITY after MEASURE."""
+
+    def setUp(self):
+        self.t = QBasicTerminal(); self.t.num_qubits = 1
+
+    def _runp(self, lines, nq=1):
+        t = QBasicTerminal(); t.num_qubits = nq
+        for l in lines:
+            t.process(l, track_undo=False)
+        _, out = capture(t.cmd_run)
+        t._out = out
+        return t
+
+    def test_round_half_away_from_zero(self):
+        self.assertEqual(self.t.eval_expr('round(2.5)'), 3.0)
+        self.assertEqual(self.t.eval_expr('round(3.5)'), 4.0)
+        self.assertEqual(self.t.eval_expr('round(-2.5)'), -3.0)
+        self.assertAlmostEqual(self.t.eval_expr('round(2.345, 2)'), 2.35)
+
+    def test_chained_comparison_raises(self):
+        self.assertTrue(bool(self.t._safe_eval('3 < 5')))
+        with self.assertRaises(ValueError):
+            self.t._safe_eval('1 < 2 < 3')
+
+    def test_dim_inclusive_top_index(self):
+        t = self._runp(['10 DIM a(5)', '20 LET a(5)=7', '30 LET v=a(5)'])
+        self.assertEqual(t.variables.get('v'), 7.0)
+        t2 = self._runp(['10 DIM a(5)', '20 LET a(6)=1'])
+        self.assertIn('OUT OF RANGE', t2._out)
+
+    def test_redim_clear_vs_preserve(self):
+        t = self._runp(['10 DIM a(3)', '20 LET a(1)=9', '30 REDIM a(5)', '40 LET v=a(1)'])
+        self.assertEqual(t.variables.get('v'), 0.0)
+        t2 = self._runp(['10 DIM a(3)', '20 LET a(1)=9', '30 REDIM PRESERVE a(5)', '40 LET v=a(1)'])
+        self.assertEqual(t2.variables.get('v'), 9.0)
+
+    def test_meas_print_hint(self):
+        t = self._runp(['10 X 0', '20 MEAS 0 -> m', '30 PRINT m', '40 MEASURE'])
+        self.assertIn('mid-circuit', t._out)
+
+    def test_density_after_measure(self):
+        t = QBasicTerminal(); t.num_qubits = 1
+        t.process('SET_DENSITY [[0.5,0],[0,0.5]]', track_undo=False)
+        for l in ['10 H 0', '20 MEASURE']:
+            t.process(l, track_undo=False)
+        capture(t.cmd_run)
+        _, dout = capture(t.cmd_density, '')
+        self.assertIn('Density matrix', dout)
+
+
 if __name__ == '__main__':
     if hasattr(sys.stdout, 'reconfigure'):
         sys.stdout.reconfigure(encoding='utf-8')