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()