Release v0.1.0

- Wrap simulation controls in form to prevent page reruns on change
- Fix TempCo test configs to use 2+ temperature points
- Add Installation, Quick Start, and usage examples to README

.gitea/workflows/ci.yaml

@@ -72,7 +72,7 @@ jobs:
   release:
     name: Release
     needs: [lint, typecheck, test]
-    if: startsWith(github.ref, 'refs/tags/v')
+    if: startsWith(gitea.ref, 'refs/tags/v')
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
@@ -91,7 +91,22 @@ jobs:
         run: python -m build
 
       - name: Create Release
-        uses: softprops/action-gh-release@v1
+        run: |
-        with:
+          TAG_NAME=${GITHUB_REF#refs/tags/}
-          files: dist/*
+          VERSION=${TAG_NAME#v}
-          generate_release_notes: true
+          BODY=$(awk "/^## \[${VERSION}\]/{flag=1; next} /^## \\[/{flag=0} flag" CHANGELOG.md)
+          echo "Creating release ${TAG_NAME}"
+          RESPONSE=$(curl -s -X POST -H "Authorization: token ${GITHUB_TOKEN}" -H "Content-Type: application/json" -d "{\"tag_name\": \"${TAG_NAME}\", \"name\": \"${TAG_NAME}\", \"body\": $(echo "$BODY" | jq -Rs .)}" "${GITHUB_SERVER_URL}/api/v1/repos/${GITHUB_REPOSITORY}/releases")
+          RELEASE_ID=$(echo "$RESPONSE" | jq -r '.id')
+          echo "Created release ID: ${RELEASE_ID}"
+          if [ "$RELEASE_ID" != "null" ] && [ -n "$RELEASE_ID" ]; then
+            for file in dist/*; do
+              echo "Uploading $(basename ${file})..."
+              curl -s -X POST -H "Authorization: token ${GITHUB_TOKEN}" -F "attachment=@${file}" "${GITHUB_SERVER_URL}/api/v1/repos/${GITHUB_REPOSITORY}/releases/${RELEASE_ID}/assets?name=$(basename ${file})"
+            done
+          else
+            echo "Failed to create release: $RESPONSE"
+            exit 1
+          fi
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

CHANGELOG.md

@@ -7,6 +7,88 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.0] - 2025-12-04
+
+### Added
+- Streamlit Dashboard Enhancement (Sprint 17)
+  - HAL-based instrument control (no direct physics access)
+  - Test execution page for running TempCo characterisation
+  - Results viewer page with filtering and historical data
+  - Form-based parameter controls preventing UI clunkiness
+  - Live simulation charts with auto-start
+- End-to-end integration tests covering full workflow
+- Updated README with installation and usage instructions
+- Proprietary licence
+
+### Changed
+- Integration tests now run 100x faster with simulation time scaling
+- Removed confusing pause/clear chart buttons from dashboard
+
+### Fixed
+- CI release workflow now creates proper releases with changelog description
+
+### Technical
+- Dashboard uses InstrumentFactory and InstrumentSet abstraction
+- Embedded SimulationServer with threading synchronisation
+- SQLite repository close() method for Windows file handle cleanup
+- 259 unit tests, 12 integration tests all passing
+- Coverage: 100% on core physics/instrument modules
+
+## [0.1.0-beta.2] - 2025-12-03
+
+### Added
+- Test Executive Framework (Sprint 14)
+  - TestContext dataclass providing runtime context for tests
+  - ITest abstract base class defining test interface
+  - TestLogger for recording measurements, results, and events
+  - LimitChecker for evaluating pass/fail against specification limits
+  - TestRunner for orchestrating test execution
+  - SQLite-based TestRepository for persisting test data
+  - Parquet measurement storage for efficient time-series data
+- DVT Test Implementation (Sprint 15)
+  - BaseDVTTest providing common test utilities
+  - TempCo characterisation test (temperature coefficient measurement)
+  - Temperature sweep with automatic thermal settling
+  - Linear regression TempCo calculation (ppm/°C)
+  - Comprehensive integration tests for end-to-end validation
+
+### Technical
+- Test framework supports data logging, limit evaluation, and result persistence
+- TempCo test demonstrates full end-to-end workflow: configure instruments → sweep temperature → measure → calculate → evaluate
+- All framework and test components fully type-checked and linted
+
+## [0.1.0-beta.1] - 2025-12-02
+
+### Added
+- Hardware Abstraction Layer (HAL) with instrument interface protocols
+  - IThermalChamber protocol with temperature control methods
+  - IPowerSupply protocol with voltage/current control and measurement
+  - IMultimeter protocol with DC voltage, current, and resistance measurement
+- Instrument drivers implementing HAL interfaces
+  - ThermalChamberDriver implements IThermalChamber
+  - PowerSupplyDriver implements IPowerSupply
+  - MultimeterDriver implements IMultimeter
+- Instrument factory pattern for backend abstraction
+  - InstrumentSet dataclass containing chamber, PSU, and DMM
+  - InstrumentConfig for specifying backend (simulator/pyvisa) and connection details
+  - InstrumentFactory.create() for creating instrument sets from configuration
+- Transport layer abstraction
+  - Transport ABC defining connect/disconnect/read/write/query interface
+  - TCPTransport implementation for TCP/IP connections
+- Comprehensive test suite for HAL (16 tests)
+  - Interface implementation verification
+  - Factory pattern testing with mocked backends
+  - Configuration validation
+
+### Changed
+- Drivers now explicitly inherit from interface ABCs for maximum type safety
+- Moved InstrumentServer to instruments/transport for better architecture
+
+### Technical
+- ABC-based interfaces ensure compile-time interface compliance
+- Factory pattern enables seamless switching between simulated and real hardware
+- All HAL components fully type-checked with mypy strict mode
+
 ## [0.1.0-alpha.3] - 2025-12-02
 
 ### Added
@@ -73,9 +155,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 | Version | Date | Milestone |
 |---------|------|-----------|
-| 0.1.0 | TBD | MVP Complete |
+| 0.1.0 | 2025-12-04 | MVP Complete |
-| 0.1.0-beta.2 | TBD | First DVT test runs |
+| 0.1.0-beta.2 | 2025-12-03 | First DVT test runs |
-| 0.1.0-beta.1 | TBD | HAL complete |
+| 0.1.0-beta.1 | 2025-12-02 | HAL complete |
 | 0.1.0-alpha.3 | 2025-12-02 | Network ready |
 | 0.1.0-alpha.2 | 2025-12-02 | Visual demo |
 | 0.1.0-alpha.1 | 2025-12-02 | Physics engine |

LICENSE

@@ -0,0 +1,5 @@
+Copyright (c) 2025 Kai Chappell. All rights reserved.
+
+This software is proprietary and confidential. Unauthorized copying,
+distribution, modification, or use of this software, via any medium,
+is strictly prohibited without prior written permission from the author.

README.md

@@ -1,12 +1,12 @@
 # py_dvt_ate
 
-**ThermalATE: Coupled Physics DVT Simulation Platform**
+**Coupled Physics DVT Simulation Platform**
 
-A software simulation environment that accurately models the physical coupling between thermal and electrical domains, enabling DVT (Design Validation Test) engineers to develop, validate, and debug characterisation test sequences without physical access to laboratory equipment.
+A software simulation environment for offline development of ATE (Automated Test Equipment) characterisation algorithms. Accurately models thermal-electrical coupling, enabling DVT engineers to develop and validate test sequences without physical laboratory access.
 
 ## Overview
 
-ThermalATE enables offline development of ATE (Automated Test Equipment) characterisation algorithms by simulating:
+py_dvt_ate simulates a complete DVT test bench:
 
 - **Thermal Chamber** - Temperature control with realistic ramp and settling behaviour
 - **Programmable Power Supply** - Voltage/current control and measurement
@@ -29,11 +29,78 @@ ThermalATE enables offline development of ATE (Automated Test Equipment) charact
 | [Technical Specification](docs/02_technical_specification.md) | Specifies **how** to implement the system |
 | [Architecture Decisions](docs/03_architecture_decisions.md) | Explains **why** decisions were made |
 
+## Installation
+
+```bash
+# Install with development dependencies
+pip install -e ".[dev]"
+```
+
+## Quick Start
+
+### Interactive Dashboard
+
+Launch the Streamlit dashboard to visualise the physics simulation and run tests:
+
+```bash
+py-dvt-ate dashboard
+```
+
+This opens a browser window with:
+- **Live Simulation** - Real-time temperature/voltage charts with physics coupling
+- **Test Execution** - Run TempCo characterisation tests
+- **Results Viewer** - Browse and analyse historical test results
+
+### CLI Commands
+
+```bash
+# Start the simulation server (TCP ports for SCPI instruments)
+py-dvt-ate serve
+
+# List available tests
+py-dvt-ate tests list
+
+# Run a TempCo test
+py-dvt-ate tests run tempco --config config/tempco_test.yaml
+```
+
+### Programmatic API
+
+```python
+from py_dvt_ate.instruments import InstrumentFactory
+from py_dvt_ate.simulation import SimulationServer
+
+# Start simulation server
+server = SimulationServer()
+server.start()
+
+# Create instruments via HAL
+factory = InstrumentFactory()
+instruments = factory.create_from_config("config/default.yaml")
+
+# Control instruments using standard interfaces
+instruments.chamber.set_temperature(85.0)
+instruments.psu.set_voltage(1, 5.0)
+instruments.psu.enable_output(1, True)
+voltage = instruments.dmm.measure_dc_voltage()
+
+print(f"Output voltage: {voltage:.4f} V")
+```
+
 ## Project Status
 
-**Status:** In Development
+**Status:** MVP Complete (v0.1.0)
 
-This project is currently being developed. See the requirements document for the full scope and success criteria.
+The core vertical slice is functional:
+- Physics engine with thermal-electrical coupling
+- Virtual instruments (chamber, PSU, DMM)
+- Hardware Abstraction Layer
+- SCPI-over-TCP server
+- Test framework with TempCo test
+- Streamlit dashboard
+- SQLite/Parquet data persistence
+
+See the requirements document for the full scope and future phases.
 
 ## Technology Stack
 
@@ -50,4 +117,4 @@ Kai Chappell
 
 ## Licence
 
-TBD
+Proprietary - All rights reserved. See [LICENSE](LICENSE) for details.

config/default.yaml

@@ -0,0 +1,149 @@
+# py_dvt_ate Default Configuration
+# This file contains default settings for the DVT simulation platform.
+# Copy this file and modify values as needed for your environment.
+
+# =============================================================================
+# Instrument Configuration
+# =============================================================================
+instruments:
+  # Backend selection: "simulator" or "pyvisa"
+  # - simulator: Use virtual instruments with physics simulation (for development)
+  # - pyvisa: Connect to real instruments via PyVISA (for production testing)
+  backend: simulator
+
+  # Simulator backend configuration
+  # Used when backend=simulator. Virtual instruments are exposed as TCP servers.
+  simulator:
+    host: localhost
+    thermal_chamber_port: 5001
+    power_supply_port: 5002
+    multimeter_port: 5003
+
+  # PyVISA backend configuration
+  # Used when backend=pyvisa. Provide VISA resource strings for real instruments.
+  # Example: "TCPIP::192.168.1.10::5001::SOCKET"
+  pyvisa:
+    thermal_chamber: null
+    power_supply: null
+    multimeter: null
+
+# =============================================================================
+# Physics Simulation Parameters
+# =============================================================================
+physics:
+  # Physics engine update rate (Hz)
+  # Higher rates provide better accuracy but use more CPU.
+  update_rate_hz: 100.0
+
+  # Thermal model parameters
+  thermal:
+    # Chamber thermal time constant (seconds)
+    # Time for chamber temperature to reach 63% of final value
+    chamber_time_constant_s: 30.0
+
+    # DUT case thermal time constant (seconds)
+    # Time for case temperature to reach 63% of final value
+    case_time_constant_s: 5.0
+
+    # Junction-to-case thermal resistance (°C/W)
+    # How much the junction heats above case per watt dissipated
+    theta_jc: 15.0
+
+    # Case-to-ambient thermal resistance (°C/W)
+    # How much the case heats above ambient per watt dissipated
+    theta_ca: 5.0
+
+  # Thermal chamber behaviour
+  chamber:
+    # Maximum temperature ramp rate (°C/min)
+    # Real chambers have limited heating/cooling rates
+    ramp_rate_c_per_min: 10.0
+
+    # Temperature stability window (°C)
+    # Chamber is considered stable when within ±this value of setpoint
+    stability_window_c: 0.5
+
+    # Stability duration requirement (seconds)
+    # Chamber must remain in stability window for this duration
+    stability_time_s: 30.0
+
+# =============================================================================
+# DUT (Device Under Test) Configuration
+# =============================================================================
+dut:
+  # DUT model type
+  # Currently supported: "ldo"
+  model: ldo
+
+  # DUT model parameters
+  parameters:
+    # Nominal output voltage at 25°C (V)
+    nominal_output_voltage: 3.3
+
+    # Temperature coefficient (ppm/°C)
+    # Voltage change per degree: ΔV = V₀ × tempco × ΔT / 1e6
+    tempco_ppm_per_c: 50.0
+
+    # Quiescent current at 25°C (µA)
+    quiescent_current_ua: 50.0
+
+    # Quiescent current temperature coefficient (per °C)
+    # Iq change per degree: ΔIq = Iq₀ × tempco × ΔT
+    quiescent_current_tempco: 0.003
+
+    # Dropout voltage (V)
+    # Minimum Vin-Vout differential for regulation
+    dropout_voltage: 0.3
+
+# =============================================================================
+# Data Storage Configuration
+# =============================================================================
+data:
+  # SQLite database path for test runs and results
+  database_path: ./data/py_dvt_ate.db
+
+  # Directory for measurement data files (Parquet format)
+  measurements_dir: ./data/measurements
+
+  # Directory for generated reports (PDF, HTML)
+  reports_dir: ./data/reports
+
+# =============================================================================
+# Logging Configuration
+# =============================================================================
+logging:
+  # Logging level: DEBUG, INFO, WARNING, ERROR, CRITICAL
+  level: INFO
+
+  # Log file path
+  # Use null to disable file logging
+  file: ./data/logs/py_dvt_ate.log
+
+  # Log message format
+  # Uses Python logging format strings
+  format: "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+
+# =============================================================================
+# Dashboard Configuration (Streamlit)
+# =============================================================================
+dashboard:
+  # Enable/disable the Streamlit dashboard
+  enabled: true
+
+  # Dashboard server port
+  port: 8501
+
+# =============================================================================
+# API Configuration (Phase 2)
+# =============================================================================
+api:
+  # Enable/disable the REST API server
+  # Currently not implemented (Phase 2 feature)
+  enabled: false
+
+  # API server host
+  # Use "0.0.0.0" to listen on all interfaces
+  host: "0.0.0.0"
+
+  # API server port
+  port: 8000

docs/02_technical_specification.md

@@ -450,109 +450,123 @@ High-level call → Driver → SCPI command → Transport → Instrument
 ```python
 # py_dvt_ate/instruments/interfaces.py
 
-from typing import Protocol, runtime_checkable
+from abc import ABC, abstractmethod
 
 
 @runtime_checkable
-class IThermalChamber(Protocol):
+class IThermalChamber(ABC):
     """Hardware abstraction for thermal chambers."""
 
+    @abstractmethod
     def set_temperature(self, setpoint: float) -> None:
-        """Set target temperature in degrees Celsius."""
+        """[docstring]"""  
-        ...
+        pass
 
+    @abstractmethod
     def get_temperature(self) -> float:
-        """Get current actual temperature in degrees Celsius."""
+        """[docstring]"""  
-        ...
+        pass
 
+    @abstractmethod
     def get_setpoint(self) -> float:
-        """Get current temperature setpoint."""
+        """[docstring]"""  
-        ...
+        pass
 
+    @abstractmethod
     def is_stable(self) -> bool:
-        """Check if temperature has stabilised at setpoint."""
+        """[docstring]"""  
-        ...
+        pass
 
+    @abstractmethod
     def wait_until_stable(
         self,
         timeout: float = 300.0,
         poll_interval: float = 1.0
     ) -> bool:
-        """
+        """[docstring]"""  
-        Block until temperature stabilises or timeout.
+        pass
-
-        Returns:
-            True if stable, False if timeout
-        """
-        ...
 
+    @abstractmethod
     def set_ramp_rate(self, rate: float) -> None:
-        """Set temperature ramp rate in degrees C per minute."""
+        """[docstring]"""  
-        ...
+        pass
 
 
 @runtime_checkable
-class IPowerSupply(Protocol):
+class IPowerSupply(ABC):
     """Hardware abstraction for programmable power supplies."""
 
+    @abstractmethod
     def set_voltage(self, channel: int, voltage: float) -> None:
-        """Set output voltage for specified channel."""
+        """[docstring]"""  
-        ...
+        pass
 
+    @abstractmethod
     def get_voltage(self, channel: int) -> float:
-        """Get voltage setpoint for specified channel."""
+        """[docstring]"""  
-        ...
+        pass
 
+    @abstractmethod
     def set_current_limit(self, channel: int, current: float) -> None:
-        """Set current limit for specified channel."""
+        """[docstring]"""  
-        ...
+        pass
 
+    @abstractmethod
     def get_current_limit(self, channel: int) -> float:
-        """Get current limit for specified channel."""
+        """[docstring]"""  
-        ...
+        pass
 
+    @abstractmethod
     def measure_voltage(self, channel: int) -> float:
-        """Measure actual output voltage."""
+        """[docstring]"""  
-        ...
+        pass
 
+    @abstractmethod
     def measure_current(self, channel: int) -> float:
-        """Measure actual output current."""
+        """[docstring]"""  
-        ...
+        pass
 
+    @abstractmethod
     def enable_output(self, channel: int, enable: bool) -> None:
-        """Enable or disable channel output."""
+        """[docstring]"""  
-        ...
+        pass
 
+    @abstractmethod
     def is_output_enabled(self, channel: int) -> bool:
-        """Check if channel output is enabled."""
+        """[docstring]"""  
-        ...
+        pass
 
 
 @runtime_checkable
-class IMultimeter(Protocol):
+class IMultimeter(ABC):
     """Hardware abstraction for digital multimeters."""
 
+    @abstractmethod
     def measure_dc_voltage(self, range: str = "AUTO") -> float:
-        """Measure DC voltage. Range: AUTO, 0.1, 1, 10, 100, 1000."""
+        """[docstring]"""  
-        ...
+        pass
 
+    @abstractmethod
     def measure_dc_current(self, range: str = "AUTO") -> float:
-        """Measure DC current."""
+        """[docstring]"""  
-        ...
+        pass
 
+    @abstractmethod
     def measure_resistance(self, range: str = "AUTO") -> float:
-        """Measure resistance."""
+        """[docstring]"""  
-        ...
+        pass
 
+    @abstractmethod
     def set_integration_time(self, nplc: float) -> None:
-        """Set integration time in power line cycles (0.1 to 100)."""
+        """[docstring]"""  
-        ...
+        pass
 
 
 @runtime_checkable
-class ITestLogger(Protocol):
+class ITestLogger(ABC):
     """Abstraction for test data logging."""
 
+    @abstractmethod
     def log_measurement(
         self,
         parameter: str,
@@ -560,9 +574,10 @@ class ITestLogger(Protocol):
         unit: str,
         conditions: dict[str, float] | None = None
     ) -> None:
-        """Log a single measurement."""
+        """[docstring]"""  
-        ...
+        pass
 
+    @abstractmethod
     def log_result(
         self,
         parameter: str,
@@ -571,12 +586,13 @@ class ITestLogger(Protocol):
         lower_limit: float | None = None,
         upper_limit: float | None = None
     ) -> None:
-        """Log a test result with optional limits."""
+        """[docstring]"""  
-        ...
+        pass
 
+    @abstractmethod
     def log_event(self, message: str, level: str = "INFO") -> None:
-        """Log a test event or message."""
+        """[docstring]"""  
-        ...
+        pass
 ```
 
 ### 4.2 Transport Interface
@@ -584,36 +600,42 @@ class ITestLogger(Protocol):
 ```python
 # py_dvt_ate/instruments/transport/base.py
 
-from typing import Protocol
+from abc import ABC, abstractmethod
 
 
-class Transport(Protocol):
+class Transport(ABC):
     """Abstract transport interface for instrument communication."""
 
+    @abstractmethod
     def connect(self) -> None:
-        """Establish connection to instrument."""
+        """[docstring]"""  
-        ...
+        pass
 
+    @abstractmethod
     def disconnect(self) -> None:
-        """Close connection to instrument."""
+        """[docstring]"""  
-        ...
+        pass
 
+    @abstractmethod
     def write(self, command: str) -> None:
-        """Send command to instrument."""
+        """[docstring]"""  
-        ...
+        pass
 
+    @abstractmethod
     def read(self, timeout: float | None = None) -> str:
-        """Read response from instrument."""
+        """[docstring]"""  
-        ...
+        pass
 
+    @abstractmethod
     def query(self, command: str, timeout: float | None = None) -> str:
-        """Send command and read response."""
+        """[docstring]"""  
-        ...
+        pass
 
     @property
+    @abstractmethod
     def is_connected(self) -> bool:
-        """Check if connection is active."""
+        """[docstring]"""  
-        ...
+        pass
 ```
 
 ### 4.3 Test Interface
@@ -624,7 +646,7 @@ class Transport(Protocol):
 from dataclasses import dataclass, field
 from datetime import datetime
 from enum import Enum
-from typing import Protocol
+from abc import ABC, abstractmethod
 from uuid import UUID
 
 
@@ -675,22 +697,25 @@ class TestContext:
     config: dict
 
 
-class ITest(Protocol):
+class ITest(ABC):
     """Interface for test implementations."""
 
     @property
+    @abstractmethod
     def name(self) -> str:
-        """Test name identifier."""
+        """[docstring]"""  
-        ...
+        pass
 
     @property
+    @abstractmethod
     def description(self) -> str:
-        """Human-readable test description."""
+        """[docstring]"""  
-        ...
+        pass
 
+    @abstractmethod
     def execute(self, context: TestContext) -> TestStatus:
-        """Execute the test, return status."""
+        """[docstring]"""  
-        ...
+        pass
 ```
 
 ### 4.4 Factory Interface
@@ -1173,30 +1198,34 @@ Schema:
 ```python
 # py_dvt_ate/data/repository.py (interface)
 
-from typing import Protocol
+from abc import ABC, abstractmethod
 from uuid import UUID
 
 
-class ITestRepository(Protocol):
+class ITestRepository(ABC):
     """Repository interface for test data."""
 
+    @abstractmethod
     def create_run(
         self,
         test_name: str,
         config: dict,
         operator: str | None = None
     ) -> UUID:
-        """Create a new test run, return its ID."""
+        """[docstring]"""  
-        ...
+        pass
 
+    @abstractmethod
     def update_run_status(self, run_id: UUID, status: str) -> None:
-        """Update test run status."""
+        """[docstring]"""  
-        ...
+        pass
 
+    @abstractmethod
     def complete_run(self, run_id: UUID, status: str) -> None:
-        """Mark test run as complete with final status."""
+        """[docstring]"""  
-        ...
+        pass
 
+    @abstractmethod
     def save_result(
         self,
         run_id: UUID,
@@ -1206,28 +1235,32 @@ class ITestRepository(Protocol):
         lower_limit: float | None = None,
         upper_limit: float | None = None
     ) -> None:
-        """Save a test result."""
+        """[docstring]"""  
-        ...
+        pass
 
+    @abstractmethod
     def save_measurements(
         self,
         run_id: UUID,
         measurements: list["Measurement"]
     ) -> None:
-        """Save batch of measurements to Parquet."""
+        """[docstring]"""  
-        ...
+        pass
 
+    @abstractmethod
     def get_run(self, run_id: UUID) -> "TestRun":
-        """Get test run by ID."""
+        """[docstring]"""  
-        ...
+        pass
 
+    @abstractmethod
     def get_results(self, run_id: UUID) -> list["TestResult"]:
-        """Get all results for a test run."""
+        """[docstring]"""  
-        ...
+        pass
 
+    @abstractmethod
     def get_measurements_dataframe(self, run_id: UUID):
-        """Get measurements as pandas DataFrame."""
+        """[docstring]"""  
-        ...
+        pass
 ```
 
 ---

pyproject.toml

@@ -37,6 +37,8 @@ dev = [
     "pytest-asyncio>=0.21",
     "ruff>=0.1",
     "mypy>=1.0",
+    "types-PyYAML>=6.0",
+    "pandas-stubs>=2.0",
 ]
 
 [project.scripts]

src/py_dvt_ate/__init__.py

@@ -1,3 +1,3 @@
 """py_dvt_ate: Coupled Physics DVT Simulation Platform."""
 
-__version__ = "0.1.0-alpha.3"
+__version__ = "0.1.0"

src/py_dvt_ate/app/cli.py

@@ -1,6 +1,6 @@
 """Command-line interface for py_dvt_ate."""
 
-from typing import Annotated, Optional
+from typing import Annotated
 
 import typer
 
@@ -23,7 +23,7 @@ def version_callback(value: bool) -> None:
 @app.callback()
 def main(
     version: Annotated[
-        Optional[bool],
+        bool | None,
         typer.Option(
             "--version",
             "-v",
@@ -83,5 +83,81 @@ def serve(
     )
 
 
+@app.command(name="list-tests")
+def list_tests_cmd() -> None:
+    """List all available DVT tests."""
+    from py_dvt_ate.app.test_commands import list_tests
+
+    list_tests()
+
+
+@app.command(name="run-test")
+def run_test_cmd(
+    test_name: Annotated[
+        str,
+        typer.Argument(help="Name of the test to run (use list-tests to see available tests)."),
+    ],
+    config_file: Annotated[
+        str | None,
+        typer.Option("--config", "-c", help="Path to configuration YAML file."),
+    ] = None,
+    operator: Annotated[
+        str | None,
+        typer.Option("--operator", "-o", help="Operator identifier (e.g., email address)."),
+    ] = None,
+    description: Annotated[
+        str | None,
+        typer.Option("--description", "-d", help="Test run description."),
+    ] = None,
+) -> None:
+    """Run a specific DVT test.
+
+    The test will connect to instruments based on the configuration file
+    (default: config/default.yaml). Results are stored in the data directory.
+    """
+    from py_dvt_ate.app.test_commands import run_test
+
+    run_test(
+        test_name=test_name,
+        config_file=config_file,
+        operator=operator,
+        description=description,
+    )
+
+
+@app.command(name="query")
+def query_cmd(
+    instrument: Annotated[
+        str,
+        typer.Argument(help="Instrument to query (chamber, psu, or dmm)."),
+    ],
+    command: Annotated[
+        str,
+        typer.Argument(help="SCPI command to send (e.g., *IDN?, TEMP:SETPOINT?)."),
+    ],
+    config_file: Annotated[
+        str | None,
+        typer.Option("--config", "-c", help="Path to configuration YAML file."),
+    ] = None,
+) -> None:
+    """Send a SCPI command to an instrument and print the response.
+
+    Useful for debugging and manual instrument control. Connect to
+    instruments based on configuration and send raw SCPI commands.
+
+    Examples:
+        py-dvt-ate query chamber "*IDN?"
+        py-dvt-ate query psu "VOLT? 1"
+        py-dvt-ate query dmm "MEAS:VOLT:DC?"
+    """
+    from py_dvt_ate.app.instrument_commands import query_instrument
+
+    query_instrument(
+        instrument=instrument,
+        command=command,
+        config_file=config_file,
+    )
+
+
 if __name__ == "__main__":
     app()

src/py_dvt_ate/app/config.py

@@ -0,0 +1,200 @@
+"""Configuration models for py_dvt_ate.
+
+This module defines Pydantic models for all configuration sections.
+Configuration can be loaded from YAML files and validated at runtime.
+"""
+
+import os
+from pathlib import Path
+from typing import Any, Literal
+
+import yaml
+from pydantic import BaseModel, Field
+
+
+class SimulatorConfig(BaseModel):
+    """Configuration for simulator instrument backend."""
+
+    host: str = "localhost"
+    thermal_chamber_port: int = 5001
+    power_supply_port: int = 5002
+    multimeter_port: int = 5003
+
+
+class PyVISAConfig(BaseModel):
+    """Configuration for PyVISA instrument backend."""
+
+    thermal_chamber: str | None = None
+    power_supply: str | None = None
+    multimeter: str | None = None
+
+
+class InstrumentsConfig(BaseModel):
+    """Instrument backend configuration."""
+
+    backend: Literal["simulator", "pyvisa"] = "simulator"
+    simulator: SimulatorConfig = Field(default_factory=SimulatorConfig)
+    pyvisa: PyVISAConfig = Field(default_factory=PyVISAConfig)
+
+
+class ThermalConfig(BaseModel):
+    """Thermal physics parameters."""
+
+    chamber_time_constant_s: float = 30.0
+    case_time_constant_s: float = 5.0
+    theta_jc: float = 15.0  # °C/W (junction to case)
+    theta_ca: float = 5.0  # °C/W (case to ambient)
+
+
+class ChamberConfig(BaseModel):
+    """Thermal chamber behaviour parameters."""
+
+    ramp_rate_c_per_min: float = 10.0
+    stability_window_c: float = 0.5
+    stability_time_s: float = 30.0
+
+
+class PhysicsConfig(BaseModel):
+    """Physics simulation parameters."""
+
+    update_rate_hz: float = 100.0
+    thermal: ThermalConfig = Field(default_factory=ThermalConfig)
+    chamber: ChamberConfig = Field(default_factory=ChamberConfig)
+
+
+class DUTParameters(BaseModel):
+    """DUT model parameters."""
+
+    nominal_output_voltage: float = 3.3
+    tempco_ppm_per_c: float = 50.0
+    quiescent_current_ua: float = 50.0
+    quiescent_current_tempco: float = 0.003
+    dropout_voltage: float = 0.3
+
+
+class DUTConfig(BaseModel):
+    """DUT model configuration."""
+
+    model: str = "ldo"
+    parameters: DUTParameters = Field(default_factory=DUTParameters)
+
+
+class DataConfig(BaseModel):
+    """Data storage paths."""
+
+    database_path: str = "./data/py_dvt_ate.db"
+    measurements_dir: str = "./data/measurements"
+    reports_dir: str = "./data/reports"
+
+
+class LoggingConfig(BaseModel):
+    """Logging configuration."""
+
+    level: str = "INFO"
+    file: str = "./data/logs/py_dvt_ate.log"
+    format: str = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+
+
+class DashboardConfig(BaseModel):
+    """Dashboard (Streamlit) configuration."""
+
+    enabled: bool = True
+    port: int = 8501
+
+
+class APIConfig(BaseModel):
+    """API server configuration (Phase 2)."""
+
+    enabled: bool = False
+    host: str = "0.0.0.0"
+    port: int = 8000
+
+
+class AppConfig(BaseModel):
+    """Root configuration model."""
+
+    instruments: InstrumentsConfig = Field(default_factory=InstrumentsConfig)
+    physics: PhysicsConfig = Field(default_factory=PhysicsConfig)
+    dut: DUTConfig = Field(default_factory=DUTConfig)
+    data: DataConfig = Field(default_factory=DataConfig)
+    logging: LoggingConfig = Field(default_factory=LoggingConfig)
+    dashboard: DashboardConfig = Field(default_factory=DashboardConfig)
+    api: APIConfig = Field(default_factory=APIConfig)
+
+
+def _apply_env_overrides(config_dict: dict[str, Any]) -> None:
+    """Apply environment variable overrides to config dictionary.
+
+    Environment variables follow the pattern: PYDVTATE__{SECTION}__{KEY}
+    For nested keys, use double underscores: PYDVTATE__{SECTION}__{SUBSECTION}__{KEY}
+
+    Examples:
+        PYDVTATE__INSTRUMENTS__BACKEND=pyvisa
+        PYDVTATE__PHYSICS__UPDATE_RATE_HZ=50.0
+        PYDVTATE__SIMULATOR__HOST=192.168.1.100
+    """
+    prefix = "PYDVTATE__"
+
+    for env_key, env_value in os.environ.items():
+        if not env_key.startswith(prefix):
+            continue
+
+        # Remove prefix and split into parts
+        key_parts = env_key[len(prefix) :].lower().split("__")
+
+        # Navigate/create nested structure
+        current = config_dict
+        for part in key_parts[:-1]:
+            if part not in current:
+                current[part] = {}
+            current = current[part]
+
+        # Set the final value
+        final_key = key_parts[-1]
+        # Try to parse as YAML to handle types (int, float, bool, etc.)
+        try:
+            current[final_key] = yaml.safe_load(env_value)
+        except yaml.YAMLError:
+            # If parsing fails, use as string
+            current[final_key] = env_value
+
+
+def load_config(config_path: str | Path | None = None) -> AppConfig:
+    """Load configuration from YAML file with environment variable overrides.
+
+    Args:
+        config_path: Path to YAML configuration file. If None, uses defaults only.
+
+    Returns:
+        Validated AppConfig instance.
+
+    Raises:
+        FileNotFoundError: If config_path is provided but does not exist.
+        yaml.YAMLError: If YAML file is malformed.
+        pydantic.ValidationError: If configuration is invalid.
+
+    Environment Variables:
+        Configuration can be overridden using environment variables with the
+        pattern PYDVTATE__{SECTION}__{KEY}. For example:
+            PYDVTATE__INSTRUMENTS__BACKEND=pyvisa
+            PYDVTATE__PHYSICS__UPDATE_RATE_HZ=50.0
+    """
+    # Start with empty dict (will use Pydantic defaults)
+    config_dict: dict[str, Any] = {}
+
+    # Load from YAML file if provided
+    if config_path is not None:
+        path = Path(config_path)
+        if not path.exists():
+            raise FileNotFoundError(f"Configuration file not found: {config_path}")
+
+        with path.open("r") as f:
+            loaded = yaml.safe_load(f)
+            if loaded is not None:
+                config_dict = loaded
+
+    # Apply environment variable overrides
+    _apply_env_overrides(config_dict)
+
+    # Validate and return
+    return AppConfig(**config_dict)

src/py_dvt_ate/app/instrument_commands.py

@@ -0,0 +1,68 @@
+"""Instrument query commands for CLI."""
+
+import typer
+
+from py_dvt_ate.app.config import load_config
+from py_dvt_ate.instruments.factory import InstrumentConfig, InstrumentFactory
+
+
+def query_instrument(
+    instrument: str,
+    command: str,
+    config_file: str | None = None,
+) -> None:
+    """Send a SCPI command to an instrument and print the response.
+
+    Args:
+        instrument: Instrument to query (chamber, psu, or dmm).
+        command: SCPI command to send.
+        config_file: Path to configuration YAML file.
+    """
+    # Load configuration
+    config_path = config_file or "config/default.yaml"
+    try:
+        config = load_config(config_path)
+    except FileNotFoundError as err:
+        typer.echo(f"Error: Configuration file not found: {config_path}", err=True)
+        raise typer.Exit(code=1) from err
+    except Exception as e:
+        typer.echo(f"Error loading configuration: {e}", err=True)
+        raise typer.Exit(code=1) from e
+
+    # Create instruments
+    try:
+        # Convert AppConfig to InstrumentConfig
+        inst_config = InstrumentConfig(
+            backend=config.instruments.backend,
+            simulator_host=config.instruments.simulator.host,
+            chamber_port=config.instruments.simulator.thermal_chamber_port,
+            psu_port=config.instruments.simulator.power_supply_port,
+            dmm_port=config.instruments.simulator.multimeter_port,
+            chamber_visa=config.instruments.pyvisa.thermal_chamber,
+            psu_visa=config.instruments.pyvisa.power_supply,
+            dmm_visa=config.instruments.pyvisa.multimeter,
+        )
+        instruments = InstrumentFactory.create(inst_config)
+    except Exception as e:
+        typer.echo(f"Error connecting to instruments: {e}", err=True)
+        raise typer.Exit(code=1) from e
+
+    # Send command to the specified instrument
+    try:
+        # Access the transport layer to send raw commands
+        if instrument == "chamber":
+            response = instruments.chamber._transport.query(command)  # type: ignore[attr-defined]
+        elif instrument == "psu":
+            response = instruments.psu._transport.query(command)  # type: ignore[attr-defined]
+        elif instrument == "dmm":
+            response = instruments.dmm._transport.query(command)  # type: ignore[attr-defined]
+        else:
+            typer.echo(f"Error: Unknown instrument '{instrument}'", err=True)
+            typer.echo("Valid instruments: chamber, psu, dmm", err=True)
+            raise typer.Exit(code=1)
+
+        if response:
+            typer.echo(response)
+    except Exception as e:
+        typer.echo(f"Error sending command: {e}", err=True)
+        raise typer.Exit(code=1) from e

src/py_dvt_ate/app/test_commands.py

@@ -0,0 +1,175 @@
+"""Test execution commands for CLI."""
+
+import importlib
+import inspect
+from pathlib import Path
+
+import typer
+
+from py_dvt_ate.app.config import load_config
+from py_dvt_ate.data.repository import SQLiteRepository
+from py_dvt_ate.framework.context import ITest
+from py_dvt_ate.framework.runner import TestRunner
+from py_dvt_ate.instruments.factory import InstrumentConfig, InstrumentFactory
+
+
+def _discover_tests() -> dict[str, type]:
+    """Discover all available tests by scanning the tests package.
+
+    Returns:
+        Dictionary mapping test names to test classes.
+    """
+    tests: dict[str, type] = {}
+
+    # Find the tests package directory
+    import py_dvt_ate.tests
+
+    tests_pkg_path = Path(py_dvt_ate.tests.__file__).parent
+
+    # Scan all Python files in the tests package
+    for py_file in tests_pkg_path.rglob("*.py"):
+        if py_file.name.startswith("_"):
+            continue
+
+        # Convert file path to module name
+        rel_path = py_file.relative_to(tests_pkg_path.parent)
+        module_name = "py_dvt_ate." + str(rel_path.with_suffix("")).replace("/", ".").replace("\\", ".")
+
+        try:
+            module = importlib.import_module(module_name)
+
+            # Find all classes that implement ITest
+            for _name, obj in inspect.getmembers(module, inspect.isclass):
+                if (
+                    obj is not ITest
+                    and issubclass(obj, ITest)
+                    and not inspect.isabstract(obj)
+                    and hasattr(obj, "name")
+                ):
+                    # Create instance to get the name property
+                    instance = obj()
+                    tests[instance.name] = obj
+
+        except (ImportError, AttributeError):
+            continue
+
+    return tests
+
+
+def list_tests() -> None:
+    """List all available DVT tests."""
+    tests = _discover_tests()
+
+    if not tests:
+        typer.echo("No tests found.")
+        return
+
+    typer.echo("Available DVT tests:")
+    typer.echo("")
+
+    for test_name in sorted(tests.keys()):
+        test_class = tests[test_name]
+        instance = test_class()
+        typer.echo(f"  {test_name:15s}  {instance.description}")
+
+
+def run_test(
+    test_name: str,
+    config_file: str | None = None,
+    operator: str | None = None,
+    description: str | None = None,
+) -> None:
+    """Run a specific DVT test.
+
+    Args:
+        test_name: Name of the test to run.
+        config_file: Path to configuration YAML file.
+        operator: Operator identifier (e.g., email address).
+        description: Test run description.
+    """
+    # Discover available tests
+    tests = _discover_tests()
+
+    if test_name not in tests:
+        typer.echo(f"Error: Test \'{test_name}\' not found.", err=True)
+        typer.echo("", err=True)
+        typer.echo("Available tests:", err=True)
+        for name in sorted(tests.keys()):
+            typer.echo(f"  - {name}", err=True)
+        raise typer.Exit(code=1)
+
+    # Load configuration
+    config_path = config_file or "config/default.yaml"
+    try:
+        config = load_config(config_path)
+    except FileNotFoundError as err:
+        typer.echo(f"Error: Configuration file not found: {config_path}", err=True)
+        typer.echo("Run with --config to specify a different config file.", err=True)
+        raise typer.Exit(code=1) from err
+    except Exception as e:
+        typer.echo(f"Error loading configuration: {e}", err=True)
+        raise typer.Exit(code=1) from e
+
+    # Create repository
+    try:
+        repository = SQLiteRepository(config.data.database_path)
+    except Exception as e:
+        typer.echo(f"Error initialising repository: {e}", err=True)
+        raise typer.Exit(code=1) from e
+
+    # Create instruments
+    typer.echo(f"Connecting to instruments ({config.instruments.backend})...")
+    try:
+        # Convert AppConfig to InstrumentConfig
+        inst_config = InstrumentConfig(
+            backend=config.instruments.backend,
+            simulator_host=config.instruments.simulator.host,
+            chamber_port=config.instruments.simulator.thermal_chamber_port,
+            psu_port=config.instruments.simulator.power_supply_port,
+            dmm_port=config.instruments.simulator.multimeter_port,
+            chamber_visa=config.instruments.pyvisa.thermal_chamber,
+            psu_visa=config.instruments.pyvisa.power_supply,
+            dmm_visa=config.instruments.pyvisa.multimeter,
+        )
+        instruments = InstrumentFactory.create(inst_config)
+    except Exception as e:
+        typer.echo(f"Error connecting to instruments: {e}", err=True)
+        raise typer.Exit(code=1) from e
+
+    # Create test instance
+    test_class = tests[test_name]
+    test = test_class()
+
+    # Run test
+    typer.echo(f"Running test: {test.name}")
+    typer.echo(f"Description: {test.description}")
+    typer.echo("")
+
+    try:
+        runner = TestRunner(repository)
+        run_id = runner.run_test(
+            test=test,
+            instruments=instruments,
+            operator=operator,
+            description=description,
+        )
+
+        # Retrieve final status
+        run = repository.get_run(run_id)
+        typer.echo("")
+        typer.echo(f"Test completed: {run.status.value}")
+        typer.echo(f"Run ID: {run_id}")
+
+        # Exit with appropriate code
+        if run.status.value == "PASSED":
+            raise typer.Exit(code=0)
+        else:
+            raise typer.Exit(code=1)
+
+    except KeyboardInterrupt:
+        typer.echo("")
+        typer.echo("Test interrupted by user.")
+        raise typer.Exit(code=130) from None
+    except Exception as e:
+        typer.echo(f"Error running test: {e}", err=True)
+        raise typer.Exit(code=1) from e

src/py_dvt_ate/data/__init__.py

@@ -0,0 +1,14 @@
+"""Data persistence layer.
+
+Provides storage for test runs, results, and measurements using
+SQLite for metadata and Parquet for time-series data.
+"""
+
+from py_dvt_ate.data.models import Measurement, TestResult, TestRun, TestStatus
+
+__all__ = [
+    "Measurement",
+    "TestResult",
+    "TestRun",
+    "TestStatus",
+]

src/py_dvt_ate/data/models.py

@@ -0,0 +1,83 @@
+"""Data models for test persistence.
+
+This module defines dataclasses representing test runs, results, and measurements.
+These models map to SQLite tables (for metadata) and Parquet files (for time-series).
+"""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+
+
+class TestStatus(Enum):
+    """Test run status."""
+
+    PENDING = "pending"
+    RUNNING = "running"
+    PASSED = "passed"
+    FAILED = "failed"
+    ERROR = "error"
+    SKIPPED = "skipped"
+
+
+@dataclass
+class TestRun:
+    """Test run metadata.
+
+    Maps to the test_runs SQLite table.
+    """
+
+    id: str  # UUID
+    test_name: str
+    started_at: datetime
+    status: TestStatus
+    config_json: str  # JSON string of test configuration
+    description: str | None = None
+    completed_at: datetime | None = None
+    operator: str | None = None
+    notes: str | None = None
+    created_at: datetime = field(default_factory=datetime.now)
+
+
+@dataclass(frozen=True)
+class TestResult:
+    """Immutable test result with limits.
+
+    Maps to the test_results SQLite table.
+    Represents a single scalar measurement with pass/fail limits.
+    """
+
+    id: str  # UUID
+    test_run_id: str  # Foreign key to test_runs.id
+    parameter: str
+    value: float
+    unit: str
+    measured_at: datetime
+    lower_limit: float | None = None
+    upper_limit: float | None = None
+
+    @property
+    def passed(self) -> bool | None:
+        """Evaluate pass/fail. None if no limits defined."""
+        if self.lower_limit is None and self.upper_limit is None:
+            return None
+        lower_ok = self.lower_limit is None or self.value >= self.lower_limit
+        upper_ok = self.upper_limit is None or self.value <= self.upper_limit
+        return lower_ok and upper_ok
+
+
+@dataclass(frozen=True)
+class Measurement:
+    """Immutable measurement record for time-series data.
+
+    Maps to Parquet files for efficient storage and analysis.
+    Includes measurement conditions (temperature, voltage, current) at time of measurement.
+    """
+
+    timestamp: float  # Seconds since epoch (high precision)
+    parameter: str
+    value: float
+    unit: str
+    temperature: float = 0.0  # Chamber temperature at measurement
+    input_voltage: float = 0.0  # DUT input voltage at measurement
+    load_current: float = 0.0  # DUT load current at measurement

src/py_dvt_ate/data/repository.py

@@ -0,0 +1,415 @@
+"""Data repository implementation using SQLite and Parquet.
+
+This module provides SQLite-based storage for test run metadata and results.
+Time-series measurements are stored separately in Parquet files.
+"""
+
+import json
+import sqlite3
+from abc import ABC, abstractmethod
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+from uuid import UUID, uuid4
+
+import pandas as pd
+
+from py_dvt_ate.data.models import Measurement, TestResult, TestRun, TestStatus
+
+
+class ITestRepository(ABC):
+    """Repository interface for test data."""
+
+    @abstractmethod
+    def create_run(
+        self,
+        test_name: str,
+        config: dict[str, Any],
+        operator: str | None = None,
+        description: str | None = None,
+    ) -> UUID:
+        """Create a new test run and return its ID."""
+
+    @abstractmethod
+    def update_run_status(self, run_id: UUID, status: TestStatus) -> None:
+        """Update the status of a test run."""
+
+    @abstractmethod
+    def complete_run(self, run_id: UUID, status: TestStatus) -> None:
+        """Mark a test run as complete with final status."""
+
+    @abstractmethod
+    def save_result(
+        self,
+        run_id: UUID,
+        parameter: str,
+        value: float,
+        unit: str,
+        lower_limit: float | None = None,
+        upper_limit: float | None = None,
+    ) -> None:
+        """Save a scalar test result."""
+
+    @abstractmethod
+    def save_measurements(
+        self,
+        run_id: UUID,
+        measurements: list[Measurement],
+    ) -> None:
+        """Save time-series measurements (implemented in Parquet extension)."""
+
+    @abstractmethod
+    def get_run(self, run_id: UUID) -> TestRun:
+        """Retrieve test run metadata by ID."""
+
+    @abstractmethod
+    def get_results(self, run_id: UUID) -> list[TestResult]:
+        """Retrieve all test results for a run."""
+
+    @abstractmethod
+    def get_measurements_dataframe(self, run_id: UUID) -> pd.DataFrame | None:
+        """Retrieve measurements as pandas DataFrame."""
+
+    @abstractmethod
+    def get_all_runs(self) -> list[TestRun]:
+        """Retrieve all test runs, ordered by started_at descending."""
+
+    def close(self) -> None:
+        """Close repository and release resources. Optional to implement."""
+
+
+class SQLiteRepository(ITestRepository):
+    """SQLite-based repository for test data.
+
+    Stores test run metadata and scalar results in SQLite.
+    Time-series measurements are stored in Parquet files.
+    """
+
+    def __init__(self, db_path: str | Path, measurements_dir: str | Path | None = None):
+        """Initialise repository with database and measurements paths.
+
+        Args:
+            db_path: Path to SQLite database file
+            measurements_dir: Directory for Parquet measurement files
+                            (defaults to db_path parent / "measurements")
+        """
+        self.db_path = Path(db_path)
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+
+        if measurements_dir is None:
+            self.measurements_dir = self.db_path.parent / "measurements"
+        else:
+            self.measurements_dir = Path(measurements_dir)
+
+        self.measurements_dir.mkdir(parents=True, exist_ok=True)
+        self._init_database()
+
+    def _init_database(self) -> None:
+        """Create database tables if they don't exist."""
+        with sqlite3.connect(self.db_path) as conn:
+            conn.execute(
+                """
+                CREATE TABLE IF NOT EXISTS test_runs (
+                    id TEXT PRIMARY KEY,
+                    test_name TEXT NOT NULL,
+                    description TEXT,
+                    started_at TEXT NOT NULL,
+                    completed_at TEXT,
+                    status TEXT NOT NULL DEFAULT 'pending',
+                    config_json TEXT NOT NULL,
+                    operator TEXT,
+                    notes TEXT,
+                    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+                )
+                """
+            )
+            conn.execute(
+                """
+                CREATE TABLE IF NOT EXISTS test_results (
+                    id TEXT PRIMARY KEY,
+                    test_run_id TEXT NOT NULL,
+                    parameter TEXT NOT NULL,
+                    value REAL NOT NULL,
+                    unit TEXT,
+                    lower_limit REAL,
+                    upper_limit REAL,
+                    passed INTEGER NOT NULL,
+                    measured_at TEXT NOT NULL,
+                    FOREIGN KEY (test_run_id) REFERENCES test_runs(id)
+                )
+                """
+            )
+            conn.execute(
+                "CREATE INDEX IF NOT EXISTS idx_test_runs_status ON test_runs(status)"
+            )
+            conn.execute(
+                "CREATE INDEX IF NOT EXISTS idx_test_runs_name ON test_runs(test_name)"
+            )
+            conn.execute(
+                "CREATE INDEX IF NOT EXISTS idx_test_results_run ON test_results(test_run_id)"
+            )
+            conn.execute(
+                "CREATE INDEX IF NOT EXISTS idx_test_results_param ON test_results(parameter)"
+            )
+            conn.commit()
+
+    def create_run(
+        self,
+        test_name: str,
+        config: dict[str, Any],
+        operator: str | None = None,
+        description: str | None = None,
+    ) -> UUID:
+        """Create a new test run and return its ID."""
+        run_id = uuid4()
+        started_at = datetime.now()
+        config_json = json.dumps(config)
+
+        with sqlite3.connect(self.db_path) as conn:
+            conn.execute(
+                """
+                INSERT INTO test_runs (
+                    id, test_name, description, started_at, status,
+                    config_json, operator, created_at
+                )
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    str(run_id),
+                    test_name,
+                    description,
+                    started_at.isoformat(),
+                    TestStatus.PENDING.value,
+                    config_json,
+                    operator,
+                    datetime.now().isoformat(),
+                ),
+            )
+            conn.commit()
+
+        return run_id
+
+    def update_run_status(self, run_id: UUID, status: TestStatus) -> None:
+        """Update the status of a test run."""
+        with sqlite3.connect(self.db_path) as conn:
+            conn.execute(
+                "UPDATE test_runs SET status = ? WHERE id = ?",
+                (status.value, str(run_id)),
+            )
+            conn.commit()
+
+    def complete_run(self, run_id: UUID, status: TestStatus) -> None:
+        """Mark a test run as complete with final status."""
+        completed_at = datetime.now()
+
+        with sqlite3.connect(self.db_path) as conn:
+            conn.execute(
+                """
+                UPDATE test_runs
+                SET status = ?, completed_at = ?
+                WHERE id = ?
+                """,
+                (status.value, completed_at.isoformat(), str(run_id)),
+            )
+            conn.commit()
+
+    def save_result(
+        self,
+        run_id: UUID,
+        parameter: str,
+        value: float,
+        unit: str,
+        lower_limit: float | None = None,
+        upper_limit: float | None = None,
+    ) -> None:
+        """Save a scalar test result."""
+        result_id = uuid4()
+        measured_at = datetime.now()
+
+        # Calculate pass/fail
+        passed = 1  # Default to pass if no limits
+        if lower_limit is not None or upper_limit is not None:
+            lower_ok = lower_limit is None or value >= lower_limit
+            upper_ok = upper_limit is None or value <= upper_limit
+            passed = 1 if (lower_ok and upper_ok) else 0
+
+        with sqlite3.connect(self.db_path) as conn:
+            conn.execute(
+                """
+                INSERT INTO test_results (
+                    id, test_run_id, parameter, value, unit,
+                    lower_limit, upper_limit, passed, measured_at
+                )
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    str(result_id),
+                    str(run_id),
+                    parameter,
+                    value,
+                    unit,
+                    lower_limit,
+                    upper_limit,
+                    passed,
+                    measured_at.isoformat(),
+                ),
+            )
+            conn.commit()
+
+    def save_measurements(
+        self,
+        run_id: UUID,
+        measurements: list[Measurement],
+    ) -> None:
+        """Save time-series measurements to Parquet file.
+
+        Measurements are stored in Parquet format for efficient time-series storage.
+        File path: {measurements_dir}/run_{run_id}/measurements.parquet
+        """
+        if not measurements:
+            return
+
+        # Create run-specific directory
+        run_dir = self.measurements_dir / f"run_{run_id}"
+        run_dir.mkdir(parents=True, exist_ok=True)
+
+        # Convert measurements to DataFrame
+        data = {
+            "timestamp": [m.timestamp for m in measurements],
+            "parameter": [m.parameter for m in measurements],
+            "value": [m.value for m in measurements],
+            "unit": [m.unit for m in measurements],
+            "temperature": [m.temperature for m in measurements],
+            "input_voltage": [m.input_voltage for m in measurements],
+            "load_current": [m.load_current for m in measurements],
+        }
+        df = pd.DataFrame(data)
+
+        # Save to Parquet (append mode if file exists)
+        parquet_path = run_dir / "measurements.parquet"
+        if parquet_path.exists():
+            # Read existing data and append
+            existing_df = pd.read_parquet(parquet_path)
+            df = pd.concat([existing_df, df], ignore_index=True)
+
+        df.to_parquet(parquet_path, index=False, engine="pyarrow")
+
+    def get_run(self, run_id: UUID) -> TestRun:
+        """Retrieve test run metadata by ID."""
+        with sqlite3.connect(self.db_path) as conn:
+            conn.row_factory = sqlite3.Row
+            cursor = conn.execute(
+                "SELECT * FROM test_runs WHERE id = ?",
+                (str(run_id),),
+            )
+            row = cursor.fetchone()
+
+            if row is None:
+                msg = f"Test run {run_id} not found"
+                raise ValueError(msg)
+
+            return TestRun(
+                id=row["id"],
+                test_name=row["test_name"],
+                description=row["description"],
+                started_at=datetime.fromisoformat(row["started_at"]),
+                completed_at=(
+                    datetime.fromisoformat(row["completed_at"])
+                    if row["completed_at"]
+                    else None
+                ),
+                status=TestStatus(row["status"]),
+                config_json=row["config_json"],
+                operator=row["operator"],
+                notes=row["notes"],
+                created_at=datetime.fromisoformat(row["created_at"]),
+            )
+
+    def get_results(self, run_id: UUID) -> list[TestResult]:
+        """Retrieve all test results for a run."""
+        with sqlite3.connect(self.db_path) as conn:
+            conn.row_factory = sqlite3.Row
+            cursor = conn.execute(
+                "SELECT * FROM test_results WHERE test_run_id = ?",
+                (str(run_id),),
+            )
+            rows = cursor.fetchall()
+
+            return [
+                TestResult(
+                    id=row["id"],
+                    test_run_id=row["test_run_id"],
+                    parameter=row["parameter"],
+                    value=row["value"],
+                    unit=row["unit"],
+                    lower_limit=row["lower_limit"],
+                    upper_limit=row["upper_limit"],
+                    measured_at=datetime.fromisoformat(row["measured_at"]),
+                )
+                for row in rows
+            ]
+
+    def get_measurements_dataframe(self, run_id: UUID) -> pd.DataFrame | None:
+        """Retrieve measurements as pandas DataFrame from Parquet file.
+
+        Args:
+            run_id: Test run ID
+
+        Returns:
+            DataFrame with measurement data, or None if no measurements exist
+        """
+        parquet_path = self.measurements_dir / f"run_{run_id}" / "measurements.parquet"
+
+        if not parquet_path.exists():
+            return None
+
+        return pd.read_parquet(parquet_path)
+
+    def get_all_runs(self) -> list[TestRun]:
+        """Retrieve all test runs, ordered by started_at descending.
+
+        Returns:
+            List of all TestRun objects, newest first.
+        """
+        with sqlite3.connect(self.db_path) as conn:
+            conn.row_factory = sqlite3.Row
+            cursor = conn.cursor()
+
+            cursor.execute("""
+                SELECT id, test_name, started_at, status, config_json,
+                       description, completed_at, operator, notes, created_at
+                FROM test_runs
+                ORDER BY started_at DESC
+            """)
+
+            rows = cursor.fetchall()
+
+            return [
+                TestRun(
+                    id=row["id"],
+                    test_name=row["test_name"],
+                    started_at=datetime.fromisoformat(row["started_at"]),
+                    status=TestStatus(row["status"]),
+                    config_json=row["config_json"],
+                    description=row["description"],
+                    completed_at=(
+                        datetime.fromisoformat(row["completed_at"])
+                        if row["completed_at"]
+                        else None
+                    ),
+                    operator=row["operator"],
+                    notes=row["notes"],
+                    created_at=datetime.fromisoformat(row["created_at"]),
+                )
+                for row in rows
+            ]
+
+    def close(self) -> None:
+        """Close repository and release resources.
+
+        SQLite connections are managed via context managers and auto-close.
+        This method performs explicit cleanup for Windows file handle issues.
+        """
+        # Force garbage collection to release any lingering connections
+        import gc
+        gc.collect()

src/py_dvt_ate/framework/__init__.py

@@ -3,3 +3,20 @@
 Provides test sequencing, measurement logging, limit checking,
 and runtime context management for DVT characterisation tests.
 """
+
+from py_dvt_ate.framework.context import ITest, TestContext
+from py_dvt_ate.framework.limits import Limit, LimitSet, check_value, evaluate_results
+from py_dvt_ate.framework.logger import ITestLogger, TestLogger
+from py_dvt_ate.framework.runner import TestRunner
+
+__all__ = [
+    "ITest",
+    "ITestLogger",
+    "Limit",
+    "LimitSet",
+    "TestContext",
+    "TestLogger",
+    "TestRunner",
+    "check_value",
+    "evaluate_results",
+]

src/py_dvt_ate/framework/context.py

@@ -0,0 +1,111 @@
+"""Test framework context and interface definitions.
+
+This module defines the core abstractions for the test executive framework:
+- TestContext: Runtime context passed to tests during execution
+- ITest: Abstract base class that all DVT tests must implement
+
+The test framework orchestrates test execution, measurement logging, and
+result evaluation against limits.
+"""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+from uuid import UUID
+
+from py_dvt_ate.data.models import TestStatus
+
+if TYPE_CHECKING:
+    # Avoid circular imports while maintaining type checking
+    from py_dvt_ate.framework.logger import ITestLogger
+    from py_dvt_ate.instruments.factory import InstrumentSet
+
+
+@dataclass
+class TestContext:
+    """Runtime context for test execution.
+
+    Provides access to instruments, logging, and configuration during test
+    execution. Passed to each test's execute() method.
+
+    Attributes:
+        run_id: Unique identifier for this test run (UUID).
+        instruments: Hardware abstraction layer providing access to all instruments.
+        logger: Test logger for recording measurements and events.
+        config: Test-specific configuration dictionary.
+    """
+
+    run_id: UUID
+    instruments: "InstrumentSet"
+    logger: "ITestLogger"
+    config: dict[str, Any]
+
+
+class ITest(ABC):
+    """Abstract base class for DVT test implementations.
+
+    All characterisation tests must inherit from this class and implement
+    the required properties and methods. The test runner uses these to
+    discover, describe, and execute tests.
+
+    Example:
+        class TempCoTest(ITest):
+            @property
+            def name(self) -> str:
+                return "tempco"
+
+            @property
+            def description(self) -> str:
+                return "Output voltage temperature coefficient"
+
+            def execute(self, context: TestContext) -> TestStatus:
+                # Test implementation...
+                return TestStatus.PASSED
+    """
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Return the unique test identifier.
+
+        Used for test discovery and selection. Should be lowercase,
+        alphanumeric with underscores (e.g., "tempco", "load_regulation").
+
+        Returns:
+            Unique test name string.
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def description(self) -> str:
+        """Return a human-readable test description.
+
+        Describes what the test measures or characterises. Displayed in
+        reports and user interfaces.
+
+        Returns:
+            Brief description of the test purpose.
+        """
+        pass
+
+    @abstractmethod
+    def execute(self, context: TestContext) -> TestStatus:
+        """Execute the test with the given context.
+
+        Contains the test logic: configure instruments, take measurements,
+        log results, and evaluate pass/fail. The test should use the
+        context.logger to record measurements and context.instruments to
+        control equipment.
+
+        Args:
+            context: Runtime context with instruments, logger, and config.
+
+        Returns:
+            Final test status (PASSED, FAILED, ERROR, etc.).
+
+        Raises:
+            Exception: If a critical error occurs during test execution.
+                      The test runner will catch this and mark the test as ERROR.
+        """
+        pass

src/py_dvt_ate/framework/limits.py

@@ -0,0 +1,238 @@
+"""Limit checking utilities for test result evaluation.
+
+This module provides utilities for evaluating measurements against specification
+limits and determining pass/fail status. Used by tests to check if results meet
+requirements and by the test runner to determine overall test status.
+"""
+
+from dataclasses import dataclass
+from typing import Any
+
+from py_dvt_ate.data.models import TestResult, TestStatus
+
+
+@dataclass(frozen=True)
+class Limit:
+    """Specification limit for a parameter.
+
+    Represents a single limit specification with optional lower and upper bounds.
+    Used to define test specifications and evaluate pass/fail.
+
+    Attributes:
+        parameter: Parameter name this limit applies to.
+        lower: Optional lower limit (inclusive). None means no lower limit.
+        upper: Optional upper limit (inclusive). None means no upper limit.
+        unit: Unit of measurement for the limits.
+
+    Example:
+        temp_co_limit = Limit("temp_co", lower=-50.0, upper=50.0, unit="ppm/°C")
+    """
+
+    parameter: str
+    lower: float | None = None
+    upper: float | None = None
+    unit: str = ""
+
+    def check(self, value: float) -> bool | None:
+        """Check if a value is within this limit.
+
+        Args:
+            value: Value to check against limits.
+
+        Returns:
+            True if value is within limits, False if outside limits.
+            None if no limits are defined (informational parameter).
+
+        Example:
+            limit = Limit("v_out", lower=3.25, upper=3.35, unit="V")
+            limit.check(3.30)  # Returns True
+            limit.check(3.40)  # Returns False
+        """
+        if self.lower is None and self.upper is None:
+            return None
+
+        lower_ok = self.lower is None or value >= self.lower
+        upper_ok = self.upper is None or value <= self.upper
+        return lower_ok and upper_ok
+
+
+@dataclass(frozen=True)
+class LimitSet:
+    """Collection of limits for a test.
+
+    Groups multiple parameter limits together as a test specification.
+    Can be loaded from configuration or defined programmatically.
+
+    Attributes:
+        name: Name of this limit set (e.g., "nominal", "extended").
+        limits: Dictionary mapping parameter names to Limit objects.
+
+    Example:
+        limits = LimitSet(
+            name="nominal",
+            limits={
+                "temp_co": Limit("temp_co", -50.0, 50.0, "ppm/°C"),
+                "v_out": Limit("v_out", 3.25, 3.35, "V"),
+            }
+        )
+    """
+
+    name: str
+    limits: dict[str, Limit]
+
+    def get_limit(self, parameter: str) -> Limit | None:
+        """Get the limit for a specific parameter.
+
+        Args:
+            parameter: Parameter name to look up.
+
+        Returns:
+            Limit object if found, None if parameter has no limit defined.
+        """
+        return self.limits.get(parameter)
+
+    def check(self, parameter: str, value: float) -> bool | None:
+        """Check if a value is within limits for a parameter.
+
+        Args:
+            parameter: Parameter name.
+            value: Value to check.
+
+        Returns:
+            True if within limits, False if outside limits.
+            None if parameter has no limit defined.
+        """
+        limit = self.get_limit(parameter)
+        if limit is None:
+            return None
+        return limit.check(value)
+
+    @classmethod
+    def from_dict(cls, name: str, limits_dict: dict[str, Any]) -> "LimitSet":
+        """Create a LimitSet from a dictionary.
+
+        Useful for loading limit sets from YAML configuration files.
+
+        Args:
+            name: Name for this limit set.
+            limits_dict: Dictionary with parameter names as keys and limit
+                        specifications as values. Each limit spec should have:
+                        - "lower": Optional lower limit
+                        - "upper": Optional upper limit
+                        - "unit": Unit of measurement
+
+        Returns:
+            LimitSet instance.
+
+        Example:
+            config = {
+                "temp_co": {"lower": -50.0, "upper": 50.0, "unit": "ppm/°C"},
+                "v_out": {"lower": 3.25, "upper": 3.35, "unit": "V"},
+            }
+            limits = LimitSet.from_dict("nominal", config)
+        """
+        limits = {}
+        for param, spec in limits_dict.items():
+            limits[param] = Limit(
+                parameter=param,
+                lower=spec.get("lower"),
+                upper=spec.get("upper"),
+                unit=spec.get("unit", ""),
+            )
+        return cls(name=name, limits=limits)
+
+
+def check_value(
+    value: float,
+    lower: float | None = None,
+    upper: float | None = None,
+) -> bool | None:
+    """Check if a value is within specified limits.
+
+    Utility function for quick limit checking without creating Limit objects.
+
+    Args:
+        value: Value to check.
+        lower: Optional lower limit (inclusive).
+        upper: Optional upper limit (inclusive).
+
+    Returns:
+        True if value is within limits, False if outside limits.
+        None if no limits are specified.
+
+    Example:
+        check_value(3.30, lower=3.25, upper=3.35)  # Returns True
+        check_value(3.40, lower=3.25, upper=3.35)  # Returns False
+        check_value(3.30)  # Returns None (no limits)
+    """
+    if lower is None and upper is None:
+        return None
+
+    lower_ok = lower is None or value >= lower
+    upper_ok = upper is None or value <= upper
+    return lower_ok and upper_ok
+
+
+def evaluate_results(results: list[TestResult]) -> TestStatus:
+    """Evaluate a list of test results to determine overall status.
+
+    Aggregates multiple test results into a single pass/fail determination.
+    If any result fails its limits, the overall status is FAILED.
+    If all results pass (or have no limits), the overall status is PASSED.
+
+    Args:
+        results: List of TestResult objects to evaluate.
+
+    Returns:
+        TestStatus.PASSED if all results pass their limits.
+        TestStatus.FAILED if any result fails its limits.
+        TestStatus.PASSED if no results have limits defined (informational only).
+
+    Example:
+        results = [
+            TestResult(..., value=25.0, lower_limit=-50.0, upper_limit=50.0),
+            TestResult(..., value=3.30, lower_limit=3.25, upper_limit=3.35),
+        ]
+        status = evaluate_results(results)  # Returns TestStatus.PASSED
+    """
+    if not results:
+        return TestStatus.PASSED
+
+    # Check if any result failed
+    for result in results:
+        if result.passed is False:
+            return TestStatus.FAILED
+
+    # All results passed (or had no limits)
+    return TestStatus.PASSED
+
+
+def format_limit_violation(result: TestResult) -> str:
+    """Format a limit violation message for a failed result.
+
+    Creates a human-readable message describing why a result failed.
+    Useful for logging and reporting.
+
+    Args:
+        result: TestResult that failed its limits.
+
+    Returns:
+        Formatted violation message.
+
+    Example:
+        result = TestResult(..., parameter="v_out", value=3.40,
+                           lower_limit=3.25, upper_limit=3.35, unit="V")
+        message = format_limit_violation(result)
+        # Returns: "v_out: 3.400 V [FAIL] (limits: 3.250 to 3.350 V)"
+    """
+    status = "PASS" if result.passed else "FAIL"
+    limits_str = ""
+
+    if result.lower_limit is not None and result.upper_limit is not None:
+        limits_str = f" (limits: {result.lower_limit:.3f} to {result.upper_limit:.3f} {result.unit})"
+    elif result.lower_limit is not None:
+        limits_str = f" (minimum: {result.lower_limit:.3f} {result.unit})"
+    elif result.upper_limit is not None:
+        limits_str = f" (maximum: {result.upper_limit:.3f} {result.unit})"
+
+    return f"{result.parameter}: {result.value:.3f} {result.unit} [{status}]{limits_str}"

src/py_dvt_ate/framework/logger.py

@@ -0,0 +1,222 @@
+"""Test logger for recording measurements and events.
+
+This module provides the logging infrastructure for DVT tests. The test logger
+records time-series measurements, scalar results with limits, and event messages
+during test execution.
+"""
+
+import time
+from abc import ABC, abstractmethod
+from datetime import datetime
+from uuid import UUID
+
+from py_dvt_ate.data.models import Measurement
+from py_dvt_ate.data.repository import ITestRepository
+
+
+class ITestLogger(ABC):
+    """Abstract interface for test data logging.
+
+    Provides methods for logging measurements, results, and events during
+    test execution. Implementations are responsible for persisting this
+    data to the appropriate storage backend.
+    """
+
+    @abstractmethod
+    def log_measurement(
+        self,
+        parameter: str,
+        value: float,
+        unit: str,
+        conditions: dict[str, float] | None = None,
+    ) -> None:
+        """Log a time-series measurement with environmental conditions.
+
+        Used for logging raw measurements taken during the test. These are
+        stored as time-series data for later analysis and plotting.
+
+        Args:
+            parameter: Measurement parameter name (e.g., "v_out", "i_q").
+            value: Measured value.
+            unit: Unit of measurement (e.g., "V", "A", "°C").
+            conditions: Optional environmental conditions at time of measurement:
+                       - "temperature": Chamber temperature (°C)
+                       - "input_voltage": DUT input voltage (V)
+                       - "load_current": DUT load current (A)
+
+        Example:
+            logger.log_measurement(
+                "v_out", 3.301, "V",
+                conditions={"temperature": 25.0, "input_voltage": 5.0}
+            )
+        """
+        pass
+
+    @abstractmethod
+    def log_result(
+        self,
+        parameter: str,
+        value: float,
+        unit: str,
+        lower_limit: float | None = None,
+        upper_limit: float | None = None,
+    ) -> None:
+        """Log a scalar test result with pass/fail limits.
+
+        Used for logging calculated or derived results that will be evaluated
+        against specification limits. These appear in test reports and determine
+        overall pass/fail status.
+
+        Args:
+            parameter: Result parameter name (e.g., "temp_co", "load_reg").
+            value: Calculated or measured value.
+            unit: Unit of measurement (e.g., "ppm/°C", "%", "mV").
+            lower_limit: Optional lower limit for pass/fail evaluation.
+            upper_limit: Optional upper limit for pass/fail evaluation.
+
+        Example:
+            logger.log_result(
+                "temp_co", 23.5, "ppm/°C",
+                lower_limit=-50.0, upper_limit=50.0
+            )
+        """
+        pass
+
+    @abstractmethod
+    def log_event(self, message: str, level: str = "INFO") -> None:
+        """Log a test event or message.
+
+        Used for logging informational messages, warnings, and errors during
+        test execution. Useful for debugging and understanding test flow.
+
+        Args:
+            message: Event message text.
+            level: Log level ("DEBUG", "INFO", "WARNING", "ERROR").
+
+        Example:
+            logger.log_event("Waiting for thermal stability", level="INFO")
+        """
+        pass
+
+    @abstractmethod
+    def flush(self) -> None:
+        """Flush any buffered data to storage.
+
+        Forces any buffered measurements or results to be written to the
+        underlying storage backend. Called automatically at end of test,
+        but can be called manually for long-running tests.
+        """
+        pass
+
+
+class TestLogger(ITestLogger):
+    """Concrete test logger implementation using repository pattern.
+
+    Buffers measurements in memory and writes them in batches to a
+    repository for efficiency. Results and events are written immediately.
+
+    Attributes:
+        run_id: UUID of the test run this logger is associated with.
+        repository: Data repository for persisting measurements and results.
+        measurement_buffer: In-memory buffer of measurements awaiting write.
+        buffer_size: Number of measurements to buffer before auto-flush.
+    """
+
+    def __init__(
+        self,
+        run_id: UUID,
+        repository: ITestRepository,
+        buffer_size: int = 100,
+    ):
+        """Initialise test logger.
+
+        Args:
+            run_id: UUID of the test run to associate logs with.
+            repository: Repository for persisting data.
+            buffer_size: Number of measurements to buffer before auto-flush.
+                        Default 100 provides good balance of performance
+                        and memory usage.
+        """
+        self.run_id = run_id
+        self.repository = repository
+        self.buffer_size = buffer_size
+        self.measurement_buffer: list[Measurement] = []
+
+    def log_measurement(
+        self,
+        parameter: str,
+        value: float,
+        unit: str,
+        conditions: dict[str, float] | None = None,
+    ) -> None:
+        """Log a time-series measurement with environmental conditions.
+
+        Measurements are buffered in memory and written to the repository
+        in batches for efficiency.
+        """
+        conditions = conditions or {}
+        measurement = Measurement(
+            timestamp=time.time(),
+            parameter=parameter,
+            value=value,
+            unit=unit,
+            temperature=conditions.get("temperature", 0.0),
+            input_voltage=conditions.get("input_voltage", 0.0),
+            load_current=conditions.get("load_current", 0.0),
+        )
+        self.measurement_buffer.append(measurement)
+
+        # Auto-flush when buffer is full
+        if len(self.measurement_buffer) >= self.buffer_size:
+            self.flush()
+
+    def log_result(
+        self,
+        parameter: str,
+        value: float,
+        unit: str,
+        lower_limit: float | None = None,
+        upper_limit: float | None = None,
+    ) -> None:
+        """Log a scalar test result with pass/fail limits.
+
+        Results are written immediately to the repository (not buffered).
+        """
+        self.repository.save_result(
+            run_id=self.run_id,
+            parameter=parameter,
+            value=value,
+            unit=unit,
+            lower_limit=lower_limit,
+            upper_limit=upper_limit,
+        )
+
+    def log_event(self, message: str, level: str = "INFO") -> None:
+        """Log a test event or message.
+
+        Events are currently logged to console. Future versions may
+        persist events to the repository.
+        """
+        timestamp = datetime.now().strftime("%H:%M:%S.%f")[:-3]
+        print(f"[{timestamp}] {level:7s} {message}")
+
+    def flush(self) -> None:
+        """Flush buffered measurements to repository.
+
+        Writes all buffered measurements to the repository in a single
+        batch operation, then clears the buffer.
+        """
+        if self.measurement_buffer:
+            self.repository.save_measurements(
+                run_id=self.run_id,
+                measurements=self.measurement_buffer,
+            )
+            self.measurement_buffer.clear()
+
+    def __del__(self) -> None:
+        """Ensure buffered data is flushed on logger destruction."""
+        try:
+            self.flush()
+        except Exception:
+            # Ignore errors during cleanup
+            pass

src/py_dvt_ate/framework/runner.py

@@ -0,0 +1,203 @@
+"""Test runner for orchestrating DVT test execution.
+
+This module provides the TestRunner class, which coordinates test execution,
+manages test lifecycle, and ensures proper logging and error handling.
+"""
+
+import json
+import traceback
+from typing import Any
+from uuid import UUID
+
+from py_dvt_ate.data.models import TestStatus
+from py_dvt_ate.data.repository import ITestRepository
+from py_dvt_ate.framework.context import ITest, TestContext
+from py_dvt_ate.framework.limits import evaluate_results
+from py_dvt_ate.framework.logger import TestLogger
+from py_dvt_ate.instruments.factory import InstrumentSet
+
+
+class TestRunner:
+    """Orchestrates DVT test execution.
+
+    The test runner manages the complete test lifecycle:
+    1. Creates a test run record in the repository
+    2. Sets up logging and context
+    3. Executes the test with proper error handling
+    4. Evaluates results against limits
+    5. Updates final status and flushes data
+
+    Attributes:
+        repository: Data repository for persisting test results.
+
+    Example:
+        runner = TestRunner(repository)
+        instruments = factory.create(config)
+        run_id = runner.run_test(
+            test=TempCoTest(),
+            instruments=instruments,
+            config={"temp_points": [-40, 25, 85]},
+            operator="alice@example.com"
+        )
+    """
+
+    def __init__(self, repository: ITestRepository):
+        """Initialise test runner.
+
+        Args:
+            repository: Repository for persisting test data.
+        """
+        self.repository = repository
+
+    def run_test(
+        self,
+        test: ITest,
+        instruments: InstrumentSet,
+        config: dict[str, Any] | None = None,
+        operator: str | None = None,
+        description: str | None = None,
+    ) -> UUID:
+        """Run a DVT test with full lifecycle management.
+
+        Creates a test run, executes the test with proper error handling,
+        evaluates results, and updates final status. All measurements and
+        results are persisted to the repository.
+
+        Args:
+            test: Test instance to execute (implements ITest).
+            instruments: Instrument set for test to use.
+            config: Optional test-specific configuration dictionary.
+            operator: Optional operator identifier (e.g., email address).
+            description: Optional human-readable test run description.
+
+        Returns:
+            UUID of the test run. Can be used to retrieve results later.
+
+        Raises:
+            Exception: Only if repository operations fail. Test execution
+                      errors are caught and recorded as ERROR status.
+
+        Example:
+            run_id = runner.run_test(
+                test=TempCoTest(),
+                instruments=instruments,
+                config={"temp_points": [-40, 25, 85]},
+                operator="alice@example.com",
+                description="Characterisation run #42"
+            )
+            print(f"Test run ID: {run_id}")
+        """
+        config = config or {}
+
+        # Create test run record
+        run_id = self.repository.create_run(
+            test_name=test.name,
+            config=config,
+            operator=operator,
+            description=description or test.description,
+        )
+
+        # Create logger for this run
+        logger = TestLogger(run_id=run_id, repository=self.repository)
+
+        # Create test context
+        context = TestContext(
+            run_id=run_id,
+            instruments=instruments,
+            logger=logger,
+            config=config,
+        )
+
+        # Update status to running
+        self.repository.update_run_status(run_id, TestStatus.RUNNING)
+
+        # Execute test with error handling
+        try:
+            logger.log_event(f"Starting test: {test.name}", level="INFO")
+            logger.log_event(f"Description: {test.description}", level="INFO")
+
+            # Log configuration
+            if config:
+                config_str = json.dumps(config, indent=2)
+                logger.log_event(f"Configuration:\n{config_str}", level="DEBUG")
+
+            # Execute the test
+            status = test.execute(context)
+
+            # Flush any buffered measurements
+            logger.flush()
+
+            # Evaluate results if test didn't explicitly set status
+            if status == TestStatus.RUNNING:
+                results = self.repository.get_results(run_id)
+                status = evaluate_results(results)
+                logger.log_event(
+                    f"Test completed. Evaluated {len(results)} results: {status.value}",
+                    level="INFO",
+                )
+
+            # Update final status
+            self.repository.complete_run(run_id, status)
+            logger.log_event(f"Test finished with status: {status.value}", level="INFO")
+
+        except KeyboardInterrupt:
+            # User interrupted - mark as error but don't swallow interrupt
+            logger.log_event("Test interrupted by user", level="WARNING")
+            logger.flush()
+            self.repository.complete_run(run_id, TestStatus.ERROR)
+            raise
+
+        except Exception as e:
+            # Test execution error - log and mark as ERROR
+            error_msg = f"Test execution failed: {e}"
+            logger.log_event(error_msg, level="ERROR")
+            logger.log_event(traceback.format_exc(), level="DEBUG")
+            logger.flush()
+            self.repository.complete_run(run_id, TestStatus.ERROR)
+            logger.log_event("Test finished with status: ERROR", level="INFO")
+
+        return run_id
+
+    def run_tests(
+        self,
+        tests: list[ITest],
+        instruments: InstrumentSet,
+        config: dict[str, Any] | None = None,
+        operator: str | None = None,
+    ) -> list[UUID]:
+        """Run multiple tests sequentially.
+
+        Convenience method for running a suite of tests. Each test is run
+        independently with its own test run record. If one test fails, the
+        remaining tests still execute.
+
+        Args:
+            tests: List of test instances to execute.
+            instruments: Instrument set shared by all tests.
+            config: Optional configuration applied to all tests.
+            operator: Optional operator identifier.
+
+        Returns:
+            List of test run UUIDs in execution order.
+
+        Example:
+            run_ids = runner.run_tests(
+                tests=[TempCoTest(), LoadRegTest(), LineRegTest()],
+                instruments=instruments,
+                config={"common_setting": 42},
+                operator="alice@example.com"
+            )
+            for run_id in run_ids:
+                run = repository.get_run(run_id)
+                print(f"{run.test_name}: {run.status.value}")
+        """
+        run_ids = []
+        for test in tests:
+            run_id = self.run_test(
+                test=test,
+                instruments=instruments,
+                config=config,
+                operator=operator,
+            )
+            run_ids.append(run_id)
+        return run_ids

src/py_dvt_ate/instruments/__init__.py

@@ -7,3 +7,23 @@ This package provides everything needed to communicate with lab instruments:
 - Instrument drivers
 - Factory for creating configured instrument sets
 """
+
+from py_dvt_ate.instruments.factory import (
+    InstrumentConfig,
+    InstrumentFactory,
+    InstrumentSet,
+)
+from py_dvt_ate.instruments.interfaces import (
+    IMultimeter,
+    IPowerSupply,
+    IThermalChamber,
+)
+
+__all__ = [
+    "IThermalChamber",
+    "IPowerSupply",
+    "IMultimeter",
+    "InstrumentSet",
+    "InstrumentConfig",
+    "InstrumentFactory",
+]

src/py_dvt_ate/instruments/drivers/__init__.py

@@ -3,3 +3,15 @@
 Each driver translates high-level operations into SCPI commands
 and handles responses from instruments.
 """
+
+from py_dvt_ate.instruments.drivers.base import BaseDriver
+from py_dvt_ate.instruments.drivers.chamber import ThermalChamberDriver
+from py_dvt_ate.instruments.drivers.multimeter import MultimeterDriver
+from py_dvt_ate.instruments.drivers.power_supply import PowerSupplyDriver
+
+__all__ = [
+    "BaseDriver",
+    "ThermalChamberDriver",
+    "PowerSupplyDriver",
+    "MultimeterDriver",
+]

src/py_dvt_ate/instruments/drivers/base.py

@@ -0,0 +1,197 @@
+"""Base class for SCPI instrument drivers.
+
+This module provides the foundation for implementing client-side instrument
+drivers that communicate via SCPI commands over a transport layer.
+"""
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from py_dvt_ate.instruments.transport.base import Transport
+
+
+class BaseDriver:
+    """Base class for SCPI instrument drivers.
+
+    Provides common functionality for communicating with instruments via
+    SCPI commands. Subclasses implement instrument-specific command methods.
+
+    All drivers depend on a Transport instance for low-level communication.
+
+    Attributes:
+        transport: The transport layer for communication.
+    """
+
+    def __init__(self, transport: "Transport") -> None:
+        """Initialise the driver with a transport layer.
+
+        Args:
+            transport: Transport instance for communication (TCP, VISA, etc.).
+        """
+        self.transport = transport
+
+    def connect(self) -> None:
+        """Establish connection to the instrument.
+
+        Raises:
+            ConnectionError: If connection fails.
+        """
+        self.transport.connect()
+
+    def disconnect(self) -> None:
+        """Close connection to the instrument.
+
+        Safe to call multiple times (idempotent).
+        """
+        self.transport.disconnect()
+
+    @property
+    def is_connected(self) -> bool:
+        """Check if connection is active.
+
+        Returns:
+            True if connected, False otherwise.
+        """
+        return self.transport.is_connected
+
+    def write(self, command: str) -> None:
+        """Send a SCPI command to the instrument.
+
+        Args:
+            command: SCPI command string (without terminator).
+
+        Raises:
+            ConnectionError: If not connected.
+            IOError: If write fails.
+        """
+        self.transport.write(command)
+
+    def query(self, command: str, timeout: float | None = None) -> str:
+        """Send a SCPI query and read the response.
+
+        Args:
+            command: SCPI query string (without terminator).
+            timeout: Read timeout in seconds. None uses default.
+
+        Returns:
+            Response string from instrument.
+
+        Raises:
+            ConnectionError: If not connected.
+            TimeoutError: If read times out.
+            IOError: If communication fails.
+        """
+        return self.transport.query(command, timeout)
+
+    def query_float(self, command: str, timeout: float | None = None) -> float:
+        """Send a SCPI query and parse response as float.
+
+        Args:
+            command: SCPI query string.
+            timeout: Read timeout in seconds.
+
+        Returns:
+            Parsed floating-point value.
+
+        Raises:
+            ConnectionError: If not connected.
+            TimeoutError: If read times out.
+            IOError: If communication fails.
+            ValueError: If response cannot be parsed as float.
+        """
+        response = self.query(command, timeout)
+        try:
+            return float(response.strip())
+        except ValueError as err:
+            raise ValueError(f"Cannot parse '{response}' as float") from err
+
+    def query_int(self, command: str, timeout: float | None = None) -> int:
+        """Send a SCPI query and parse response as integer.
+
+        Args:
+            command: SCPI query string.
+            timeout: Read timeout in seconds.
+
+        Returns:
+            Parsed integer value.
+
+        Raises:
+            ConnectionError: If not connected.
+            TimeoutError: If read times out.
+            IOError: If communication fails.
+            ValueError: If response cannot be parsed as integer.
+        """
+        response = self.query(command, timeout)
+        try:
+            return int(response.strip())
+        except ValueError as err:
+            raise ValueError(f"Cannot parse '{response}' as int") from err
+
+    def query_bool(self, command: str, timeout: float | None = None) -> bool:
+        """Send a SCPI query and parse response as boolean.
+
+        Interprets "1", "ON", "TRUE" as True; "0", "OFF", "FALSE" as False.
+
+        Args:
+            command: SCPI query string.
+            timeout: Read timeout in seconds.
+
+        Returns:
+            Parsed boolean value.
+
+        Raises:
+            ConnectionError: If not connected.
+            TimeoutError: If read times out.
+            IOError: If communication fails.
+            ValueError: If response cannot be parsed as boolean.
+        """
+        response = self.query(command, timeout).strip().upper()
+        if response in ("1", "ON", "TRUE"):
+            return True
+        if response in ("0", "OFF", "FALSE"):
+            return False
+        raise ValueError(f"Cannot parse '{response}' as bool")
+
+    def identify(self) -> str:
+        """Query instrument identification (*IDN?).
+
+        Returns:
+            Identification string in format:
+            "Manufacturer,Model,SerialNumber,FirmwareVersion"
+
+        Raises:
+            ConnectionError: If not connected.
+            IOError: If communication fails.
+        """
+        return self.query("*IDN?")
+
+    def reset(self) -> None:
+        """Reset instrument to default state (*RST).
+
+        Raises:
+            ConnectionError: If not connected.
+            IOError: If communication fails.
+        """
+        self.write("*RST")
+
+    def clear_status(self) -> None:
+        """Clear instrument status (*CLS).
+
+        Raises:
+            ConnectionError: If not connected.
+            IOError: If communication fails.
+        """
+        self.write("*CLS")
+
+    def operation_complete(self) -> bool:
+        """Query operation complete status (*OPC?).
+
+        Returns:
+            True if operation complete.
+
+        Raises:
+            ConnectionError: If not connected.
+            IOError: If communication fails.
+        """
+        response = self.query("*OPC?")
+        return response.strip() == "1"

src/py_dvt_ate/instruments/drivers/chamber.py

@@ -0,0 +1,142 @@
+"""Thermal chamber SCPI driver.
+
+This module implements a client-side driver for thermal chambers that
+communicate via SCPI commands.
+"""
+
+import time
+
+from py_dvt_ate.instruments.drivers.base import BaseDriver
+from py_dvt_ate.instruments.interfaces import IThermalChamber
+
+
+class ThermalChamberDriver(BaseDriver, IThermalChamber):
+    """SCPI driver for thermal chambers.
+
+    Provides high-level Python API for controlling thermal chambers via
+    SCPI commands. Implements the IThermalChamber interface.
+
+    SCPI Commands Used:
+        TEMP:SETPOINT <value>  - Set target temperature (°C)
+        TEMP:SETPOINT?         - Query current setpoint
+        TEMP:ACTUAL?           - Query actual chamber temperature
+        TEMP:STAB?             - Query stability (1=stable, 0=settling)
+        TEMP:RAMP <rate>       - Set temperature ramp rate (°C/min)
+        TEMP:RAMP?             - Query ramp rate
+
+    Example:
+        >>> transport = TCPTransport("localhost", 5001)
+        >>> chamber = ThermalChamberDriver(transport)
+        >>> chamber.connect()
+        >>> chamber.set_temperature(85.0)
+        >>> chamber.wait_until_stable(timeout=600.0)
+        >>> temp = chamber.get_temperature()
+    """
+
+    def set_temperature(self, setpoint: float) -> None:
+        """Set the chamber temperature setpoint.
+
+        Args:
+            setpoint: Target temperature in degrees Celsius.
+
+        Raises:
+            ConnectionError: If not connected.
+            IOError: If command fails.
+        """
+        self.write(f"TEMP:SETPOINT {setpoint:.2f}")
+
+    def get_temperature(self) -> float:
+        """Get the actual chamber temperature.
+
+        Returns:
+            Current chamber temperature in degrees Celsius.
+
+        Raises:
+            ConnectionError: If not connected.
+            IOError: If query fails.
+        """
+        return self.query_float("TEMP:ACTUAL?")
+
+    def get_setpoint(self) -> float:
+        """Get the current temperature setpoint.
+
+        Returns:
+            Current setpoint in degrees Celsius.
+
+        Raises:
+            ConnectionError: If not connected.
+            IOError: If query fails.
+        """
+        return self.query_float("TEMP:SETPOINT?")
+
+    def is_stable(self) -> bool:
+        """Check if chamber temperature is stable.
+
+        Temperature is considered stable when it has settled within
+        the instrument's configured stability threshold of the setpoint.
+
+        Returns:
+            True if temperature is stable, False if still settling.
+
+        Raises:
+            ConnectionError: If not connected.
+            IOError: If query fails.
+        """
+        return self.query_bool("TEMP:STAB?")
+
+    def wait_until_stable(
+        self, timeout: float = 300.0, poll_interval: float = 1.0
+    ) -> bool:
+        """Wait until chamber temperature stabilises.
+
+        Polls the stability status at regular intervals until stable
+        or timeout is reached.
+
+        Args:
+            timeout: Maximum time to wait in seconds. Default 300s (5 minutes).
+            poll_interval: Time between stability checks in seconds. Default 1s.
+
+        Returns:
+            True if temperature stabilised within timeout, False if timed out.
+
+        Raises:
+            ConnectionError: If not connected.
+            IOError: If communication fails.
+            ValueError: If timeout or poll_interval are negative.
+        """
+        if timeout < 0:
+            raise ValueError("Timeout must be non-negative")
+        if poll_interval <= 0:
+            raise ValueError("Poll interval must be positive")
+
+        start_time = time.time()
+        while time.time() - start_time < timeout:
+            if self.is_stable():
+                return True
+            time.sleep(poll_interval)
+
+        return False
+
+    def set_ramp_rate(self, rate: float) -> None:
+        """Set the temperature ramp rate.
+
+        Args:
+            rate: Ramp rate in degrees Celsius per minute.
+
+        Raises:
+            ConnectionError: If not connected.
+            IOError: If command fails.
+        """
+        self.write(f"TEMP:RAMP {rate:.2f}")
+
+    def get_ramp_rate(self) -> float:
+        """Get the current temperature ramp rate.
+
+        Returns:
+            Ramp rate in degrees Celsius per minute.
+
+        Raises:
+            ConnectionError: If not connected.
+            IOError: If query fails.
+        """
+        return self.query_float("TEMP:RAMP?")

src/py_dvt_ate/instruments/drivers/multimeter.py

@@ -0,0 +1,158 @@
+"""Multimeter SCPI driver.
+
+This module implements a client-side driver for digital multimeters
+that communicate via SCPI commands.
+"""
+
+from py_dvt_ate.instruments.drivers.base import BaseDriver
+from py_dvt_ate.instruments.interfaces import IMultimeter
+
+
+class MultimeterDriver(BaseDriver, IMultimeter):
+    """SCPI driver for digital multimeters.
+
+    Provides high-level Python API for making measurements with DMMs via
+    SCPI commands. Implements the IMultimeter interface.
+
+    SCPI Commands Used:
+        MEAS:VOLT:DC?      - Measure DC voltage
+        MEAS:CURR:DC?      - Measure DC current
+        CONF:VOLT:DC       - Configure for DC voltage measurement
+        CONF:CURR:DC       - Configure for DC current measurement
+        CONF?              - Query current configuration
+        READ?              - Take measurement with current configuration
+
+    Example:
+        >>> transport = TCPTransport("localhost", 5003)
+        >>> dmm = MultimeterDriver(transport)
+        >>> dmm.connect()
+        >>> voltage = dmm.measure_dc_voltage()
+        >>> current = dmm.measure_dc_current()
+    """
+
+    def measure_dc_voltage(self, range: str = "AUTO") -> float:
+        """Measure DC voltage.
+
+        Configures the meter for DC voltage and takes a measurement.
+
+        Args:
+            range: Measurement range. Default "AUTO" for auto-ranging.
+                  Note: Range parameter currently not supported by simulator.
+
+        Returns:
+            Measured voltage in volts.
+
+        Raises:
+            ConnectionError: If not connected.
+            IOError: If query fails.
+        """
+        # Note: Range parameter not yet implemented in virtual instrument
+        return self.query_float("MEAS:VOLT:DC?")
+
+    def measure_dc_current(self, range: str = "AUTO") -> float:
+        """Measure DC current.
+
+        Configures the meter for DC current and takes a measurement.
+
+        Args:
+            range: Measurement range. Default "AUTO" for auto-ranging.
+                  Note: Range parameter currently not supported by simulator.
+
+        Returns:
+            Measured current in amps.
+
+        Raises:
+            ConnectionError: If not connected.
+            IOError: If query fails.
+        """
+        # Note: Range parameter not yet implemented in virtual instrument
+        return self.query_float("MEAS:CURR:DC?")
+
+    def measure_resistance(self, range: str = "AUTO") -> float:
+        """Measure resistance.
+
+        Configures the meter for resistance and takes a measurement.
+
+        Args:
+            range: Measurement range. Default "AUTO" for auto-ranging.
+
+        Returns:
+            Measured resistance in ohms.
+
+        Raises:
+            ConnectionError: If not connected.
+            IOError: If query fails.
+            NotImplementedError: If instrument does not support resistance.
+        """
+        # Note: Resistance measurement not yet implemented in virtual instrument
+        raise NotImplementedError(
+            "Resistance measurement not yet supported by virtual instrument"
+        )
+
+    def set_integration_time(self, nplc: float) -> None:
+        """Set the integration time.
+
+        Args:
+            nplc: Integration time in number of power line cycles (NPLC).
+                 Typical values: 0.02, 0.2, 1, 10, 100.
+
+        Raises:
+            ConnectionError: If not connected.
+            IOError: If command fails.
+            NotImplementedError: If instrument does not support integration time.
+        """
+        # Note: Integration time not yet implemented in virtual instrument
+        raise NotImplementedError(
+            "Integration time setting not yet supported by virtual instrument"
+        )
+
+    def configure_dc_voltage(self) -> None:
+        """Configure meter for DC voltage measurement.
+
+        Sets the measurement function without taking a measurement.
+        Use read() to take a measurement after configuring.
+
+        Raises:
+            ConnectionError: If not connected.
+            IOError: If command fails.
+        """
+        self.write("CONF:VOLT:DC")
+
+    def configure_dc_current(self) -> None:
+        """Configure meter for DC current measurement.
+
+        Sets the measurement function without taking a measurement.
+        Use read() to take a measurement after configuring.
+
+        Raises:
+            ConnectionError: If not connected.
+            IOError: If command fails.
+        """
+        self.write("CONF:CURR:DC")
+
+    def get_configuration(self) -> str:
+        """Get the current measurement configuration.
+
+        Returns:
+            Configuration string (e.g., "VOLT:DC", "CURR:DC").
+
+        Raises:
+            ConnectionError: If not connected.
+            IOError: If query fails.
+        """
+        return self.query("CONF?").strip('"')
+
+    def read(self) -> float:
+        """Take a measurement using the current configuration.
+
+        Must call configure_dc_voltage() or configure_dc_current() first
+        to set the measurement function.
+
+        Returns:
+            Measured value (voltage in V or current in A).
+
+        Raises:
+            ConnectionError: If not connected.
+            IOError: If query fails.
+        """
+        return self.query_float("READ?")

src/py_dvt_ate/instruments/drivers/power_supply.py

@@ -0,0 +1,153 @@
+"""Power supply SCPI driver.
+
+This module implements a client-side driver for programmable power supplies
+that communicate via SCPI commands.
+"""
+
+from py_dvt_ate.instruments.drivers.base import BaseDriver
+from py_dvt_ate.instruments.interfaces import IPowerSupply
+
+
+class PowerSupplyDriver(BaseDriver, IPowerSupply):
+    """SCPI driver for programmable power supplies.
+
+    Provides high-level Python API for controlling power supplies via
+    SCPI commands. Implements the IPowerSupply interface.
+
+    Note: This driver assumes a single-channel instrument. The channel
+    parameter is accepted for interface compatibility but currently ignored.
+
+    SCPI Commands Used:
+        VOLT <value>       - Set output voltage (V)
+        VOLT?              - Query voltage setpoint
+        CURR <value>       - Set current limit (A)
+        CURR?              - Query current limit
+        OUTP <ON|OFF|1|0>  - Enable/disable output
+        OUTP?              - Query output state (1=on, 0=off)
+        MEAS:VOLT?         - Measure actual output voltage
+        MEAS:CURR?         - Measure actual output current
+
+    Example:
+        >>> transport = TCPTransport("localhost", 5002)
+        >>> psu = PowerSupplyDriver(transport)
+        >>> psu.connect()
+        >>> psu.set_voltage(1, 3.3)
+        >>> psu.set_current_limit(1, 0.5)
+        >>> psu.enable_output(1, True)
+        >>> voltage = psu.measure_voltage(1)
+    """
+
+    def set_voltage(self, channel: int, voltage: float) -> None:
+        """Set the output voltage setpoint.
+
+        Args:
+            channel: Channel number (currently ignored, single channel assumed).
+            voltage: Target voltage in volts.
+
+        Raises:
+            ConnectionError: If not connected.
+            IOError: If command fails.
+        """
+        self.write(f"VOLT {voltage:.3f}")
+
+    def get_voltage(self, channel: int) -> float:
+        """Get the voltage setpoint.
+
+        Args:
+            channel: Channel number (currently ignored, single channel assumed).
+
+        Returns:
+            Current voltage setpoint in volts.
+
+        Raises:
+            ConnectionError: If not connected.
+            IOError: If query fails.
+        """
+        return self.query_float("VOLT?")
+
+    def set_current_limit(self, channel: int, current: float) -> None:
+        """Set the current limit.
+
+        Args:
+            channel: Channel number (currently ignored, single channel assumed).
+            current: Current limit in amps.
+
+        Raises:
+            ConnectionError: If not connected.
+            IOError: If command fails.
+        """
+        self.write(f"CURR {current:.3f}")
+
+    def get_current_limit(self, channel: int) -> float:
+        """Get the current limit.
+
+        Args:
+            channel: Channel number (currently ignored, single channel assumed).
+
+        Returns:
+            Current limit in amps.
+
+        Raises:
+            ConnectionError: If not connected.
+            IOError: If query fails.
+        """
+        return self.query_float("CURR?")
+
+    def measure_voltage(self, channel: int) -> float:
+        """Measure the actual output voltage.
+
+        Args:
+            channel: Channel number (currently ignored, single channel assumed).
+
+        Returns:
+            Measured voltage in volts.
+
+        Raises:
+            ConnectionError: If not connected.
+            IOError: If query fails.
+        """
+        return self.query_float("MEAS:VOLT?")
+
+    def measure_current(self, channel: int) -> float:
+        """Measure the actual output current.
+
+        Args:
+            channel: Channel number (currently ignored, single channel assumed).
+
+        Returns:
+            Measured current in amps.
+
+        Raises:
+            ConnectionError: If not connected.
+            IOError: If query fails.
+        """
+        return self.query_float("MEAS:CURR?")
+
+    def enable_output(self, channel: int, enable: bool) -> None:
+        """Enable or disable the output.
+
+        Args:
+            channel: Channel number (currently ignored, single channel assumed).
+            enable: True to enable output, False to disable.
+
+        Raises:
+            ConnectionError: If not connected.
+            IOError: If command fails.
+        """
+        state = "ON" if enable else "OFF"
+        self.write(f"OUTP {state}")
+
+    def is_output_enabled(self, channel: int) -> bool:
+        """Check if output is enabled.
+
+        Args:
+            channel: Channel number (currently ignored, single channel assumed).
+
+        Returns:
+            True if output is enabled, False if disabled.
+
+        Raises:
+            ConnectionError: If not connected.
+            IOError: If query fails.
+        """
+        return self.query_bool("OUTP?")

src/py_dvt_ate/instruments/factory.py

@@ -0,0 +1,176 @@
+"""Instrument factory for creating configured instrument sets.
+
+This module provides a factory pattern for creating sets of instruments
+based on configuration. It abstracts away the choice between simulated
+and real hardware, allowing test code to be written once and run against
+either backend.
+"""
+
+from dataclasses import dataclass
+from typing import Literal
+
+from py_dvt_ate.instruments.interfaces import IMultimeter, IPowerSupply, IThermalChamber
+
+
+@dataclass
+class InstrumentSet:
+    """Container for a complete set of instruments.
+
+    Holds all instruments needed for DVT testing. All instruments implement
+    the interface protocols (IThermalChamber, IPowerSupply, IMultimeter),
+    allowing them to be simulated or real hardware.
+
+    Attributes:
+        chamber: Thermal chamber for temperature control.
+        psu: Programmable power supply for DUT power.
+        dmm: Digital multimeter for precision measurements.
+    """
+
+    chamber: IThermalChamber
+    psu: IPowerSupply
+    dmm: IMultimeter
+
+
+@dataclass
+class InstrumentConfig:
+    """Configuration for instrument connections.
+
+    Defines how to connect to instruments. The backend determines whether
+    to use simulated instruments (TCP connections to virtual instruments)
+    or real hardware (PyVISA connections).
+
+    Attributes:
+        backend: "simulator" for virtual instruments, "pyvisa" for real hardware.
+
+        Simulator Settings:
+            simulator_host: Hostname/IP of simulation server. Default "localhost".
+            chamber_port: TCP port for thermal chamber simulator. Default 5001.
+            psu_port: TCP port for power supply simulator. Default 5002.
+            dmm_port: TCP port for multimeter simulator. Default 5003.
+
+        PyVISA Settings (for real hardware):
+            chamber_visa: VISA resource string for thermal chamber (e.g., "TCPIP::192.168.1.10::INSTR").
+            psu_visa: VISA resource string for power supply.
+            dmm_visa: VISA resource string for multimeter.
+    """
+
+    backend: Literal["simulator", "pyvisa"]
+
+    # Simulator settings
+    simulator_host: str = "localhost"
+    chamber_port: int = 5001
+    psu_port: int = 5002
+    dmm_port: int = 5003
+
+    # PyVISA settings (for real hardware)
+    chamber_visa: str | None = None
+    psu_visa: str | None = None
+    dmm_visa: str | None = None
+
+
+class InstrumentFactory:
+    """Factory for creating instrument sets from configuration.
+
+    This factory encapsulates the creation logic for instrument sets,
+    hiding the complexity of instantiating transports and drivers based
+    on the chosen backend.
+
+    Example:
+        >>> config = InstrumentConfig(backend="simulator")
+        >>> instruments = InstrumentFactory.create(config)
+        >>> instruments.chamber.set_temperature(85.0)
+        >>> instruments.psu.set_voltage(1, 3.3)
+        >>> voltage = instruments.dmm.measure_dc_voltage()
+    """
+
+    @staticmethod
+    def create(config: InstrumentConfig) -> InstrumentSet:
+        """Create instrument set based on configuration.
+
+        Args:
+            config: Configuration specifying backend and connection details.
+
+        Returns:
+            InstrumentSet containing all configured instruments.
+
+        Raises:
+            ValueError: If backend is unknown or configuration is invalid.
+            ConnectionError: If unable to connect to instruments.
+        """
+        if config.backend == "simulator":
+            return InstrumentFactory._create_simulated(config)
+        elif config.backend == "pyvisa":
+            return InstrumentFactory._create_pyvisa(config)
+        else:
+            raise ValueError(f"Unknown backend: {config.backend}")
+
+    @staticmethod
+    def _create_simulated(config: InstrumentConfig) -> InstrumentSet:
+        """Create simulated instruments connected via TCP.
+
+        Creates TCP transports for each virtual instrument and wraps them
+        in SCPI drivers. The simulation server must be running and listening
+        on the configured ports.
+
+        Args:
+            config: Configuration with simulator_host and port settings.
+
+        Returns:
+            InstrumentSet with simulated instruments.
+
+        Raises:
+            ConnectionError: If unable to connect to simulation server.
+        """
+        from py_dvt_ate.instruments.drivers.chamber import ThermalChamberDriver
+        from py_dvt_ate.instruments.drivers.multimeter import MultimeterDriver
+        from py_dvt_ate.instruments.drivers.power_supply import PowerSupplyDriver
+        from py_dvt_ate.instruments.transport.tcp import TCPTransport
+
+        # Create transports for each instrument
+        chamber_transport = TCPTransport(config.simulator_host, config.chamber_port)
+        psu_transport = TCPTransport(config.simulator_host, config.psu_port)
+        dmm_transport = TCPTransport(config.simulator_host, config.dmm_port)
+
+        # Wrap transports in drivers
+        return InstrumentSet(
+            chamber=ThermalChamberDriver(chamber_transport),
+            psu=PowerSupplyDriver(psu_transport),
+            dmm=MultimeterDriver(dmm_transport),
+        )
+
+    @staticmethod
+    def _create_pyvisa(config: InstrumentConfig) -> InstrumentSet:
+        """Create PyVISA instruments for real hardware.
+
+        Creates VISA transports for each real instrument and wraps them
+        in SCPI drivers. Requires PyVISA to be installed and VISA resource
+        strings to be configured.
+
+        Args:
+            config: Configuration with chamber_visa, psu_visa, dmm_visa settings.
+
+        Returns:
+            InstrumentSet with real hardware instruments.
+
+        Raises:
+            NotImplementedError: PyVISA backend not yet implemented.
+            ValueError: If required VISA resource strings are missing.
+        """
+        # Future implementation would use pyvisa.ResourceManager
+        # to create VISA transports:
+        #
+        # import pyvisa
+        # from py_dvt_ate.instruments.transport.visa import VISATransport
+        #
+        # rm = pyvisa.ResourceManager()
+        # chamber_transport = VISATransport(rm.open_resource(config.chamber_visa))
+        # psu_transport = VISATransport(rm.open_resource(config.psu_visa))
+        # dmm_transport = VISATransport(rm.open_resource(config.dmm_visa))
+        #
+        # return InstrumentSet(
+        #     chamber=ThermalChamberDriver(chamber_transport),
+        #     psu=PowerSupplyDriver(psu_transport),
+        #     dmm=MultimeterDriver(dmm_transport),
+        # )
+
+        raise NotImplementedError("PyVISA backend not yet implemented")

src/py_dvt_ate/instruments/interfaces.py

@@ -0,0 +1,362 @@
+"""Instrument interface protocols.
+
+This module defines the Hardware Abstraction Layer (HAL) interfaces for all
+laboratory instruments used in DVT testing. These protocols allow test code
+to be written against abstract interfaces rather than concrete implementations,
+enabling seamless switching between simulated and real hardware.
+
+The interfaces use ABC (Abstract Base Classes) for maximum type safety and
+explicit interface implementation. All drivers must inherit from these base
+classes and implement all abstract methods.
+"""
+
+from abc import ABC, abstractmethod
+
+
+class IThermalChamber(ABC):
+    """Hardware abstraction for thermal chambers.
+
+    Defines the interface for controlling environmental temperature during
+    thermal characterisation tests. Implementations may be virtual instruments
+    (simulators) or real hardware drivers.
+
+    Temperature units are always degrees Celsius.
+    """
+
+    @abstractmethod
+    def set_temperature(self, setpoint: float) -> None:
+        """Set the chamber temperature setpoint.
+
+        Args:
+            setpoint: Target temperature in degrees Celsius.
+
+        Raises:
+            ConnectionError: If not connected to instrument.
+            IOError: If command fails or instrument reports error.
+        """
+        pass
+
+    @abstractmethod
+    def get_temperature(self) -> float:
+        """Get the actual chamber temperature.
+
+        Returns:
+            Current chamber air temperature in degrees Celsius.
+
+        Raises:
+            ConnectionError: If not connected to instrument.
+            IOError: If query fails or instrument reports error.
+        """
+        pass
+
+    @abstractmethod
+    def get_setpoint(self) -> float:
+        """Get the current temperature setpoint.
+
+        Returns:
+            Current target temperature in degrees Celsius.
+
+        Raises:
+            ConnectionError: If not connected to instrument.
+            IOError: If query fails or instrument reports error.
+        """
+        pass
+
+    @abstractmethod
+    def is_stable(self) -> bool:
+        """Check if chamber temperature is stable.
+
+        Temperature is considered stable when it has settled within
+        the instrument's configured stability threshold of the setpoint
+        for a minimum dwell time.
+
+        Returns:
+            True if temperature is stable, False if still settling.
+
+        Raises:
+            ConnectionError: If not connected to instrument.
+            IOError: If query fails or instrument reports error.
+        """
+        pass
+
+    @abstractmethod
+    def wait_until_stable(
+        self, timeout: float = 300.0, poll_interval: float = 1.0
+    ) -> bool:
+        """Wait until chamber temperature stabilises.
+
+        Polls the stability status at regular intervals until stable
+        or timeout is reached. This is a blocking call.
+
+        Args:
+            timeout: Maximum time to wait in seconds. Default 300s (5 minutes).
+            poll_interval: Time between stability checks in seconds. Default 1s.
+
+        Returns:
+            True if temperature stabilised within timeout, False if timed out.
+
+        Raises:
+            ConnectionError: If not connected to instrument.
+            IOError: If communication fails.
+            ValueError: If timeout or poll_interval are invalid.
+        """
+        pass
+
+    @abstractmethod
+    def set_ramp_rate(self, rate: float) -> None:
+        """Set the temperature ramp rate.
+
+        Controls how quickly the chamber changes temperature when moving
+        to a new setpoint. Slower ramp rates reduce thermal shock to DUT.
+
+        Args:
+            rate: Ramp rate in degrees Celsius per minute.
+
+        Raises:
+            ConnectionError: If not connected to instrument.
+            IOError: If command fails or instrument reports error.
+            ValueError: If rate is negative or exceeds instrument limits.
+        """
+        pass
+
+
+class IPowerSupply(ABC):
+    """Hardware abstraction for programmable power supplies.
+
+    Defines the interface for controlling DC power supplies during electrical
+    characterisation tests. Implementations may be virtual instruments
+    (simulators) or real hardware drivers.
+
+    Voltage units are always volts (V).
+    Current units are always amps (A).
+    """
+
+    @abstractmethod
+    def set_voltage(self, channel: int, voltage: float) -> None:
+        """Set the output voltage setpoint.
+
+        Args:
+            channel: Output channel number (1-based indexing).
+            voltage: Target voltage in volts.
+
+        Raises:
+            ConnectionError: If not connected to instrument.
+            IOError: If command fails or instrument reports error.
+            ValueError: If channel is invalid or voltage out of range.
+        """
+        pass
+
+    @abstractmethod
+    def get_voltage(self, channel: int) -> float:
+        """Get the voltage setpoint.
+
+        Returns the programmed voltage, not the measured output voltage.
+        Use measure_voltage() to get the actual output voltage.
+
+        Args:
+            channel: Output channel number (1-based indexing).
+
+        Returns:
+            Current voltage setpoint in volts.
+
+        Raises:
+            ConnectionError: If not connected to instrument.
+            IOError: If query fails or instrument reports error.
+            ValueError: If channel is invalid.
+        """
+        pass
+
+    @abstractmethod
+    def set_current_limit(self, channel: int, current: float) -> None:
+        """Set the current limit.
+
+        The supply will operate in constant voltage mode until output current
+        reaches this limit, then transition to constant current mode.
+
+        Args:
+            channel: Output channel number (1-based indexing).
+            current: Current limit in amps.
+
+        Raises:
+            ConnectionError: If not connected to instrument.
+            IOError: If command fails or instrument reports error.
+            ValueError: If channel is invalid or current out of range.
+        """
+        pass
+
+    @abstractmethod
+    def get_current_limit(self, channel: int) -> float:
+        """Get the current limit.
+
+        Args:
+            channel: Output channel number (1-based indexing).
+
+        Returns:
+            Current limit in amps.
+
+        Raises:
+            ConnectionError: If not connected to instrument.
+            IOError: If query fails or instrument reports error.
+            ValueError: If channel is invalid.
+        """
+        pass
+
+    @abstractmethod
+    def measure_voltage(self, channel: int) -> float:
+        """Measure the actual output voltage.
+
+        Args:
+            channel: Output channel number (1-based indexing).
+
+        Returns:
+            Measured output voltage in volts.
+
+        Raises:
+            ConnectionError: If not connected to instrument.
+            IOError: If query fails or instrument reports error.
+            ValueError: If channel is invalid.
+        """
+        pass
+
+    @abstractmethod
+    def measure_current(self, channel: int) -> float:
+        """Measure the actual output current.
+
+        Args:
+            channel: Output channel number (1-based indexing).
+
+        Returns:
+            Measured output current in amps.
+
+        Raises:
+            ConnectionError: If not connected to instrument.
+            IOError: If query fails or instrument reports error.
+            ValueError: If channel is invalid.
+        """
+        pass
+
+    @abstractmethod
+    def enable_output(self, channel: int, enable: bool) -> None:
+        """Enable or disable the output.
+
+        Args:
+            channel: Output channel number (1-based indexing).
+            enable: True to enable output, False to disable.
+
+        Raises:
+            ConnectionError: If not connected to instrument.
+            IOError: If command fails or instrument reports error.
+            ValueError: If channel is invalid.
+        """
+        pass
+
+    @abstractmethod
+    def is_output_enabled(self, channel: int) -> bool:
+        """Check if output is enabled.
+
+        Args:
+            channel: Output channel number (1-based indexing).
+
+        Returns:
+            True if output is enabled, False if disabled.
+
+        Raises:
+            ConnectionError: If not connected to instrument.
+            IOError: If query fails or instrument reports error.
+            ValueError: If channel is invalid.
+        """
+        pass
+
+
+class IMultimeter(ABC):
+    """Hardware abstraction for digital multimeters.
+
+    Defines the interface for making precision measurements with DMMs during
+    electrical characterisation tests. Implementations may be virtual instruments
+    (simulators) or real hardware drivers.
+
+    Voltage units are always volts (V).
+    Current units are always amps (A).
+    Resistance units are always ohms (Ω).
+    """
+
+    @abstractmethod
+    def measure_dc_voltage(self, range: str = "AUTO") -> float:
+        """Measure DC voltage.
+
+        Configures the meter for DC voltage and takes a measurement.
+
+        Args:
+            range: Measurement range. Default "AUTO" for auto-ranging.
+                  Specific ranges depend on instrument capabilities.
+
+        Returns:
+            Measured voltage in volts.
+
+        Raises:
+            ConnectionError: If not connected to instrument.
+            IOError: If query fails or instrument reports error.
+            ValueError: If range is invalid for this instrument.
+        """
+        pass
+
+    @abstractmethod
+    def measure_dc_current(self, range: str = "AUTO") -> float:
+        """Measure DC current.
+
+        Configures the meter for DC current and takes a measurement.
+
+        Args:
+            range: Measurement range. Default "AUTO" for auto-ranging.
+                  Specific ranges depend on instrument capabilities.
+
+        Returns:
+            Measured current in amps.
+
+        Raises:
+            ConnectionError: If not connected to instrument.
+            IOError: If query fails or instrument reports error.
+            ValueError: If range is invalid for this instrument.
+        """
+        pass
+
+    @abstractmethod
+    def measure_resistance(self, range: str = "AUTO") -> float:
+        """Measure resistance.
+
+        Configures the meter for resistance and takes a measurement.
+
+        Args:
+            range: Measurement range. Default "AUTO" for auto-ranging.
+                  Specific ranges depend on instrument capabilities.
+
+        Returns:
+            Measured resistance in ohms.
+
+        Raises:
+            ConnectionError: If not connected to instrument.
+            IOError: If query fails or instrument reports error.
+            ValueError: If range is invalid for this instrument.
+            NotImplementedError: If instrument does not support resistance.
+        """
+        pass
+
+    @abstractmethod
+    def set_integration_time(self, nplc: float) -> None:
+        """Set the integration time.
+
+        Integration time affects measurement accuracy and speed. Higher
+        values (more power line cycles) provide better noise rejection
+        but take longer to measure.
+
+        Args:
+            nplc: Integration time in number of power line cycles (NPLC).
+                 Typical values: 0.02, 0.2, 1, 10, 100.
+
+        Raises:
+            ConnectionError: If not connected to instrument.
+            IOError: If command fails or instrument reports error.
+            ValueError: If nplc is invalid for this instrument.
+            NotImplementedError: If instrument does not support integration time.
+        """
+        pass

src/py_dvt_ate/instruments/transport/__init__.py

@@ -1,6 +1,13 @@
 """Transport layer for instrument communication.
 
 Provides connection abstractions for different backends:
+- TCP server for hosting SCPI instruments
 - TCP sockets (for simulation server)
 - PyVISA (for real instruments)
 """
+
+from py_dvt_ate.instruments.transport.base import Transport
+from py_dvt_ate.instruments.transport.server import InstrumentServer, SCPIDevice
+from py_dvt_ate.instruments.transport.tcp import TCPTransport
+
+__all__ = ["Transport", "TCPTransport", "InstrumentServer", "SCPIDevice"]

src/py_dvt_ate/instruments/transport/base.py

@@ -0,0 +1,93 @@
+"""Base transport interface for instrument communication."""
+
+from abc import ABC, abstractmethod
+
+
+class Transport(ABC):
+    """Abstract transport interface for instrument communication.
+
+    This abstract base class defines the interface that all transport
+    implementations (TCP, VISA, etc.) must implement. It provides basic
+    connection management and communication primitives for SCPI-based
+    instruments.
+
+    Implementations must inherit from this class and implement all abstract
+    methods.
+    """
+
+    @abstractmethod
+    def connect(self) -> None:
+        """Establish connection to instrument.
+
+        Raises:
+            ConnectionError: If connection fails.
+        """
+        pass
+
+    @abstractmethod
+    def disconnect(self) -> None:
+        """Close connection to instrument.
+
+        Should be idempotent - safe to call multiple times.
+        """
+        pass
+
+    @abstractmethod
+    def write(self, command: str) -> None:
+        """Send command to instrument.
+
+        Args:
+            command: SCPI command string to send (without terminator).
+
+        Raises:
+            ConnectionError: If not connected.
+            IOError: If write fails.
+        """
+        pass
+
+    @abstractmethod
+    def read(self, timeout: float | None = None) -> str:
+        """Read response from instrument.
+
+        Args:
+            timeout: Read timeout in seconds. None uses default.
+
+        Returns:
+            Response string from instrument (without terminator).
+
+        Raises:
+            ConnectionError: If not connected.
+            TimeoutError: If read times out.
+            IOError: If read fails.
+        """
+        pass
+
+    @abstractmethod
+    def query(self, command: str, timeout: float | None = None) -> str:
+        """Send command and read response.
+
+        Convenience method combining write() and read().
+
+        Args:
+            command: SCPI command string to send.
+            timeout: Read timeout in seconds. None uses default.
+
+        Returns:
+            Response string from instrument.
+
+        Raises:
+            ConnectionError: If not connected.
+            TimeoutError: If read times out.
+            IOError: If communication fails.
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def is_connected(self) -> bool:
+        """Check if connection is active.
+
+        Returns:
+            True if connected, False otherwise.
+        """
+        pass

src/py_dvt_ate/instruments/transport/server.py

@@ -1,32 +1,56 @@
-"""Async TCP server for exposing virtual instruments over network.
+"""Async TCP server for exposing instruments over network.
 
-This module provides the InstrumentServer class that hosts virtual SCPI
+This module provides the InstrumentServer class that hosts SCPI
 instruments over TCP, allowing client applications to communicate using
 standard SCPI commands over a network connection.
+
+This is a general-purpose server that works with any object implementing
+the SCPIDevice protocol (having a process(command) -> str method).
 """
 
 from __future__ import annotations
 
 import asyncio
 import logging
-from typing import TYPE_CHECKING
+from functools import partial
+from typing import Protocol, runtime_checkable
 
-if TYPE_CHECKING:
+__all__ = ["InstrumentServer", "SCPIDevice"]
-    from py_dvt_ate.simulation.virtual.base import BaseInstrument
-
-# Re-export for type checking - actual import happens at runtime via registration
-__all__ = ["InstrumentServer"]
 
 logger = logging.getLogger(__name__)
 
 
+@runtime_checkable
+class SCPIDevice(Protocol):
+    """Protocol for SCPI-compatible devices.
+
+    Any object with a process method matching this signature can be
+    served by InstrumentServer.
+    """
+
+    def process(self, command: str) -> str:
+        """Process a SCPI command and return the response.
+
+        Args:
+            command: SCPI command string to process.
+
+        Returns:
+            Response string (may be empty for commands with no response).
+        """
+        ...
+
+
 class InstrumentServer:
-    """Async TCP server hosting virtual SCPI instruments.
+    """Async TCP server hosting SCPI instruments.
 
     Each instrument is assigned a port. Clients connect via TCP and send
     SCPI commands as newline-terminated strings. Responses are also
     newline-terminated.
 
+    This server can host any device implementing the SCPIDevice protocol,
+    including both virtual instruments (simulators) and adapters for
+    real hardware.
+
     Attributes:
         host: Host address to bind to.
     """
@@ -38,7 +62,7 @@ class InstrumentServer:
             host: Host address to bind to. Defaults to localhost.
         """
         self._host = host
-        self._instruments: dict[int, BaseInstrument] = {}
+        self._instruments: dict[int, SCPIDevice] = {}
         self._servers: list[asyncio.Server] = []
         self._running = False
 
@@ -52,12 +76,12 @@ class InstrumentServer:
         """Check if server is currently running."""
         return self._running
 
-    def register_instrument(self, port: int, instrument: BaseInstrument) -> None:
+    def register_instrument(self, port: int, instrument: SCPIDevice) -> None:
         """Register an instrument to be served on a specific port.
 
         Args:
             port: TCP port number to serve the instrument on.
-            instrument: Virtual instrument to serve.
+            instrument: SCPI device to serve (any object with process method).
 
         Raises:
             ValueError: If port is already registered.
@@ -76,7 +100,7 @@ class InstrumentServer:
             port,
         )
 
-    def get_instrument(self, port: int) -> BaseInstrument | None:
+    def get_instrument(self, port: int) -> SCPIDevice | None:
         """Get the instrument registered on a port.
 
         Args:
@@ -109,8 +133,9 @@ class InstrumentServer:
         self._running = True
 
         for port, instrument in self._instruments.items():
+            handler = partial(self._handle_client, instrument=instrument, port=port)
             server = await asyncio.start_server(
-                lambda r, w, inst=instrument, p=port: self._handle_client(r, w, inst, p),
+                handler,
                 self._host,
                 port,
             )
@@ -154,7 +179,7 @@ class InstrumentServer:
         self,
         reader: asyncio.StreamReader,
         writer: asyncio.StreamWriter,
-        instrument: BaseInstrument,
+        instrument: SCPIDevice,
         port: int,
     ) -> None:
         """Handle a client connection.
@@ -191,9 +216,11 @@ class InstrumentServer:
                 # Process command through instrument
                 response = instrument.process(command)
 
-                # Send response with newline terminator
+                # Send response with newline terminator (only if non-empty)
+                # Per SCPI protocol: commands that complete successfully without
+                # output do not send a response. Only queries and errors respond.
                 if response:
-                    writer.write(f"{response}\n".encode("utf-8"))
+                    writer.write(f"{response}\n".encode())
                     await writer.drain()
                     logger.debug("Port %d sent: %s", port, response)
 

src/py_dvt_ate/instruments/transport/tcp.py

@@ -0,0 +1,195 @@
+"""TCP socket transport for instrument communication."""
+
+import socket
+from typing import Any
+
+from py_dvt_ate.instruments.transport.base import Transport
+
+
+class TCPTransport(Transport):
+    """TCP socket transport implementation.
+
+    Implements the Transport interface for communicating with SCPI
+    instruments over TCP/IP using newline-terminated messages.
+
+    Attributes:
+        host: Hostname or IP address of the instrument.
+        port: TCP port number.
+        timeout: Default socket timeout in seconds.
+    """
+
+    def __init__(
+        self,
+        host: str,
+        port: int,
+        timeout: float = 5.0,
+        encoding: str = "utf-8",
+    ) -> None:
+        """Initialise TCP transport.
+
+        Args:
+            host: Hostname or IP address.
+            port: TCP port number.
+            timeout: Default socket timeout in seconds.
+            encoding: Text encoding for commands and responses.
+        """
+        self._host = host
+        self._port = port
+        self._timeout = timeout
+        self._encoding = encoding
+        self._socket: socket.socket | None = None
+
+    @property
+    def host(self) -> str:
+        """Get the host address."""
+        return self._host
+
+    @property
+    def port(self) -> int:
+        """Get the port number."""
+        return self._port
+
+    @property
+    def is_connected(self) -> bool:
+        """Check if connection is active.
+
+        Returns:
+            True if connected, False otherwise.
+        """
+        return self._socket is not None
+
+    def connect(self) -> None:
+        """Establish connection to instrument.
+
+        Raises:
+            ConnectionError: If connection fails or already connected.
+        """
+        if self.is_connected:
+            raise ConnectionError("Already connected")
+
+        try:
+            self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            self._socket.settimeout(self._timeout)
+            self._socket.connect((self._host, self._port))
+        except OSError as err:
+            self._socket = None
+            raise ConnectionError(
+                f"Failed to connect to {self._host}:{self._port}: {err}"
+            ) from err
+
+    def disconnect(self) -> None:
+        """Close connection to instrument.
+
+        Safe to call multiple times (idempotent).
+        """
+        if self._socket is not None:
+            try:
+                self._socket.close()
+            except OSError:
+                pass  # Ignore errors during close
+            finally:
+                self._socket = None
+
+    def write(self, command: str) -> None:
+        """Send command to instrument.
+
+        Commands are sent with newline terminator appended.
+
+        Args:
+            command: SCPI command string to send (without terminator).
+
+        Raises:
+            ConnectionError: If not connected.
+            IOError: If write fails.
+        """
+        if not self.is_connected or self._socket is None:
+            raise ConnectionError("Not connected")
+
+        try:
+            message = f"{command}\n".encode(self._encoding)
+            self._socket.sendall(message)
+        except OSError as err:
+            raise OSError(f"Write failed: {err}") from err
+
+    def read(self, timeout: float | None = None) -> str:
+        """Read response from instrument.
+
+        Reads until newline terminator is received.
+
+        Args:
+            timeout: Read timeout in seconds. None uses default.
+
+        Returns:
+            Response string from instrument (without terminator).
+
+        Raises:
+            ConnectionError: If not connected.
+            TimeoutError: If read times out.
+            IOError: If read fails.
+        """
+        if not self.is_connected or self._socket is None:
+            raise ConnectionError("Not connected")
+
+        # Set timeout if specified
+        old_timeout = self._socket.gettimeout()
+        if timeout is not None:
+            self._socket.settimeout(timeout)
+
+        try:
+            # Read line by line (newline-terminated protocol)
+            response_bytes = b""
+            while True:
+                chunk = self._socket.recv(1)
+                if not chunk:
+                    raise ConnectionError("Connection closed by remote host")
+                response_bytes += chunk
+                if chunk == b"\n":
+                    break
+
+            # Decode and strip whitespace
+            return response_bytes.decode(self._encoding).strip()
+
+        except ConnectionError:
+            raise  # Re-raise ConnectionError as-is
+        except TimeoutError as err:
+            raise TimeoutError("Read timeout") from err
+        except (OSError, UnicodeDecodeError) as err:
+            raise OSError(f"Read failed: {err}") from err
+        finally:
+            # Restore original timeout
+            if timeout is not None:
+                self._socket.settimeout(old_timeout)
+
+    def query(self, command: str, timeout: float | None = None) -> str:
+        """Send command and read response.
+
+        Convenience method combining write() and read().
+
+        Args:
+            command: SCPI command string to send.
+            timeout: Read timeout in seconds. None uses default.
+
+        Returns:
+            Response string from instrument.
+
+        Raises:
+            ConnectionError: If not connected.
+            TimeoutError: If read times out.
+            IOError: If communication fails.
+        """
+        self.write(command)
+        return self.read(timeout)
+
+    def __enter__(self) -> "TCPTransport":
+        """Context manager entry."""
+        self.connect()
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        """Context manager exit."""
+        self.disconnect()
+
+    def __repr__(self) -> str:
+        """String representation."""
+        status = "connected" if self.is_connected else "disconnected"
+        return f"TCPTransport({self._host}:{self._port}, {status})"

src/py_dvt_ate/simulation/__init__.py

@@ -2,9 +2,10 @@
 
 Provides virtual instruments backed by a coupled thermal-electrical
 physics engine. Used for development and testing without real hardware.
+
+Note: InstrumentServer has moved to py_dvt_ate.instruments.transport
 """
 
 from py_dvt_ate.simulation.server import ServerConfig, SimulationServer
-from py_dvt_ate.simulation.tcp_server import InstrumentServer
 
-__all__ = ["InstrumentServer", "ServerConfig", "SimulationServer"]
+__all__ = ["ServerConfig", "SimulationServer"]

src/py_dvt_ate/simulation/physics/models/base.py

@@ -1,15 +1,14 @@
-"""Base protocol for Device Under Test (DUT) models.
+"""Base interface for Device Under Test (DUT) models.
 
 Defines the interface that all DUT models must implement to integrate
 with the physics engine.
 """
 
-from typing import Protocol, runtime_checkable
+from abc import ABC, abstractmethod
 
 
-@runtime_checkable
+class DUTModel(ABC):
-class DUTModel(Protocol):
+    """Abstract base class for DUT electrical/thermal models.
-    """Protocol for DUT electrical/thermal models.
 
     DUT models encapsulate the temperature-dependent electrical behaviour
     of a device, enabling realistic simulation of thermal-electrical coupling.
@@ -18,8 +17,12 @@ class DUTModel(Protocol):
     All voltage parameters are in volts.
     All current parameters are in amps.
     All power parameters are in watts.
+
+    Implementations must inherit from this class and implement all abstract
+    methods.
     """
 
+    @abstractmethod
     def calculate_output_voltage(self, junction_temperature: float) -> float:
         """Calculate the output voltage at the given junction temperature.
 
@@ -29,8 +32,9 @@ class DUTModel(Protocol):
         Returns:
             Output voltage in volts.
         """
-        ...
+        pass
 
+    @abstractmethod
     def calculate_quiescent_current(self, junction_temperature: float) -> float:
         """Calculate the quiescent current at the given junction temperature.
 
@@ -40,8 +44,9 @@ class DUTModel(Protocol):
         Returns:
             Quiescent current in amps.
         """
-        ...
+        pass
 
+    @abstractmethod
     def calculate_power_dissipation(
         self,
         input_voltage: float,
@@ -58,4 +63,4 @@ class DUTModel(Protocol):
         Returns:
             Power dissipation in watts.
         """
-        ...
+        pass

src/py_dvt_ate/simulation/physics/models/ldo.py

@@ -7,6 +7,8 @@ and power dissipation calculations.
 
 from dataclasses import dataclass
 
+from py_dvt_ate.simulation.physics.models.base import DUTModel
+
 
 @dataclass(frozen=True)
 class LDOParameters:
@@ -35,7 +37,7 @@ class LDOParameters:
 REFERENCE_TEMPERATURE_C = 25.0
 
 
-class LDOModel:
+class LDOModel(DUTModel):
     """Temperature-dependent LDO voltage regulator model.
 
     Models the electrical behaviour of a linear voltage regulator with:
@@ -44,7 +46,7 @@ class LDOModel:
     - Dropout voltage that increases with temperature
     - Power dissipation from (Vin - Vout) × Iload + Vin × Iq
 
-    This class implements the DUTModel protocol.
+    This class implements the DUTModel interface.
     """
 
     def __init__(
@@ -194,7 +196,7 @@ class LDOModel:
         # Temperature ratio (reference is approximately 300K ≈ 27°C)
         temp_ratio = t_kelvin / 300.0
 
-        return self._params.dropout_voltage * (temp_ratio**1.5)
+        return float(self._params.dropout_voltage * (temp_ratio**1.5))
 
     def is_in_dropout(self, junction_temperature: float) -> bool:
         """Check if the LDO is in dropout at current operating point.

src/py_dvt_ate/simulation/server.py

@@ -11,8 +11,8 @@ import logging
 import signal
 from dataclasses import dataclass
 
+from py_dvt_ate.instruments.transport import InstrumentServer
 from py_dvt_ate.simulation.physics.engine import PhysicsEngine
-from py_dvt_ate.simulation.tcp_server import InstrumentServer
 from py_dvt_ate.simulation.virtual.chamber import ThermalChamberSim
 from py_dvt_ate.simulation.virtual.multimeter import MultimeterSim
 from py_dvt_ate.simulation.virtual.power_supply import PowerSupplySim
@@ -57,17 +57,39 @@ class SimulationServer:
         self._instrument_server: InstrumentServer | None = None
         self._physics_task: asyncio.Task[None] | None = None
         self._running = False
+        self._paused = False  # Pause physics simulation
+        self._time_scale = 1.0  # Simulation time multiplier
 
     @property
     def is_running(self) -> bool:
         """Check if server is currently running."""
         return self._running
 
+    @property
+    def paused(self) -> bool:
+        """Check if physics simulation is paused."""
+        return self._paused
+
+    @paused.setter
+    def paused(self, value: bool) -> None:
+        """Pause or resume the physics simulation."""
+        self._paused = value
+
     @property
     def physics_engine(self) -> PhysicsEngine | None:
         """Get the physics engine instance."""
         return self._physics_engine
 
+    @property
+    def time_scale(self) -> float:
+        """Get the current time scale multiplier."""
+        return self._time_scale
+
+    @time_scale.setter
+    def time_scale(self, value: float) -> None:
+        """Set the time scale multiplier (e.g., 10.0 = 10x faster)."""
+        self._time_scale = max(0.1, min(value, 1000.0))
+
     def _setup(self) -> None:
         """Create and wire up all components."""
         # Create physics engine
@@ -101,8 +123,12 @@ class SimulationServer:
         dt = self._physics_engine.dt
 
         while self._running:
+            if not self._paused:
+                # Step physics multiple times based on time scale
+                steps_per_tick = max(1, int(self._time_scale))
+                for _ in range(steps_per_tick):
                     self._physics_engine.step()
-            # Sleep for the physics timestep
+            # Sleep for the physics timestep (wall clock time)
             await asyncio.sleep(dt)
 
     async def start(self) -> None:

src/py_dvt_ate/simulation/virtual/chamber.py

@@ -26,6 +26,8 @@ class ThermalChamberSim(BaseInstrument):
         TEMP:SETPOINT?         - Query current setpoint
         TEMP:ACTUAL?           - Query actual chamber temperature
         TEMP:STAB?             - Query temperature stability (1=stable, 0=settling)
+        TEMP:RAMP <value>      - Set temperature ramp rate in degrees C/min
+        TEMP:RAMP?             - Query current ramp rate
 
     Attributes:
         manufacturer: "PyDVTATE"
@@ -47,6 +49,7 @@ class ThermalChamberSim(BaseInstrument):
             physics_engine: Reference to physics engine for temperature state.
         """
         self._setpoint = 25.0  # Default setpoint
+        self._ramp_rate = 10.0  # Default ramp rate in degrees C/min
         super().__init__(physics_engine)
 
     def _setup_commands(self) -> None:
@@ -54,10 +57,12 @@ class ThermalChamberSim(BaseInstrument):
         self.register_command("TEMP:SETPOINT", self._handle_temp_setpoint)
         self.register_command("TEMP:ACTUAL", self._handle_temp_actual)
         self.register_command("TEMP:STAB", self._handle_temp_stab)
+        self.register_command("TEMP:RAMP", self._handle_temp_ramp)
 
     def reset(self) -> None:
         """Reset chamber to default state."""
         self._setpoint = 25.0
+        self._ramp_rate = 10.0
         if self._physics_engine is not None:
             self._physics_engine.set_chamber_setpoint(self._setpoint)
 
@@ -82,8 +87,8 @@ class ThermalChamberSim(BaseInstrument):
 
         try:
             setpoint = float(command.arguments[0])
-        except ValueError:
+        except ValueError as err:
-            raise ValueError(f"Invalid temperature value: {command.arguments[0]}")
+            raise ValueError(f"Invalid temperature value: {command.arguments[0]}") from err
 
         self._setpoint = setpoint
         if self._physics_engine is not None:
@@ -141,3 +146,36 @@ class ThermalChamberSim(BaseInstrument):
         if error <= self.STABILITY_THRESHOLD:
             return "1"
         return "0"
+
+    def _handle_temp_ramp(self, command: SCPICommand) -> str:
+        """Handle TEMP:RAMP command/query.
+
+        Args:
+            command: Parsed SCPI command.
+
+        Returns:
+            Ramp rate value for query, empty string for set command.
+
+        Raises:
+            ValueError: If ramp rate argument is invalid.
+        """
+        if command.is_query:
+            return f"{self._ramp_rate:.2f}"
+
+        # Set command requires one argument
+        if not command.arguments:
+            raise ValueError("TEMP:RAMP requires a value")
+
+        try:
+            ramp_rate = float(command.arguments[0])
+        except ValueError as err:
+            raise ValueError(f"Invalid ramp rate value: {command.arguments[0]}") from err
+
+        if ramp_rate <= 0:
+            raise ValueError("Ramp rate must be positive")
+
+        self._ramp_rate = ramp_rate
+        # Note: Simulator doesn't currently model ramp rate dynamics
+        # The value is stored but not used in physics calculations
+
+        return ""

src/py_dvt_ate/simulation/virtual/power_supply.py

@@ -94,8 +94,8 @@ class PowerSupplySim(BaseInstrument):
 
         try:
             voltage = float(command.arguments[0])
-        except ValueError:
+        except ValueError as err:
-            raise ValueError(f"Invalid voltage value: {command.arguments[0]}")
+            raise ValueError(f"Invalid voltage value: {command.arguments[0]}") from err
 
         if voltage < 0:
             raise ValueError("Voltage cannot be negative")
@@ -127,8 +127,8 @@ class PowerSupplySim(BaseInstrument):
 
         try:
             current = float(command.arguments[0])
-        except ValueError:
+        except ValueError as err:
-            raise ValueError(f"Invalid current value: {command.arguments[0]}")
+            raise ValueError(f"Invalid current value: {command.arguments[0]}") from err
 
         if current < 0:
             raise ValueError("Current limit cannot be negative")

src/py_dvt_ate/tests/base.py

@@ -0,0 +1,158 @@
+"""Base class and utilities for DVT test implementations.
+
+This module provides common functionality shared across all DVT tests,
+including thermal settling helpers, measurement utilities, and statistical
+calculations.
+"""
+
+import time
+from abc import ABC
+from collections.abc import Callable
+
+from py_dvt_ate.framework.context import ITest, TestContext
+
+
+class BaseDVTTest(ITest, ABC):
+    """Abstract base class for DVT tests with common utilities.
+
+    Provides helper methods for thermal settling, measurement averaging,
+    and other common test patterns. All DVT tests should inherit from
+    this class rather than directly from ITest.
+    """
+
+    def wait_for_temperature(
+        self,
+        context: TestContext,
+        setpoint: float,
+        timeout: float = 300.0,
+        poll_interval: float = 1.0,
+    ) -> bool:
+        """Wait for thermal chamber to stabilise at setpoint.
+
+        Sets the chamber temperature and waits until stable. Logs progress
+        to the test logger.
+
+        Args:
+            context: Test context with instruments and logger.
+            setpoint: Target temperature in degrees Celsius.
+            timeout: Maximum wait time in seconds. Default 300s (5 minutes).
+            poll_interval: Time between stability checks. Default 1s.
+
+        Returns:
+            True if temperature stabilised within timeout, False if timed out.
+
+        Raises:
+            ConnectionError: If instrument communication fails.
+            IOError: If instrument reports error.
+        """
+        chamber = context.instruments.chamber
+
+        # Set the temperature
+        chamber.set_temperature(setpoint)
+        context.logger.log_event(
+            f"Set thermal chamber to {setpoint:.1f}°C, waiting for stability...",
+            level="INFO",
+        )
+
+        # Wait for stability
+        start_time = time.time()
+        elapsed = 0.0
+
+        while elapsed < timeout:
+            if chamber.is_stable():
+                actual = chamber.get_temperature()
+                context.logger.log_event(
+                    f"Chamber stable at {actual:.2f}°C "
+                    f"(target {setpoint:.1f}°C) after {elapsed:.1f}s",
+                    level="INFO",
+                )
+                return True
+
+            time.sleep(poll_interval)
+            elapsed = time.time() - start_time
+
+        # Timeout
+        actual = chamber.get_temperature()
+        context.logger.log_event(
+            f"Timeout waiting for stability. Chamber at {actual:.2f}°C, "
+            f"target {setpoint:.1f}°C after {timeout:.1f}s",
+            level="WARNING",
+        )
+        return False
+
+    def measure_averaged(
+        self,
+        measurement_func: Callable[[], float],
+        num_samples: int = 5,
+        settle_time: float = 0.1,
+    ) -> tuple[float, float]:
+        """Take multiple measurements and return mean and standard deviation.
+
+        Useful for reducing noise in measurements by averaging multiple samples.
+
+        Args:
+            measurement_func: Function that returns a single measurement.
+            num_samples: Number of samples to average. Default 5.
+            settle_time: Delay between samples in seconds. Default 0.1s.
+
+        Returns:
+            Tuple of (mean, standard_deviation).
+
+        Raises:
+            ValueError: If num_samples < 1.
+            Exception: If measurement_func raises an exception.
+        """
+        if num_samples < 1:
+            raise ValueError("num_samples must be at least 1")
+
+        samples: list[float] = []
+        for _ in range(num_samples):
+            if settle_time > 0 and len(samples) > 0:
+                time.sleep(settle_time)
+            samples.append(measurement_func())
+
+        mean = sum(samples) / len(samples)
+
+        if len(samples) == 1:
+            std_dev = 0.0
+        else:
+            variance = sum((x - mean) ** 2 for x in samples) / (len(samples) - 1)
+            std_dev = variance ** 0.5
+
+        return mean, std_dev
+
+    def thermal_settle(
+        self,
+        context: TestContext,
+        additional_settle_time: float = 5.0,
+    ) -> None:
+        """Wait for additional thermal settling after chamber reports stable.
+
+        After the chamber reports stable temperature, this adds additional
+        settling time to ensure the DUT junction temperature has also stabilised.
+        This is important for measurements sensitive to self-heating effects.
+
+        Args:
+            context: Test context with logger.
+            additional_settle_time: Extra settling time in seconds. Default 5s.
+        """
+        if additional_settle_time > 0:
+            context.logger.log_event(
+                f"Additional thermal settling for {additional_settle_time:.1f}s...",
+                level="INFO",
+            )
+            time.sleep(additional_settle_time)
+
+    def delay(self, seconds: float, message: str | None = None) -> None:
+        """Sleep for specified duration.
+
+        Simple utility for adding delays in test sequences.
+
+        Args:
+            seconds: Delay duration in seconds.
+            message: Optional message describing reason for delay.
+        """
+        if message:
+            # Could log this if needed
+            pass
+        time.sleep(seconds)

src/py_dvt_ate/tests/thermal/tempco.py

@@ -0,0 +1,243 @@
+"""Temperature Coefficient (TempCo) characterisation test.
+
+This test characterises the output voltage temperature coefficient by
+sweeping the chamber temperature and measuring output voltage at each point.
+The TempCo is calculated from the linear regression slope and expressed
+in parts per million per degree Celsius (ppm/C).
+"""
+
+from py_dvt_ate.data.models import TestStatus
+from py_dvt_ate.framework.context import TestContext
+from py_dvt_ate.tests.base import BaseDVTTest
+
+
+class TempCoTest(BaseDVTTest):
+    """Temperature coefficient characterisation test.
+
+    Measures how output voltage varies with temperature. This is a critical
+    parameter for voltage regulators, as it indicates stability across
+    the operating temperature range.
+
+    Test Procedure:
+        1. Configure DUT supply voltage and load current
+        2. Sweep chamber temperature from min to max
+        3. At each temperature point:
+           - Wait for thermal stability
+           - Measure output voltage (averaged)
+           - Log measurement with conditions
+        4. Calculate TempCo from linear regression
+        5. Evaluate against specification limits
+
+    Configuration:
+        temperatures: List of temperature points (C). Default: [-40, -20, 0, 25, 50, 85]
+        input_voltage: DUT input voltage (V). Default: 5.0
+        load_current: DUT load current (A). Default: 0.1
+        settle_time: Additional settling time at each temp (s). Default: 5.0
+        num_samples: Number of measurements to average per point. Default: 5
+        tempco_limit: Maximum allowed TempCo magnitude (ppm/C). Default: +/-50.0
+    """
+
+    @property
+    def name(self) -> str:
+        """Return test identifier."""
+        return "tempco"
+
+    @property
+    def description(self) -> str:
+        """Return test description."""
+        return "Output voltage temperature coefficient"
+
+    def execute(self, context: TestContext) -> TestStatus:
+        """Execute TempCo characterisation test.
+
+        Args:
+            context: Test context with instruments, logger, and configuration.
+
+        Returns:
+            PASSED if TempCo is within limits, FAILED otherwise.
+            ERROR if a critical failure occurs.
+        """
+        try:
+            # Get configuration
+            config = context.config
+            temperatures = config.get("temperatures", [-40.0, -20.0, 0.0, 25.0, 50.0, 85.0])
+            input_voltage = config.get("input_voltage", 5.0)
+            load_current = config.get("load_current", 0.1)
+            settle_time = config.get("settle_time", 5.0)
+            num_samples = config.get("num_samples", 5)
+            tempco_limit = config.get("tempco_limit", 50.0)
+
+            context.logger.log_event(
+                f"Starting TempCo test: {len(temperatures)} temperature points, "
+                f"Vin={input_voltage}V, Iload={load_current}A",
+                level="INFO",
+            )
+
+            # Configure DUT power
+            context.logger.log_event(
+                f"Configuring PSU: Vin={input_voltage}V, Ilimit={load_current + 0.5}A",
+                level="INFO",
+            )
+            psu = context.instruments.psu
+            psu.set_voltage(1, input_voltage)
+            psu.set_current_limit(1, load_current + 0.5)  # Add headroom
+            psu.enable_output(1, True)
+
+            # Storage for measurements
+            temp_points: list[float] = []
+            vout_points: list[float] = []
+
+            # Temperature sweep
+            for temp_setpoint in temperatures:
+                context.logger.log_event(
+                    f"Temperature point: {temp_setpoint}C",
+                    level="INFO",
+                )
+
+                # Wait for thermal stability
+                stable = self.wait_for_temperature(
+                    context,
+                    temp_setpoint,
+                    timeout=300.0,
+                )
+                if not stable:
+                    context.logger.log_event(
+                        f"Warning: Temperature did not stabilise at {temp_setpoint}C",
+                        level="WARNING",
+                    )
+
+                # Additional settling for DUT junction temperature
+                self.thermal_settle(context, settle_time)
+
+                # Measure output voltage (averaged)
+                actual_temp = context.instruments.chamber.get_temperature()
+
+                def measure_vout() -> float:
+                    return context.instruments.dmm.measure_dc_voltage()
+
+                vout_mean, vout_std = self.measure_averaged(
+                    measure_vout,
+                    num_samples=num_samples,
+                )
+
+                # Log individual measurement
+                context.logger.log_measurement(
+                    parameter="v_out",
+                    value=vout_mean,
+                    unit="V",
+                    conditions={
+                        "temperature": actual_temp,
+                        "input_voltage": input_voltage,
+                        "load_current": load_current,
+                    },
+                )
+
+                context.logger.log_event(
+                    f"Measured Vout = {vout_mean:.6f}V +/- {vout_std * 1e6:.1f}uV "
+                    f"at T={actual_temp:.2f}C",
+                    level="INFO",
+                )
+
+                # Store for TempCo calculation
+                temp_points.append(actual_temp)
+                vout_points.append(vout_mean)
+
+            # Calculate TempCo from linear regression
+            tempco_ppm = self._calculate_tempco(temp_points, vout_points)
+
+            context.logger.log_event(
+                f"Calculated TempCo = {tempco_ppm:.2f} ppm/C",
+                level="INFO",
+            )
+
+            # Log result with limits
+            context.logger.log_result(
+                parameter="temp_co",
+                value=tempco_ppm,
+                unit="ppm/C",
+                lower_limit=-abs(tempco_limit),
+                upper_limit=abs(tempco_limit),
+            )
+
+            # Evaluate pass/fail
+            passed = abs(tempco_ppm) <= tempco_limit
+
+            if passed:
+                context.logger.log_event(
+                    f"TempCo test PASSED: {tempco_ppm:.2f} ppm/C within +/-{tempco_limit} ppm/C",
+                    level="INFO",
+                )
+                return TestStatus.PASSED
+            else:
+                context.logger.log_event(
+                    f"TempCo test FAILED: {tempco_ppm:.2f} ppm/C exceeds +/-{tempco_limit} ppm/C",
+                    level="ERROR",
+                )
+                return TestStatus.FAILED
+
+        except Exception as e:
+            context.logger.log_event(
+                f"TempCo test ERROR: {e!s}",
+                level="ERROR",
+            )
+            return TestStatus.ERROR
+
+        finally:
+            # Cleanup: disable PSU output
+            try:
+                context.instruments.psu.enable_output(1, False)
+                context.logger.log_event("PSU output disabled", level="INFO")
+            except Exception:
+                pass  # Best effort cleanup
+
+    def _calculate_tempco(
+        self,
+        temperatures: list[float],
+        voltages: list[float],
+    ) -> float:
+        """Calculate temperature coefficient from measurements.
+
+        Uses linear regression to find the slope (dV/dT), then converts
+        to ppm/C relative to the nominal voltage (voltage at median temperature).
+
+        Args:
+            temperatures: Temperature measurements in C.
+            voltages: Output voltage measurements in V.
+
+        Returns:
+            Temperature coefficient in ppm/C.
+
+        Raises:
+            ValueError: If insufficient data points.
+        """
+        if len(temperatures) < 2 or len(temperatures) != len(voltages):
+            raise ValueError("Need at least 2 matching temperature-voltage pairs")
+
+        n = len(temperatures)
+
+        # Linear regression: V = a + b*T
+        # We want slope b = dV/dT
+        mean_t = sum(temperatures) / n
+        mean_v = sum(voltages) / n
+
+        # Covariance and variance
+        cov = sum(
+            (t - mean_t) * (v - mean_v)
+            for t, v in zip(temperatures, voltages, strict=True)
+        )
+        var_t = sum((t - mean_t) ** 2 for t in temperatures)
+
+        if var_t == 0:
+            raise ValueError("Temperature variance is zero (all temps identical)")
+
+        slope = cov / var_t  # dV/dT in V/C
+
+        # Find nominal voltage (voltage at median temperature)
+        sorted_pairs = sorted(zip(temperatures, voltages, strict=True))
+        mid_idx = len(sorted_pairs) // 2
+        v_nominal = sorted_pairs[mid_idx][1]
+
+        # Convert to ppm/C: (dV/dT) / V_nom * 10^6
+        tempco_ppm = (slope / v_nominal) * 1e6
+
+        return tempco_ppm

tests/integration/conftest.py

@@ -1 +1,135 @@
 """Configuration for integration tests."""
+
+import asyncio
+import threading
+import time
+from collections.abc import Generator
+
+import pytest
+
+from py_dvt_ate.simulation.server import ServerConfig, SimulationServer
+
+
+class ServerThread:
+    """Helper class to run SimulationServer in a background thread.
+
+    This allows synchronous test code to run in the main thread while
+    the async server runs in its own thread with its own event loop.
+    """
+
+    def __init__(self, config: ServerConfig):
+        """Initialise the server thread.
+
+        Args:
+            config: Server configuration.
+        """
+        self.config = config
+        self.server: SimulationServer | None = None
+        self.thread: threading.Thread | None = None
+        self.loop: asyncio.AbstractEventLoop | None = None
+        self._started = threading.Event()
+        self._error: Exception | None = None
+
+    def _run_server(self) -> None:
+        """Run the server in the background thread."""
+        try:
+            # Create new event loop for this thread
+            self.loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(self.loop)
+
+            # Create and start server
+            self.server = SimulationServer(self.config)
+            self.loop.run_until_complete(self.server.start())
+
+            # Signal that server is started
+            self._started.set()
+
+            # Run event loop until stopped
+            self.loop.run_forever()
+
+        except Exception as e:
+            self._error = e
+            self._started.set()  # Unblock waiting thread even on error
+        finally:
+            # Cleanup
+            if self.server is not None and self.loop is not None:
+                try:
+                    self.loop.run_until_complete(self.server.stop())
+                except Exception:
+                    pass
+            if self.loop is not None:
+                self.loop.close()
+
+    def start(self, timeout: float = 5.0) -> None:
+        """Start the server thread.
+
+        Args:
+            timeout: Maximum time to wait for server to start (seconds).
+
+        Raises:
+            RuntimeError: If server fails to start within timeout.
+            Exception: If server raises an exception during startup.
+        """
+        self.thread = threading.Thread(target=self._run_server, daemon=True)
+        self.thread.start()
+
+        # Wait for server to start
+        if not self._started.wait(timeout=timeout):
+            raise RuntimeError("Server failed to start within timeout")
+
+        # Check if there was an error during startup
+        if self._error is not None:
+            raise self._error
+
+        # Give server a bit more time to fully initialize
+        time.sleep(0.1)
+
+    def stop(self, timeout: float = 5.0) -> None:
+        """Stop the server thread.
+
+        Args:
+            timeout: Maximum time to wait for server to stop (seconds).
+        """
+        if self.loop is not None and self.loop.is_running():
+            # Schedule stop in the server's event loop
+            self.loop.call_soon_threadsafe(self.loop.stop)
+
+        if self.thread is not None:
+            self.thread.join(timeout=timeout)
+            self.thread = None
+
+
+@pytest.fixture
+def simulation_server() -> Generator[ServerConfig, None, None]:
+    """Provide a running simulation server for integration tests.
+
+    The server runs in a background thread with its own event loop,
+    allowing synchronous test code to run in the main thread.
+
+    Yields:
+        ServerConfig with connection details for the running server.
+    """
+    # Use unique ports for each test to avoid conflicts
+    import random
+
+    base_port = random.randint(20000, 30000)
+
+    config = ServerConfig(
+        host="127.0.0.1",
+        chamber_port=base_port,
+        psu_port=base_port + 1,
+        dmm_port=base_port + 2,
+        physics_rate_hz=100.0,
+    )
+
+    server_thread = ServerThread(config)
+    server_thread.start()
+
+    # Speed up simulation for tests (100x faster)
+    if server_thread.server is not None:
+        server_thread.server.time_scale = 100.0
+
+    try:
+        yield config
+    finally:
+        server_thread.stop()

tests/integration/test_e2e.py

@@ -0,0 +1,289 @@
+"""End-to-end integration tests for py_dvt_ate.
+
+This module contains comprehensive tests that exercise the entire system:
+- Simulation server startup
+- Instrument connectivity via HAL
+- Test execution through the framework
+- Data persistence
+- Results retrieval
+
+These tests verify that all components work together correctly in a
+complete workflow from server start to results analysis.
+"""
+
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+from py_dvt_ate.data.models import TestStatus
+from py_dvt_ate.data.repository import SQLiteRepository
+from py_dvt_ate.framework.runner import TestRunner
+from py_dvt_ate.instruments.factory import InstrumentConfig, InstrumentFactory
+from py_dvt_ate.simulation.server import ServerConfig
+from py_dvt_ate.tests.thermal.tempco import TempCoTest
+
+
+def test_e2e_tempco_characterization(simulation_server: ServerConfig) -> None:
+    """End-to-end test: Run complete TempCo characterization workflow.
+
+    This test exercises the entire system:
+    1. Simulation server is running (from fixture)
+    2. Create instruments via HAL factory
+    3. Create test repository and runner
+    4. Execute TempCo test
+    5. Verify results are persisted
+    6. Verify measurements are stored
+    7. Retrieve and analyze results
+
+    This is the closest test to real-world usage, verifying that all
+    components integrate correctly.
+    """
+    with TemporaryDirectory() as tmpdir:
+        # Step 1: Create instruments via HAL
+        instrument_config = InstrumentConfig(
+            backend="simulator",
+            simulator_host=simulation_server.host,
+            chamber_port=simulation_server.chamber_port,
+            psu_port=simulation_server.psu_port,
+            dmm_port=simulation_server.dmm_port,
+        )
+
+        instruments = InstrumentFactory.create(instrument_config)
+
+        # Connect to instruments
+        instruments.chamber.transport.connect()
+        instruments.psu.transport.connect()
+        instruments.dmm.transport.connect()
+
+        # Verify instrument connectivity
+        idn = instruments.chamber.get_temperature()  # Should not raise
+        assert isinstance(idn, float)
+
+        # Step 2: Create repository and test runner
+        db_path = Path(tmpdir) / "test.db"
+        repository = SQLiteRepository(str(db_path))
+        runner = TestRunner(repository)
+
+        # Step 3: Execute TempCo test with minimal config for speed
+        test = TempCoTest()
+        config = {
+            "temperatures": [0.0, 25.0, 50.0],  # Reduced for test speed
+            "input_voltage": 5.0,
+            "load_current": 0.1,
+            "settle_time": 0.5,  # Reduced for test speed
+            "num_samples": 3,  # Reduced for test speed
+            "tempco_limit": 100.0,  # Relaxed for test
+        }
+
+        run_id = runner.run_test(
+            test=test,
+            instruments=instruments,
+            config=config,
+            operator="test_user",
+            description="E2E integration test",
+        )
+
+        # Step 4: Verify run was created
+        assert run_id is not None
+        run = repository.get_run(run_id)
+        assert run.test_name == "tempco"
+        assert run.status in [TestStatus.PASSED, TestStatus.FAILED]  # Either is valid
+        assert run.completed_at is not None
+        assert run.operator == "test_user"
+
+        # Step 5: Verify results were stored
+        results = repository.get_results(run_id)
+        assert len(results) > 0
+
+        # Should have TempCo result
+        tempco_result = next((r for r in results if r.parameter == "temp_co"), None)
+        assert tempco_result is not None
+        assert tempco_result.unit == "ppm/C"
+        assert tempco_result.lower_limit is not None
+        assert tempco_result.upper_limit is not None
+
+        # Step 6: Verify measurements were stored
+        measurements_df = repository.get_measurements_dataframe(run_id)
+        assert measurements_df is not None
+        assert not measurements_df.empty
+
+        # Should have v_out measurements
+        v_out_measurements = measurements_df[measurements_df["parameter"] == "v_out"]
+        assert len(v_out_measurements) >= 3  # At least one per temperature point
+
+        # Step 7: Verify data integrity
+        # All measurements should have valid values
+        assert (measurements_df["value"] > 0).all()
+        # All measurements should have units
+        assert measurements_df["unit"].notna().all()
+        # Timestamps should be monotonically increasing
+        assert measurements_df["timestamp"].is_monotonic_increasing
+
+        # Cleanup: close repository before tempdir cleanup (Windows file locking)
+        repository.close()
+
+
+def test_e2e_server_lifecycle(simulation_server: ServerConfig) -> None:
+    """Test simulation server lifecycle management.
+
+    Verifies that:
+    - Server starts successfully
+    - Physics engine is running
+    - Multiple instruments can connect
+    - Server can be stopped cleanly
+    """
+    # Server is already running from fixture (in background thread)
+    # We verify it works by connecting instruments
+
+    # Multiple instruments should be able to connect
+    config = InstrumentConfig(
+        backend="simulator",
+        simulator_host=simulation_server.host,
+        chamber_port=simulation_server.chamber_port,
+        psu_port=simulation_server.psu_port,
+        dmm_port=simulation_server.dmm_port,
+    )
+
+    instruments1 = InstrumentFactory.create(config)
+    instruments2 = InstrumentFactory.create(config)
+
+    # Connect instruments
+    instruments1.chamber.transport.connect()
+    instruments2.chamber.transport.connect()
+
+    # Both should work independently
+    temp1 = instruments1.chamber.get_temperature()
+    temp2 = instruments2.chamber.get_temperature()
+
+    assert isinstance(temp1, float)
+    assert isinstance(temp2, float)
+    # Both should read similar values (same simulation)
+    assert abs(temp1 - temp2) < 1.0  # Within 1 degree
+
+
+def test_e2e_instrument_hal_abstraction(simulation_server: ServerConfig) -> None:
+    """Test Hardware Abstraction Layer works correctly.
+
+    Verifies that:
+    - Instruments implement HAL interfaces
+    - Commands work through HAL
+    - State changes propagate through physics
+    """
+    config = InstrumentConfig(
+        backend="simulator",
+        simulator_host=simulation_server.host,
+        chamber_port=simulation_server.chamber_port,
+        psu_port=simulation_server.psu_port,
+        dmm_port=simulation_server.dmm_port,
+    )
+
+    instruments = InstrumentFactory.create(config)
+
+    # Connect instruments
+    instruments.chamber.transport.connect()
+    instruments.psu.transport.connect()
+    instruments.dmm.transport.connect()
+
+    # Test thermal chamber HAL
+    instruments.chamber.set_temperature(30.0)
+    setpoint = instruments.chamber.get_setpoint()
+    assert setpoint == 30.0
+
+    # Test power supply HAL
+    instruments.psu.set_voltage(1, 5.0)
+    instruments.psu.set_current_limit(1, 0.5)
+    instruments.psu.enable_output(1, True)
+
+    voltage_setpoint = instruments.psu.get_voltage(1)
+    assert voltage_setpoint == 5.0
+
+    enabled = instruments.psu.is_output_enabled(1)
+    assert enabled is True
+
+    # Wait a moment for physics to update
+    import time
+    time.sleep(0.1)
+
+    # Measure voltage with DMM
+    measured_voltage = instruments.dmm.measure_dc_voltage()
+    assert isinstance(measured_voltage, float)
+    # Should be reading DUT output voltage (close to nominal)
+    assert 3.0 < measured_voltage < 3.6  # LDO output
+
+
+def test_e2e_multiple_test_runs(simulation_server: ServerConfig) -> None:
+    """Test running multiple tests sequentially.
+
+    Verifies that:
+    - Multiple tests can be run in sequence
+    - Each test gets its own run ID
+    - All results are stored correctly
+    - Repository handles multiple runs
+    """
+    with TemporaryDirectory() as tmpdir:
+        config = InstrumentConfig(
+            backend="simulator",
+            simulator_host=simulation_server.host,
+            chamber_port=simulation_server.chamber_port,
+            psu_port=simulation_server.psu_port,
+            dmm_port=simulation_server.dmm_port,
+        )
+
+        instruments = InstrumentFactory.create(config)
+
+        # Connect instruments
+        instruments.chamber.transport.connect()
+        instruments.psu.transport.connect()
+        instruments.dmm.transport.connect()
+
+        db_path = Path(tmpdir) / "test.db"
+        repository = SQLiteRepository(str(db_path))
+        runner = TestRunner(repository)
+
+        # Run same test twice with different configs
+        test = TempCoTest()
+
+        config1 = {
+            "temperatures": [0.0, 25.0],  # Need at least 2 points for TempCo
+            "input_voltage": 5.0,
+            "load_current": 0.1,
+            "settle_time": 0.5,
+            "num_samples": 3,
+            "tempco_limit": 100.0,
+        }
+
+        config2 = {
+            "temperatures": [25.0, 50.0],  # Need at least 2 points for TempCo
+            "input_voltage": 3.3,
+            "load_current": 0.05,
+            "settle_time": 0.5,
+            "num_samples": 3,
+            "tempco_limit": 100.0,
+        }
+
+        run_id1 = runner.run_test(test, instruments, config1, operator="test_user_1")
+        run_id2 = runner.run_test(test, instruments, config2, operator="test_user_2")
+
+        # Both runs should complete
+        assert run_id1 != run_id2
+
+        run1 = repository.get_run(run_id1)
+        run2 = repository.get_run(run_id2)
+
+        assert run1.operator == "test_user_1"
+        assert run2.operator == "test_user_2"
+
+        # Both should have results
+        results1 = repository.get_results(run_id1)
+        results2 = repository.get_results(run_id2)
+
+        assert len(results1) > 0
+        assert len(results2) > 0
+
+        # Verify get_all_runs works
+        all_runs = repository.get_all_runs()
+        assert len(all_runs) >= 2
+        assert any(r.id == str(run_id1) for r in all_runs)
+        assert any(r.id == str(run_id2) for r in all_runs)
+
+        # Cleanup: close repository before tempdir cleanup (Windows file locking)
+        repository.close()

tests/integration/test_tcp_server.py

@@ -9,12 +9,10 @@ import asyncio
 
 import pytest
 
+from py_dvt_ate.instruments.transport import InstrumentServer
 from py_dvt_ate.simulation.physics.engine import PhysicsEngine
 from py_dvt_ate.simulation.server import ServerConfig, SimulationServer
-from py_dvt_ate.simulation.tcp_server import InstrumentServer
 from py_dvt_ate.simulation.virtual.chamber import ThermalChamberSim
-from py_dvt_ate.simulation.virtual.multimeter import MultimeterSim
-from py_dvt_ate.simulation.virtual.power_supply import PowerSupplySim
 
 
 @pytest.mark.asyncio(loop_scope="function")
@@ -75,6 +73,8 @@ class TestInstrumentServer:
             # Set temperature setpoint
             writer.write(b"TEMP:SETPOINT 85.0\n")
             await writer.drain()
+            # Small delay to ensure server processes command before next one
+            await asyncio.sleep(0.01)
 
             # Query setpoint
             writer.write(b"TEMP:SETPOINT?\n")
@@ -214,6 +214,7 @@ class TestSimulationServer:
             psu_r, psu_w = await asyncio.open_connection("127.0.0.1", 16201)
             psu_w.write(b"VOLT 5.0\n")
             await psu_w.drain()
+            await asyncio.sleep(0.01)  # Allow server to process
             psu_w.write(b"OUTP ON\n")
             await psu_w.drain()
 

tests/integration/test_tempco.py

@@ -0,0 +1,250 @@
+"""Integration tests for TempCo characterisation test.
+
+Full end-to-end test of the TempCo test with simulated instruments.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from py_dvt_ate.data.models import TestStatus
+from py_dvt_ate.data.repository import SQLiteRepository
+from py_dvt_ate.framework.context import TestContext
+from py_dvt_ate.framework.logger import TestLogger
+from py_dvt_ate.instruments.factory import InstrumentConfig, InstrumentFactory
+from py_dvt_ate.simulation.server import ServerConfig
+from py_dvt_ate.tests.thermal.tempco import TempCoTest
+
+
+class TestTempCoIntegration:
+    """Integration tests for TempCo test with simulator."""
+
+    def test_tempco_runs_successfully(
+        self, tmp_path: Path, simulation_server: ServerConfig
+    ) -> None:
+        """Test TempCo test runs end-to-end with simulator."""
+        # Create instrument set connected to simulator
+        instrument_config = InstrumentConfig(
+            backend="simulator",
+            simulator_host=simulation_server.host,
+            chamber_port=simulation_server.chamber_port,
+            psu_port=simulation_server.psu_port,
+            dmm_port=simulation_server.dmm_port,
+        )
+        instruments = InstrumentFactory.create(instrument_config)
+
+        # Create test repository
+        db_path = tmp_path / "test.db"
+        repository = SQLiteRepository(db_path)
+
+        # Create test run
+        run_id = repository.create_run(
+            test_name="tempco",
+            config={
+                "temperatures": [23.0, 25.0, 27.0],  # Close to start temp for fast settling
+                "input_voltage": 5.0,
+                "load_current": 0.1,
+                "settle_time": 0.2,  # Short since temps close to start
+                "num_samples": 3,  # Reduced for faster test
+                "tempco_limit": 100.0,  # Relaxed for testing
+            },
+            description="Integration test of TempCo",
+        )
+
+        # Create test logger
+        logger = TestLogger(run_id, repository)
+
+        # Create test context
+        context = TestContext(
+            run_id=run_id,
+            instruments=instruments,
+            logger=logger,
+            config={
+                "temperatures": [23.0, 25.0, 27.0],
+                "input_voltage": 5.0,
+                "load_current": 0.1,
+                "settle_time": 0.2,
+                "num_samples": 3,
+                "tempco_limit": 100.0,
+            },
+        )
+
+        # Create test
+        test = TempCoTest()
+        assert test.name == "tempco"
+        assert test.description == "Output voltage temperature coefficient"
+
+        # Connect to instruments
+        instruments.chamber.connect()  # type: ignore[attr-defined]
+        instruments.psu.connect()  # type: ignore[attr-defined]
+        instruments.dmm.connect()  # type: ignore[attr-defined]
+
+        try:
+            # Configure instruments
+            instruments.chamber.set_ramp_rate(10.0)  # Fast ramp for testing
+            instruments.psu.enable_output(1, False)  # Ensure off initially
+
+            # Run test
+            status = test.execute(context)
+
+            # Verify test completed
+            assert status in (TestStatus.PASSED, TestStatus.FAILED)
+
+            # Flush logger to ensure all data is written
+            logger.flush()
+
+            # Update run status
+            repository.complete_run(run_id, status)
+
+            # Verify results were logged
+            results = repository.get_results(run_id)
+            assert len(results) > 0
+
+            # Find TempCo result
+            tempco_result = next(r for r in results if r.parameter == "temp_co")
+            assert tempco_result is not None
+            assert tempco_result.unit == "ppm/C"
+            assert tempco_result.lower_limit == -100.0
+            assert tempco_result.upper_limit == 100.0
+
+            # Verify measurements were logged
+            df = repository.get_measurements_dataframe(run_id)
+            assert df is not None
+            assert len(df) >= 3  # At least 3 temperature points
+
+            # Verify v_out measurements exist
+            vout_measurements = df[df["parameter"] == "v_out"]
+            assert len(vout_measurements) >= 3
+
+            # Verify temperature conditions were logged
+            assert "temperature" in df.columns
+            temps_recorded = vout_measurements["temperature"].unique()
+            assert len(temps_recorded) >= 3
+
+        finally:
+            # Disconnect from instruments
+            instruments.chamber.disconnect()  # type: ignore[attr-defined]
+            instruments.psu.disconnect()  # type: ignore[attr-defined]
+            instruments.dmm.disconnect()  # type: ignore[attr-defined]
+
+    def test_tempco_with_minimal_config(
+        self, tmp_path: Path, simulation_server: ServerConfig
+    ) -> None:
+        """Test TempCo uses default configuration when not specified."""
+        # Create instrument set
+        instrument_config = InstrumentConfig(
+            backend="simulator",
+            simulator_host=simulation_server.host,
+            chamber_port=simulation_server.chamber_port,
+            psu_port=simulation_server.psu_port,
+            dmm_port=simulation_server.dmm_port,
+        )
+        instruments = InstrumentFactory.create(instrument_config)
+
+        # Create repository
+        db_path = tmp_path / "test_minimal.db"
+        repository = SQLiteRepository(db_path)
+        run_id = repository.create_run(
+            test_name="tempco",
+            config={},  # Empty config - should use defaults
+        )
+
+        # Create logger and context with minimal config
+        logger = TestLogger(run_id, repository)
+        context = TestContext(
+            run_id=run_id,
+            instruments=instruments,
+            logger=logger,
+            config={
+                # Override temperatures for faster test
+                "temperatures": [24.0, 26.0],
+                "settle_time": 0.2,
+                "num_samples": 2,
+            },
+        )
+
+        # Execute test
+        test = TempCoTest()
+
+        # Connect to instruments
+        instruments.chamber.connect()  # type: ignore[attr-defined]
+        instruments.psu.connect()  # type: ignore[attr-defined]
+        instruments.dmm.connect()  # type: ignore[attr-defined]
+
+        try:
+            # Run test
+            status = test.execute(context)
+
+            # Should complete without error
+            assert status in (TestStatus.PASSED, TestStatus.FAILED, TestStatus.ERROR)
+
+            logger.flush()
+            repository.complete_run(run_id, status)
+
+            # Verify some data was logged
+            results = repository.get_results(run_id)
+            assert len(results) >= 1
+
+        finally:
+            # Disconnect from instruments
+            instruments.chamber.disconnect()  # type: ignore[attr-defined]
+            instruments.psu.disconnect()  # type: ignore[attr-defined]
+            instruments.dmm.disconnect()  # type: ignore[attr-defined]
+
+    def test_tempco_handles_errors_gracefully(
+        self, tmp_path: Path, simulation_server: ServerConfig
+    ) -> None:
+        """Test TempCo returns ERROR status when instruments fail."""
+        # Create instrument set
+        instrument_config = InstrumentConfig(
+            backend="simulator",
+            simulator_host=simulation_server.host,
+            chamber_port=simulation_server.chamber_port,
+            psu_port=simulation_server.psu_port,
+            dmm_port=simulation_server.dmm_port,
+        )
+        instruments = InstrumentFactory.create(instrument_config)
+
+        # Create repository
+        db_path = tmp_path / "test_error.db"
+        repository = SQLiteRepository(db_path)
+        run_id = repository.create_run(test_name="tempco", config={})
+
+        # Create logger and context
+        logger = TestLogger(run_id, repository)
+        context = TestContext(
+            run_id=run_id,
+            instruments=instruments,
+            logger=logger,
+            config={
+                "temperatures": [],  # Invalid: empty temperature list
+                "settle_time": 0.1,
+            },
+        )
+
+        # Execute test
+        test = TempCoTest()
+
+        # Connect to instruments
+        instruments.chamber.connect()  # type: ignore[attr-defined]
+        instruments.psu.connect()  # type: ignore[attr-defined]
+        instruments.dmm.connect()  # type: ignore[attr-defined]
+
+        try:
+            # Should handle gracefully (may return FAILED or ERROR)
+            # The test should not raise an unhandled exception
+            try:
+                status = test.execute(context)
+                # If it completes, it should indicate an error or failure
+                assert status in (TestStatus.ERROR, TestStatus.FAILED)
+            except Exception:
+                # Or it might raise, which we also consider handled
+                pass
+
+            logger.flush()
+
+        finally:
+            # Disconnect from instruments
+            instruments.chamber.disconnect()  # type: ignore[attr-defined]
+            instruments.psu.disconnect()  # type: ignore[attr-defined]
+            instruments.dmm.disconnect()  # type: ignore[attr-defined]

tests/unit/test_config.py

@@ -0,0 +1,266 @@
+"""Tests for configuration loading and validation."""
+
+from pathlib import Path
+from typing import Any
+
+import pytest
+import yaml
+from pydantic import ValidationError
+
+from py_dvt_ate.app.config import (
+    APIConfig,
+    AppConfig,
+    ChamberConfig,
+    DashboardConfig,
+    DataConfig,
+    DUTConfig,
+    DUTParameters,
+    InstrumentsConfig,
+    LoggingConfig,
+    PhysicsConfig,
+    PyVISAConfig,
+    SimulatorConfig,
+    ThermalConfig,
+    load_config,
+)
+
+
+def test_default_config_values() -> None:
+    """Test that default configuration values are correct."""
+    config = AppConfig()
+
+    assert config.instruments.backend == "simulator"
+    assert config.instruments.simulator.host == "localhost"
+    assert config.instruments.simulator.thermal_chamber_port == 5001
+
+    assert config.physics.update_rate_hz == 100.0
+    assert config.physics.thermal.chamber_time_constant_s == 30.0
+    assert config.physics.thermal.theta_jc == 15.0
+
+    assert config.dut.model == "ldo"
+    assert config.dut.parameters.nominal_output_voltage == 3.3
+    assert config.dut.parameters.tempco_ppm_per_c == 50.0
+
+    assert config.data.database_path == "./data/py_dvt_ate.db"
+    assert config.logging.level == "INFO"
+    assert config.dashboard.enabled is True
+    assert config.api.enabled is False
+
+
+def test_load_config_with_defaults_only() -> None:
+    """Test loading config without a file uses defaults."""
+    config = load_config(None)
+
+    assert config.instruments.backend == "simulator"
+    assert config.physics.update_rate_hz == 100.0
+
+
+def test_load_config_from_file(tmp_path: Path) -> None:
+    """Test loading configuration from YAML file."""
+    config_file = tmp_path / "test_config.yaml"
+    config_data = {
+        "instruments": {"backend": "pyvisa"},
+        "physics": {"update_rate_hz": 50.0},
+        "dut": {"model": "custom_ldo"},
+    }
+
+    with config_file.open("w") as f:
+        yaml.dump(config_data, f)
+
+    config = load_config(config_file)
+
+    assert config.instruments.backend == "pyvisa"
+    assert config.physics.update_rate_hz == 50.0
+    assert config.dut.model == "custom_ldo"
+    # Defaults still apply
+    assert config.instruments.simulator.host == "localhost"
+
+
+def test_load_config_partial_override(tmp_path: Path) -> None:
+    """Test that partial config overrides work correctly."""
+    config_file = tmp_path / "partial.yaml"
+    config_data = {
+        "physics": {
+            "thermal": {
+                "theta_jc": 20.0,
+                # Other thermal params should use defaults
+            }
+        }
+    }
+
+    with config_file.open("w") as f:
+        yaml.dump(config_data, f)
+
+    config = load_config(config_file)
+
+    # Overridden value
+    assert config.physics.thermal.theta_jc == 20.0
+    # Default values
+    assert config.physics.thermal.theta_ca == 5.0
+    assert config.physics.thermal.chamber_time_constant_s == 30.0
+
+
+def test_load_config_missing_file() -> None:
+    """Test that loading from missing file raises FileNotFoundError."""
+    with pytest.raises(FileNotFoundError, match="Configuration file not found"):
+        load_config("nonexistent.yaml")
+
+
+def test_load_config_invalid_yaml(tmp_path: Path) -> None:
+    """Test that malformed YAML raises an error."""
+    config_file = tmp_path / "invalid.yaml"
+    config_file.write_text("invalid: yaml: content: [\n")
+
+    with pytest.raises(yaml.YAMLError):
+        load_config(config_file)
+
+
+def test_load_config_validation_error(tmp_path: Path) -> None:
+    """Test that invalid configuration raises ValidationError."""
+    config_file = tmp_path / "invalid_config.yaml"
+    config_data = {
+        "instruments": {"backend": "invalid_backend"},  # Not in Literal["simulator", "pyvisa"]
+    }
+
+    with config_file.open("w") as f:
+        yaml.dump(config_data, f)
+
+    with pytest.raises(ValidationError):
+        load_config(config_file)
+
+
+def test_env_override_simple(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    """Test environment variable override for simple values."""
+    config_file = tmp_path / "config.yaml"
+    config_data: dict[str, Any] = {}
+
+    with config_file.open("w") as f:
+        yaml.dump(config_data, f)
+
+    monkeypatch.setenv("PYDVTATE__INSTRUMENTS__BACKEND", "pyvisa")
+    monkeypatch.setenv("PYDVTATE__PHYSICS__UPDATE_RATE_HZ", "200.0")
+
+    config = load_config(config_file)
+
+    assert config.instruments.backend == "pyvisa"
+    assert config.physics.update_rate_hz == 200.0
+
+
+def test_env_override_nested(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    """Test environment variable override for nested values."""
+    config_file = tmp_path / "config.yaml"
+    config_data: dict[str, Any] = {}
+
+    with config_file.open("w") as f:
+        yaml.dump(config_data, f)
+
+    monkeypatch.setenv("PYDVTATE__INSTRUMENTS__SIMULATOR__HOST", "192.168.1.100")
+    monkeypatch.setenv("PYDVTATE__INSTRUMENTS__SIMULATOR__THERMAL_CHAMBER_PORT", "6001")
+    monkeypatch.setenv("PYDVTATE__PHYSICS__THERMAL__THETA_JC", "25.0")
+
+    config = load_config(config_file)
+
+    assert config.instruments.simulator.host == "192.168.1.100"
+    assert config.instruments.simulator.thermal_chamber_port == 6001
+    assert config.physics.thermal.theta_jc == 25.0
+
+
+def test_env_override_types(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    """Test that environment variables are parsed to correct types."""
+    config_file = tmp_path / "config.yaml"
+    config_data: dict[str, Any] = {}
+
+    with config_file.open("w") as f:
+        yaml.dump(config_data, f)
+
+    monkeypatch.setenv("PYDVTATE__DASHBOARD__ENABLED", "false")  # bool
+    monkeypatch.setenv("PYDVTATE__DASHBOARD__PORT", "9000")  # int
+    monkeypatch.setenv("PYDVTATE__PHYSICS__UPDATE_RATE_HZ", "75.5")  # float
+
+    config = load_config(config_file)
+
+    assert config.dashboard.enabled is False
+    assert config.dashboard.port == 9000
+    assert config.physics.update_rate_hz == 75.5
+
+
+def test_env_override_precedence(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    """Test that environment variables override file values."""
+    config_file = tmp_path / "config.yaml"
+    config_data = {"physics": {"update_rate_hz": 50.0}}
+
+    with config_file.open("w") as f:
+        yaml.dump(config_data, f)
+
+    monkeypatch.setenv("PYDVTATE__PHYSICS__UPDATE_RATE_HZ", "150.0")
+
+    config = load_config(config_file)
+
+    # Environment variable should win
+    assert config.physics.update_rate_hz == 150.0
+
+
+def test_env_variables_ignored_without_prefix(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """Test that environment variables without prefix are ignored."""
+    config_file = tmp_path / "config.yaml"
+    config_data: dict[str, Any] = {}
+
+    with config_file.open("w") as f:
+        yaml.dump(config_data, f)
+
+    # These should be ignored
+    monkeypatch.setenv("BACKEND", "pyvisa")
+    monkeypatch.setenv("UPDATE_RATE_HZ", "200.0")
+
+    config = load_config(config_file)
+
+    # Should use defaults
+    assert config.instruments.backend == "simulator"
+    assert config.physics.update_rate_hz == 100.0
+
+
+def test_simulator_config_defaults() -> None:
+    """Test SimulatorConfig default values."""
+    config = SimulatorConfig()
+    assert config.host == "localhost"
+    assert config.thermal_chamber_port == 5001
+    assert config.power_supply_port == 5002
+    assert config.multimeter_port == 5003
+
+
+def test_pyvisa_config_defaults() -> None:
+    """Test PyVISAConfig default values."""
+    config = PyVISAConfig()
+    assert config.thermal_chamber is None
+    assert config.power_supply is None
+    assert config.multimeter is None
+
+
+def test_complete_config_structure() -> None:
+    """Test that all config sections can be instantiated."""
+    config = AppConfig(
+        instruments=InstrumentsConfig(
+            backend="pyvisa",
+            simulator=SimulatorConfig(host="192.168.1.1"),
+            pyvisa=PyVISAConfig(thermal_chamber="TCPIP::192.168.1.10::INSTR"),
+        ),
+        physics=PhysicsConfig(
+            update_rate_hz=50.0,
+            thermal=ThermalConfig(theta_jc=20.0),
+            chamber=ChamberConfig(ramp_rate_c_per_min=5.0),
+        ),
+        dut=DUTConfig(
+            model="custom", parameters=DUTParameters(nominal_output_voltage=5.0)
+        ),
+        data=DataConfig(database_path="/tmp/test.db"),
+        logging=LoggingConfig(level="DEBUG"),
+        dashboard=DashboardConfig(enabled=False),
+        api=APIConfig(enabled=True, port=9000),
+    )
+
+    assert config.instruments.backend == "pyvisa"
+    assert config.physics.update_rate_hz == 50.0
+    assert config.dut.parameters.nominal_output_voltage == 5.0
+    assert config.api.port == 9000

tests/unit/test_drivers.py

@@ -0,0 +1,346 @@
+"""Unit tests for instrument drivers.
+
+Tests SCPI command formatting and driver functionality using mock transports.
+"""
+
+from unittest.mock import MagicMock
+
+import pytest
+
+from py_dvt_ate.instruments.drivers.base import BaseDriver
+from py_dvt_ate.instruments.drivers.chamber import ThermalChamberDriver
+from py_dvt_ate.instruments.drivers.multimeter import MultimeterDriver
+from py_dvt_ate.instruments.drivers.power_supply import PowerSupplyDriver
+
+
+@pytest.fixture
+def mock_transport():
+    """Create a mock transport for testing."""
+    transport = MagicMock()
+    transport.is_connected = True
+    return transport
+
+
+class TestBaseDriver:
+    """Tests for BaseDriver base class."""
+
+    def test_connect(self, mock_transport):
+        """Test connection establishment."""
+        driver = BaseDriver(mock_transport)
+        driver.connect()
+        mock_transport.connect.assert_called_once()
+
+    def test_disconnect(self, mock_transport):
+        """Test disconnection."""
+        driver = BaseDriver(mock_transport)
+        driver.disconnect()
+        mock_transport.disconnect.assert_called_once()
+
+    def test_is_connected(self, mock_transport):
+        """Test connection status check."""
+        driver = BaseDriver(mock_transport)
+        assert driver.is_connected is True
+
+    def test_write(self, mock_transport):
+        """Test SCPI command write."""
+        driver = BaseDriver(mock_transport)
+        driver.write("VOLT 3.3")
+        mock_transport.write.assert_called_once_with("VOLT 3.3")
+
+    def test_query(self, mock_transport):
+        """Test SCPI query."""
+        mock_transport.query.return_value = "3.300"
+        driver = BaseDriver(mock_transport)
+        result = driver.query("VOLT?")
+        assert result == "3.300"
+        mock_transport.query.assert_called_once_with("VOLT?", None)
+
+    def test_query_float(self, mock_transport):
+        """Test SCPI query with float parsing."""
+        mock_transport.query.return_value = "3.300"
+        driver = BaseDriver(mock_transport)
+        result = driver.query_float("VOLT?")
+        assert result == 3.3
+        assert isinstance(result, float)
+
+    def test_query_float_invalid(self, mock_transport):
+        """Test SCPI query with invalid float response."""
+        mock_transport.query.return_value = "INVALID"
+        driver = BaseDriver(mock_transport)
+        with pytest.raises(ValueError, match="Cannot parse 'INVALID' as float"):
+            driver.query_float("VOLT?")
+
+    def test_query_int(self, mock_transport):
+        """Test SCPI query with integer parsing."""
+        mock_transport.query.return_value = "42"
+        driver = BaseDriver(mock_transport)
+        result = driver.query_int("COUNT?")
+        assert result == 42
+        assert isinstance(result, int)
+
+    def test_query_int_invalid(self, mock_transport):
+        """Test SCPI query with invalid integer response."""
+        mock_transport.query.return_value = "3.14"
+        driver = BaseDriver(mock_transport)
+        with pytest.raises(ValueError, match="Cannot parse '3.14' as int"):
+            driver.query_int("COUNT?")
+
+    def test_query_bool_true_variants(self, mock_transport):
+        """Test SCPI query with boolean parsing - true variants."""
+        driver = BaseDriver(mock_transport)
+
+        for value in ["1", "ON", "TRUE", "on", "true"]:
+            mock_transport.query.return_value = value
+            result = driver.query_bool("OUTP?")
+            assert result is True
+
+    def test_query_bool_false_variants(self, mock_transport):
+        """Test SCPI query with boolean parsing - false variants."""
+        driver = BaseDriver(mock_transport)
+
+        for value in ["0", "OFF", "FALSE", "off", "false"]:
+            mock_transport.query.return_value = value
+            result = driver.query_bool("OUTP?")
+            assert result is False
+
+    def test_query_bool_invalid(self, mock_transport):
+        """Test SCPI query with invalid boolean response."""
+        mock_transport.query.return_value = "MAYBE"
+        driver = BaseDriver(mock_transport)
+        with pytest.raises(ValueError, match="Cannot parse 'MAYBE' as bool"):
+            driver.query_bool("OUTP?")
+
+    def test_identify(self, mock_transport):
+        """Test instrument identification query."""
+        mock_transport.query.return_value = "Manufacturer,Model,SN123,1.0.0"
+        driver = BaseDriver(mock_transport)
+        result = driver.identify()
+        assert result == "Manufacturer,Model,SN123,1.0.0"
+        mock_transport.query.assert_called_once_with("*IDN?", None)
+
+    def test_reset(self, mock_transport):
+        """Test instrument reset command."""
+        driver = BaseDriver(mock_transport)
+        driver.reset()
+        mock_transport.write.assert_called_once_with("*RST")
+
+    def test_clear_status(self, mock_transport):
+        """Test clear status command."""
+        driver = BaseDriver(mock_transport)
+        driver.clear_status()
+        mock_transport.write.assert_called_once_with("*CLS")
+
+    def test_operation_complete(self, mock_transport):
+        """Test operation complete query."""
+        mock_transport.query.return_value = "1"
+        driver = BaseDriver(mock_transport)
+        result = driver.operation_complete()
+        assert result is True
+        mock_transport.query.assert_called_once_with("*OPC?", None)
+
+
+class TestThermalChamberDriver:
+    """Tests for ThermalChamberDriver."""
+
+    def test_set_temperature(self, mock_transport):
+        """Test temperature setpoint command."""
+        driver = ThermalChamberDriver(mock_transport)
+        driver.set_temperature(85.0)
+        mock_transport.write.assert_called_once_with("TEMP:SETPOINT 85.00")
+
+    def test_get_temperature(self, mock_transport):
+        """Test temperature measurement query."""
+        mock_transport.query.return_value = "25.50"
+        driver = ThermalChamberDriver(mock_transport)
+        temp = driver.get_temperature()
+        assert temp == 25.5
+        mock_transport.query.assert_called_once_with("TEMP:ACTUAL?", None)
+
+    def test_get_setpoint(self, mock_transport):
+        """Test setpoint query."""
+        mock_transport.query.return_value = "85.00"
+        driver = ThermalChamberDriver(mock_transport)
+        setpoint = driver.get_setpoint()
+        assert setpoint == 85.0
+        mock_transport.query.assert_called_once_with("TEMP:SETPOINT?", None)
+
+    def test_is_stable_true(self, mock_transport):
+        """Test stability check - stable."""
+        mock_transport.query.return_value = "1"
+        driver = ThermalChamberDriver(mock_transport)
+        assert driver.is_stable() is True
+
+    def test_is_stable_false(self, mock_transport):
+        """Test stability check - not stable."""
+        mock_transport.query.return_value = "0"
+        driver = ThermalChamberDriver(mock_transport)
+        assert driver.is_stable() is False
+
+    def test_wait_until_stable_immediate(self, mock_transport):
+        """Test wait for stability - already stable."""
+        mock_transport.query.return_value = "1"
+        driver = ThermalChamberDriver(mock_transport)
+        result = driver.wait_until_stable(timeout=5.0, poll_interval=0.1)
+        assert result is True
+
+    def test_wait_until_stable_timeout(self, mock_transport):
+        """Test wait for stability - timeout."""
+        mock_transport.query.return_value = "0"  # Never becomes stable
+        driver = ThermalChamberDriver(mock_transport)
+        result = driver.wait_until_stable(timeout=0.2, poll_interval=0.1)
+        assert result is False
+
+    def test_wait_until_stable_invalid_timeout(self, mock_transport):
+        """Test wait with negative timeout."""
+        driver = ThermalChamberDriver(mock_transport)
+        with pytest.raises(ValueError, match="Timeout must be non-negative"):
+            driver.wait_until_stable(timeout=-1.0)
+
+    def test_wait_until_stable_invalid_interval(self, mock_transport):
+        """Test wait with non-positive poll interval."""
+        driver = ThermalChamberDriver(mock_transport)
+        with pytest.raises(ValueError, match="Poll interval must be positive"):
+            driver.wait_until_stable(poll_interval=0.0)
+
+    def test_set_ramp_rate(self, mock_transport):
+        """Test ramp rate command."""
+        driver = ThermalChamberDriver(mock_transport)
+        driver.set_ramp_rate(5.0)
+        mock_transport.write.assert_called_once_with("TEMP:RAMP 5.00")
+
+    def test_get_ramp_rate(self, mock_transport):
+        """Test ramp rate query."""
+        mock_transport.query.return_value = "5.00"
+        driver = ThermalChamberDriver(mock_transport)
+        rate = driver.get_ramp_rate()
+        assert rate == 5.0
+
+
+class TestPowerSupplyDriver:
+    """Tests for PowerSupplyDriver."""
+
+    def test_set_voltage(self, mock_transport):
+        """Test voltage setpoint command."""
+        driver = PowerSupplyDriver(mock_transport)
+        driver.set_voltage(1, 3.3)
+        mock_transport.write.assert_called_once_with("VOLT 3.300")
+
+    def test_get_voltage(self, mock_transport):
+        """Test voltage setpoint query."""
+        mock_transport.query.return_value = "3.300"
+        driver = PowerSupplyDriver(mock_transport)
+        voltage = driver.get_voltage(1)
+        assert voltage == 3.3
+
+    def test_set_current_limit(self, mock_transport):
+        """Test current limit command."""
+        driver = PowerSupplyDriver(mock_transport)
+        driver.set_current_limit(1, 0.5)
+        mock_transport.write.assert_called_once_with("CURR 0.500")
+
+    def test_get_current_limit(self, mock_transport):
+        """Test current limit query."""
+        mock_transport.query.return_value = "0.500"
+        driver = PowerSupplyDriver(mock_transport)
+        current = driver.get_current_limit(1)
+        assert current == 0.5
+
+    def test_measure_voltage(self, mock_transport):
+        """Test voltage measurement."""
+        mock_transport.query.return_value = "3.305"
+        driver = PowerSupplyDriver(mock_transport)
+        voltage = driver.measure_voltage(1)
+        assert voltage == 3.305
+        mock_transport.query.assert_called_once_with("MEAS:VOLT?", None)
+
+    def test_measure_current(self, mock_transport):
+        """Test current measurement."""
+        mock_transport.query.return_value = "0.125"
+        driver = PowerSupplyDriver(mock_transport)
+        current = driver.measure_current(1)
+        assert current == 0.125
+        mock_transport.query.assert_called_once_with("MEAS:CURR?", None)
+
+    def test_enable_output_on(self, mock_transport):
+        """Test enable output command."""
+        driver = PowerSupplyDriver(mock_transport)
+        driver.enable_output(1, True)
+        mock_transport.write.assert_called_once_with("OUTP ON")
+
+    def test_enable_output_off(self, mock_transport):
+        """Test disable output command."""
+        driver = PowerSupplyDriver(mock_transport)
+        driver.enable_output(1, False)
+        mock_transport.write.assert_called_once_with("OUTP OFF")
+
+    def test_is_output_enabled_true(self, mock_transport):
+        """Test output enabled query - enabled."""
+        mock_transport.query.return_value = "1"
+        driver = PowerSupplyDriver(mock_transport)
+        assert driver.is_output_enabled(1) is True
+
+    def test_is_output_enabled_false(self, mock_transport):
+        """Test output enabled query - disabled."""
+        mock_transport.query.return_value = "0"
+        driver = PowerSupplyDriver(mock_transport)
+        assert driver.is_output_enabled(1) is False
+
+
+class TestMultimeterDriver:
+    """Tests for MultimeterDriver."""
+
+    def test_measure_dc_voltage(self, mock_transport):
+        """Test DC voltage measurement."""
+        mock_transport.query.return_value = "3.300000"
+        driver = MultimeterDriver(mock_transport)
+        voltage = driver.measure_dc_voltage()
+        assert voltage == 3.3
+        mock_transport.query.assert_called_once_with("MEAS:VOLT:DC?", None)
+
+    def test_measure_dc_current(self, mock_transport):
+        """Test DC current measurement."""
+        mock_transport.query.return_value = "0.125000"
+        driver = MultimeterDriver(mock_transport)
+        current = driver.measure_dc_current()
+        assert current == 0.125
+        mock_transport.query.assert_called_once_with("MEAS:CURR:DC?", None)
+
+    def test_measure_resistance_not_implemented(self, mock_transport):
+        """Test resistance measurement raises NotImplementedError."""
+        driver = MultimeterDriver(mock_transport)
+        with pytest.raises(NotImplementedError, match="Resistance measurement"):
+            driver.measure_resistance()
+
+    def test_set_integration_time_not_implemented(self, mock_transport):
+        """Test integration time setting raises NotImplementedError."""
+        driver = MultimeterDriver(mock_transport)
+        with pytest.raises(NotImplementedError, match="Integration time"):
+            driver.set_integration_time(1.0)
+
+    def test_configure_dc_voltage(self, mock_transport):
+        """Test configure for DC voltage."""
+        driver = MultimeterDriver(mock_transport)
+        driver.configure_dc_voltage()
+        mock_transport.write.assert_called_once_with("CONF:VOLT:DC")
+
+    def test_configure_dc_current(self, mock_transport):
+        """Test configure for DC current."""
+        driver = MultimeterDriver(mock_transport)
+        driver.configure_dc_current()
+        mock_transport.write.assert_called_once_with("CONF:CURR:DC")
+
+    def test_get_configuration(self, mock_transport):
+        """Test get current configuration."""
+        mock_transport.query.return_value = '"VOLT:DC"'
+        driver = MultimeterDriver(mock_transport)
+        config = driver.get_configuration()
+        assert config == "VOLT:DC"
+        mock_transport.query.assert_called_once_with("CONF?", None)
+
+    def test_read(self, mock_transport):
+        """Test read measurement with current configuration."""
+        mock_transport.query.return_value = "3.300000"
+        driver = MultimeterDriver(mock_transport)
+        value = driver.read()
+        assert value == 3.3
+        mock_transport.query.assert_called_once_with("READ?", None)

tests/unit/test_instruments.py

@@ -0,0 +1,273 @@
+"""Unit tests for instrument interfaces and factory.
+
+Tests the Hardware Abstraction Layer (HAL) interfaces and the factory
+pattern for creating instrument sets.
+"""
+
+import pytest
+
+from py_dvt_ate.instruments import (
+    IMultimeter,
+    InstrumentConfig,
+    InstrumentFactory,
+    InstrumentSet,
+    IPowerSupply,
+    IThermalChamber,
+)
+from py_dvt_ate.instruments.drivers import (
+    MultimeterDriver,
+    PowerSupplyDriver,
+    ThermalChamberDriver,
+)
+
+
+class TestInterfaceImplementation:
+    """Test that drivers correctly implement the interface protocols."""
+
+    def test_thermal_chamber_implements_interface(self):
+        """Verify ThermalChamberDriver implements IThermalChamber."""
+        # ABC inheritance ensures interface compliance at class definition time
+        assert issubclass(ThermalChamberDriver, IThermalChamber)
+
+    def test_power_supply_implements_interface(self):
+        """Verify PowerSupplyDriver implements IPowerSupply."""
+        assert issubclass(PowerSupplyDriver, IPowerSupply)
+
+    def test_multimeter_implements_interface(self):
+        """Verify MultimeterDriver implements IMultimeter."""
+        assert issubclass(MultimeterDriver, IMultimeter)
+
+    def test_thermal_chamber_has_all_methods(self):
+        """Verify ThermalChamberDriver has all required methods."""
+        required_methods = [
+            "set_temperature",
+            "get_temperature",
+            "get_setpoint",
+            "is_stable",
+            "wait_until_stable",
+            "set_ramp_rate",
+        ]
+        for method in required_methods:
+            assert hasattr(ThermalChamberDriver, method)
+
+    def test_power_supply_has_all_methods(self):
+        """Verify PowerSupplyDriver has all required methods."""
+        required_methods = [
+            "set_voltage",
+            "get_voltage",
+            "set_current_limit",
+            "get_current_limit",
+            "measure_voltage",
+            "measure_current",
+            "enable_output",
+            "is_output_enabled",
+        ]
+        for method in required_methods:
+            assert hasattr(PowerSupplyDriver, method)
+
+    def test_multimeter_has_all_methods(self):
+        """Verify MultimeterDriver has all required methods."""
+        required_methods = [
+            "measure_dc_voltage",
+            "measure_dc_current",
+            "measure_resistance",
+            "set_integration_time",
+        ]
+        for method in required_methods:
+            assert hasattr(MultimeterDriver, method)
+
+
+class TestInstrumentSet:
+    """Test the InstrumentSet dataclass."""
+
+    def test_instrument_set_creation(self):
+        """Verify InstrumentSet can be created with mock instruments."""
+        from unittest.mock import Mock
+
+        # Create mock instruments that satisfy the interface
+        mock_chamber = Mock(spec=IThermalChamber)
+        mock_psu = Mock(spec=IPowerSupply)
+        mock_dmm = Mock(spec=IMultimeter)
+
+        instrument_set = InstrumentSet(
+            chamber=mock_chamber, psu=mock_psu, dmm=mock_dmm
+        )
+
+        assert instrument_set.chamber is mock_chamber
+        assert instrument_set.psu is mock_psu
+        assert instrument_set.dmm is mock_dmm
+
+    def test_instrument_set_type_annotations(self):
+        """Verify InstrumentSet has correct type annotations."""
+        annotations = InstrumentSet.__annotations__
+
+        assert annotations["chamber"] == IThermalChamber
+        assert annotations["psu"] == IPowerSupply
+        assert annotations["dmm"] == IMultimeter
+
+
+class TestInstrumentConfig:
+    """Test the InstrumentConfig dataclass."""
+
+    def test_config_defaults_simulator(self):
+        """Verify default configuration for simulator backend."""
+        config = InstrumentConfig(backend="simulator")
+
+        assert config.backend == "simulator"
+        assert config.simulator_host == "localhost"
+        assert config.chamber_port == 5001
+        assert config.psu_port == 5002
+        assert config.dmm_port == 5003
+        assert config.chamber_visa is None
+        assert config.psu_visa is None
+        assert config.dmm_visa is None
+
+    def test_config_custom_ports(self):
+        """Verify configuration accepts custom port settings."""
+        config = InstrumentConfig(
+            backend="simulator",
+            simulator_host="192.168.1.100",
+            chamber_port=6001,
+            psu_port=6002,
+            dmm_port=6003,
+        )
+
+        assert config.simulator_host == "192.168.1.100"
+        assert config.chamber_port == 6001
+        assert config.psu_port == 6002
+        assert config.dmm_port == 6003
+
+    def test_config_pyvisa_backend(self):
+        """Verify configuration for PyVISA backend."""
+        config = InstrumentConfig(
+            backend="pyvisa",
+            chamber_visa="TCPIP::192.168.1.10::INSTR",
+            psu_visa="TCPIP::192.168.1.11::INSTR",
+            dmm_visa="TCPIP::192.168.1.12::INSTR",
+        )
+
+        assert config.backend == "pyvisa"
+        assert config.chamber_visa == "TCPIP::192.168.1.10::INSTR"
+        assert config.psu_visa == "TCPIP::192.168.1.11::INSTR"
+        assert config.dmm_visa == "TCPIP::192.168.1.12::INSTR"
+
+
+class TestInstrumentFactory:
+    """Test the InstrumentFactory."""
+
+    def test_factory_rejects_unknown_backend(self):
+        """Verify factory raises error for unknown backend."""
+        config = InstrumentConfig(backend="invalid")  # type: ignore
+
+        with pytest.raises(ValueError, match="Unknown backend: invalid"):
+            InstrumentFactory.create(config)
+
+    def test_factory_pyvisa_not_implemented(self):
+        """Verify PyVISA backend raises NotImplementedError."""
+        config = InstrumentConfig(backend="pyvisa")
+
+        with pytest.raises(NotImplementedError, match="PyVISA backend not yet"):
+            InstrumentFactory.create(config)
+
+    def test_factory_creates_instrument_set(self):
+        """Verify factory creates InstrumentSet with correct structure."""
+        from unittest.mock import Mock, patch
+
+        config = InstrumentConfig(backend="simulator")
+
+        # Mock the transports and drivers to avoid actual connections
+        # Patch where they're imported FROM, not where they're used
+        with (
+            patch(
+                "py_dvt_ate.instruments.transport.tcp.TCPTransport"
+            ) as mock_tcp_transport,
+            patch(
+                "py_dvt_ate.instruments.drivers.chamber.ThermalChamberDriver"
+            ) as mock_chamber,
+            patch(
+                "py_dvt_ate.instruments.drivers.power_supply.PowerSupplyDriver"
+            ) as mock_psu,
+            patch(
+                "py_dvt_ate.instruments.drivers.multimeter.MultimeterDriver"
+            ) as mock_dmm,
+        ):
+            # Create mock instrument instances
+            mock_chamber_instance = Mock(spec=IThermalChamber)
+            mock_psu_instance = Mock(spec=IPowerSupply)
+            mock_dmm_instance = Mock(spec=IMultimeter)
+
+            mock_chamber.return_value = mock_chamber_instance
+            mock_psu.return_value = mock_psu_instance
+            mock_dmm.return_value = mock_dmm_instance
+
+            instrument_set = InstrumentFactory.create(config)
+
+            # Verify InstrumentSet was created
+            assert isinstance(instrument_set, InstrumentSet)
+
+            # Verify transports were created with correct parameters
+            assert mock_tcp_transport.call_count == 3
+            mock_tcp_transport.assert_any_call("localhost", 5001)  # chamber
+            mock_tcp_transport.assert_any_call("localhost", 5002)  # psu
+            mock_tcp_transport.assert_any_call("localhost", 5003)  # dmm
+
+            # Verify drivers were created
+            assert mock_chamber.call_count == 1
+            assert mock_psu.call_count == 1
+            assert mock_dmm.call_count == 1
+
+            # Verify InstrumentSet contains the mock instances
+            assert instrument_set.chamber is mock_chamber_instance
+            assert instrument_set.psu is mock_psu_instance
+            assert instrument_set.dmm is mock_dmm_instance
+
+    def test_factory_uses_custom_ports(self):
+        """Verify factory uses custom port configuration."""
+        from unittest.mock import patch
+
+        config = InstrumentConfig(
+            backend="simulator",
+            simulator_host="testserver",
+            chamber_port=7001,
+            psu_port=7002,
+            dmm_port=7003,
+        )
+
+        with patch(
+            "py_dvt_ate.instruments.transport.tcp.TCPTransport"
+        ) as mock_tcp_transport:
+            InstrumentFactory.create(config)
+
+            # Verify custom host and ports were used
+            mock_tcp_transport.assert_any_call("testserver", 7001)
+            mock_tcp_transport.assert_any_call("testserver", 7002)
+            mock_tcp_transport.assert_any_call("testserver", 7003)
+
+    def test_factory_returns_correct_types(self):
+        """Verify factory returns instruments implementing correct interfaces."""
+        from unittest.mock import Mock, patch
+
+        config = InstrumentConfig(backend="simulator")
+
+        with (
+            patch("py_dvt_ate.instruments.transport.tcp.TCPTransport"),
+            patch(
+                "py_dvt_ate.instruments.drivers.chamber.ThermalChamberDriver"
+            ) as mock_chamber,
+            patch(
+                "py_dvt_ate.instruments.drivers.power_supply.PowerSupplyDriver"
+            ) as mock_psu,
+            patch(
+                "py_dvt_ate.instruments.drivers.multimeter.MultimeterDriver"
+            ) as mock_dmm,
+        ):
+            # Make the mocks subclasses of the interfaces
+            mock_chamber.return_value = Mock(spec=IThermalChamber)
+            mock_psu.return_value = Mock(spec=IPowerSupply)
+            mock_dmm.return_value = Mock(spec=IMultimeter)
+
+            instrument_set = InstrumentFactory.create(config)
+
+            # Verify returned instruments satisfy the interface specs
+            # (Mock with spec=Interface makes isinstance checks work)
+            assert isinstance(instrument_set, InstrumentSet)

tests/unit/test_physics_models.py

@@ -63,7 +63,7 @@ class TestThermalState:
 
         # Should not raise
         hash(state)
-        {state}  # Can be added to a set
+        _ = {state}  # Can be added to a set
 
 
 class TestElectricalState:

tests/unit/test_repository.py

@@ -0,0 +1,308 @@
+"""Unit tests for data repository."""
+
+import tempfile
+from pathlib import Path
+from uuid import uuid4
+
+import pandas as pd
+import pytest
+
+from py_dvt_ate.data.models import Measurement, TestStatus
+from py_dvt_ate.data.repository import SQLiteRepository
+
+
+@pytest.fixture
+def temp_db():
+    """Create a temporary database for testing."""
+    # Use ignore_cleanup_errors=True for Windows file locking issues
+    with tempfile.TemporaryDirectory(ignore_cleanup_errors=True) as tmpdir:
+        db_path = Path(tmpdir) / "test.db"
+        yield db_path
+
+
+@pytest.fixture
+def repository(temp_db):
+    """Create a repository instance for testing."""
+    import gc
+    repo = SQLiteRepository(temp_db)
+    yield repo
+    # Ensure all connections and file handles are closed before cleanup
+    # This is critical on Windows to prevent PermissionError
+    repo.close()
+    del repo
+    gc.collect()
+
+
+def test_create_run(repository):
+    """Test creating a new test run."""
+    config = {"temperature": 25.0, "voltage": 3.3}
+    run_id = repository.create_run(
+        test_name="TempCo Test",
+        config=config,
+        operator="Test Engineer",
+        description="Test description",
+    )
+
+    assert run_id is not None
+
+    # Verify run was created
+    run = repository.get_run(run_id)
+    assert run.test_name == "TempCo Test"
+    assert run.operator == "Test Engineer"
+    assert run.description == "Test description"
+    assert run.status == TestStatus.PENDING
+
+
+def test_update_run_status(repository):
+    """Test updating test run status."""
+    run_id = repository.create_run("Test", config={})
+
+    repository.update_run_status(run_id, TestStatus.RUNNING)
+    run = repository.get_run(run_id)
+    assert run.status == TestStatus.RUNNING
+
+    repository.update_run_status(run_id, TestStatus.PASSED)
+    run = repository.get_run(run_id)
+    assert run.status == TestStatus.PASSED
+
+
+def test_complete_run(repository):
+    """Test completing a test run."""
+    run_id = repository.create_run("Test", config={})
+
+    repository.complete_run(run_id, TestStatus.PASSED)
+    run = repository.get_run(run_id)
+
+    assert run.status == TestStatus.PASSED
+    assert run.completed_at is not None
+
+
+def test_save_result(repository):
+    """Test saving a test result."""
+    run_id = repository.create_run("Test", config={})
+
+    repository.save_result(
+        run_id=run_id,
+        parameter="output_voltage",
+        value=3.305,
+        unit="V",
+        lower_limit=3.267,
+        upper_limit=3.333,
+    )
+
+    results = repository.get_results(run_id)
+    assert len(results) == 1
+
+    result = results[0]
+    assert result.parameter == "output_voltage"
+    assert result.value == 3.305
+    assert result.unit == "V"
+    assert result.lower_limit == 3.267
+    assert result.upper_limit == 3.333
+    assert result.passed is True
+
+
+def test_save_result_fail(repository):
+    """Test saving a failing test result."""
+    run_id = repository.create_run("Test", config={})
+
+    repository.save_result(
+        run_id=run_id,
+        parameter="output_voltage",
+        value=3.350,  # Outside upper limit
+        unit="V",
+        lower_limit=3.267,
+        upper_limit=3.333,
+    )
+
+    results = repository.get_results(run_id)
+    result = results[0]
+    assert result.passed is False
+
+
+def test_save_result_no_limits(repository):
+    """Test saving a result without limits."""
+    run_id = repository.create_run("Test", config={})
+
+    repository.save_result(
+        run_id=run_id,
+        parameter="temperature",
+        value=25.5,
+        unit="°C",
+    )
+
+    results = repository.get_results(run_id)
+    result = results[0]
+    assert result.passed is None  # No limits defined
+
+
+def test_save_measurements(repository):
+    """Test saving time-series measurements to Parquet."""
+    run_id = repository.create_run("Test", config={})
+
+    measurements = [
+        Measurement(
+            timestamp=1234567890.0,
+            parameter="voltage",
+            value=3.3,
+            unit="V",
+            temperature=25.0,
+            input_voltage=5.0,
+            load_current=0.1,
+        ),
+        Measurement(
+            timestamp=1234567891.0,
+            parameter="voltage",
+            value=3.31,
+            unit="V",
+            temperature=25.1,
+            input_voltage=5.0,
+            load_current=0.1,
+        ),
+    ]
+
+    repository.save_measurements(run_id, measurements)
+
+    # Verify measurements were saved
+    df = repository.get_measurements_dataframe(run_id)
+    assert df is not None
+    assert len(df) == 2
+    assert list(df["parameter"]) == ["voltage", "voltage"]
+    assert list(df["value"]) == [3.3, 3.31]
+
+
+def test_save_measurements_append(repository):
+    """Test appending measurements to existing Parquet file."""
+    run_id = repository.create_run("Test", config={})
+
+    # Save first batch
+    measurements1 = [
+        Measurement(
+            timestamp=1234567890.0,
+            parameter="voltage",
+            value=3.3,
+            unit="V",
+        )
+    ]
+    repository.save_measurements(run_id, measurements1)
+
+    # Save second batch
+    measurements2 = [
+        Measurement(
+            timestamp=1234567891.0,
+            parameter="voltage",
+            value=3.31,
+            unit="V",
+        )
+    ]
+    repository.save_measurements(run_id, measurements2)
+
+    # Verify both batches are present
+    df = repository.get_measurements_dataframe(run_id)
+    assert df is not None
+    assert len(df) == 2
+
+
+def test_get_measurements_nonexistent(repository):
+    """Test getting measurements for non-existent run."""
+    fake_id = uuid4()
+    df = repository.get_measurements_dataframe(fake_id)
+    assert df is None
+
+
+def test_save_empty_measurements(repository):
+    """Test saving empty measurement list."""
+    run_id = repository.create_run("Test", config={})
+    repository.save_measurements(run_id, [])
+
+    df = repository.get_measurements_dataframe(run_id)
+    assert df is None
+
+
+def test_get_nonexistent_run(repository):
+    """Test getting a non-existent run raises error."""
+    fake_id = uuid4()
+    with pytest.raises(ValueError, match="not found"):
+        repository.get_run(fake_id)
+
+
+def test_multiple_results(repository):
+    """Test saving and retrieving multiple results."""
+    run_id = repository.create_run("Test", config={})
+
+    repository.save_result(run_id, "voltage", 3.3, "V")
+    repository.save_result(run_id, "current", 50.0, "uA")
+    repository.save_result(run_id, "temperature", 25.0, "°C")
+
+    results = repository.get_results(run_id)
+    assert len(results) == 3
+
+    parameters = {r.parameter for r in results}
+    assert parameters == {"voltage", "current", "temperature"}
+
+
+def test_custom_measurements_dir(temp_db):
+    """Test using a custom measurements directory."""
+    import gc
+    with tempfile.TemporaryDirectory() as tmpdir:
+        measurements_dir = Path(tmpdir) / "custom_measurements"
+        repo = SQLiteRepository(temp_db, measurements_dir=measurements_dir)
+
+        run_id = repo.create_run("Test", config={})
+        measurements = [
+            Measurement(
+                timestamp=1234567890.0,
+                parameter="voltage",
+                value=3.3,
+                unit="V",
+            )
+        ]
+        repo.save_measurements(run_id, measurements)
+
+        # Verify file is in custom directory
+        expected_path = measurements_dir / f"run_{run_id}" / "measurements.parquet"
+        assert expected_path.exists()
+
+        # Clean up repository before temp directory cleanup
+        del repo
+        gc.collect()
+
+
+def test_parquet_schema(repository):
+    """Test that Parquet file has correct schema."""
+    run_id = repository.create_run("Test", config={})
+
+    measurements = [
+        Measurement(
+            timestamp=1234567890.123,
+            parameter="voltage",
+            value=3.3,
+            unit="V",
+            temperature=25.5,
+            input_voltage=5.0,
+            load_current=0.1,
+        )
+    ]
+    repository.save_measurements(run_id, measurements)
+
+    df = repository.get_measurements_dataframe(run_id)
+    assert df is not None
+
+    # Check columns
+    expected_columns = {
+        "timestamp",
+        "parameter",
+        "value",
+        "unit",
+        "temperature",
+        "input_voltage",
+        "load_current",
+    }
+    assert set(df.columns) == expected_columns
+
+    # Check data types (approximately)
+    assert pd.api.types.is_float_dtype(df["timestamp"])
+    assert pd.api.types.is_string_dtype(df["parameter"]) or pd.api.types.is_object_dtype(
+        df["parameter"]
+    )
+    assert pd.api.types.is_float_dtype(df["value"])

tests/unit/test_transport.py

@@ -0,0 +1,263 @@
+"""Unit tests for transport layer."""
+
+import socket
+from unittest.mock import MagicMock, Mock, patch
+
+import pytest
+
+from py_dvt_ate.instruments.transport.tcp import TCPTransport
+
+
+class TestTCPTransport:
+    """Tests for TCPTransport class."""
+
+    @pytest.fixture
+    def transport(self) -> TCPTransport:
+        """Create transport instance for tests."""
+        return TCPTransport("localhost", 5025, timeout=1.0)
+
+    def test_creation(self, transport: TCPTransport) -> None:
+        """Test TCPTransport can be created with valid parameters."""
+        assert transport.host == "localhost"
+        assert transport.port == 5025
+        assert not transport.is_connected
+
+    def test_repr(self, transport: TCPTransport) -> None:
+        """Test string representation."""
+        assert "localhost:5025" in repr(transport)
+        assert "disconnected" in repr(transport)
+
+    @patch("socket.socket")
+    def test_connect_success(
+        self, mock_socket_class: Mock, transport: TCPTransport
+    ) -> None:
+        """Test successful connection."""
+        mock_sock = MagicMock()
+        mock_socket_class.return_value = mock_sock
+
+        transport.connect()
+
+        assert transport.is_connected
+        mock_socket_class.assert_called_once_with(
+            socket.AF_INET, socket.SOCK_STREAM
+        )
+        mock_sock.settimeout.assert_called_once_with(1.0)
+        mock_sock.connect.assert_called_once_with(("localhost", 5025))
+
+    @patch("socket.socket")
+    def test_connect_already_connected(
+        self, mock_socket_class: Mock, transport: TCPTransport
+    ) -> None:
+        """Test connecting when already connected raises error."""
+        mock_sock = MagicMock()
+        mock_socket_class.return_value = mock_sock
+
+        transport.connect()
+
+        with pytest.raises(ConnectionError, match="Already connected"):
+            transport.connect()
+
+    @patch("socket.socket")
+    def test_connect_failure(
+        self, mock_socket_class: Mock, transport: TCPTransport
+    ) -> None:
+        """Test connection failure raises ConnectionError."""
+        mock_sock = MagicMock()
+        mock_socket_class.return_value = mock_sock
+        mock_sock.connect.side_effect = OSError("Connection refused")
+
+        with pytest.raises(ConnectionError, match="Failed to connect"):
+            transport.connect()
+
+        assert not transport.is_connected
+
+    @patch("socket.socket")
+    def test_disconnect(
+        self, mock_socket_class: Mock, transport: TCPTransport
+    ) -> None:
+        """Test disconnect closes socket."""
+        mock_sock = MagicMock()
+        mock_socket_class.return_value = mock_sock
+
+        transport.connect()
+        transport.disconnect()
+
+        mock_sock.close.assert_called_once()
+        assert not transport.is_connected
+
+    def test_disconnect_when_not_connected(self, transport: TCPTransport) -> None:
+        """Test disconnect is idempotent."""
+        transport.disconnect()  # Should not raise
+        assert not transport.is_connected
+
+    @patch("socket.socket")
+    def test_write(self, mock_socket_class: Mock, transport: TCPTransport) -> None:
+        """Test write sends command with newline."""
+        mock_sock = MagicMock()
+        mock_socket_class.return_value = mock_sock
+
+        transport.connect()
+        transport.write("*IDN?")
+
+        mock_sock.sendall.assert_called_once_with(b"*IDN?\n")
+
+    def test_write_not_connected(self, transport: TCPTransport) -> None:
+        """Test write when not connected raises error."""
+        with pytest.raises(ConnectionError, match="Not connected"):
+            transport.write("*IDN?")
+
+    @patch("socket.socket")
+    def test_write_failure(
+        self, mock_socket_class: Mock, transport: TCPTransport
+    ) -> None:
+        """Test write failure raises IOError."""
+        mock_sock = MagicMock()
+        mock_socket_class.return_value = mock_sock
+        mock_sock.sendall.side_effect = OSError("Write failed")
+
+        transport.connect()
+
+        with pytest.raises(OSError, match="Write failed"):
+            transport.write("*IDN?")
+
+    @patch("socket.socket")
+    def test_read(self, mock_socket_class: Mock, transport: TCPTransport) -> None:
+        """Test read receives response until newline."""
+        mock_sock = MagicMock()
+        mock_socket_class.return_value = mock_sock
+
+        # Simulate receiving "OK\n" byte by byte
+        mock_sock.recv.side_effect = [b"O", b"K", b"\n"]
+
+        transport.connect()
+        response = transport.read()
+
+        assert response == "OK"
+
+    @patch("socket.socket")
+    def test_read_with_timeout(
+        self, mock_socket_class: Mock, transport: TCPTransport
+    ) -> None:
+        """Test read with custom timeout."""
+        mock_sock = MagicMock()
+        mock_socket_class.return_value = mock_sock
+        mock_sock.gettimeout.return_value = 1.0
+
+        # Simulate receiving "OK\n"
+        mock_sock.recv.side_effect = [b"O", b"K", b"\n"]
+
+        transport.connect()
+        response = transport.read(timeout=2.0)
+
+        assert response == "OK"
+        # Verify timeout was changed and restored
+        assert mock_sock.settimeout.call_count == 3  # connect + custom + restore
+        mock_sock.settimeout.assert_any_call(2.0)
+        mock_sock.settimeout.assert_any_call(1.0)
+
+    def test_read_not_connected(self, transport: TCPTransport) -> None:
+        """Test read when not connected raises error."""
+        with pytest.raises(ConnectionError, match="Not connected"):
+            transport.read()
+
+    @patch("socket.socket")
+    def test_read_timeout(
+        self, mock_socket_class: Mock, transport: TCPTransport
+    ) -> None:
+        """Test read timeout raises TimeoutError."""
+        mock_sock = MagicMock()
+        mock_socket_class.return_value = mock_sock
+        mock_sock.recv.side_effect = TimeoutError("Timed out")
+
+        transport.connect()
+
+        with pytest.raises(TimeoutError, match="Read timeout"):
+            transport.read()
+
+    @patch("socket.socket")
+    def test_read_connection_closed(
+        self, mock_socket_class: Mock, transport: TCPTransport
+    ) -> None:
+        """Test read when connection closed raises error."""
+        mock_sock = MagicMock()
+        mock_socket_class.return_value = mock_sock
+        mock_sock.recv.return_value = b""  # Empty means connection closed
+
+        transport.connect()
+
+        with pytest.raises(ConnectionError, match="Connection closed"):
+            transport.read()
+
+    @patch("socket.socket")
+    def test_query(self, mock_socket_class: Mock, transport: TCPTransport) -> None:
+        """Test query combines write and read."""
+        mock_sock = MagicMock()
+        mock_socket_class.return_value = mock_sock
+
+        # Simulate receiving "Test Device\n"
+        mock_sock.recv.side_effect = [
+            b"T",
+            b"e",
+            b"s",
+            b"t",
+            b" ",
+            b"D",
+            b"e",
+            b"v",
+            b"i",
+            b"c",
+            b"e",
+            b"\n",
+        ]
+
+        transport.connect()
+        response = transport.query("*IDN?")
+
+        assert response == "Test Device"
+        mock_sock.sendall.assert_called_once_with(b"*IDN?\n")
+
+    @patch("socket.socket")
+    def test_query_with_timeout(
+        self, mock_socket_class: Mock, transport: TCPTransport
+    ) -> None:
+        """Test query with custom timeout."""
+        mock_sock = MagicMock()
+        mock_socket_class.return_value = mock_sock
+        mock_sock.gettimeout.return_value = 1.0
+
+        mock_sock.recv.side_effect = [b"O", b"K", b"\n"]
+
+        transport.connect()
+        response = transport.query("*IDN?", timeout=3.0)
+
+        assert response == "OK"
+        mock_sock.settimeout.assert_any_call(3.0)
+
+    @patch("socket.socket")
+    def test_context_manager(
+        self, mock_socket_class: Mock, transport: TCPTransport
+    ) -> None:
+        """Test context manager connects and disconnects."""
+        mock_sock = MagicMock()
+        mock_socket_class.return_value = mock_sock
+
+        with transport:
+            assert transport.is_connected
+
+        mock_sock.close.assert_called_once()
+        assert not transport.is_connected
+
+    @patch("socket.socket")
+    def test_context_manager_with_exception(
+        self, mock_socket_class: Mock, transport: TCPTransport
+    ) -> None:
+        """Test context manager disconnects even on exception."""
+        mock_sock = MagicMock()
+        mock_socket_class.return_value = mock_sock
+
+        with pytest.raises(ValueError):
+            with transport:
+                raise ValueError("Test error")
+
+        mock_sock.close.assert_called_once()
+        assert not transport.is_connected