splurge-dsv 2025.1.0__tar.gz → 2025.1.1__tar.gz

{splurge_dsv-2025.1.0/splurge_dsv.egg-info → splurge_dsv-2025.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splurge-dsv
-Version: 2025.1.0
+Version: 2025.1.1
 Summary: A utility library for working with DSV (Delimited String Values) files
 Author: Jim Schilling
 License-Expression: MIT
@@ -243,6 +243,27 @@ The project follows strict coding standards:
 
 ## Changelog
 
+### 2025.1.1 (2025-01-XX)
+
+#### 🔧 Code Quality Improvements
+- **Refactored Complex Regex Logic**: Extracted Windows drive letter validation logic from `_check_dangerous_characters` into a dedicated `_is_valid_windows_drive_pattern` helper method in `PathValidator` for better readability and maintainability
+- **Exception Handling Consistency**: Fixed inconsistency in `ResourceManager.acquire()` method to properly re-raise `NotImplementedError` without wrapping it in `SplurgeResourceAcquisitionError`
+- **Import Organization**: Moved all imports to the top of modules across the entire codebase for better code structure and PEP 8 compliance
+
+#### 🧪 Testing Enhancements
+- **Public API Focus**: Removed all tests that validated private implementation details, focusing exclusively on public API behavior validation
+- **Comprehensive Resource Manager Tests**: Added extensive test suite for `ResourceManager` module covering all public methods, edge cases, error scenarios, and context manager behavior
+- **Bookend Logic Clarification**: Updated and corrected all tests related to `StringTokenizer.remove_bookends` to properly reflect its single-character, symmetric bookend matching behavior
+- **Path Validation Test Clarity**: Clarified test expectations and comments for Windows drive-relative paths (e.g., "C:file.txt") to reflect the validator's intentionally strict security design
+
+#### 🐛 Bug Fixes
+- **Test Reliability**: Fixed failing tests in `ResourceManager` context manager scenarios by properly handling file truncation and line ending normalization
+- **Ruff Compliance**: Resolved all linting warnings including unused variables and imports
+
+#### 📚 Documentation Updates
+- **Method Documentation**: Updated `ResourceManager.acquire()` docstring to include `NotImplementedError` in the Raises section
+- **Test Comments**: Enhanced test documentation with clearer explanations of expected behaviors and edge cases
+
 ### 2025.1.0 (2025-08-25)
 
 #### 🎉 Major Features

{splurge_dsv-2025.1.0 → splurge_dsv-2025.1.1}/README.md

@@ -214,6 +214,27 @@ The project follows strict coding standards:
 
 ## Changelog
 
+### 2025.1.1 (2025-01-XX)
+
+#### 🔧 Code Quality Improvements
+- **Refactored Complex Regex Logic**: Extracted Windows drive letter validation logic from `_check_dangerous_characters` into a dedicated `_is_valid_windows_drive_pattern` helper method in `PathValidator` for better readability and maintainability
+- **Exception Handling Consistency**: Fixed inconsistency in `ResourceManager.acquire()` method to properly re-raise `NotImplementedError` without wrapping it in `SplurgeResourceAcquisitionError`
+- **Import Organization**: Moved all imports to the top of modules across the entire codebase for better code structure and PEP 8 compliance
+
+#### 🧪 Testing Enhancements
+- **Public API Focus**: Removed all tests that validated private implementation details, focusing exclusively on public API behavior validation
+- **Comprehensive Resource Manager Tests**: Added extensive test suite for `ResourceManager` module covering all public methods, edge cases, error scenarios, and context manager behavior
+- **Bookend Logic Clarification**: Updated and corrected all tests related to `StringTokenizer.remove_bookends` to properly reflect its single-character, symmetric bookend matching behavior
+- **Path Validation Test Clarity**: Clarified test expectations and comments for Windows drive-relative paths (e.g., "C:file.txt") to reflect the validator's intentionally strict security design
+
+#### 🐛 Bug Fixes
+- **Test Reliability**: Fixed failing tests in `ResourceManager` context manager scenarios by properly handling file truncation and line ending normalization
+- **Ruff Compliance**: Resolved all linting warnings including unused variables and imports
+
+#### 📚 Documentation Updates
+- **Method Documentation**: Updated `ResourceManager.acquire()` docstring to include `NotImplementedError` in the Raises section
+- **Test Comments**: Enhanced test documentation with clearer explanations of expected behaviors and edge cases
+
 ### 2025.1.0 (2025-08-25)
 
 #### 🎉 Major Features

{splurge_dsv-2025.1.0 → splurge_dsv-2025.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "splurge-dsv"
-version = "2025.1.0"
+version = "2025.1.1"
 description = "A utility library for working with DSV (Delimited String Values) files"
 readme = "README.md"
 requires-python = ">=3.10"

{splurge_dsv-2025.1.0 → splurge_dsv-2025.1.1/splurge_dsv.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splurge-dsv
-Version: 2025.1.0
+Version: 2025.1.1
 Summary: A utility library for working with DSV (Delimited String Values) files
 Author: Jim Schilling
 License-Expression: MIT
@@ -243,6 +243,27 @@ The project follows strict coding standards:
 
 ## Changelog
 
+### 2025.1.1 (2025-01-XX)
+
+#### 🔧 Code Quality Improvements
+- **Refactored Complex Regex Logic**: Extracted Windows drive letter validation logic from `_check_dangerous_characters` into a dedicated `_is_valid_windows_drive_pattern` helper method in `PathValidator` for better readability and maintainability
+- **Exception Handling Consistency**: Fixed inconsistency in `ResourceManager.acquire()` method to properly re-raise `NotImplementedError` without wrapping it in `SplurgeResourceAcquisitionError`
+- **Import Organization**: Moved all imports to the top of modules across the entire codebase for better code structure and PEP 8 compliance
+
+#### 🧪 Testing Enhancements
+- **Public API Focus**: Removed all tests that validated private implementation details, focusing exclusively on public API behavior validation
+- **Comprehensive Resource Manager Tests**: Added extensive test suite for `ResourceManager` module covering all public methods, edge cases, error scenarios, and context manager behavior
+- **Bookend Logic Clarification**: Updated and corrected all tests related to `StringTokenizer.remove_bookends` to properly reflect its single-character, symmetric bookend matching behavior
+- **Path Validation Test Clarity**: Clarified test expectations and comments for Windows drive-relative paths (e.g., "C:file.txt") to reflect the validator's intentionally strict security design
+
+#### 🐛 Bug Fixes
+- **Test Reliability**: Fixed failing tests in `ResourceManager` context manager scenarios by properly handling file truncation and line ending normalization
+- **Ruff Compliance**: Resolved all linting warnings including unused variables and imports
+
+#### 📚 Documentation Updates
+- **Method Documentation**: Updated `ResourceManager.acquire()` docstring to include `NotImplementedError` in the Raises section
+- **Test Comments**: Enhanced test documentation with clearer explanations of expected behaviors and edge cases
+
 ### 2025.1.0 (2025-08-25)
 
 #### 🎉 Major Features

{splurge_dsv-2025.1.0 → splurge_dsv-2025.1.1}/tests/test_dsv_helper.py

@@ -5,6 +5,8 @@ Tests all public methods of the DsvHelper class including
 parsing, file operations, and streaming functionality.
 """
 
+import os
+import platform
 from pathlib import Path
 
 import pytest
@@ -80,6 +82,10 @@ class TestDsvHelperParse:
         """Test parsing with bracket bookends."""
         result = DsvHelper.parse("[a],[b],[c]", delimiter=",", bookend="[")
         assert result == ["[a]", "[b]", "[c]"]
+        
+        # Test with matching bracket bookends
+        result = DsvHelper.parse("[a[,[b[,[c[", delimiter=",", bookend="[")
+        assert result == ["a", "b", "c"]
 
     def test_parse_empty_string(self) -> None:
         """Test parsing empty string."""
@@ -502,7 +508,6 @@ class TestDsvHelperEdgeCases:
     def test_parse_file_with_permission_error(self, tmp_path: Path) -> None:
         """Test parsing file with permission error."""
         # Skip this test on Windows as permission handling differs
-        import platform
         if platform.system() == "Windows":
             pytest.skip("Permission error test not reliable on Windows")
         
@@ -510,7 +515,6 @@ class TestDsvHelperEdgeCases:
         test_file.write_text("a,b,c")
         
         # Make file unreadable
-        import os
         os.chmod(test_file, 0o000)
         
         try:

{splurge_dsv-2025.1.0 → splurge_dsv-2025.1.1}/tests/test_path_validator.py

@@ -6,6 +6,7 @@ path validation, security checks, and filename sanitization.
 """
 
 import os
+import platform
 import tempfile
 from pathlib import Path
 from unittest.mock import patch
@@ -61,7 +62,6 @@ class TestPathValidatorValidatePath:
     def test_validate_relative_path_allowed(self, tmp_path: Path) -> None:
         """Test validating relative path when allowed."""
         # Skip this test on Windows due to temp directory cleanup issues
-        import platform
         if platform.system() == "Windows":
             pytest.skip("Relative path test not reliable on Windows")
         
@@ -180,7 +180,7 @@ class TestPathValidatorValidatePath:
             "file:name.txt",
             ":file.txt",
             "file.txt:",
-            "C:file.txt",  # Missing slash
+            "C:file.txt",  # Drive-relative path is valid on Windows but rejected by this validator
             "file:C.txt"
         ]
         
@@ -190,8 +190,6 @@ class TestPathValidatorValidatePath:
 
     def test_validate_unreadable_file_raises_error(self, tmp_path: Path) -> None:
         """Test that unreadable file raises error."""
-        import platform
-        
         # Skip this test on Windows as chmod(0o000) doesn't make files unreadable
         if platform.system() == "Windows":
             pytest.skip("File permission test not reliable on Windows")
@@ -343,7 +341,7 @@ class TestPathValidatorIsSafePath:
             "file:name.txt",
             ":file.txt",
             "file.txt:",
-            "C:file.txt"
+            "C:file.txt"  # Drive-relative path is valid on Windows but rejected by this validator
         ]
         
         for path in invalid_paths:
@@ -355,8 +353,6 @@ class TestPathValidatorEdgeCases:
 
     def test_validate_path_with_symlinks(self, tmp_path: Path) -> None:
         """Test validating path with symlinks."""
-        import platform
-        
         # Skip this test on Windows as symlink creation requires elevated privileges
         if platform.system() == "Windows":
             pytest.skip("Symlink test requires elevated privileges on Windows")
@@ -386,6 +382,8 @@ class TestPathValidatorEdgeCases:
         result = PathValidator.validate_path(spaced_file, must_exist=True)
         assert result == spaced_file.resolve()
 
+
+
     def test_sanitize_filename_with_unicode(self) -> None:
         """Test sanitizing filename with Unicode characters."""
         result = PathValidator.sanitize_filename("αβγ<>.txt")

{splurge_dsv-2025.1.0 → splurge_dsv-2025.1.1}/tests/test_resource_manager.py

@@ -6,12 +6,14 @@ file operations, temporary files, and stream management.
 """
 
 import os
+import platform
 from pathlib import Path
 
 import pytest
 
 from splurge_dsv.exceptions import (
     SplurgeResourceAcquisitionError,
+    SplurgeResourceReleaseError,
     SplurgeFileNotFoundError,
     SplurgeFilePermissionError,
     SplurgeFileEncodingError,
@@ -33,7 +35,6 @@ class TestResourceManager:
         """Test ResourceManager initialization."""
         manager = ResourceManager()
         assert not manager.is_acquired()
-        assert manager._resource is None
 
     def test_acquire_not_implemented(self) -> None:
         """Test that acquire raises NotImplementedError when _create_resource is not implemented."""
@@ -53,6 +54,64 @@ class TestResourceManager:
         manager = ResourceManager()
         assert not manager.is_acquired()
 
+    def test_acquire_twice_raises_error(self) -> None:
+        """Test that acquiring twice raises error."""
+        class TestResourceManager(ResourceManager):
+            def _create_resource(self):
+                return "test_resource"
+        
+        manager = TestResourceManager()
+        resource = manager.acquire()
+        assert resource == "test_resource"
+        assert manager.is_acquired()
+        
+        with pytest.raises(SplurgeResourceAcquisitionError, match="Resource is already acquired"):
+            manager.acquire()
+
+    def test_acquire_release_cycle(self) -> None:
+        """Test complete acquire/release cycle."""
+        class TestResourceManager(ResourceManager):
+            def _create_resource(self):
+                return "test_resource"
+            
+            def _cleanup_resource(self):
+                # Simulate cleanup
+                pass
+        
+        manager = TestResourceManager()
+        
+        # Initial state
+        assert not manager.is_acquired()
+        
+        # Acquire
+        resource = manager.acquire()
+        assert resource == "test_resource"
+        assert manager.is_acquired()
+        
+        # Release
+        manager.release()
+        assert not manager.is_acquired()
+        
+        # Can acquire again after release
+        resource2 = manager.acquire()
+        assert resource2 == "test_resource"
+        assert manager.is_acquired()
+
+    def test_release_with_cleanup_error_raises_error(self) -> None:
+        """Test that cleanup error during release raises SplurgeResourceReleaseError."""
+        class TestResourceManager(ResourceManager):
+            def _create_resource(self):
+                return "test_resource"
+            
+            def _cleanup_resource(self):
+                raise RuntimeError("Cleanup failed")
+        
+        manager = TestResourceManager()
+        manager.acquire()
+        
+        with pytest.raises(SplurgeResourceReleaseError, match="Failed to release resource"):
+            manager.release()
+
 
 class TestFileResourceManager:
     """Test the FileResourceManager class."""
@@ -131,6 +190,40 @@ class TestFileResourceManager:
         
         assert test_file.read_text() == "original content appended content"
 
+    def test_context_manager_read_write_mode(self, tmp_path: Path) -> None:
+        """Test context manager with read-write mode."""
+        test_file = tmp_path / "rw_test.txt"
+        test_file.write_text("original content")
+        
+        with FileResourceManager(test_file, mode="r+") as file_handle:
+            content = file_handle.read()
+            assert content == "original content"
+            
+            file_handle.seek(0)
+            file_handle.truncate()  # Clear the file
+            file_handle.write("new content")
+        
+        assert test_file.read_text() == "new content"
+
+    def test_context_manager_binary_write_mode(self, tmp_path: Path) -> None:
+        """Test context manager with binary write mode."""
+        test_file = tmp_path / "binary_write.bin"
+        
+        with FileResourceManager(test_file, mode="wb") as file_handle:
+            file_handle.write(b"binary content")
+        
+        assert test_file.read_bytes() == b"binary content"
+
+    def test_context_manager_binary_append_mode(self, tmp_path: Path) -> None:
+        """Test context manager with binary append mode."""
+        test_file = tmp_path / "binary_append.bin"
+        test_file.write_bytes(b"original")
+        
+        with FileResourceManager(test_file, mode="ab") as file_handle:
+            file_handle.write(b" appended")
+        
+        assert test_file.read_bytes() == b"original appended"
+
     def test_nonexistent_file_read_mode_raises_error(self, tmp_path: Path) -> None:
         """Test that non-existent file raises error in read mode."""
         test_file = tmp_path / "nonexistent.txt"
@@ -150,8 +243,6 @@ class TestFileResourceManager:
 
     def test_file_permission_error(self, tmp_path: Path) -> None:
         """Test file permission error."""
-        import platform
-        
         # Skip this test on Windows as chmod(0o000) doesn't make files unreadable
         if platform.system() == "Windows":
             pytest.skip("File permission test not reliable on Windows")
@@ -172,8 +263,6 @@ class TestFileResourceManager:
 
     def test_encoding_error(self, tmp_path: Path) -> None:
         """Test encoding error."""
-        import platform
-        
         # Skip this test on Windows as encoding error handling may differ
         if platform.system() == "Windows":
             pytest.skip("Encoding error test not reliable on Windows")
@@ -199,6 +288,82 @@ class TestFileResourceManager:
         with pytest.raises(SplurgePathValidationError):
             FileResourceManager(test_dir, mode="r")
 
+    def test_context_manager_exception_propagation(self, tmp_path: Path) -> None:
+        """Test that exceptions in context manager are properly propagated."""
+        test_file = tmp_path / "exception_test.txt"
+        test_file.write_text("content")
+        
+        with pytest.raises(RuntimeError, match="Test exception"):
+            with FileResourceManager(test_file, mode="r") as _:
+                raise RuntimeError("Test exception")
+
+    def test_context_manager_close_error_raises_error(self, tmp_path: Path) -> None:
+        """Test that close error raises SplurgeResourceReleaseError."""
+        test_file = tmp_path / "close_error_test.txt"
+        test_file.write_text("content")
+        
+        # Create a file handle that will fail to close
+        class FailingFileHandle:
+            def __init__(self, file_path):
+                self.file_path = file_path
+                self.closed = False
+            
+            def read(self):
+                return "content"
+            
+            def close(self):
+                raise OSError("Failed to close")
+        
+        # Mock the file opening to return our failing handle
+        original_open = open
+        try:
+            def mock_open(*args, **kwargs):
+                return FailingFileHandle(test_file)
+            
+            # Replace open function temporarily
+            import builtins
+            builtins.open = mock_open
+            
+            with pytest.raises(SplurgeResourceReleaseError, match="Failed to close file"):
+                with FileResourceManager(test_file, mode="r") as file_handle:
+                    content = file_handle.read()
+                    assert content == "content"
+        finally:
+            # Restore original open function
+            builtins.open = original_open
+
+    def test_context_manager_multiple_operations(self, tmp_path: Path) -> None:
+        """Test multiple operations within context manager."""
+        test_file = tmp_path / "multi_op_test.txt"
+        test_file.write_text("line1\nline2\nline3")
+        
+        with FileResourceManager(test_file, mode="r") as file_handle:
+            # Multiple read operations
+            line1 = file_handle.readline()
+            line2 = file_handle.readline()
+            line3 = file_handle.readline()
+            
+            assert line1 == "line1\n"
+            assert line2 == "line2\n"
+            assert line3 == "line3"
+
+    def test_context_manager_with_encoding_parameters(self, tmp_path: Path) -> None:
+        """Test context manager with various encoding parameters."""
+        test_file = tmp_path / "encoding_params_test.txt"
+        content = "test content with special chars: éñü"
+        test_file.write_text(content, encoding='utf-8')
+        
+        with FileResourceManager(
+            test_file, 
+            mode="r", 
+            encoding="utf-8", 
+            errors="strict",
+            newline=None,
+            buffering=1024
+        ) as file_handle:
+            read_content = file_handle.read()
+            assert read_content == content
+
 
 class TestStreamResourceManager:
     """Test the StreamResourceManager class."""
@@ -276,9 +441,9 @@ class TestStreamResourceManager:
         # Should be marked as closed after context manager exits
         assert manager.is_closed
 
-    def test_is_closed_property(self) -> None:
-        """Test is_closed property."""
-        class CloseableStream:
+    def test_context_manager_with_close_error_raises_error(self) -> None:
+        """Test that close error raises SplurgeResourceReleaseError."""
+        class FailingCloseStream:
             def __init__(self):
                 self.closed = False
             
@@ -286,16 +451,44 @@ class TestStreamResourceManager:
                 return iter([1, 2, 3])
             
             def close(self):
-                self.closed = True
+                raise RuntimeError("Close failed")
         
-        stream = CloseableStream()
-        manager = StreamResourceManager(stream)
-        assert not manager.is_closed
+        stream = FailingCloseStream()
+        with pytest.raises(SplurgeResourceReleaseError, match="Failed to close stream"):
+            with StreamResourceManager(stream) as managed_stream:
+                items = list(managed_stream)
+                assert items == [1, 2, 3]
+
+    def test_context_manager_exception_propagation(self) -> None:
+        """Test that exceptions in context manager are properly propagated."""
+        stream = iter([1, 2, 3])
         
-        with manager:
-            pass
+        with pytest.raises(RuntimeError, match="Test exception"):
+            with StreamResourceManager(stream) as _:
+                raise RuntimeError("Test exception")
+
+    def test_context_manager_multiple_iterations(self) -> None:
+        """Test multiple iterations within context manager."""
+        stream = iter([1, 2, 3])
         
-        assert manager.is_closed
+        with StreamResourceManager(stream) as managed_stream:
+            # First iteration
+            items1 = list(managed_stream)
+            assert items1 == [1, 2, 3]
+            
+            # Second iteration (should be empty since stream is exhausted)
+            items2 = list(managed_stream)
+            assert items2 == []
+
+    def test_context_manager_with_generator(self) -> None:
+        """Test context manager with generator function."""
+        def number_generator():
+            for i in range(1, 4):
+                yield i
+        
+        with StreamResourceManager(number_generator()) as managed_stream:
+            items = list(managed_stream)
+            assert items == [1, 2, 3]
 
 
 class TestSafeFileOperation:
@@ -337,6 +530,32 @@ class TestSafeFileOperation:
             with safe_file_operation(test_file, mode="r"):
                 pass
 
+    def test_safe_file_operation_with_all_parameters(self, tmp_path: Path) -> None:
+        """Test safe file operation with all parameters."""
+        test_file = tmp_path / "all_params_test.txt"
+        content = "test content"
+        test_file.write_text(content)
+        
+        with safe_file_operation(
+            test_file, 
+            mode="r", 
+            encoding="utf-8", 
+            errors="strict",
+            newline=None,
+            buffering=1024
+        ) as file_handle:
+            read_content = file_handle.read()
+            assert read_content == content
+
+    def test_safe_file_operation_exception_propagation(self, tmp_path: Path) -> None:
+        """Test that exceptions in safe file operation are properly propagated."""
+        test_file = tmp_path / "exception_test.txt"
+        test_file.write_text("content")
+        
+        with pytest.raises(RuntimeError, match="Test exception"):
+            with safe_file_operation(test_file, mode="r") as _:
+                raise RuntimeError("Test exception")
+
 
 class TestSafeStreamOperation:
     """Test the safe_stream_operation context manager."""
@@ -386,50 +605,23 @@ class TestSafeStreamOperation:
         
         assert not stream.closed
 
-
-class TestSafeOpenFile:
-    """Test the _safe_open_file helper function."""
-
-    def test_safe_open_file_text_mode(self, tmp_path: Path) -> None:
-        """Test safe file opening in text mode."""
-        from splurge_dsv.resource_manager import _safe_open_file
-        
-        test_file = tmp_path / "test.txt"
-        test_file.write_text("test content")
-        
-        with _safe_open_file(test_file, mode="r", encoding="utf-8") as file_handle:
-            content = file_handle.read()
-            assert content == "test content"
-
-    def test_safe_open_file_binary_mode(self, tmp_path: Path) -> None:
-        """Test safe file opening in binary mode."""
-        from splurge_dsv.resource_manager import _safe_open_file
-        
-        test_file = tmp_path / "test.bin"
-        test_file.write_bytes(b"binary content")
-        
-        with _safe_open_file(test_file, mode="rb") as file_handle:
-            content = file_handle.read()
-            assert content == b"binary content"
-
-    def test_safe_open_file_nonexistent_raises_error(self, tmp_path: Path) -> None:
-        """Test that non-existent file raises SplurgeFileNotFoundError."""
-        from splurge_dsv.resource_manager import _safe_open_file
-        
-        test_file = tmp_path / "nonexistent.txt"
+    def test_safe_stream_operation_exception_propagation(self) -> None:
+        """Test that exceptions in safe stream operation are properly propagated."""
+        stream = iter([1, 2, 3])
         
-        with pytest.raises(SplurgeFileNotFoundError):
-            with _safe_open_file(test_file, mode="r"):
-                pass
+        with pytest.raises(RuntimeError, match="Test exception"):
+            with safe_stream_operation(stream) as _:
+                raise RuntimeError("Test exception")
 
-    def test_safe_open_file_invalid_path_raises_error(self) -> None:
-        """Test that invalid path raises SplurgeResourceAcquisitionError."""
-        from splurge_dsv.resource_manager import _safe_open_file
+    def test_safe_stream_operation_with_generator(self) -> None:
+        """Test safe stream operation with generator function."""
+        def number_generator():
+            for i in range(1, 4):
+                yield i
         
-        # Invalid characters in filename cause OSError which gets converted to SplurgeResourceAcquisitionError
-        with pytest.raises(SplurgeResourceAcquisitionError):
-            with _safe_open_file(Path("file<with>invalid:chars?.txt"), mode="r"):
-                pass
+        with safe_stream_operation(number_generator()) as managed_stream:
+            items = list(managed_stream)
+            assert items == [1, 2, 3]
 
 
 class TestResourceManagerEdgeCases:
@@ -483,8 +675,6 @@ class TestResourceManagerEdgeCases:
 
     def test_file_resource_manager_error_handling(self, tmp_path: Path) -> None:
         """Test file resource manager error handling."""
-        import platform
-        
         # Skip this test on Windows as chmod(0o000) doesn't make files unreadable
         if platform.system() == "Windows":
             pytest.skip("File permission test not reliable on Windows")
@@ -502,3 +692,114 @@ class TestResourceManagerEdgeCases:
         finally:
             # Restore permissions
             os.chmod(test_file, 0o644)
+
+    def test_file_resource_manager_with_special_characters(self, tmp_path: Path) -> None:
+        """Test file resource manager with special characters in content."""
+        test_file = tmp_path / "special_chars.txt"
+        content = "Special chars: éñüß©®™\nNew line\r\nCarriage return"
+        test_file.write_text(content, encoding='utf-8', newline='')
+        
+        with FileResourceManager(test_file, mode="r", encoding="utf-8", newline='') as file_handle:
+            read_content = file_handle.read()
+            assert read_content == content
+
+    def test_stream_resource_manager_with_none_values(self) -> None:
+        """Test stream resource manager with None values in stream."""
+        stream = iter([1, None, 3, None, 5])
+        with StreamResourceManager(stream) as managed_stream:
+            items = list(managed_stream)
+            assert items == [1, None, 3, None, 5]
+
+    def test_file_resource_manager_with_different_line_endings(self, tmp_path: Path) -> None:
+        """Test file resource manager with different line endings."""
+        test_file = tmp_path / "line_endings.txt"
+        content = "line1\nline2\r\nline3\rline4"
+        test_file.write_text(content, encoding='utf-8', newline='')
+        
+        with FileResourceManager(test_file, mode="r", newline='') as file_handle:
+            lines = file_handle.readlines()
+            assert len(lines) == 4
+            assert lines[0] == "line1\n"
+            assert lines[1] == "line2\r\n"
+            assert lines[2] == "line3\r"
+            assert lines[3] == "line4"
+
+    def test_resource_manager_with_custom_resource(self) -> None:
+        """Test ResourceManager with custom resource implementation."""
+        class CustomResource:
+            def __init__(self, value):
+                self.value = value
+                self.closed = False
+            
+            def close(self):
+                self.closed = True
+        
+        class CustomResourceManager(ResourceManager):
+            def __init__(self, value):
+                super().__init__()
+                self.value = value
+            
+            def _create_resource(self):
+                return CustomResource(self.value)
+            
+            def _cleanup_resource(self):
+                if self._resource:
+                    self._resource.close()
+        
+        manager = CustomResourceManager("test_value")
+        
+        # Test acquire/release cycle
+        resource = manager.acquire()
+        assert resource.value == "test_value"
+        assert not resource.closed
+        assert manager.is_acquired()
+        
+        manager.release()
+        assert resource.closed
+        assert not manager.is_acquired()
+
+    def test_file_resource_manager_with_relative_path(self, tmp_path: Path) -> None:
+        """Test file resource manager with relative path."""
+        # Change to tmp_path directory
+        original_cwd = os.getcwd()
+        os.chdir(tmp_path)
+        
+        try:
+            test_file = Path("relative_test.txt")
+            test_file.write_text("relative content")
+            
+            with FileResourceManager(test_file, mode="r") as file_handle:
+                content = file_handle.read()
+                assert content == "relative content"
+        finally:
+            # Restore original working directory
+            os.chdir(original_cwd)
+
+    def test_stream_resource_manager_with_iterator_protocol(self) -> None:
+        """Test stream resource manager with custom iterator protocol."""
+        class CustomIterator:
+            def __init__(self, data):
+                self.data = data
+                self.index = 0
+                self.closed = False
+            
+            def __iter__(self):
+                return self
+            
+            def __next__(self):
+                if self.index >= len(self.data):
+                    raise StopIteration
+                result = self.data[self.index]
+                self.index += 1
+                return result
+            
+            def close(self):
+                self.closed = True
+        
+        custom_iter = CustomIterator([1, 2, 3, 4, 5])
+        
+        with StreamResourceManager(custom_iter) as managed_stream:
+            items = list(managed_stream)
+            assert items == [1, 2, 3, 4, 5]
+        
+        assert custom_iter.closed

{splurge_dsv-2025.1.0 → splurge_dsv-2025.1.1}/tests/test_string_tokenizer.py

@@ -177,11 +177,19 @@ class TestStringTokenizerRemoveBookends:
         """Test removing brackets from both ends."""
         result = StringTokenizer.remove_bookends("[hello]", bookend="[")
         assert result == "[hello]"
+        
+        # Test with matching bookend character
+        result = StringTokenizer.remove_bookends("[hello[", bookend="[")
+        assert result == "hello"
 
     def test_remove_parentheses(self) -> None:
         """Test removing parentheses from both ends."""
         result = StringTokenizer.remove_bookends("(hello)", bookend="(")
         assert result == "(hello)"
+        
+        # Test with matching bookend character
+        result = StringTokenizer.remove_bookends("(hello(", bookend="(")
+        assert result == "hello"
 
     def test_remove_with_spaces(self) -> None:
         """Test removing bookends with spaces."""
@@ -207,6 +215,14 @@ class TestStringTokenizerRemoveBookends:
         """Test removing single character bookend."""
         result = StringTokenizer.remove_bookends("'a'", bookend="'")
         assert result == "a"
+        
+        # Test with single character that doesn't match at both ends
+        result = StringTokenizer.remove_bookends("'a", bookend="'")
+        assert result == "'a"
+        
+        # Test with single character that matches at both ends
+        result = StringTokenizer.remove_bookends("'a'", bookend="'")
+        assert result == "a"
 
     def test_remove_empty_string(self) -> None:
         """Test removing bookends from empty string."""
@@ -237,11 +253,53 @@ class TestStringTokenizerRemoveBookends:
         """Test removing multi-character bookend."""
         result = StringTokenizer.remove_bookends("[[hello]]", bookend="[[")
         assert result == "[[hello]]"
+        
+        # Test with matching multi-character bookend
+        result = StringTokenizer.remove_bookends("[[hello[[", bookend="[[")
+        assert result == "hello"
 
     def test_remove_with_complex_bookend(self) -> None:
         """Test removing complex bookend pattern."""
         result = StringTokenizer.remove_bookends("STARThelloEND", bookend="START")
         assert result == "STARThelloEND"
+        
+        # Test with matching complex bookend
+        result = StringTokenizer.remove_bookends("STARThelloSTART", bookend="START")
+        assert result == "hello"
+
+    def test_remove_single_bookend_character_logic(self) -> None:
+        """Test that bookend logic uses single character matching at both ends."""
+        # Test with single character bookend that matches at both ends
+        result = StringTokenizer.remove_bookends("***hello***", bookend="*")
+        assert result == "**hello**"
+        
+        # Test with single character bookend that matches at both ends (removes one from each end)
+        result = StringTokenizer.remove_bookends("***hello**", bookend="*")
+        assert result == "**hello*"
+        
+        # Test with single character bookend that matches exactly at both ends
+        result = StringTokenizer.remove_bookends("*hello*", bookend="*")
+        assert result == "hello"
+        
+        # Test with asymmetric brackets - should not be removed
+        result = StringTokenizer.remove_bookends("[hello]", bookend="[")
+        assert result == "[hello]"
+        
+        # Test with asymmetric brackets - should not be removed
+        result = StringTokenizer.remove_bookends("[hello]", bookend="]")
+        assert result == "[hello]"
+        
+        # Test edge case: string with only bookend characters (removes one from each end)
+        result = StringTokenizer.remove_bookends("**", bookend="*")
+        assert result == ""
+        
+        # Test edge case: string with only bookend characters
+        result = StringTokenizer.remove_bookends("***", bookend="*")
+        assert result == "*"
+        
+        # Test edge case: string with only bookend characters
+        result = StringTokenizer.remove_bookends("****", bookend="*")
+        assert result == "**"
 
 
 class TestStringTokenizerEdgeCases:
@@ -261,6 +319,10 @@ class TestStringTokenizerEdgeCases:
         """Test removing bookends with Unicode content."""
         result = StringTokenizer.remove_bookends("«αβγ»", bookend="«")
         assert result == "«αβγ»"
+        
+        # Test with matching Unicode bookend
+        result = StringTokenizer.remove_bookends("«αβγ«", bookend="«")
+        assert result == "αβγ"
 
     def test_parse_with_newlines(self) -> None:
         """Test parsing with newlines in content."""

{splurge_dsv-2025.1.0 → splurge_dsv-2025.1.1}/tests/test_text_file_helper.py

@@ -5,6 +5,8 @@ Tests all public methods of the TextFileHelper class including
 line counting, file previewing, reading, and streaming operations.
 """
 
+import os
+import platform
 from pathlib import Path
 
 import pytest
@@ -559,8 +561,6 @@ class TestTextFileHelperEdgeCases:
 
     def test_read_file_with_permission_error(self, tmp_path: Path) -> None:
         """Test reading file with permission error."""
-        import platform
-        
         # Skip this test on Windows as chmod(0o000) doesn't make files unreadable
         if platform.system() == "Windows":
             pytest.skip("File permission test not reliable on Windows")
@@ -569,7 +569,6 @@ class TestTextFileHelperEdgeCases:
         test_file.write_text("content")
         
         # Make file unreadable
-        import os
         os.chmod(test_file, 0o000)
         
         try: