rustest 0.1.0__cp312-cp312-macosx_11_0_arm64.whl → 0.3.0__cp312-cp312-macosx_11_0_arm64.whl

rustest/__init__.py

@@ -2,23 +2,27 @@
 
 from __future__ import annotations
 
-from . import _decorators
-from ._cli import main
-from ._reporting import RunReport, TestResult
+from . import decorators
+from .approx import approx
+from .cli import main
+from .reporting import RunReport, TestResult
 from .core import run
 
-fixture = _decorators.fixture
-mark = _decorators.mark
-parametrize = _decorators.parametrize
-skip = _decorators.skip
+fixture = decorators.fixture
+mark = decorators.mark
+parametrize = decorators.parametrize
+raises = decorators.raises
+skip = decorators.skip
 
 __all__ = [
     "RunReport",
     "TestResult",
+    "approx",
     "fixture",
     "main",
     "mark",
     "parametrize",
+    "raises",
     "run",
     "skip",
 ]

rustest/__main__.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import sys
 
-from ._cli import main
+from .cli import main
 
 if __name__ == "__main__":
     sys.exit(main())

rustest/approx.py

@@ -0,0 +1,160 @@
+"""Approximate comparison for floating-point numbers.
+
+This module provides the `approx` class for comparing floating-point numbers
+with a tolerance, similar to pytest.approx.
+"""
+
+from typing import Any, Mapping, Sequence, Union
+
+# Type alias for values that can be approximated
+ApproxValue = Union[float, int, complex, Sequence[Any], Mapping[str, Any]]
+
+
+class approx:
+    """Assert that two numbers (or collections of numbers) are equal to each other
+    within some tolerance.
+
+    This is similar to pytest.approx and is useful for comparing floating-point
+    numbers that may have small rounding errors.
+
+    Usage:
+        assert 0.1 + 0.2 == approx(0.3)
+        assert 0.1 + 0.2 == approx(0.3, rel=1e-6)
+        assert 0.1 + 0.2 == approx(0.3, abs=1e-9)
+        assert [0.1 + 0.2, 0.3] == approx([0.3, 0.3])
+        assert {"a": 0.1 + 0.2} == approx({"a": 0.3})
+
+    Args:
+        expected: The expected value to compare against
+        rel: The relative tolerance (default: 1e-6)
+        abs: The absolute tolerance (default: 1e-12)
+
+    By default, numbers are considered close if the difference between them is
+    less than or equal to:
+        abs(expected * rel) + abs_tolerance
+    """
+
+    def __init__(
+        self,
+        expected: ApproxValue,
+        rel: float = 1e-6,
+        abs: float = 1e-12,
+    ) -> None:
+        """Initialize approx with expected value and tolerances.
+
+        Args:
+            expected: The expected value to compare against
+            rel: The relative tolerance (default: 1e-6)
+            abs: The absolute tolerance (default: 1e-12)
+        """
+        super().__init__()
+        self.expected = expected
+        self.rel = rel
+        self.abs = abs
+
+    def __repr__(self) -> str:
+        """Return a string representation of the approx object."""
+        return f"approx({self.expected!r}, rel={self.rel}, abs={self.abs})"
+
+    def __eq__(self, actual: Any) -> bool:
+        """Compare actual value with expected value within tolerance.
+
+        Args:
+            actual: The actual value to compare
+
+        Returns:
+            True if the values are approximately equal, False otherwise
+        """
+        return self._approx_compare(actual, self.expected)
+
+    def _approx_compare(self, actual: Any, expected: Any) -> bool:
+        """Recursively compare actual and expected values.
+
+        Args:
+            actual: The actual value
+            expected: The expected value
+
+        Returns:
+            True if values are approximately equal, False otherwise
+        """
+        # Handle None
+        if actual is None or expected is None:
+            return actual == expected
+
+        # Handle dictionaries
+        if isinstance(expected, dict):
+            if not isinstance(actual, dict):
+                return False
+            if set(actual.keys()) != set(expected.keys()):
+                return False
+            return all(self._approx_compare(actual[k], expected[k]) for k in expected.keys())
+
+        # Handle sequences (lists, tuples, etc.) but not strings
+        if isinstance(expected, (list, tuple)) and not isinstance(expected, str):
+            # Check that actual is the same type (list vs tuple matters)
+            if type(actual) is not type(expected):
+                return False
+            if len(actual) != len(expected):
+                return False
+            return all(self._approx_compare(a, e) for a, e in zip(actual, expected))
+
+        # Handle numbers (float, int, complex)
+        if isinstance(expected, (float, int, complex)) and isinstance(
+            actual, (float, int, complex)
+        ):
+            return self._is_close(actual, expected)
+
+        # For other types, use exact equality
+        return actual == expected
+
+    def _is_close(
+        self, actual: Union[float, int, complex], expected: Union[float, int, complex]
+    ) -> bool:
+        """Check if two numbers are close within tolerance.
+
+        Uses the formula: |actual - expected| <= max(rel * max(|actual|, |expected|), abs)
+
+        Args:
+            actual: The actual number
+            expected: The expected number
+
+        Returns:
+            True if numbers are close, False otherwise
+        """
+        # Handle infinities and NaN
+        if isinstance(actual, complex) or isinstance(expected, complex):
+            # For complex numbers, compare real and imaginary parts separately
+            if isinstance(actual, complex) and isinstance(expected, complex):
+                return self._is_close(actual.real, expected.real) and self._is_close(
+                    actual.imag, expected.imag
+                )
+            # One is complex, the other is not
+            if isinstance(actual, complex):
+                return self._is_close(actual.real, expected) and abs(actual.imag) <= self.abs
+            else:  # expected is complex
+                return self._is_close(actual, expected.real) and abs(expected.imag) <= self.abs
+
+        # Convert to float for comparison
+        actual_float = float(actual)
+        expected_float = float(expected)
+
+        # Handle special float values
+        if actual_float == expected_float:
+            # This handles infinities and zeros
+            return True
+
+        # Check for NaN - NaN should never be equal to anything
+        import math
+
+        if math.isnan(actual_float) or math.isnan(expected_float):
+            return False
+
+        # Check for infinities
+        if math.isinf(actual_float) or math.isinf(expected_float):
+            return actual_float == expected_float
+
+        # Calculate tolerance
+        abs_diff = abs(actual_float - expected_float)
+        tolerance = max(self.rel * max(abs(actual_float), abs(expected_float)), self.abs)
+
+        return abs_diff <= tolerance

rustest/{_cli.py → cli.py}

@@ -5,7 +5,7 @@ from __future__ import annotations
 import argparse
 from collections.abc import Sequence
 
-from ._reporting import RunReport, TestResult
+from .reporting import RunReport, TestResult
 from .core import run
 
 

rustest/core.py

@@ -4,8 +4,8 @@ from __future__ import annotations
 
 from collections.abc import Sequence
 
-from . import _rust
-from ._reporting import RunReport
+from . import rust
+from .reporting import RunReport
 
 
 def run(
@@ -17,5 +17,5 @@ def run(
 ) -> RunReport:
     """Execute tests and return a rich report."""
 
-    raw_report = _rust.run(list(paths), pattern, workers, capture_output)
+    raw_report = rust.run(list(paths), pattern, workers, capture_output)
     return RunReport.from_py(raw_report)

rustest/{_decorators.py → decorators.py}

@@ -192,3 +192,159 @@ class MarkGenerator:
 
 # Create a singleton instance
 mark = MarkGenerator()
+
+
+class ExceptionInfo:
+    """Information about an exception caught by raises().
+
+    Attributes:
+        type: The exception type
+        value: The exception instance
+        traceback: The exception traceback
+    """
+
+    def __init__(
+        self, exc_type: type[BaseException], exc_value: BaseException, exc_tb: Any
+    ) -> None:
+        super().__init__()
+        self.type = exc_type
+        self.value = exc_value
+        self.traceback = exc_tb
+
+    def __repr__(self) -> str:
+        return f"<ExceptionInfo {self.type.__name__}({self.value!r})>"
+
+
+class RaisesContext:
+    """Context manager for asserting that code raises a specific exception.
+
+    This mimics pytest.raises() behavior, supporting:
+    - Single or tuple of exception types
+    - Optional regex matching of exception messages
+    - Access to caught exception information
+
+    Usage:
+        with raises(ValueError):
+            int("not a number")
+
+        with raises(ValueError, match="invalid literal"):
+            int("not a number")
+
+        with raises((ValueError, TypeError)):
+            some_function()
+
+        # Access the caught exception
+        with raises(ValueError) as exc_info:
+            raise ValueError("oops")
+        assert "oops" in str(exc_info.value)
+    """
+
+    def __init__(
+        self,
+        exc_type: type[BaseException] | tuple[type[BaseException], ...],
+        *,
+        match: str | None = None,
+    ) -> None:
+        super().__init__()
+        self.exc_type = exc_type
+        self.match_pattern = match
+        self.excinfo: ExceptionInfo | None = None
+
+    def __enter__(self) -> RaisesContext:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: Any,
+    ) -> bool:
+        # No exception was raised
+        if exc_type is None:
+            exc_name = self._format_exc_name()
+            msg = f"DID NOT RAISE {exc_name}"
+            raise AssertionError(msg)
+
+        # At this point, we know an exception was raised, so exc_val cannot be None
+        assert exc_val is not None, "exc_val must not be None when exc_type is not None"
+
+        # Check if the exception type matches
+        if not issubclass(exc_type, self.exc_type):
+            # Unexpected exception type - let it propagate
+            return False
+
+        # Store the exception information
+        self.excinfo = ExceptionInfo(exc_type, exc_val, exc_tb)
+
+        # Check if the message matches the pattern (if provided)
+        if self.match_pattern is not None:
+            import re
+
+            exc_message = str(exc_val)
+            if not re.search(self.match_pattern, exc_message):
+                msg = (
+                    f"Pattern {self.match_pattern!r} does not match "
+                    f"{exc_message!r}. Exception: {exc_type.__name__}: {exc_message}"
+                )
+                raise AssertionError(msg)
+
+        # Suppress the exception (it was expected)
+        return True
+
+    def _format_exc_name(self) -> str:
+        """Format the expected exception name(s) for error messages."""
+        if isinstance(self.exc_type, tuple):
+            names = " or ".join(exc.__name__ for exc in self.exc_type)
+            return names
+        return self.exc_type.__name__
+
+    @property
+    def value(self) -> BaseException:
+        """Access the caught exception value."""
+        if self.excinfo is None:
+            msg = "No exception was caught"
+            raise AttributeError(msg)
+        return self.excinfo.value
+
+    @property
+    def type(self) -> type[BaseException]:
+        """Access the caught exception type."""
+        if self.excinfo is None:
+            msg = "No exception was caught"
+            raise AttributeError(msg)
+        return self.excinfo.type
+
+
+def raises(
+    exc_type: type[BaseException] | tuple[type[BaseException], ...],
+    *,
+    match: str | None = None,
+) -> RaisesContext:
+    """Assert that code raises a specific exception.
+
+    Args:
+        exc_type: The expected exception type(s). Can be a single type or tuple of types.
+        match: Optional regex pattern to match against the exception message.
+
+    Returns:
+        A context manager that catches and validates the exception.
+
+    Raises:
+        AssertionError: If no exception is raised, or if the message doesn't match.
+
+    Usage:
+        with raises(ValueError):
+            int("not a number")
+
+        with raises(ValueError, match="invalid literal"):
+            int("not a number")
+
+        with raises((ValueError, TypeError)):
+            some_function()
+
+        # Access the caught exception
+        with raises(ValueError) as exc_info:
+            raise ValueError("oops")
+        assert "oops" in str(exc_info.value)
+    """
+    return RaisesContext(exc_type, match=match)

rustest/{_reporting.py → reporting.py}

@@ -5,7 +5,7 @@ from __future__ import annotations
 from collections.abc import Iterable
 from dataclasses import dataclass
 
-from . import _rust
+from . import rust
 
 
 @dataclass(slots=True)
@@ -23,7 +23,7 @@ class TestResult:
     stderr: str | None
 
     @classmethod
-    def from_py(cls, result: _rust.PyTestResult) -> "TestResult":
+    def from_py(cls, result: rust.PyTestResult) -> "TestResult":
         return cls(
             name=result.name,
             path=result.path,
@@ -47,7 +47,7 @@ class RunReport:
     results: tuple[TestResult, ...]
 
     @classmethod
-    def from_py(cls, report: _rust.PyRunReport) -> "RunReport":
+    def from_py(cls, report: rust.PyRunReport) -> "RunReport":
         return cls(
             total=report.total,
             passed=report.passed,

rustest/{_rust.py → rust.py}

@@ -19,5 +19,5 @@ def run(
     """Placeholder implementation that mirrors the extension signature."""
 
     raise NotImplementedError(
-        "The rustest native extension is unavailable. Tests must patch rustest._rust.run."
+        "The rustest native extension is unavailable. Tests must patch rustest.rust.run."
     )

rustest/{_rust.pyi → rust.pyi}

@@ -1,11 +1,11 @@
-"""Type stubs for the Rust extension module."""
+"""Type stubs for the rustest Rust extension module."""
 
 from __future__ import annotations
 
-from collections.abc import Sequence
+from typing import Sequence
 
 class PyTestResult:
-    """Test result from Rust layer."""
+    """Individual test result from the Rust extension."""
 
     name: str
     path: str
@@ -16,20 +16,20 @@ class PyTestResult:
     stderr: str | None
 
 class PyRunReport:
-    """Run report from Rust layer."""
+    """Test run report from the Rust extension."""
 
     total: int
     passed: int
     failed: int
     skipped: int
     duration: float
-    results: Sequence[PyTestResult]
+    results: list[PyTestResult]
 
 def run(
-    paths: list[str],
+    paths: Sequence[str],
     pattern: str | None,
     workers: int | None,
     capture_output: bool,
 ) -> PyRunReport:
-    """Run tests and return a report."""
+    """Execute tests and return a report."""
     ...

{rustest-0.1.0.dist-info → rustest-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rustest
-Version: 0.1.0
+Version: 0.3.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -12,7 +12,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Rust
 Classifier: Topic :: Software Development :: Testing
-Requires-Dist: typing-extensions>=4.8
+Requires-Dist: typing-extensions>=4.15
 Requires-Dist: basedpyright>=1.19 ; extra == 'dev'
 Requires-Dist: maturin>=1.4,<2 ; extra == 'dev'
 Requires-Dist: poethepoet>=0.22 ; extra == 'dev'
@@ -30,40 +30,55 @@ Project-URL: Repository, https://github.com/Apex-Engineers-Inc/rustest
 
 # rustest
 
-Rustest (pronounced like Russ-Test) is a Rust-powered test runner that aims to provide the most common pytest ergonomics with a focus on raw performance. Get **78x faster** test execution with familiar syntax and minimal setup.
+Rustest (pronounced like Russ-Test) is a Rust-powered test runner that aims to provide the most common pytest ergonomics with a focus on raw performance. Get **~2x faster** test execution with familiar syntax and minimal setup.
 
 ## Why rustest?
 
-- 🚀 **78x faster** than pytest (measured on real-world integration tests)
+- 🚀 **About 2x faster** than pytest on the rustest integration test suite
 - ✅ Familiar `@fixture`, `@parametrize`, `@skip`, and `@mark` decorators
 - 🔍 Automatic test discovery (`test_*.py` and `*_test.py` files)
 - 🎯 Simple, clean API—if you know pytest, you already know rustest
+- 🧮 Built-in `approx()` helper for tolerant numeric comparisons across scalars, collections, and complex numbers
+- 🪤 `raises()` context manager for precise exception assertions with optional message matching
 - 📦 Easy installation with pip or uv
-- ⚡ Sub-10ms execution for small test suites—tests feel instant
+- ⚡ Low-overhead execution keeps small suites feeling instant
 
 ## Performance
 
-Rustest is designed for speed. Our benchmarks show **78x faster** execution compared to pytest on the rustest integration test suite (~199 tests):
+Rustest is designed for speed. Our latest benchmarks on the rustest integration suite (~200 tests) show a consistent **2.1x wall-clock speedup** over pytest:
 
-| Test Runner | Time | Tests/Second | Speedup |
-|-------------|------|--------------|---------|
-| pytest      | 0.39s | 502 | 1.0x (baseline) |
-| rustest     | 0.005s | 39,800 | **78x faster** |
+| Test Runner | Reported Runtime† | Wall Clock‡ | Speedup (wall) | Command |
+|-------------|------------------|-------------|----------------|---------|
+| pytest      | 0.43–0.59s       | 1.33–1.59s  | 1.0x (baseline) | `pytest tests/ examples/tests/ -q`
+| rustest     | 0.003s           | 0.69–0.70s  | **~2.1x faster** | `python -m rustest tests/ examples/tests/`§
 
-**Actual CI measurements:**
-- **pytest**: 196 passed, 5 skipped in 0.39s
-- **rustest**: 194 passed, 5 skipped in 0.005s
+### Large parametrized stress test
 
-**Why so fast?**
-- **Near-zero startup time**: Native Rust binary vs Python interpreter startup
-- **Rust-native test discovery**: Minimal imports until test execution
-- **Optimized fixture resolution**: Efficient dependency graph in Rust
-- **Efficient orchestration**: ~50-100μs per-test overhead vs ~1-2ms in pytest
+We also profiled an extreme case with **10,000 parametrized invocations** to ensure rustest scales on synthetic but heavy workloads. The test lives in [`benchmarks/test_large_parametrize.py`](benchmarks/test_large_parametrize.py) and simply asserts `value + value == 2 * value` across every case. Running the module on its own shows a dramatic gap:
+
+| Test Runner | Avg. Wall Clock (3 runs) | Speedup | Command |
+|-------------|--------------------------|---------|---------|
+| pytest      | 9.72s                    | 1.0x    | `pytest benchmarks/test_large_parametrize.py -q`§
+| rustest     | 0.41s                    | **~24x** | `python -m rustest benchmarks/test_large_parametrize.py`§
+
+† pytest and rustest both report only active test execution time; rustest's figure omits Python interpreter start-up overhead.
+
+‡ Integration-suite wall-clock timing measured with the shell `time` builtin across two consecutive runs in the same environment.
+
+§ Commands executed with `PYTHONPATH=python` in this repository checkout to exercise the local sources. Pytest relies on a small compatibility shim in [`benchmarks/conftest.py`](benchmarks/conftest.py) so it understands the rustest-style decorators. Large-parametrization timings come from averaging three `time.perf_counter()` measurements with output suppressed via `subprocess.DEVNULL`.
+
+Rustest counts parametrized cases slightly differently than pytest, so you will see 199 executed cases vs. pytest's 201 discoveries on the same suite—the reported pass/skip counts still align.
+
+**Why is rustest faster?**
+- **Near-zero startup time**: Native Rust binary minimizes overhead before Python code starts running.
+- **Rust-native test discovery**: Minimal imports until test execution keeps collection quick.
+- **Optimized fixture resolution**: Efficient dependency graph resolution reduces per-test work.
+- **Lean orchestration**: Rust handles scheduling and reporting so the Python interpreter focuses on running test bodies.
 
 **Real-world impact:**
-- **200 tests**: 0.39s → 0.005s (instant feedback)
-- **1,000 tests**: ~2s → ~0.025s (tests complete before you can switch tabs)
-- **10,000 tests**: ~20s → ~0.25s (dramatically faster feedback loops)
+- **200 tests** (this repository): 1.46s → 0.70s (average wall-clock, ~0.76s saved per run)
+- **1,000 tests** (projected): ~7.3s → ~3.4s assuming similar scaling
+- **10,000 tests** (projected): ~73s → ~34s—minutes saved across CI runs
 
 See [BENCHMARKS.md](BENCHMARKS.md) for detailed performance analysis and methodology.
 
@@ -91,14 +106,14 @@ If you want to contribute to rustest, see [DEVELOPMENT.md](DEVELOPMENT.md) for s
 Create a file `test_math.py`:
 
 ```python
-from rustest import fixture, parametrize, mark
+from rustest import fixture, parametrize, mark, approx, raises
 
 @fixture
 def numbers() -> list[int]:
     return [1, 2, 3, 4, 5]
 
 def test_sum(numbers: list[int]) -> None:
-    assert sum(numbers) == 15
+    assert sum(numbers) == approx(15)
 
 @parametrize("value,expected", [(2, 4), (3, 9), (4, 16)])
 def test_square(value: int, expected: int) -> None:
@@ -109,6 +124,10 @@ def test_expensive_operation() -> None:
     # This test is marked as slow for filtering
     result = sum(range(1000000))
     assert result > 0
+
+def test_division_by_zero_is_reported() -> None:
+    with raises(ZeroDivisionError, match="division by zero"):
+        1 / 0
 ```
 
 ### 2. Run Your Tests
@@ -229,6 +248,21 @@ def test_api_configuration(api_client: dict) -> None:
     assert api_client["timeout"] == 30
 ```
 
+#### Assertion Helpers
+
+Rustest ships helpers for expressive assertions:
+
+```python
+from rustest import approx, raises
+
+def test_nearly_equal() -> None:
+    assert 0.1 + 0.2 == approx(0.3, rel=1e-9)
+
+def test_raises_with_message() -> None:
+    with raises(ValueError, match="invalid configuration"):
+        raise ValueError("invalid configuration")
+```
+
 #### Yield Fixtures with Setup/Teardown
 
 Fixtures can use `yield` to perform cleanup after tests:
@@ -407,6 +441,142 @@ def test_full_workflow() -> None:
     pass
 ```
 
+#### Test Classes
+
+Rustest supports pytest-style test classes, allowing you to organize related tests together:
+
+```python
+from rustest import fixture, parametrize, mark
+
+class TestBasicMath:
+    """Group related tests in a class."""
+
+    def test_addition(self):
+        assert 1 + 1 == 2
+
+    def test_subtraction(self):
+        assert 5 - 3 == 2
+
+    def test_multiplication(self):
+        assert 3 * 4 == 12
+```
+
+**Using Fixtures in Test Classes:**
+
+Test methods can inject fixtures just like standalone test functions:
+
+```python
+from rustest import fixture
+
+@fixture
+def calculator():
+    return {"add": lambda x, y: x + y, "multiply": lambda x, y: x * y}
+
+class TestCalculator:
+    """Test class using fixtures."""
+
+    def test_addition(self, calculator):
+        assert calculator["add"](2, 3) == 5
+
+    def test_multiplication(self, calculator):
+        assert calculator["multiply"](4, 5) == 20
+```
+
+**Class-Scoped Fixtures:**
+
+Class-scoped fixtures are shared across all test methods in the same class, perfect for expensive setup operations:
+
+```python
+from rustest import fixture
+
+@fixture(scope="class")
+def database():
+    """Expensive setup shared across all tests in a class."""
+    db = {"connection": "db://test", "data": []}
+    return db
+
+class TestDatabase:
+    """All tests share the same database fixture instance."""
+
+    def test_connection(self, database):
+        assert database["connection"] == "db://test"
+
+    def test_add_data(self, database):
+        database["data"].append("item1")
+        assert len(database["data"]) >= 1
+
+    def test_data_persists(self, database):
+        # Same database instance, so previous test's data is still there
+        assert len(database["data"]) >= 1
+```
+
+**Fixture Methods Within Test Classes:**
+
+You can define fixtures as methods inside test classes, providing class-specific setup:
+
+```python
+from rustest import fixture
+
+class TestWithFixtureMethod:
+    """Test class with its own fixture methods."""
+
+    @fixture(scope="class")
+    def class_resource(self):
+        """Fixture method shared across tests in this class."""
+        resource = {"value": 42, "name": "test_resource"}
+        yield resource
+        # Teardown happens after all tests in class
+        resource["closed"] = True
+
+    @fixture
+    def per_test_data(self, class_resource):
+        """Fixture method that depends on another fixture."""
+        return {"id": id(self), "resource": class_resource}
+
+    def test_uses_class_resource(self, class_resource):
+        assert class_resource["value"] == 42
+
+    def test_uses_per_test_data(self, per_test_data):
+        assert "resource" in per_test_data
+        assert per_test_data["resource"]["value"] == 42
+```
+
+**Class Variables and Instance Variables:**
+
+Test classes can use class variables for shared state and instance variables for per-test isolation:
+
+```python
+class TestWithVariables:
+    """Test class with class and instance variables."""
+
+    class_variable = "shared_data"  # Shared across all tests
+
+    def test_class_variable(self):
+        # Access class variable
+        assert self.class_variable == "shared_data"
+        assert TestWithVariables.class_variable == "shared_data"
+
+    def test_instance_variable(self):
+        # Each test gets a fresh instance
+        self.instance_var = "test_specific"
+        assert self.instance_var == "test_specific"
+```
+
+**Parametrized Test Methods:**
+
+Use `@parametrize` on class methods just like regular test functions:
+
+```python
+from rustest import parametrize
+
+class TestParametrized:
+    """Test class with parametrized methods."""
+
+    @parametrize("value,expected", [(2, 4), (3, 9), (4, 16)])
+    def test_square(self, value, expected):
+        assert value ** 2 == expected
+```
+
 ### Test Output
 
 When you run rustest, you'll see clean, informative output:
@@ -436,13 +606,14 @@ Rustest aims to provide the most commonly-used pytest features with dramatically
 | **Core Test Discovery** |
 | `test_*.py` / `*_test.py` files | ✅ | ✅ | Rustest uses Rust for dramatically faster discovery |
 | Test function detection (`test_*`) | ✅ | ✅ | |
-| Test class detection (`Test*`) | ✅ | ✅ | via `unittest.TestCase` support |
+| Test class detection (`Test*`) | ✅ | ✅ | Full pytest-style class support with fixture methods |
 | Pattern-based filtering | ✅ | ✅ | `-k` pattern matching |
 | **Fixtures** |
 | `@fixture` decorator | ✅ | ✅ | Rust-based dependency resolution |
 | Fixture dependency injection | ✅ | ✅ | Much faster in rustest |
 | Fixture scopes (function/class/module/session) | ✅ | ✅ | Full support for all scopes |
 | Yield fixtures (setup/teardown) | ✅ | ✅ | Full support with cleanup |
+| Fixture methods within test classes | ✅ | ✅ | Define fixtures as class methods |
 | Fixture parametrization | ✅ | 🚧 | Planned |
 | **Parametrization** |
 | `@parametrize` decorator | ✅ | ✅ | Full support with custom IDs |

rustest-0.3.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+rustest-0.3.0.dist-info/METADATA,sha256=0A5bldOq84__CL4XWiYg5vnQdoHBiO-OmcVTXrpIcQo,20349
+rustest-0.3.0.dist-info/WHEEL,sha256=nw13728gRokCivwI6SCanennWBgDOflh2lHvovMwAi8,104
+rustest-0.3.0.dist-info/entry_points.txt,sha256=7fUa3LO8vudQ4dKG1sTRaDnxcMdBSZsWs9EyuxFQ7Lk,48
+rustest-0.3.0.dist-info/licenses/LICENSE,sha256=s64ibUGtb6jEDBsYuxUFtMr_c4PaqYP-vj3YY6QtTGw,1075
+rustest/__init__.py,sha256=0CkHfrmIjpGw6DMu2VcZLOUpBVtdwsN-aitn-RzOglo,514
+rustest/__main__.py,sha256=bBvo5gsSluUzlDTDvn5bP_gZZEXMwJQZMqVA5W1M1v8,178
+rustest/approx.py,sha256=MKmuorBBHqpH0h0QaIMVjbm3-mXJ0E90limEgSHHVfw,5744
+rustest/cli.py,sha256=fO6D09b7Se6aqC8EHwA0jCy2tokrgX9fYcNhMni_5Xs,8699
+rustest/core.py,sha256=8gZ1VsFtc3rUwyhwREm74e03E-sB8iNp4sJb2w8hUBk,485
+rustest/decorators.py,sha256=nijzNG8NQXZd8kEfMjhSB-85gLoIjaIMxwZQNUNWgrE,11373
+rustest/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rustest/reporting.py,sha256=3-R8aljv2ZbmjOa9Q9KZeCPsMaitm8nZ96LoJS_NnUQ,1623
+rustest/rust.cpython-312-darwin.so,sha256=yDbdByHqH9DPDzHTxnRO8zLRTtEUXMpwMWQN8uOPSNE,1466544
+rustest/rust.py,sha256=tCIvjYd06VxoT_rKvv2o8CpXW_pFNua5VgcRDjLgU78,659
+rustest/rust.pyi,sha256=lezCHLSIedCPQ1fc6Bd5Vxc34AhI8IOgIFNrNLRxX7Y,706
+rustest-0.3.0.dist-info/RECORD,,

rustest-0.1.0.dist-info/RECORD

@@ -1,14 +0,0 @@
-rustest-0.1.0.dist-info/METADATA,sha256=MxCLrEAs8gtwnesn3cpHVwnD-lzCdw7A03a2aTmxrvI,13963
-rustest-0.1.0.dist-info/WHEEL,sha256=nw13728gRokCivwI6SCanennWBgDOflh2lHvovMwAi8,104
-rustest-0.1.0.dist-info/entry_points.txt,sha256=7fUa3LO8vudQ4dKG1sTRaDnxcMdBSZsWs9EyuxFQ7Lk,48
-rustest-0.1.0.dist-info/licenses/LICENSE,sha256=s64ibUGtb6jEDBsYuxUFtMr_c4PaqYP-vj3YY6QtTGw,1075
-rustest/__init__.py,sha256=K7MyGPARnn97RSjk-E_x_1KjqD49RK4fII_sZ_0rdcc,439
-rustest/__main__.py,sha256=nqdz6DhrDze715SXxtzAYV2sie3CPoy7IvWCdcyHJEM,179
-rustest/_cli.py,sha256=kq9LAwHaJmZ-gnAlTsz7Ov8r1fiDvNoLf4hEI3sxhng,8700
-rustest/_decorators.py,sha256=EFcAmZfThiyj_J5l6fEx7Ix9LroXIBrOwa8QuxltNLI,6561
-rustest/_reporting.py,sha256=6nVcccX1dgEBW72wCOeOIl5I-OE-ukjJD0VQs56pwjo,1626
-rustest/_rust.cpython-312-darwin.so,sha256=8UZE-rrDiDzt935EmW22CWWSjS5dtNQisjKVzAKglVg,1466832
-rustest/_rust.py,sha256=k3nXhGiehOVY_S6w28rIdrc0CEc3gFLgwWVOEMcPOZo,660
-rustest/_rust.pyi,sha256=fDFLX0qj4G_bV1sHmTtRPI26grTDG_LFzPFEqp5vFGk,671
-rustest/core.py,sha256=xmBUpuPs0r0HQthc9J5dCQYkZnXqfxqIfSGkHeoqQS4,488
-rustest-0.1.0.dist-info/RECORD,,