コード例 #1
0
 def test_bitwise_ops(self):
     self.assertEqual(
         int(BitSequence(0x01, length=8) | BitSequence(0x02, length=8)), 3)
     self.assertEqual(
         int(BitSequence(0x07, length=8) & BitSequence(0x02, length=8)), 2)
     self.assertEqual(
         int(BitZSequence(0x01, length=8) | BitSequence(0x02, length=8)), 3)
     self.assertEqual(
         int(BitSequence(0x07, length=8) & BitZSequence(0x02, length=8)), 2)
     self.assertRaises(BitSequenceError, BitZSequence.__or__, self.bzs4,
                       self.bzs5)
     self.assertRaises(BitSequenceError, BitZSequence.__and__, self.bzs4,
                       self.bzs5)
     self.assertEqual(repr(self.bzs6), '00000000100Z01')
     self.assertEqual(repr(self.bzs6 | self.bzs4), '11Z1Z010ZZ0Z01')
     self.assertEqual(repr(self.bzs6 & self.bzs4), '00Z0Z000ZZ0Z00')
     self.assertEqual(repr(self.bzs4 & self.bs7), '11Z1Z010ZZ0000')
     self.assertEqual(repr(self.bs7 & self.bzs4), '11Z1Z010ZZ0000')
     self.assertEqual(repr(self.bzs4 | self.bs7), '11Z1Z010ZZ1101')
     self.assertEqual(repr(self.bs7 | self.bzs4), '11Z1Z010ZZ1101')
     self.assertEqual(repr(self.bs7.invert()), '00000101010110')
     self.assertEqual(repr(self.bzs4.invert()), '00Z0Z101ZZ1011')
     self.assertLess(self.bs5, self.bs6)
     self.assertLessEqual(self.bs5, self.bs6)
     self.assertLess(self.bs6, self.bs5)
     self.assertLessEqual(self.bs6, self.bs5)
コード例 #2
0
ファイル: bits.py プロジェクト: kery-chen/pyftdi
 def test_cmp(self):
     self.assertTrue(self.bs1 == self.bs1)
     self.assertTrue(self.bs1 != self.bs2)
     self.assertTrue(self.bs2 != BitSequence(0x02, msb=True, length=4))
     self.assertTrue(self.bzs2 == self.bzs2)
     self.assertTrue(self.bzs1 != self.bzs2)
     self.assertTrue(self.bs1 == self.bzs1)
     self.assertTrue(self.bzs1 == self.bs1)
     self.assertTrue(self.bzs3 != self.bzs2)
     self.assertNotEqual(self.bzs4, self.bzs5)
     bzs = BitZSequence(self.bs7)
     self.assertTrue(bzs == self.bs7)
     bzs |= BitZSequence('00Z0Z000ZZ0Z00')
     self.assertFalse(bzs == self.bs7)
     self.assertTrue(bzs.matches(self.bs7))
コード例 #3
0
 def test_cmp(self):
     self.assertTrue(self.bs1 == self.bs1)
     self.assertTrue(self.bs1 != self.bs2)
     self.assertTrue(self.bs2 != BitSequence(0x02, msb=True, length=4))
     self.assertTrue(self.bzs2 == self.bzs2)
     self.assertTrue(self.bzs1 != self.bzs2)
     self.assertTrue(self.bs1 == self.bzs1)
     self.assertTrue(self.bzs1 == self.bs1)
     self.assertTrue(self.bzs3 != self.bzs2)
     self.assertNotEqual(self.bzs4, self.bzs5)
     bzs = BitZSequence(self.bs7)
     self.assertTrue(bzs == self.bs7)
     bzs |= BitZSequence('00Z0Z000ZZ0Z00')
     self.assertFalse(bzs == self.bs7)
     self.assertTrue(bzs.matches(self.bs7))
コード例 #4
0
 def test_init(self):
     self.assertEqual(int(BitSequence([0, 0, 1, 0])), 4)
     self.assertEqual(int(BitSequence((0, 1, 0, 0), msb=True)), 4)
     self.assertEqual(int(BitSequence(4, length=8)), 4)
     self.assertEqual(int(BitSequence(int(4), msb=True, length=8)), 32)
     self.assertEqual(int(BitSequence("0010")), 4)
     self.assertEqual(int(BitSequence("0100", msb=True)), 4)
     bs = BitSequence("0100", msb=True)
     self.assertEqual(bs, BitSequence(bs))
     bssub = BitSequence(bs[1:3])
     self.assertEqual(str(bssub), '2: 10')
     bs[0:3] = '11'
     self.assertEqual(str(bs), '4: 0011')
     bzs = BitZSequence(self.bzs4)
     self.assertEqual(bzs, self.bzs4)
     bs = BitSequence('11111010101001', msb=True)
     bs[8:12] = BitSequence(value='0000')
     self.assertEqual(repr(bs), '11000010101001')
     try:
         bs[8:12] = BitZSequence(value='ZZZZ')
     except BitSequenceError:
         pass
     except Exception as e:
         self.fail("Unexpected exception %s" % e)
     else:
         self.fail("Error was expected")
     bs = BitZSequence('1111101010100111Z1Z010ZZ0100', msb=True)
     bs[8:12] = BitZSequence(value='ZZZZ')
     self.assertEqual(repr(bs), '1111101010100111ZZZZ10ZZ0100')
     bs[8:12] = BitSequence(value='0000')
     self.assertEqual(repr(bs), '1111101010100111000010ZZ0100')
     n = 548521358
     bs = BitSequence(bin(n), msb=True)
     self.assertEqual(int(bs), n)
     bzs = BitZSequence(bin(n), msb=True)
     self.assertEqual(str(bzs), '30: 100000 10110001 11000101 10001110')
     bs = BitSequence(bytes_=[0x44, 0x66, 0xcc], msby=False)
     self.assertEqual(int(bs), 0x4466cc)
     bs = BitSequence(bytes_=(0x44, 0x66, 0xcc), msby=True)
     self.assertEqual(int(bs), 0xcc6644)
     try:
         bs = BitSequence(bytes_=[0x44, 0x666, 0xcc], msby=False)
     except BitSequenceError:
         pass
     except Exception as e:
         self.fail("Unexpected exception %s" % e)
     else:
         self.fail("Error was expected")
コード例 #5
0
 def test_conversion(self):
     bs = BitSequence(0xCA, msb=True, length=8)
     self.assertEqual('%02x' % bs.tobyte(False), '53')
     self.assertEqual('%02x' % bs.tobyte(True), 'ca')
     self.assertEqual(bs, BitSequence(bs.tobyte(True), msb=True, length=8))
     self.assertRaises(BitSequenceError, BitZSequence.__int__, self.bzs5)
     self.assertRaises(BitSequenceError, BitZSequence.tobyte, self.bzs5)
     self.assertRaises(BitSequenceError, BitZSequence.tobytes, self.bzs5)
     bzs = BitZSequence(0xaa)
     self.assertEqual(int(bzs), 0xaa)
コード例 #6
0
ファイル: bits.py プロジェクト: kery-chen/pyftdi
 def setUp(self):
     self.bs1 = BitSequence(0x01, msb=True, length=8)
     self.bs2 = BitSequence(0x02, msb=True, length=8)
     self.bs3 = BitSequence(0x04, msb=True, length=7)
     self.bs4 = BitSequence(0x04, msb=True, length=11)
     self.bs5 = BitSequence(299999999999998)
     self.bs6 = BitSequence(299999999999999)
     self.bs7 = BitSequence(value='10010101011111')
     self.bzs1 = BitZSequence(0x01, msb=True, length=8)
     self.bzs2 = BitZSequence('0Z1')
     self.bzs3 = BitZSequence('0Z1', length=5)
     self.bzs4 = BitZSequence('0010ZZ010Z1Z11')
     self.bzs5 = BitZSequence(value=[True, False, None, False, False, True])
     self.bzs6 = BitZSequence(value=[True, False, None, False, False, True],
                              length=len(self.bzs4))
コード例 #7
0
 def test_init(self):
     self.assertEqual(int(BitSequence([0, 0, 1, 0])), 4)
     self.assertEqual(int(BitSequence((0, 1, 0, 0), msb=True)), 4)
     self.assertEqual(int(BitSequence(4, length=8)), 4)
     self.assertEqual(int(BitSequence(4L, msb=True, length=8)), 32)
     self.assertEqual(int(BitSequence("0010")), 4)
     self.assertEqual(int(BitSequence("0100", msb=True)), 4)
     bs = BitSequence("0100", msb=True)
     self.assertEqual(bs, BitSequence(bs))
     bssub = BitSequence(bs[1:3])
     self.assertEqual(str(bssub), '2: 10')
     bs[0:3] = '11'
     self.assertEqual(str(bs), '3: 011')
     bzs = BitZSequence(self.bzs4)
     self.assertEqual(bzs, self.bzs4)
     bs = BitSequence('11111010101001', msb=True)
     bs[8:12] = BitSequence(value = '0000')
     self.assertEqual(repr(bs), '11000010101001')
     try:
         bs[8:12] = BitZSequence(value = 'ZZZZ')
     except BitSequenceError:
         pass
     except Exception, e:
         self.fail("Unexpected exception %s" % e)
コード例 #8
0
 def setUp(self):
     self.bs1 = BitSequence(0x01, msb=True, length=8)
     self.bs2 = BitSequence(0x02, msb=True, length=8)
     self.bs3 = BitSequence(0x04, msb=True, length=7)
     self.bs4 = BitSequence(0x04, msb=True, length=11)
     self.bs5 = BitSequence(299999999999998)
     self.bs6 = BitSequence(299999999999999)
     self.bs7 = BitSequence(value="10010101011111")
     self.bzs1 = BitZSequence(0x01, msb=True, length=8)
     self.bzs2 = BitZSequence('0Z1')
     self.bzs3 = BitZSequence('0Z1', length=5)
     self.bzs4 = BitZSequence("0010ZZ010Z1Z11")
     self.bzs5 = BitZSequence(value=[True, False, None, False, False, True])
     self.bzs6 = BitZSequence(value=[True, False, None, False, False, True],
                              length=len(self.bzs4))
コード例 #9
0
ファイル: bits.py プロジェクト: kery-chen/pyftdi
class BitSequenceTestCase(unittest.TestCase):

    def setUp(self):
        self.bs1 = BitSequence(0x01, msb=True, length=8)
        self.bs2 = BitSequence(0x02, msb=True, length=8)
        self.bs3 = BitSequence(0x04, msb=True, length=7)
        self.bs4 = BitSequence(0x04, msb=True, length=11)
        self.bs5 = BitSequence(299999999999998)
        self.bs6 = BitSequence(299999999999999)
        self.bs7 = BitSequence(value='10010101011111')
        self.bzs1 = BitZSequence(0x01, msb=True, length=8)
        self.bzs2 = BitZSequence('0Z1')
        self.bzs3 = BitZSequence('0Z1', length=5)
        self.bzs4 = BitZSequence('0010ZZ010Z1Z11')
        self.bzs5 = BitZSequence(value=[True, False, None, False, False, True])
        self.bzs6 = BitZSequence(value=[True, False, None, False, False, True],
                                 length=len(self.bzs4))

    def test_bitwise_ops(self):
        self.assertEqual(int(BitSequence(0x01, length=8) |
                             BitSequence(0x02, length=8)), 3)
        self.assertEqual(int(BitSequence(0x07, length=8) &
                             BitSequence(0x02, length=8)), 2)
        self.assertEqual(int(BitZSequence(0x01, length=8) |
                             BitSequence(0x02, length=8)), 3)
        self.assertEqual(int(BitSequence(0x07, length=8) &
                             BitZSequence(0x02, length=8)), 2)
        self.assertRaises(BitSequenceError, BitZSequence.__or__,
                          self.bzs4, self.bzs5)
        self.assertRaises(BitSequenceError, BitZSequence.__and__,
                          self.bzs4, self.bzs5)
        self.assertEqual(repr(self.bzs6), '00000000100Z01')
        self.assertEqual(repr(self.bzs6 | self.bzs4), '11Z1Z010ZZ0Z01')
        self.assertEqual(repr(self.bzs6 & self.bzs4), '00Z0Z000ZZ0Z00')
        self.assertEqual(repr(self.bzs4 & self.bs7), '11Z1Z010ZZ0000')
        self.assertEqual(repr(self.bs7 & self.bzs4), '11Z1Z010ZZ0000')
        self.assertEqual(repr(self.bzs4 | self.bs7), '11Z1Z010ZZ1101')
        self.assertEqual(repr(self.bs7 | self.bzs4), '11Z1Z010ZZ1101')
        self.assertEqual(repr(self.bs7.invert()), '00000101010110')
        self.assertEqual(repr(self.bzs4.invert()), '00Z0Z101ZZ1011')

    def test_cmp(self):
        self.assertTrue(self.bs1 == self.bs1)
        self.assertTrue(self.bs1 != self.bs2)
        self.assertTrue(self.bs2 != BitSequence(0x02, msb=True, length=4))
        self.assertTrue(self.bzs2 == self.bzs2)
        self.assertTrue(self.bzs1 != self.bzs2)
        self.assertTrue(self.bs1 == self.bzs1)
        self.assertTrue(self.bzs1 == self.bs1)
        self.assertTrue(self.bzs3 != self.bzs2)
        self.assertNotEqual(self.bzs4, self.bzs5)
        bzs = BitZSequence(self.bs7)
        self.assertTrue(bzs == self.bs7)
        bzs |= BitZSequence('00Z0Z000ZZ0Z00')
        self.assertFalse(bzs == self.bs7)
        self.assertTrue(bzs.matches(self.bs7))

    def test_representation(self):
        self.assertEqual("%s / %r" % (self.bs1, self.bs1),
                         "8: 10000000 / 10000000")
        self.assertEqual("%s / %r" % (self.bs2, self.bs2),
                         "8: 01000000 / 01000000")
        self.assertEqual("%s / %r" % (self.bs3, self.bs3),
                         "7: 0010000 / 0010000")
        self.assertEqual("%s / %r" % (self.bs4, self.bs4),
                         "11: 001 00000000 / 00100000000")
        self.assertEqual("%s / %r" % (self.bs5, self.bs5),
                         "49: 1 00010000 11011001 00110001 01101110 10111111 "
                         "11111110 / 100010000110110010011000101101110101111"
                         "1111111110")
        self.assertEqual("%s / %r" % (self.bs6, self.bs6),
                         "49: 1 00010000 11011001 00110001 01101110 10111111 "
                         "11111111 / 100010000110110010011000101101110101111"
                         "1111111111")

        self.assertEqual(repr(self.bzs4), '11Z1Z010ZZ0100')
        self.assertEqual(repr(self.bzs5), '100Z01')

    def test_init(self):
        self.assertEqual(int(BitSequence([0, 0, 1, 0])), 4)
        self.assertEqual(int(BitSequence((0, 1, 0, 0), msb=True)), 4)
        self.assertEqual(int(BitSequence(4, length=8)), 4)
        self.assertEqual(int(BitSequence(long(4), msb=True, length=8)), 32)
        self.assertEqual(int(BitSequence("0010")), 4)
        self.assertEqual(int(BitSequence("0100", msb=True)), 4)
        bs = BitSequence("0100", msb=True)
        self.assertEqual(bs, BitSequence(bs))
        bssub = BitSequence(bs[1:3])
        self.assertEqual(str(bssub), '2: 10')
        bs[0:3] = '11'
        self.assertEqual(str(bs), '4: 0011')
        bzs = BitZSequence(self.bzs4)
        self.assertEqual(bzs, self.bzs4)
        bs = BitSequence('11111010101001', msb=True)
        bs[8:12] = BitSequence(value='0000')
        self.assertEqual(repr(bs), '11000010101001')
        try:
            bs[8:12] = BitZSequence(value='ZZZZ')
        except BitSequenceError:
            pass
        except Exception as e:
            self.fail("Unexpected exception %s" % e)
        else:
            self.fail("Error was expected")
        bs = BitZSequence('1111101010100111Z1Z010ZZ0100', msb=True)
        bs[8:12] = BitZSequence(value='ZZZZ')
        self.assertEqual(repr(bs), '1111101010100111ZZZZ10ZZ0100')
        bs[8:12] = BitSequence(value='0000')
        self.assertEqual(repr(bs), '1111101010100111000010ZZ0100')
        n = 548521358
        bs = BitSequence(bin(n), msb=True)
        self.assertEqual(int(bs), n)
        bzs = BitZSequence(bin(n), msb=True)
        self.assertEqual(str(bzs), '30: 100000 10110001 11000101 10001110')
        bs = BitSequence(bytes_=[0x44, 0x66, 0xcc], msby=False)
        self.assertEqual(int(bs), 0x4466cc)
        bs = BitSequence(bytes_=(0x44, 0x66, 0xcc), msby=True)
        self.assertEqual(int(bs), 0xcc6644)
        try:
           bs = BitSequence(bytes_=[0x44, 0x666, 0xcc], msby=False)
        except BitSequenceError:
            pass
        except Exception as e:
            self.fail("Unexpected exception %s" % e)
        else:
            self.fail("Error was expected")

    def test_conversion(self):
        bs = BitSequence(0xCA, msb=True, length=8)
        self.assertEqual('%02x' % bs.tobyte(False), '53')
        self.assertEqual('%02x' % bs.tobyte(True), 'ca')
        self.assertEqual(bs, BitSequence(bs.tobyte(True), msb=True, length=8))
        self.assertRaises(BitSequenceError, BitZSequence.__int__, self.bzs5)
        self.assertRaises(BitSequenceError, BitZSequence.tobyte, self.bzs5)
        self.assertRaises(BitSequenceError, BitZSequence.tobytes, self.bzs5)
        bzs = BitZSequence(0xaa)
        self.assertEqual(int(bzs), 0xaa)

    def test_misc(self):
        ba = BitSequence(12, msb=True, length=16)
        bb = BitSequence(12, msb=True, length=14)
        l = [ba, bb]
        l.sort(key=int)
        self.assertEqual(str(l), "[00110000000000, 0011000000000000]")
        self.assertEqual(str(ba.tobytes()), "[48, 0]")
        self.assertEqual(str(ba.tobytes(True)), "[0, 12]")
        self.assertEqual(str(bb.tobytes(True)), "[0, 12]")

        b = BitSequence(length=254)
        b[0:4] = '1111'
        self.assertEqual(str(b), '254: 000000 00000000 00000000 00000000 '
         '00000000 00000000 00000000 00000000 00000000 00000000 00000000 '
         '00000000 00000000 00000000 00000000 00000000 00000000 00000000 '
         '00000000 00000000 00000000 00000000 00000000 00000000 00000000 '
         '00000000 00000000 00000000 00000000 00000000 00000000 00001111')
        self.assertEqual(str(b.tobytes()),
            '[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, '
            '0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15]')

        b = BitSequence(bytes_=[0xa0, '\x0f', 0x77], msb=False, msby=False)
        self.assertEqual(str(['%02x' % x for x in b.tobytes(False)]),
                         "['a0', '0f', '77']")
        b = BitSequence(bytes_=[0xa0, '\x0f', 0x77], msb=True, msby=True)
        self.assertEqual(str(['%02x' % x for x in b.tobytes(True)]),
                         "['a0', '0f', '77']")
        b = BitSequence(length=7)
        b[6] = '1'
        self.assertEqual(str(b), '7: 1000000')

    def test_rotations(self):
        b = BitSequence('10101110')
        b.lsr(2)
        self.assertEqual(str(b), '8: 01011101')
        b.lsr(10)
        self.assertEqual(str(b), '8: 01010111')
        b.rsr(3)
        self.assertEqual(str(b), '8: 10111010')

    def test_concat(self):
        self.assertEqual(repr(self.bzs4+self.bzs5), '100Z0111Z1Z010ZZ0100')
        self.assertEqual(repr(self.bzs4+self.bs7),
                         '1111101010100111Z1Z010ZZ0100')
        self.assertEqual(repr(self.bs7+self.bzs4),
                         '11Z1Z010ZZ010011111010101001')
コード例 #10
0
class BitSequenceTestCase(unittest.TestCase):

    def setUp(self):
        self.bs1 = BitSequence(0x01, msb=True, length=8)
        self.bs2 = BitSequence(0x02, msb=True, length=8)
        self.bs3 = BitSequence(0x04, msb=True, length=7)
        self.bs4 = BitSequence(0x04, msb=True, length=11)
        self.bs5 = BitSequence(299999999999998)
        self.bs6 = BitSequence(299999999999999)
        self.bs7 = BitSequence(value="10010101011111")
        self.bzs1 = BitZSequence(0x01, msb=True, length=8)
        self.bzs2 = BitZSequence('0Z1')
        self.bzs3 = BitZSequence('0Z1', length=5)
        self.bzs4 = BitZSequence("0010ZZ010Z1Z11")
        self.bzs5 = BitZSequence(value=[True, False, None, False, False, True])
        self.bzs6 = BitZSequence(value=[True, False, None, False, False, True],
                                 length=len(self.bzs4))

    def test_bitwise_ops(self):
        self.assertEqual(int(BitSequence(0x01, length=8) | \
                             BitSequence(0x02, length=8)), 3)
        self.assertEqual(int(BitSequence(0x07, length=8) & \
                             BitSequence(0x02, length=8)), 2)
        self.assertEqual(int(BitZSequence(0x01, length=8) | \
                             BitSequence(0x02, length=8)), 3)
        self.assertEqual(int(BitSequence(0x07, length=8) & \
                             BitZSequence(0x02, length=8)), 2)
        self.assertRaises(BitSequenceError, BitZSequence.__or__,
                                    self.bzs4, self.bzs5)
        self.assertRaises(BitSequenceError, BitZSequence.__and__,
                                    self.bzs4, self.bzs5)
        self.assertEqual(repr(self.bzs6), '00000000100Z01')
        self.assertEqual(repr(self.bzs6 | self.bzs4), '11Z1Z010ZZ0Z01')
        self.assertEqual(repr(self.bzs6 & self.bzs4), '00Z0Z000ZZ0Z00')
        self.assertEqual(repr(self.bzs4 & self.bs7), '11Z1Z010ZZ0000')
        self.assertEqual(repr(self.bs7 & self.bzs4), '11Z1Z010ZZ0000')
        self.assertEqual(repr(self.bzs4 | self.bs7), '11Z1Z010ZZ1101')
        self.assertEqual(repr(self.bs7 | self.bzs4), '11Z1Z010ZZ1101')
        self.assertEqual(repr(self.bs7.invert()), '00000101010110')
        self.assertEqual(repr(self.bzs4.invert()), '00Z0Z101ZZ1011')

    def test_cmp(self):
        self.assertTrue(self.bs1 == self.bs1)
        self.assertTrue(self.bs1 != self.bs2)
        self.assertTrue(self.bs2 != BitSequence(0x02, msb=True, length=4))
        self.assertTrue(self.bzs2 == self.bzs2)
        self.assertTrue(self.bzs1 != self.bzs2)
        self.assertTrue(self.bs1 == self.bzs1)
        self.assertTrue(self.bzs1 == self.bs1)
        self.assertTrue(self.bzs3 != self.bzs2)
        self.assertNotEqual(self.bzs4, self.bzs5)
        bzs = BitZSequence(self.bs7)
        self.assertTrue(bzs == self.bs7)
        bzs |= BitZSequence('00Z0Z000ZZ0Z00')
        self.assertFalse(bzs == self.bs7)
        self.assertTrue(bzs.matches(self.bs7))

    def test_representation(self):
        self.assertEqual("%s / %r" % (self.bs1, self.bs1),
                         "8: 10000000 / 10000000")
        self.assertEqual("%s / %r" % (self.bs2, self.bs2),
                         "8: 01000000 / 01000000")
        self.assertEqual("%s / %r" % (self.bs3, self.bs3),
                         "7: 0010000 / 0010000")
        self.assertEqual("%s / %r" % (self.bs4, self.bs4),
                         "11: 001 00000000 / 00100000000")
        self.assertEqual("%s / %r" % (self.bs5, self.bs5),
                         "49: 1 00010000 11011001 00110001 01101110 10111111 "\
                         "11111110 / 100010000110110010011000101101110101111"\
                         "1111111110")
        self.assertEqual("%s / %r" % (self.bs6, self.bs6),
                         "49: 1 00010000 11011001 00110001 01101110 10111111 "\
                         "11111111 / 100010000110110010011000101101110101111"\
                         "1111111111")

        self.assertEqual(repr(self.bzs4), '11Z1Z010ZZ0100')
        self.assertEqual(repr(self.bzs5), '100Z01')

    def test_init(self):
        self.assertEqual(int(BitSequence([0, 0, 1, 0])), 4)
        self.assertEqual(int(BitSequence((0, 1, 0, 0), msb=True)), 4)
        self.assertEqual(int(BitSequence(4, length=8)), 4)
        self.assertEqual(int(BitSequence(4L, msb=True, length=8)), 32)
        self.assertEqual(int(BitSequence("0010")), 4)
        self.assertEqual(int(BitSequence("0100", msb=True)), 4)
        bs = BitSequence("0100", msb=True)
        self.assertEqual(bs, BitSequence(bs))
        bssub = BitSequence(bs[1:3])
        self.assertEqual(str(bssub), '2: 10')
        bs[0:3] = '11'
        self.assertEqual(str(bs), '3: 011')
        bzs = BitZSequence(self.bzs4)
        self.assertEqual(bzs, self.bzs4)
        bs = BitSequence('11111010101001', msb=True)
        bs[8:12] = BitSequence(value = '0000')
        self.assertEqual(repr(bs), '11000010101001')
        try:
            bs[8:12] = BitZSequence(value = 'ZZZZ')
        except BitSequenceError:
            pass
        except Exception, e:
            self.fail("Unexpected exception %s" % e)
        else:
コード例 #11
0
 bs[0:3] = '11'
 self.assertEqual(str(bs), '3: 011')
 bzs = BitZSequence(self.bzs4)
 self.assertEqual(bzs, self.bzs4)
 bs = BitSequence('11111010101001', msb=True)
 bs[8:12] = BitSequence(value = '0000')
 self.assertEqual(repr(bs), '11000010101001')
 try:
     bs[8:12] = BitZSequence(value = 'ZZZZ')
 except BitSequenceError:
     pass
 except Exception, e:
     self.fail("Unexpected exception %s" % e)
 else:
     self.fail("Error was expected")
 bs = BitZSequence('1111101010100111Z1Z010ZZ0100', msb=True)
 bs[8:12] = BitZSequence(value = 'ZZZZ')
 self.assertEqual(repr(bs), '1111101010100111ZZZZ10ZZ0100')
 bs[8:12] = BitSequence(value = '0000')
 self.assertEqual(repr(bs), '1111101010100111000010ZZ0100')
 n = 548521358
 bs = BitSequence(bin(n), msb=True)
 self.assertEqual(int(bs), n)
 bzs = BitZSequence(bin(n), msb=True)
 self.assertEqual(str(bzs),
     '30: 100000 10110001 11000101 10001110')
 bs = BitSequence(bytes_=[0x44, 0x66, 0xcc], msby=False)
 self.assertEqual(int(bs), 0x4466cc)
 bs = BitSequence(bytes_=(0x44, 0x66, 0xcc), msby=True)
 self.assertEqual(int(bs), 0xcc6644)
 try:
コード例 #12
0
class BitSequenceTestCase(unittest.TestCase):
    def setUp(self):
        self.bs1 = BitSequence(0x01, msb=True, length=8)
        self.bs2 = BitSequence(0x02, msb=True, length=8)
        self.bs3 = BitSequence(0x04, msb=True, length=7)
        self.bs4 = BitSequence(0x04, msb=True, length=11)
        self.bs5 = BitSequence(299999999999998)
        self.bs6 = BitSequence(299999999999999)
        self.bs7 = BitSequence(value='10010101011111')
        self.bzs1 = BitZSequence(0x01, msb=True, length=8)
        self.bzs2 = BitZSequence('0Z1')
        self.bzs3 = BitZSequence('0Z1', length=5)
        self.bzs4 = BitZSequence('0010ZZ010Z1Z11')
        self.bzs5 = BitZSequence(value=[True, False, None, False, False, True])
        self.bzs6 = BitZSequence(value=[True, False, None, False, False, True],
                                 length=len(self.bzs4))

    def test_bitwise_ops(self):
        self.assertEqual(
            int(BitSequence(0x01, length=8) | BitSequence(0x02, length=8)), 3)
        self.assertEqual(
            int(BitSequence(0x07, length=8) & BitSequence(0x02, length=8)), 2)
        self.assertEqual(
            int(BitZSequence(0x01, length=8) | BitSequence(0x02, length=8)), 3)
        self.assertEqual(
            int(BitSequence(0x07, length=8) & BitZSequence(0x02, length=8)), 2)
        self.assertRaises(BitSequenceError, BitZSequence.__or__, self.bzs4,
                          self.bzs5)
        self.assertRaises(BitSequenceError, BitZSequence.__and__, self.bzs4,
                          self.bzs5)
        self.assertEqual(repr(self.bzs6), '00000000100Z01')
        self.assertEqual(repr(self.bzs6 | self.bzs4), '11Z1Z010ZZ0Z01')
        self.assertEqual(repr(self.bzs6 & self.bzs4), '00Z0Z000ZZ0Z00')
        self.assertEqual(repr(self.bzs4 & self.bs7), '11Z1Z010ZZ0000')
        self.assertEqual(repr(self.bs7 & self.bzs4), '11Z1Z010ZZ0000')
        self.assertEqual(repr(self.bzs4 | self.bs7), '11Z1Z010ZZ1101')
        self.assertEqual(repr(self.bs7 | self.bzs4), '11Z1Z010ZZ1101')
        self.assertEqual(repr(self.bs7.invert()), '00000101010110')
        self.assertEqual(repr(self.bzs4.invert()), '00Z0Z101ZZ1011')
        self.assertLess(self.bs5, self.bs6)
        self.assertLessEqual(self.bs5, self.bs6)
        self.assertLess(self.bs6, self.bs5)
        self.assertLessEqual(self.bs6, self.bs5)

    def test_cmp(self):
        self.assertTrue(self.bs1 == self.bs1)
        self.assertTrue(self.bs1 != self.bs2)
        self.assertTrue(self.bs2 != BitSequence(0x02, msb=True, length=4))
        self.assertTrue(self.bzs2 == self.bzs2)
        self.assertTrue(self.bzs1 != self.bzs2)
        self.assertTrue(self.bs1 == self.bzs1)
        self.assertTrue(self.bzs1 == self.bs1)
        self.assertTrue(self.bzs3 != self.bzs2)
        self.assertNotEqual(self.bzs4, self.bzs5)
        bzs = BitZSequence(self.bs7)
        self.assertTrue(bzs == self.bs7)
        bzs |= BitZSequence('00Z0Z000ZZ0Z00')
        self.assertFalse(bzs == self.bs7)
        self.assertTrue(bzs.matches(self.bs7))

    def test_representation(self):
        self.assertEqual("%s / %r" % (self.bs1, self.bs1),
                         "8: 10000000 / 10000000")
        self.assertEqual("%s / %r" % (self.bs2, self.bs2),
                         "8: 01000000 / 01000000")
        self.assertEqual("%s / %r" % (self.bs3, self.bs3),
                         "7: 0010000 / 0010000")
        self.assertEqual("%s / %r" % (self.bs4, self.bs4),
                         "11: 001 00000000 / 00100000000")
        self.assertEqual(
            "%s / %r" % (self.bs5, self.bs5),
            "49: 1 00010000 11011001 00110001 01101110 10111111 "
            "11111110 / 100010000110110010011000101101110101111"
            "1111111110")
        self.assertEqual(
            "%s / %r" % (self.bs6, self.bs6),
            "49: 1 00010000 11011001 00110001 01101110 10111111 "
            "11111111 / 100010000110110010011000101101110101111"
            "1111111111")

        self.assertEqual(repr(self.bzs4), '11Z1Z010ZZ0100')
        self.assertEqual(repr(self.bzs5), '100Z01')

    def test_init(self):
        self.assertEqual(int(BitSequence([0, 0, 1, 0])), 4)
        self.assertEqual(int(BitSequence((0, 1, 0, 0), msb=True)), 4)
        self.assertEqual(int(BitSequence(4, length=8)), 4)
        self.assertEqual(int(BitSequence(int(4), msb=True, length=8)), 32)
        self.assertEqual(int(BitSequence("0010")), 4)
        self.assertEqual(int(BitSequence("0100", msb=True)), 4)
        bs = BitSequence("0100", msb=True)
        self.assertEqual(bs, BitSequence(bs))
        bssub = BitSequence(bs[1:3])
        self.assertEqual(str(bssub), '2: 10')
        bs[0:3] = '11'
        self.assertEqual(str(bs), '4: 0011')
        bzs = BitZSequence(self.bzs4)
        self.assertEqual(bzs, self.bzs4)
        bs = BitSequence('11111010101001', msb=True)
        bs[8:12] = BitSequence(value='0000')
        self.assertEqual(repr(bs), '11000010101001')
        try:
            bs[8:12] = BitZSequence(value='ZZZZ')
        except BitSequenceError:
            pass
        except Exception as e:
            self.fail("Unexpected exception %s" % e)
        else:
            self.fail("Error was expected")
        bs = BitZSequence('1111101010100111Z1Z010ZZ0100', msb=True)
        bs[8:12] = BitZSequence(value='ZZZZ')
        self.assertEqual(repr(bs), '1111101010100111ZZZZ10ZZ0100')
        bs[8:12] = BitSequence(value='0000')
        self.assertEqual(repr(bs), '1111101010100111000010ZZ0100')
        n = 548521358
        bs = BitSequence(bin(n), msb=True)
        self.assertEqual(int(bs), n)
        bzs = BitZSequence(bin(n), msb=True)
        self.assertEqual(str(bzs), '30: 100000 10110001 11000101 10001110')
        bs = BitSequence(bytes_=[0x44, 0x66, 0xcc], msby=False)
        self.assertEqual(int(bs), 0x4466cc)
        bs = BitSequence(bytes_=(0x44, 0x66, 0xcc), msby=True)
        self.assertEqual(int(bs), 0xcc6644)
        try:
            bs = BitSequence(bytes_=[0x44, 0x666, 0xcc], msby=False)
        except BitSequenceError:
            pass
        except Exception as e:
            self.fail("Unexpected exception %s" % e)
        else:
            self.fail("Error was expected")

    def test_conversion(self):
        bs = BitSequence(0xCA, msb=True, length=8)
        self.assertEqual('%02x' % bs.tobyte(False), '53')
        self.assertEqual('%02x' % bs.tobyte(True), 'ca')
        self.assertEqual(bs, BitSequence(bs.tobyte(True), msb=True, length=8))
        self.assertRaises(BitSequenceError, BitZSequence.__int__, self.bzs5)
        self.assertRaises(BitSequenceError, BitZSequence.tobyte, self.bzs5)
        self.assertRaises(BitSequenceError, BitZSequence.tobytes, self.bzs5)
        bzs = BitZSequence(0xaa)
        self.assertEqual(int(bzs), 0xaa)

    def test_misc(self):
        ba = BitSequence(12, msb=True, length=16)
        bb = BitSequence(12, msb=True, length=14)
        bl = [ba, bb]
        bl.sort(key=int)
        self.assertEqual(str(bl), "[00110000000000, 0011000000000000]")
        self.assertEqual(str(ba.tobytes()), "[48, 0]")
        self.assertEqual(str(ba.tobytes(True)), "[0, 12]")
        self.assertEqual(str(bb.tobytes(True)), "[0, 12]")

        b = BitSequence(length=254)
        b[0:4] = '1111'
        self.assertEqual(
            str(b), '254: 000000 00000000 00000000 00000000 '
            '00000000 00000000 00000000 00000000 00000000 00000000 00000000 '
            '00000000 00000000 00000000 00000000 00000000 00000000 00000000 '
            '00000000 00000000 00000000 00000000 00000000 00000000 00000000 '
            '00000000 00000000 00000000 00000000 00000000 00000000 00001111')
        self.assertEqual(
            str(b.tobytes()),
            '[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, '
            '0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15]')

        b = BitSequence(bytes_=[0xa0, '\x0f', 0x77], msb=False, msby=False)
        self.assertEqual(str(['%02x' % x for x in b.tobytes(False)]),
                         "['a0', '0f', '77']")
        b = BitSequence(bytes_=[0xa0, '\x0f', 0x77], msb=True, msby=True)
        self.assertEqual(str(['%02x' % x for x in b.tobytes(True)]),
                         "['a0', '0f', '77']")
        b = BitSequence(length=7)
        b[6] = '1'
        self.assertEqual(str(b), '7: 1000000')

    def test_rotations(self):
        b = BitSequence('10101110')
        b.lsr(2)
        self.assertEqual(str(b), '8: 01011101')
        b.lsr(10)
        self.assertEqual(str(b), '8: 01010111')
        b.rsr(3)
        self.assertEqual(str(b), '8: 10111010')

    def test_concat(self):
        self.assertEqual(repr(self.bzs4 + self.bzs5), '100Z0111Z1Z010ZZ0100')
        self.assertEqual(repr(self.bzs4 + self.bs7),
                         '1111101010100111Z1Z010ZZ0100')
        self.assertEqual(repr(self.bs7 + self.bzs4),
                         '11Z1Z010ZZ010011111010101001')