Exemplo n.º 1
0
    def test_gets(self):
        a = BitIndex()
        pos = [random.randint(0, 1000) for i in xrange(100)]
        a.sets(pos)
        self.assertEqual(a.size, max(pos) + 1)
        self.assertEqual(len(a.array), (a.size + 7) >> 3)

        self.assertTrue(a.get(pos[0]))
        self.assertTrue(all(a.gets(pos)))
        self.assertEqual(list(a.positions()), sorted(set(pos)))
Exemplo n.º 2
0
    def test_gets(self):
        a = BitIndex()
        pos = [random.randint(0, 1000) for i in xrange(100)]
        a.sets(pos)
        self.assertEqual(a.size, max(pos) + 1)
        self.assertEqual(len(a.array), (a.size + 7) >> 3)

        self.assertTrue(a.get(pos[0]))
        self.assertTrue(all(a.gets(pos)))
        self.assertEqual(list(a.positions()), sorted(set(pos)))
Exemplo n.º 3
0
    def add(self, value, position):
        if self.index_type == BITMAP_INDEX and len(self.index) > MAX_BIT_INDEX_SIZE:
            index = self.index
            self.index_type = BLOOMFILTER_INDEX
            self.index = Bloomfilter(BF_SIZE, BF_HASHES)
            for v in index:
                for pos in index[v].positions():
                    self.index.add([(v, pos)])

        if self.index_type == BITMAP_INDEX:
            if value not in self.index:
                self.index[value] = BitIndex()
            index = self.index[value]
            index.set(position)

        if self.index_type == BLOOMFILTER_INDEX:
            self.index.add([(value, position)])
            assert (value, position) in self.index
Exemplo n.º 4
0
    def test_sets(self):
        a = BitIndex()
        self.assertEqual(a.size, 0)
        self.assertEqual(len(a.array), 0)
        self.assertFalse(bool(a))
        self.assertEqual(str(a), '')

        a.set(100, True)
        self.assertEqual(a.size, 101)
        self.assertEqual(len(a.array), (a.size + 7) >> 3)
        self.assertEqual(
            a.array, b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10')
        self.assertTrue(bool(a))
        self.assertEqual(str(a), ''.join(['0'] * 100 + ['1']))

        a.sets([1, 3, 16])
        self.assertEqual(a.size, 101)
        self.assertEqual(len(a.array), (a.size + 7) >> 3)
        self.assertEqual(
            a.array, b'\x0a\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10')

        a.append()
        self.assertEqual(a.size, 102)
        self.assertEqual(len(a.array), (a.size + 7) >> 3)
        self.assertEqual(
            a.array, b'\x0a\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30')

        a.append(0)
        self.assertEqual(a.size, 103)
        self.assertEqual(len(a.array), (a.size + 7) >> 3)
        self.assertEqual(
            a.array, b'\x0a\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30')

        a.appends([1, 0, 1, True, 1, None])
        self.assertEqual(a.size, 109)
        self.assertEqual(len(a.array), (a.size + 7) >> 3)
        self.assertEqual(
            a.array,
            b'\x0a\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x0e')
Exemplo n.º 5
0
    def test_operations(self):
        a = BitIndex()
        pos_a = set(random.randint(0, 1000) for i in xrange(100))
        a.sets(pos_a)
        b = BitIndex()
        pos_b = set(random.randint(0, 1000) for i in xrange(100))
        b.sets(pos_b)
        c = BitIndex()
        pos_c = set(random.randint(0, 1000) for i in xrange(100))
        c.sets(pos_c)

        self.assertEqual(list(a.intersect(b)), sorted(pos_a & pos_b))
        self.assertEqual(list(a.intersect(b, c)),
                         sorted(pos_a & pos_b & pos_c))

        self.assertEqual(list(a.union(b)), sorted(pos_a | pos_b))
        self.assertEqual(list(a.union(b, c)), sorted(pos_a | pos_b | pos_c))

        self.assertEqual(list(a.excepts(b)), sorted(pos_a ^ (pos_a & pos_b)))
        self.assertEqual(list(a.excepts(b, c)),
                         sorted(pos_a ^ (pos_a & (pos_b | pos_c))))

        self.assertEqual(list(a.xor(b)), sorted(pos_a ^ pos_b))
Exemplo n.º 6
0
    def test_sets(self):
        a = BitIndex()
        self.assertEqual(a.size, 0)
        self.assertEqual(len(a.array), 0)
        self.assertFalse(bool(a))
        self.assertEqual(str(a), '')

        a.set(100, True)
        self.assertEqual(a.size, 101)
        self.assertEqual(len(a.array), (a.size + 7) >> 3)
        self.assertEqual(a.array, b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10')
        self.assertTrue(bool(a))
        self.assertEqual(str(a), ''.join(['0']*100 + ['1']))

        a.sets([1,3,16])
        self.assertEqual(a.size, 101)
        self.assertEqual(len(a.array), (a.size + 7) >> 3)
        self.assertEqual(a.array, b'\x0a\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10')

        a.append()
        self.assertEqual(a.size, 102)
        self.assertEqual(len(a.array), (a.size + 7) >> 3)
        self.assertEqual(a.array, b'\x0a\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30')

        a.append(0)
        self.assertEqual(a.size, 103)
        self.assertEqual(len(a.array), (a.size + 7) >> 3)
        self.assertEqual(a.array, b'\x0a\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30')

        a.appends([1,0,1,True,1, None])
        self.assertEqual(a.size, 109)
        self.assertEqual(len(a.array), (a.size + 7) >> 3)
        self.assertEqual(a.array, b'\x0a\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x0e')
Exemplo n.º 7
0
    def test_operations(self):
        a = BitIndex()
        pos_a = set(random.randint(0, 1000) for i in xrange(100))
        a.sets(pos_a)
        b = BitIndex()
        pos_b = set(random.randint(0, 1000) for i in xrange(100))
        b.sets(pos_b)
        c = BitIndex()
        pos_c = set(random.randint(0, 1000) for i in xrange(100))
        c.sets(pos_c)

        self.assertEqual(list(a.intersect(b)), sorted(pos_a & pos_b))
        self.assertEqual(list(a.intersect(b, c)), sorted(pos_a & pos_b & pos_c))

        self.assertEqual(list(a.union(b)), sorted(pos_a | pos_b))
        self.assertEqual(list(a.union(b, c)), sorted(pos_a | pos_b | pos_c))

        self.assertEqual(list(a.excepts(b)), sorted(pos_a ^ (pos_a & pos_b)))
        self.assertEqual(list(a.excepts(b, c)), sorted(pos_a ^ (pos_a & (pos_b | pos_c))))

        self.assertEqual(list(a.xor(b)), sorted(pos_a ^ pos_b))