two version of R2R are hereHEADmaster

1 files changed, 319 insertions, 0 deletions

diff --git a/.venv/lib/python3.12/site-packages/fixedint/test_fixedint.py b/.venv/lib/python3.12/site-packages/fixedint/test_fixedint.py
new file mode 100644
index 00000000..721f6742
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/fixedint/test_fixedint.py
@@ -0,0 +1,319 @@
+import unittest
+import sys
+
+PY3K = sys.version_info[0] >= 3
+
+from fixedint import *
+
+tests = []
+
+# ----------------------------------------------------------------------------
+class ClassTests(unittest.TestCase):
+    def test_subclass_base(self):
+        self.assertRaises(Exception, type, 'TestClass', (FixedInt,), {})
+        self.assertRaises(Exception, type, 'TestClass', (MutableFixedInt,), {})
+
+    def test_class_cache(self):
+        self.assertEqual(FixedInt(99), FixedInt(99))
+        self.assertEqual(MutableFixedInt(42), MutableFixedInt(42))
+
+    def test_aliases(self):
+        self.assertEqual(FixedInt(8), Int8)
+        self.assertEqual(FixedInt(16), Int16)
+        self.assertEqual(FixedInt(32), Int32)
+        self.assertEqual(FixedInt(64), Int64)
+        self.assertEqual(FixedInt(8, signed=False), UInt8)
+        self.assertEqual(FixedInt(16, signed=False), UInt16)
+        self.assertEqual(FixedInt(32, signed=False), UInt32)
+        self.assertEqual(FixedInt(64, signed=False), UInt64)
+
+    def test_subclassing(self):
+        from fixedint.util import HexFormattingMixin
+        class MyUInt32(HexFormattingMixin, UInt32):
+            pass
+        self.assertEqual(str(MyUInt32(32)), '0x00000020')
+
+tests.append(ClassTests)
+
+# ----------------------------------------------------------------------------
+class BasicTests(unittest.TestCase):
+    def test_properties(self):
+        f3 = FixedInt(3)
+        self.assertEqual(f3.width, 3)
+        self.assertEqual(f3.mutable, False)
+        self.assertEqual(f3.signed, True)
+        self.assertEqual(f3.minval, -4)
+        self.assertEqual(f3.maxval, 3)
+
+        f3 = MutableFixedInt(3)
+        self.assertEqual(f3.width, 3)
+        self.assertEqual(f3.mutable, True)
+        self.assertEqual(f3.signed, True)
+        self.assertEqual(f3.minval, -4)
+        self.assertEqual(f3.maxval, 3)
+
+        f3 = FixedInt(3, signed=False)
+        self.assertEqual(f3.width, 3)
+        self.assertEqual(f3.mutable, False)
+        self.assertEqual(f3.signed, False)
+        self.assertEqual(f3.minval, 0)
+        self.assertEqual(f3.maxval, 7)
+
+        f3 = MutableFixedInt(3, signed=False)
+        self.assertEqual(f3.width, 3)
+        self.assertEqual(f3.mutable, True)
+        self.assertEqual(f3.signed, False)
+        self.assertEqual(f3.minval, 0)
+        self.assertEqual(f3.maxval, 7)
+
+    def test_rectify(self):
+        for f10 in [FixedInt(10), MutableFixedInt(10)]:
+            self.assertEqual(int(f10(1024)), 0)
+            self.assertEqual(int(f10(1025)), 1)
+            self.assertEqual(int(f10(511)), 511)
+            self.assertEqual(int(f10(512)), -512)
+
+        for f10 in [FixedInt(10, signed=False), MutableFixedInt(10, signed=False)]:
+            self.assertEqual(int(f10(1024)), 0)
+            self.assertEqual(int(f10(1025)), 1)
+            self.assertEqual(int(f10(511)), 511)
+            self.assertEqual(int(f10(512)), 512)
+
+    def test_simple_arith(self):
+        for f8 in [Int8, MutableInt8]:
+            a = f8(15)
+            b = f8(10)
+            self.assertEqual(int(a+b), 25)
+            self.assertEqual(int(a-b), 5)
+            self.assertEqual(int(a*b), (150-256))
+            self.assertEqual(a.__truediv__(b), 1.5)
+            self.assertEqual(int(a // b), 1)
+            self.assertEqual(divmod(a, b), (1, 5))
+            self.assertEqual(divmod(15, b), (1, 5))
+            self.assertEqual(divmod(a, 10), (1, 5))
+            self.assertEqual(int(a)**b, 15**10)
+            self.assertEqual(int(a<<8), 0)
+            self.assertEqual(8<<a, 8<<15)
+            self.assertEqual(int(~a), ~15)
+            self.assertEqual(int(-a), -15)
+            self.assertEqual(int((~a) & 0xff), ~15)
+        for f64 in [Int64, MutableInt64]:
+            a = f64(15)
+            b = f64(10)
+            self.assertEqual(int(a+b), 25)
+            self.assertEqual(int(a-b), 5)
+            self.assertEqual(int(a*b), 150)
+            self.assertEqual(a.__truediv__(b), 1.5)
+            self.assertEqual(int(a // b), 1)
+            self.assertEqual(divmod(a, b), (1, 5))
+            self.assertEqual(divmod(15, b), (1, 5))
+            self.assertEqual(divmod(a, 10), (1, 5))
+            self.assertEqual(int(a)**b, 15**10)
+            self.assertEqual(int(a<<8), 15<<8)
+            self.assertEqual(8<<a, 8<<15)
+            self.assertEqual(int(~a), ~15)
+            self.assertEqual(int(-a), -15)
+
+    def test_typecast(self):
+        import math
+        for f16 in [Int16, MutableInt16]:
+            x = f16(42)
+            self.assertEqual(int(x), 42)
+            self.assertEqual(float(x), 42)
+            self.assertEqual(complex(x), 42)
+            self.assertEqual(round(x), 42)
+            if not PY3K:
+                self.assertEqual(long(x), 42)
+            self.assertEqual(bool(x), True)
+            if sys.version_info[:2] >= (2,5):
+                self.assertEqual(list(range(100))[x], 42)
+            if sys.version_info[:2] >= (2,6):
+                self.assertEqual(math.trunc(x), 42)
+
+            x = f16(0)
+            self.assertEqual(bool(x), False)
+
+    def test_compare(self):
+        for f32 in [Int32, MutableInt32]:
+            x = f32(1000000)
+            self.assertEqual(x, 1000000)
+            self.assertNotEqual(x, 1000000 + (1<<32))
+            self.assertEqual(x, f32(1000000 + (1<<32)))
+            self.assertNotEqual(x, 1000001)
+            self.assertTrue(x <= 1000000)
+            self.assertTrue(x >= 1000000)
+            self.assertTrue(x < 1000001)
+            self.assertTrue(x > 999999)
+            if not PY3K:
+                self.assertTrue(cmp(x, 999999) > 0)
+
+    def test_implicit_conversion(self):
+        f = FixedInt(72)
+        x = f(32767)
+        y = x
+        self.assertEqual(x, y)
+        x += 100
+        self.assertNotEqual(x, y)
+        x += FixedInt(80)(1<<79)
+        self.assertEqual(x.width, 80)
+
+    def test_inplace_operators(self):
+        mf = MutableFixedInt(72)
+        x = mf(32767)
+        y = x
+        self.assertEqual(x, y)
+        x += 100
+        self.assertEqual(x, y)
+        x += MutableFixedInt(80)(1<<79)
+        self.assertEqual(x.width, 72)
+        x >>= 100
+        self.assertEqual(x, 0)
+        x += 2
+        self.assertEqual(y, 2)
+        x **= 70
+        self.assertEqual(y, 2**70)
+
+    def test_str(self):
+        for ff in [FixedInt(12), MutableFixedInt(12), FixedInt(91), MutableFixedInt(91)]:
+            self.assertEqual(str(ff(1)), '1')
+            self.assertEqual(repr(ff(1)), '%s(1)' % ff.__name__)
+            self.assertEqual(str(ff(-1)), '-1')
+            self.assertEqual(hex(ff(1)), '0x1')
+
+tests.append(BasicTests)
+
+# ----------------------------------------------------------------------------
+class ExtraFunctionTests(unittest.TestCase):
+    def test_bytes(self):
+        for ff in [FixedInt(96), MutableFixedInt(96)]:
+            val = ff(-1)
+            if PY3K:
+                byte = lambda c: bytes([c])
+            else:
+                byte = lambda c: chr(c)
+            self.assertEqual(val.to_bytes(), byte(255) * 12)
+            self.assertEqual(val.to_bytes(8), byte(255) * 8)
+            self.assertEqual(ff.from_bytes(byte(255) * 12), val)
+
+        for ff in [FixedInt(32), MutableFixedInt(32)]:
+            for v in [0xdeadbeef, 0xfeedface, 0x0badf00d, 0x12345678, 0x87654321]:
+                for endian in ['big', 'little']:
+                    val = ff(v)
+                    data = val.to_bytes(byteorder=endian)
+                    self.assertEqual(len(data), 4)
+                    val2 = ff.from_bytes(data, byteorder=endian)
+                    self.assertEqual(val, val2)
+
+        for ff in [UInt32, MutableUInt32]:
+            for v in [0xdeadbeef, 0xfeedface, 0x0badf00d, 0x12345678, 0x87654321]:
+                for endian in ['big', 'little']:
+                    val = ff(v)
+                    data = val.to_bytes(byteorder=endian)
+                    self.assertEqual(len(data), 4)
+                    val2 = FixedInt.from_bytes(data, byteorder=endian, signed=False)
+                    self.assertTrue(type(val2).__name__.endswith('UInt32'))
+                    self.assertEqual(val, val2)
+
+        t = UInt32(32).to_bytes()
+        self.assertRaises(ValueError, UInt32.from_bytes, t, signed=True)
+
+    def test_slice_errors(self):
+        ff = FixedInt(24)
+        val = ff(1024)
+        # Steps unsupported
+        self.assertRaises(ValueError, lambda:val[::-1])
+        self.assertRaises(ValueError, lambda:val[::1])
+        # Mixed complex numbers unsupported
+        self.assertRaises(ValueError, lambda:val[:2+4j])
+        # Invalid indices
+        self.assertRaises(IndexError, lambda:val[100:200])
+        self.assertRaises(IndexError, lambda:val[5:0])
+        self.assertRaises(IndexError, lambda:val[1024])
+
+    def test_getslice(self):
+        for ff in [FixedInt(48), MutableFixedInt(48)]:
+            testval = 0xfedcba123456
+            fixed = ff(testval)
+
+            x = testval
+            for i in range(48):
+                self.assertEqual(fixed[i], x & 1)
+                x >>= 1
+
+            x = testval
+            for i in range(12):
+                r = fixed[i*4:i*4+4]
+                self.assertEqual(r, x & 0xf)
+                self.assertEqual(r.width, 4)
+                self.assertEqual(r.signed, False)
+                x >>= 4
+
+            x = testval
+            for i in range(12):
+                r = fixed[i*4:4j]
+                self.assertEqual(r, x & 0xf)
+                self.assertEqual(r.width, 4)
+                self.assertEqual(r.signed, False)
+                x >>= 4
+
+    def test_setslice(self):
+        ff = MutableFixedInt(28, signed=False)
+        testval = 0xbadf00d
+        val = ff(0)
+        for i in range(28):
+            val[i] = testval & (1<<i)
+        self.assertEqual(val, testval)
+
+        val = ff(0)
+        x = testval
+        for i in range(7):
+            val[i*4:i*4+4] = x & 0xf
+            x >>= 4
+        self.assertEqual(val, testval)
+
+        val = ff(0)
+        x = testval
+        for i in range(7):
+            val[i*4:4j] = x & 0xf
+            x >>= 4
+        self.assertEqual(val, testval)
+
+        val = ff(0)
+        val2 = val
+        val[:] = testval
+        self.assertEqual(val2, testval)
+
+    def test_setslice_fixedint(self):
+        # Regression test for GitHub issue #3
+        f16 = FixedInt(16, signed=False, mutable=True)
+        f8 = FixedInt(8, signed=False, mutable=True)
+        x = f16(0x0FFF)
+        y = f8(3)
+        x[0:8] = int(y)
+        assert repr(x) == 'MutableUInt16(3843)'
+        x[0:8] = y
+        assert repr(x) == 'MutableUInt16(3843)'
+
+        f95 = FixedInt(95, signed=False, mutable=True)
+        f40 = FixedInt(40, signed=False, mutable=True)
+        x = f95(0x0FFFFFFFFFFFFFFF)
+        y = f40(0xF)[0:40]
+        x[0:40] = int(y)
+        assert bin(x) == '0b111111111111111111110000000000000000000000000000000000001111'
+        x[0:40] = y
+        assert bin(x) == '0b111111111111111111110000000000000000000000000000000000001111'
+
+tests.append(ExtraFunctionTests)
+
+# ----------------------------------------------------------------------------
+def run(verbosity=1, repeat=1):
+    suite = unittest.TestSuite()
+    for cls in tests:
+        for _ in range(repeat):
+            suite.addTest(unittest.makeSuite(cls))
+
+    runner = unittest.TextTestRunner(verbosity=verbosity)
+    return runner.run(suite)
+
+if __name__ == '__main__':
+    run()