def test_cache_table_empty_table(self) -> None: inst = MemoryDescriptorSet(DataMemoryElement(), -1) inst._table = {} expected_table_pickle_bytes = pickle.dumps(inst._table, -1) inst.cache_table() assert inst.cache_element is not None self.assertEqual(inst.cache_element.get_bytes(), expected_table_pickle_bytes)
def test_remove_from_index_shared_hashes_partial(self) -> None: """ Test that only some hashes are removed from the hash index, but not others when those hashes still refer to other descriptors. """ # Simulate initial state with some descriptor hashed to one value and # other descriptors hashed to another. # Vectors of length 1 for easy dummy hashing prediction. descriptors = [ DescriptorMemoryElement(0).set_vector([0]), DescriptorMemoryElement(1).set_vector([1]), DescriptorMemoryElement(2).set_vector([2]), DescriptorMemoryElement(3).set_vector([3]), DescriptorMemoryElement(4).set_vector([4]), ] # Dummy hash function to do the simulated thing hash_func = DummyHashFunctor() hash_func.get_hash = mock.Mock( # type: ignore # Vectors of even sum hash to 0, odd to 1. side_effect=lambda vec: [vec.sum() % 2] ) d_set = MemoryDescriptorSet() d_set._table = { 0: descriptors[0], 1: descriptors[1], 2: descriptors[2], 3: descriptors[3], 4: descriptors[4], } hash2uid_kvs = MemoryKeyValueStore() hash2uid_kvs._table = { 0: {0, 2, 4}, 1: {1, 3}, } idx = LSHNearestNeighborIndex(hash_func, d_set, hash2uid_kvs) idx.hash_index = mock.Mock(spec=HashIndex) idx.remove_from_index([1, 2, 3]) # Check that only one hash vector was passed to hash_index's removal # method (deque of hash-code vectors). idx.hash_index.remove_from_index.assert_called_once_with( collections.deque([ [1], ]) ) self.assertDictEqual(d_set._table, { 0: descriptors[0], 4: descriptors[4], }) self.assertDictEqual(hash2uid_kvs._table, {0: {0, 4}})
def test_cache_table_no_cache(self) -> None: inst = MemoryDescriptorSet() inst._table = {} inst.cache_table() # should basically do nothing self.assertIsNone(inst.cache_element)