Add tests for all coverage gaps, reach 100% on macOS

- TestBestPrefixInvalidSystem: cover line 514 (bad system= arg)
- TestSystemPropertyInvalidBase: cover line 317 (invalid _base)
- TestQueryDeviceCapacityWindowsBody: cover lines 1358-1397 via
  mock.patch(create=True) injecting ctypes/msvcrt — runs on all platforms
- TestQueryCapacityWindowsDriveLetterMock: cover lines 1549-1551 via
  mocked os.name='nt' and shutil.disk_usage — runs on all platforms
- Lines 65-68: add # pragma: no cover to elif os.name == 'nt': import
  block (import-time, cannot be covered without module reload)

Local result: 319 passed, 2 skipped, TOTAL 100% coverage, pylint 10.00/10

Author: timlnx

bitmath/__init__.py

@@ -62,7 +62,7 @@
 if os.name == 'posix':
     import stat
     import fcntl
-elif os.name == 'nt':
+elif os.name == 'nt':  # pragma: no cover
     import ctypes
     import ctypes.wintypes
     import msvcrt  # pylint: disable=import-error

tests/test_best_prefix_BASE.py

@@ -99,3 +99,10 @@ def test_best_prefix_negative_huge_numbers(self):
         self.assertIs(type(negative_result), type(positive_result))
         # Verify that type is what we expect it to be
         self.assertIs(type(negative_result), bitmath.MiB)
+
+
+class TestBestPrefixInvalidSystem(TestCase):
+    def test_best_prefix_invalid_system_raises(self):
+        """best_prefix raises ValueError when an invalid system constant is passed"""
+        with self.assertRaises(ValueError):
+            bitmath.best_prefix(bitmath.MiB(1), system="bogus")

tests/test_properties.py

@@ -73,3 +73,12 @@ def test_Zib_property(self):
     def test_Yib_property(self):
         """Yib property returns a Yib instance"""
         self.assertIsInstance(self.kib.Yib, bitmath.Yib)
+
+
+class TestSystemPropertyInvalidBase(TestCase):
+    def test_system_property_invalid_base_raises(self):
+        """system property raises ValueError when _base is not 2 or 10"""
+        obj = bitmath.MiB(1)
+        obj._base = 7
+        with self.assertRaises(ValueError):
+            _ = obj.system

tests/test_query_capacity.py

@@ -30,7 +30,7 @@
 
 import os
 import pathlib
-from unittest import skipUnless
+from unittest import mock, skipUnless
 
 import bitmath
 from bitmath import Bitmath, Byte, Capacity
@@ -125,3 +125,19 @@ def test_query_capacity_windows_pathlike_drive_letter(self):
         result = bitmath.query_capacity(pathlib.PureWindowsPath("C:"))
         self.assertIsInstance(result, Capacity)
         self.assertGreater(result.total.bytes, 0)
+
+
+class TestQueryCapacityWindowsDriveLetterMock(TestCase):
+    def test_query_capacity_windows_drive_letter_normalization_mock(self):
+        """query_capacity normalizes a bare drive letter via mocked os.name='nt'"""
+        mock_usage = mock.MagicMock()
+        mock_usage.total = 1_000_000_000_000
+        mock_usage.used = 500_000_000_000
+        mock_usage.free = 500_000_000_000
+
+        with mock.patch('bitmath.os.name', 'nt'):
+            with mock.patch('bitmath.shutil.disk_usage', return_value=mock_usage) as mock_du:
+                result = bitmath.query_capacity("c:")
+
+        self.assertIsInstance(result, Capacity)
+        mock_du.assert_called_once_with("C:\\")

tests/test_query_device_capacity.py

@@ -31,7 +31,9 @@
 
 from . import TestCase
 import bitmath
+import ctypes as real_ctypes
 import os
+import types
 from unittest import mock, skipUnless
 import struct
 from contextlib import ExitStack, contextmanager
@@ -133,3 +135,63 @@ def test_query_device_capacity_unsupported_platform_fails(self):
         with mock.patch('bitmath.os.name', unsupported):
             with self.assertRaises(NotImplementedError):
                 bitmath.query_device_capacity(device)
+
+
+class TestQueryDeviceCapacityWindowsBody(TestCase):
+    """Mock-based tests for _query_device_capacity_windows body.
+
+    Run on all platforms by injecting ctypes and msvcrt into the bitmath
+    namespace via mock.patch(..., create=True).
+    """
+
+    def _make_mock_ctypes(self):
+        mc = types.SimpleNamespace(
+            Structure=real_ctypes.Structure,
+            c_longlong=real_ctypes.c_longlong,
+            c_uint=real_ctypes.c_uint,
+            c_ulong=real_ctypes.c_ulong,
+            c_byte=real_ctypes.c_byte,
+            byref=real_ctypes.byref,
+            sizeof=real_ctypes.sizeof,
+            wintypes=types.SimpleNamespace(DWORD=real_ctypes.c_ulong),
+            windll=mock.MagicMock(),
+        )
+        mc.windll.kernel32.DeviceIoControl.return_value = 1
+        return mc
+
+    def _make_mock_msvcrt(self):
+        return types.SimpleNamespace(get_osfhandle=mock.Mock(return_value=999))
+
+    def _make_windows_device(self):
+        fd = mock.MagicMock()
+        fd.name = r'\\.\PhysicalDrive0'
+        fd.fileno.return_value = 4
+        return fd
+
+    def test_windows_body_success(self):
+        """_query_device_capacity_windows succeeds via mocked ctypes and msvcrt"""
+        mock_ctypes = self._make_mock_ctypes()
+        mock_msvcrt = self._make_mock_msvcrt()
+        device_fd = self._make_windows_device()
+
+        with mock.patch('bitmath.ctypes', mock_ctypes, create=True):
+            with mock.patch('bitmath.msvcrt', mock_msvcrt, create=True):
+                result = bitmath._query_device_capacity_windows(device_fd)
+
+        # DiskSize is 0 by default — mock DeviceIoControl does not fill the struct
+        self.assertEqual(result, 0)
+        mock_msvcrt.get_osfhandle.assert_called_once_with(4)
+        mock_ctypes.windll.kernel32.DeviceIoControl.assert_called_once()
+
+    def test_windows_body_ioctl_failure_raises_oserror(self):
+        """_query_device_capacity_windows raises OSError when DeviceIoControl fails"""
+        mock_ctypes = self._make_mock_ctypes()
+        mock_ctypes.windll.kernel32.DeviceIoControl.return_value = 0
+        mock_ctypes.windll.kernel32.GetLastError.return_value = 5
+        mock_msvcrt = self._make_mock_msvcrt()
+        device_fd = self._make_windows_device()
+
+        with mock.patch('bitmath.ctypes', mock_ctypes, create=True):
+            with mock.patch('bitmath.msvcrt', mock_msvcrt, create=True):
+                with self.assertRaises(OSError):
+                    bitmath._query_device_capacity_windows(device_fd)