Add tests for parameters, instrument core, channels, and station

Add 217 new tests across 7 test files targeting the largest remaining
coverage gaps in non-driver modules.

Parameters tests (71 tests):
- tests/parameter/test_command_extended.py (17 tests): all call_by_str
  and call_cmd method combinations, arg count validation, NoCommandError
- tests/parameter/test_function_extended.py (16 tests): validation,
  name properties, parsers, callable/string cmd, get_attrs
- tests/parameter/test_grouped_parameter_extended.py (22 tests):
  DelegateGroup set/get with custom setter/getter, source_parameters,
  GroupedParameter repr and properties
- tests/parameter/test_combined_parameter_extended.py (16 tests):
  combine(), aggregator, iter/len, snapshot_base, units deprecation

Instrument core tests (146 tests):
- tests/test_instrument_extended.py: write_raw/ask_raw NotImplementedError,
  close_all, find_instrument, exist/is_valid, repr, label, add_function,
  add_submodule, get_component, print_readable_snapshot, invalidate_cache,
  parent/ancestors/root_instrument, find_or_create_instrument
- tests/test_channel_extended.py: InstrumentModule proxy methods,
  ChannelTuple operations (reversed/contains/add/index/count/get_by_name),
  ChannelList mutations and lock behavior, ChannelTupleValidator
- tests/test_station_extended.py: snapshot_base, add/remove/get component,
  close_all_registered_instruments, Station.default handling

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: jenshnielsen

tests/parameter/test_combined_parameter_extended.py

@@ -0,0 +1,133 @@
+"""Extended tests for qcodes.parameters.combined_parameter module."""
+
+from __future__ import annotations
+
+import logging
+
+import numpy as np
+import pytest
+
+from qcodes.parameters import Parameter
+from qcodes.parameters.combined_parameter import CombinedParameter, combine
+
+
+@pytest.fixture()
+def two_params() -> list[Parameter]:
+    return [
+        Parameter("x", set_cmd=None, get_cmd=None),
+        Parameter("y", set_cmd=None, get_cmd=None),
+    ]
+
+
+class TestCombineFunction:
+    def test_combine_creates_combined_parameter(
+        self, two_params: list[Parameter]
+    ) -> None:
+        """combine() convenience function returns CombinedParameter."""
+        cp = combine(*two_params, name="xy")
+        assert isinstance(cp, CombinedParameter)
+        assert cp.dimensionality == 2
+
+    def test_combine_with_label_and_unit(self, two_params: list[Parameter]) -> None:
+        """combine() passes label and unit through."""
+        cp = combine(*two_params, name="xy", label="X and Y", unit="V")
+        assert cp.parameter.label == "X and Y"
+        assert cp.parameter.unit == "V"
+
+    def test_combine_with_aggregator(self, two_params: list[Parameter]) -> None:
+        """combine() passes aggregator through."""
+        cp = combine(*two_params, name="xy", aggregator=sum)
+        assert hasattr(cp, "aggregate")
+
+
+class TestCombinedParameter:
+    def test_set_calls_parameter_sets(self, two_params: list[Parameter]) -> None:
+        """set() sets each parameter in order."""
+        cp = CombinedParameter(two_params, name="xy")
+        swept = cp.sweep(np.array([[1.0, 2.0], [3.0, 4.0]]))
+        swept.set(0)
+        assert two_params[0]() == 1.0
+        assert two_params[1]() == 2.0
+        swept.set(1)
+        assert two_params[0]() == 3.0
+        assert two_params[1]() == 4.0
+
+    def test_aggregate_with_aggregator(self, two_params: list[Parameter]) -> None:
+        """_aggregate calls the aggregator function."""
+
+        def my_agg(*vals: int) -> int:
+            return sum(vals)
+
+        cp = CombinedParameter(two_params, name="xy", aggregator=my_agg)
+        result = cp._aggregate(1, 2, 3)
+        assert result == 6
+
+    def test_aggregate_without_aggregator(self, two_params: list[Parameter]) -> None:
+        """Without aggregator, _aggregate is not set as 'aggregate' attr."""
+        cp = CombinedParameter(two_params, name="xy")
+        assert not hasattr(cp, "aggregate")
+
+    def test_iter(self, two_params: list[Parameter]) -> None:
+        """__iter__ iterates over setpoint indices."""
+        cp = CombinedParameter(two_params, name="xy")
+        swept = cp.sweep(np.array([[1, 2], [3, 4], [5, 6]]))
+        indices = list(swept)
+        assert indices == [0, 1, 2]
+
+    def test_len(self, two_params: list[Parameter]) -> None:
+        """__len__ returns number of setpoints."""
+        cp = CombinedParameter(two_params, name="xy")
+        swept = cp.sweep(np.array([[1, 2], [3, 4]]))
+        assert len(swept) == 2
+
+    def test_len_no_setpoints(self, two_params: list[Parameter]) -> None:
+        """__len__ returns 0 when no setpoints."""
+        cp = CombinedParameter(two_params, name="xy")
+        assert len(cp) == 0
+
+    def test_snapshot_base(self, two_params: list[Parameter]) -> None:
+        """snapshot_base returns dict with expected keys."""
+        cp = CombinedParameter(two_params, name="xy", label="combined", unit="mV")
+        snap = cp.snapshot_base()
+        assert snap["label"] == "combined"
+        assert snap["unit"] == "mV"
+        assert snap["full_name"] == "xy"
+        assert "__class__" in snap
+        assert "aggregator" in snap
+
+    def test_snapshot_base_with_aggregator(self, two_params: list[Parameter]) -> None:
+        """snapshot_base includes aggregator repr."""
+        cp = CombinedParameter(two_params, name="xy", aggregator=sum)
+        snap = cp.snapshot_base()
+        assert "sum" in snap["aggregator"]
+
+    def test_units_deprecated(
+        self, two_params: list[Parameter], caplog: pytest.LogCaptureFixture
+    ) -> None:
+        """Passing units= triggers a deprecation warning log."""
+        with caplog.at_level(logging.WARNING):
+            cp = CombinedParameter(two_params, name="xy", units="mV")
+        assert any("`units` is deprecated" in msg for msg in caplog.messages)
+        assert cp.parameter.unit == "mV"
+
+    def test_units_deprecated_unit_takes_precedence(
+        self, two_params: list[Parameter], caplog: pytest.LogCaptureFixture
+    ) -> None:
+        """When both unit and units are given, unit takes precedence."""
+        with caplog.at_level(logging.WARNING):
+            cp = CombinedParameter(two_params, name="xy", unit="V", units="mV")
+        assert cp.parameter.unit == "V"
+
+    def test_invalid_name_raises(self, two_params: list[Parameter]) -> None:
+        """Invalid parameter name raises ValueError."""
+        with pytest.raises(ValueError, match="valid identifier"):
+            CombinedParameter(two_params, name="invalid name")
+
+    def test_sweep_multiple_arrays(self, two_params: list[Parameter]) -> None:
+        """sweep() with multiple 1D arrays."""
+        cp = CombinedParameter(two_params, name="xy")
+        swept = cp.sweep(np.array([1, 2, 3]), np.array([4, 5, 6]))
+        assert len(swept) == 3
+        swept.set(0)
+        assert two_params[0]() == 1
+        assert two_params[1]() == 4

tests/parameter/test_command_extended.py

@@ -0,0 +1,246 @@
+"""Extended tests for qcodes.parameters.command.Command covering all call_by_* methods."""
+
+from __future__ import annotations
+
+import pytest
+
+from qcodes.parameters.command import Command, NoCommandError
+
+
+def test_call_by_str_no_parsers() -> None:
+    """String cmd + exec_str, no parsers -> call_by_str."""
+    results: list[str] = []
+
+    def exec_fn(cmd_str: str) -> str:
+        results.append(cmd_str)
+        return cmd_str
+
+    cmd = Command(arg_count=1, cmd="SET {}", exec_str=exec_fn)
+    result = cmd(42)
+    assert result == "SET 42"
+    assert results == ["SET 42"]
+
+
+def test_call_by_str_zero_args() -> None:
+    """String cmd with 0 args -> call_by_str with no formatting."""
+
+    def exec_fn(cmd_str: str) -> str:
+        return cmd_str
+
+    cmd = Command(arg_count=0, cmd="*RST", exec_str=exec_fn)
+    assert cmd() == "*RST"
+
+
+def test_call_by_str_parsed_out() -> None:
+    """String cmd + output_parser -> call_by_str_parsed_out."""
+
+    def exec_fn(cmd_str: str) -> str:
+        return cmd_str
+
+    cmd = Command(
+        arg_count=1,
+        cmd="READ {}",
+        exec_str=exec_fn,
+        output_parser=lambda x: x.upper(),
+    )
+    result = cmd("ch1")
+    assert result == "READ CH1"
+
+
+def test_call_by_str_parsed_in() -> None:
+    """String cmd + single input_parser -> call_by_str_parsed_in."""
+
+    def exec_fn(cmd_str: str) -> str:
+        return cmd_str
+
+    cmd = Command(
+        arg_count=1,
+        cmd="SET {}",
+        exec_str=exec_fn,
+        input_parser=lambda x: x * 2,
+    )
+    result = cmd(5)
+    assert result == "SET 10"
+
+
+def test_call_by_str_parsed_in_out() -> None:
+    """String cmd + input_parser + output_parser -> call_by_str_parsed_in_out."""
+
+    def exec_fn(cmd_str: str) -> str:
+        return cmd_str
+
+    cmd = Command(
+        arg_count=1,
+        cmd="MEAS {}",
+        exec_str=exec_fn,
+        input_parser=lambda x: x + 1,
+        output_parser=lambda x: f"result:{x}",
+    )
+    result = cmd(9)
+    assert result == "result:MEAS 10"
+
+
+def test_call_by_str_parsed_in2() -> None:
+    """String cmd + multi-arg input_parser -> call_by_str_parsed_in2."""
+
+    def exec_fn(cmd_str: str) -> str:
+        return cmd_str
+
+    def multi_parser(a: int, b: int) -> tuple[int, int]:
+        return (a * 10, b * 10)
+
+    cmd = Command(
+        arg_count=2,
+        cmd="SET {} {}",
+        exec_str=exec_fn,
+        input_parser=multi_parser,
+    )
+    result = cmd(3, 4)
+    assert result == "SET 30 40"
+
+
+def test_call_by_str_parsed_in2_out() -> None:
+    """String cmd + multi-arg input_parser + output_parser."""
+
+    def exec_fn(cmd_str: str) -> str:
+        return cmd_str
+
+    def multi_parser(a: int, b: int) -> tuple[int, int]:
+        return (a + 1, b + 1)
+
+    cmd = Command(
+        arg_count=2,
+        cmd="CMD {} {}",
+        exec_str=exec_fn,
+        input_parser=multi_parser,
+        output_parser=lambda x: x.replace("CMD", "OUT"),
+    )
+    result = cmd(0, 1)
+    assert result == "OUT 1 2"
+
+
+def test_call_cmd_no_parsers() -> None:
+    """Callable cmd, no parsers -> direct call."""
+
+    def my_func(a: int) -> int:
+        return a * 3
+
+    cmd = Command(arg_count=1, cmd=my_func)
+    assert cmd(7) == 21
+
+
+def test_call_cmd_parsed_out() -> None:
+    """Callable cmd + output_parser -> call_cmd_parsed_out."""
+
+    def my_func(a: int) -> int:
+        return a + 1
+
+    cmd = Command(
+        arg_count=1,
+        cmd=my_func,
+        output_parser=lambda x: x * 100,
+    )
+    assert cmd(5) == 600
+
+
+def test_call_cmd_parsed_in() -> None:
+    """Callable cmd + single input_parser -> call_cmd_parsed_in."""
+
+    def my_func(a: int) -> int:
+        return a
+
+    cmd = Command(
+        arg_count=1,
+        cmd=my_func,
+        input_parser=lambda x: x + 10,
+    )
+    assert cmd(5) == 15
+
+
+def test_call_cmd_parsed_in_out() -> None:
+    """Callable cmd + input_parser + output_parser -> call_cmd_parsed_in_out."""
+
+    def my_func(a: int) -> int:
+        return a * 2
+
+    cmd = Command(
+        arg_count=1,
+        cmd=my_func,
+        input_parser=lambda x: x + 1,
+        output_parser=lambda x: x + 100,
+    )
+    # input_parser(3) = 4, my_func(4) = 8, output_parser(8) = 108
+    assert cmd(3) == 108
+
+
+def test_call_cmd_parsed_in2() -> None:
+    """Callable cmd + multi-arg input_parser -> call_cmd_parsed_in2."""
+
+    def my_func(a: int, b: int) -> int:
+        return a + b
+
+    def multi_parser(a: int, b: int) -> tuple[int, int]:
+        return (a * 10, b * 10)
+
+    cmd = Command(
+        arg_count=2,
+        cmd=my_func,
+        input_parser=multi_parser,
+    )
+    assert cmd(3, 4) == 70
+
+
+def test_call_cmd_parsed_in2_out() -> None:
+    """Callable cmd + multi-arg input_parser + output_parser."""
+
+    def my_func(a: int, b: int) -> int:
+        return a + b
+
+    def multi_parser(a: int, b: int) -> tuple[int, int]:
+        return (a * 2, b * 3)
+
+    cmd = Command(
+        arg_count=2,
+        cmd=my_func,
+        input_parser=multi_parser,
+        output_parser=lambda x: x * -1,
+    )
+    # multi_parser(5, 10) = (10, 30), my_func(10, 30) = 40, output_parser(40) = -40
+    assert cmd(5, 10) == -40
+
+
+def test_wrong_arg_count_raises_type_error() -> None:
+    """Calling with wrong number of args raises TypeError."""
+
+    def my_func(a: int) -> int:
+        return a
+
+    cmd = Command(arg_count=1, cmd=my_func)
+
+    with pytest.raises(TypeError, match="command takes exactly 1 args"):
+        cmd()
+
+    with pytest.raises(TypeError, match="command takes exactly 1 args"):
+        cmd(1, 2)
+
+
+def test_no_command_error_when_no_cmd() -> None:
+    """NoCommandError raised when no cmd and no no_cmd_function."""
+    with pytest.raises(NoCommandError, match="no ``cmd`` provided"):
+        Command(arg_count=0, cmd=None)
+
+
+def test_no_cmd_with_no_cmd_function() -> None:
+    """no_cmd_function is used as fallback when cmd is None."""
+
+    def fallback() -> str:
+        return "fallback_called"
+
+    cmd = Command(arg_count=0, cmd=None, no_cmd_function=fallback)
+    assert cmd() == "fallback_called"
+
+
+def test_str_cmd_without_exec_str_raises() -> None:
+    """String cmd with no exec_str raises TypeError."""
+    with pytest.raises(TypeError, match="exec_str cannot be None"):
+        Command(arg_count=0, cmd="*RST", exec_str=None)