Add failing tests for best_prefix() bit-family unit bug (issue #95)

best_prefix() on Bit-family instances (Bit, Kib, Mib, kb, Mb, etc.)
incorrectly returns Byte-family units (MiB, GiB, MB, GB, etc.) because
the conversion method name is always built with a hardcoded 'B' suffix.

13 new tests document the expected behaviour across NIST and SI systems.
All 13 fail against the current implementation. Existing 30 tests pass.

Author: timlnx

tests/test_best_prefix_NIST.py

@@ -142,3 +142,58 @@ def test_bitmath_best_prefix_NIST_exbi(self):
         """bitmath.best_prefix return an exbibyte for a huge number of bytes"""
         result = bitmath.best_prefix(1152921504606846977)
         self.assertIs(type(result), bitmath.EiB)
+
+    ##################################################################
+    # Tests for bit-family inputs (issue #95)
+    #
+    # best_prefix() on a Bit-family instance should return a Bit-family
+    # result. Before the fix these all incorrectly return Byte-family
+    # units (e.g. MiB instead of Mib).
+
+    def test_bit_input_returns_bit_family(self):
+        """NIST: best_prefix on Bit() returns a Bit-family unit, not a Byte-family unit"""
+        # The exact value from issue #95
+        result = bitmath.Bit(30950093.15655963).best_prefix()
+        self.assertIsInstance(result, bitmath.Bit)
+
+    def test_bit_input_returns_mib_type(self):
+        """NIST: Bit(30950093) best_prefix is Mib, not MiB (issue #95)"""
+        result = bitmath.Bit(30950093.15655963).best_prefix()
+        self.assertIs(type(result), bitmath.Mib)
+
+    def test_kib_input_returns_mib_type(self):
+        """NIST: Kib(8192).best_prefix() returns Mib, not MiB
+
+Kib(8192) = 8,388,608 bits = 1,048,576 bytes; log(1048576, 1024) = 2 -> Mib.
+"""
+        result = bitmath.Kib(8192).best_prefix()
+        self.assertIs(type(result), bitmath.Mib)
+
+    def test_mib_input_returns_gib_type(self):
+        """NIST: Mib(8192).best_prefix() returns Gib, not GiB
+
+Mib(8192) = 8,589,934,592 bits = 1,073,741,824 bytes; log(1073741824, 1024) = 3 -> Gib.
+"""
+        result = bitmath.Mib(8192).best_prefix()
+        self.assertIs(type(result), bitmath.Gib)
+
+    def test_bit_multi_oom_round_up(self):
+        """NIST: A very large Kib rounds up into a Pib
+
+Pib(8) = 2^53 bits = 2^50 bytes; log(2^50, 1024) = 5 -> Pib.
+"""
+        large_Kib = bitmath.Kib.from_other(bitmath.Pib(8))
+        self.assertIs(type(large_Kib.best_prefix()), bitmath.Pib)
+
+    def test_bit_multi_oom_round_down(self):
+        """NIST: A very small Pib rounds down into a Kib
+
+Kib(8) = 8192 bits = 1024 bytes; log(1024, 1024) = 1 -> Kib.
+"""
+        small_Pib = bitmath.Pib.from_other(bitmath.Kib(8))
+        self.assertIs(type(small_Pib.best_prefix()), bitmath.Kib)
+
+    def test_bit_input_prefer_nist_returns_bit_family(self):
+        """NIST: best_prefix(system=NIST) on a Bit() still returns a Bit-family unit"""
+        result = bitmath.Bit(30950093.15655963).best_prefix(system=bitmath.NIST)
+        self.assertIs(type(result), bitmath.Mib)

tests/test_best_prefix_SI.py

@@ -142,3 +142,52 @@ def test_bitmath_best_prefix_SI_yotta(self):
         """bitmath.best_prefix return a yottabyte for a huge number of bytes"""
         result = bitmath.best_prefix(1000000000000000000000001, system=bitmath.SI)
         self.assertIs(type(result), bitmath.YB)
+
+    ##################################################################
+    # Tests for bit-family inputs (issue #95)
+    #
+    # best_prefix() on a Bit-family SI instance should return a
+    # Bit-family SI result. Before the fix these incorrectly return
+    # Byte-family units (e.g. MB instead of Mb).
+
+    def test_bit_input_returns_bit_family_si(self):
+        """SI: best_prefix on Bit() returns a Bit-family unit, not a Byte-family unit"""
+        result = bitmath.Bit.from_other(bitmath.Mb(1)).best_prefix(system=bitmath.SI)
+        self.assertIsInstance(result, bitmath.Bit)
+
+    def test_kb_input_returns_mb_type(self):
+        """SI: kb(8000).best_prefix() returns Mb, not MB
+
+kb(8000) = 8,000,000 bits = 1,000,000 bytes; log(1000000, 1000) = 2 -> Mb.
+"""
+        result = bitmath.kb(8000).best_prefix()
+        self.assertIs(type(result), bitmath.Mb)
+
+    def test_mb_input_returns_gb_type(self):
+        """SI: Mb(8000).best_prefix() returns Gb, not GB
+
+Mb(8000) = 8,000,000,000 bits = 1,000,000,000 bytes; log(1000000000, 1000) = 3 -> Gb.
+"""
+        result = bitmath.Mb(8000).best_prefix()
+        self.assertIs(type(result), bitmath.Gb)
+
+    def test_bit_multi_oom_round_up_si(self):
+        """SI: A very large kb rounds up into a Pb
+
+Pb(8) = 8*10^15 bits = 10^15 bytes; log(10^15, 1000) = 5 -> Pb.
+"""
+        large_kb = bitmath.kb.from_other(bitmath.Pb(8))
+        self.assertIs(type(large_kb.best_prefix()), bitmath.Pb)
+
+    def test_bit_multi_oom_round_down_si(self):
+        """SI: A very small Pb rounds down into a kb
+
+kb(8) = 8000 bits = 1000 bytes; log(1000, 1000) = 1 -> kb.
+"""
+        small_Pb = bitmath.Pb.from_other(bitmath.kb(8))
+        self.assertIs(type(small_Pb.best_prefix()), bitmath.kb)
+
+    def test_bit_input_prefer_si_returns_bit_family(self):
+        """SI: best_prefix(system=SI) on a kb() still returns a Bit-family unit"""
+        result = bitmath.kb(8000).best_prefix(system=bitmath.SI)
+        self.assertIs(type(result), bitmath.Mb)