def run_basic_test(allocator_type): print('-- [%s] basic' % allocator_type) before_lsof_count = len(get_current_process_lsof().splitlines()) q = sharedstructures.PriorityQueue(POOL_NAME_PREFIX + allocator_type, allocator_type) assert len(q) == 0 q.push(b"v1"); assert 1 == len(q) q.push(b"v3"); assert 2 == len(q) q.push(b"v20"); assert 3 == len(q) q.push(b"v2"); assert 4 == len(q) assert b"v1" == q.pop() assert 3 == len(q) assert b"v2" == q.pop() assert 2 == len(q) assert b"v20" == q.pop() assert 1 == len(q) assert b"v3" == q.pop() assert 0 == len(q) try: q.pop() assert False except IndexError: pass del q # this should unmap the shared memory pool and close the fd sharedstructures.delete_pool(POOL_NAME_PREFIX + allocator_type) # make sure we didn't leak an fd assert before_lsof_count == len(get_current_process_lsof().splitlines())
def main(): try: sharedstructures.delete_pool(POOL_NAME) run_basic_test() print('all tests passed') return 0 finally: sharedstructures.delete_pool(POOL_NAME)
def run_basic_test(allocator_type): print('-- [%s] basic' % allocator_type) before_lsof_count = len(get_current_process_lsof().splitlines()) table = sharedstructures.PrefixTree(POOL_NAME_PREFIX + allocator_type, allocator_type) expected = {} def insert_both(e, t, k, v): t[k] = v e[k] = v def delete_both(e, t, k): del t[k] del e[k] verify_state(expected, table) insert_both(expected, table, b'key1', b'value1') verify_state(expected, table) insert_both(expected, table, b'key2', b'value2') verify_state(expected, table) insert_both(expected, table, b'key3', b'value3') verify_state(expected, table) assert [b'key2', b'key3'] == list(table.keys_from(b'key2')) assert [(b'key2', b'value2'), (b'key3', b'value3')] == list(table.items_from(b'key2')) assert [b'key3'] == list(table.keys_from(b'key3')) assert [(b'key3', b'value3')] == list(table.items_from(b'key3')) assert [] == list(table.keys_from(b'key4')) assert [] == list(table.items_from(b'key4')) delete_both(expected, table, b'key2') verify_state(expected, table) try: del table[b'key2'] assert False, "del table[\'key2\'] did not raise KeyError" except KeyError: pass verify_state(expected, table) insert_both(expected, table, b'key1', b'value0') verify_state(expected, table) delete_both(expected, table, b'key1') verify_state(expected, table) delete_both(expected, table, b'key3') verify_state(expected, table) assert {} == expected del table # this should unmap the shared memory pool and close the fd sharedstructures.delete_pool(POOL_NAME_PREFIX + allocator_type) # make sure we didn't leak an fd assert before_lsof_count == len(get_current_process_lsof().splitlines())
def main(): try: sharedstructures.delete_pool('test-vector') run_basic_test() print('all tests passed') return 0 finally: sharedstructures.delete_pool('test-vector')
def run_basic_test(allocator_type): print("-- [%s] basic" % allocator_type) before_lsof_count = len(get_current_process_lsof().splitlines()) table = sharedstructures.HashTable(POOL_NAME_PREFIX + allocator_type, allocator_type) expected = {} def insert_both(e, t, k, v): t[k] = v e[k] = v def delete_both(e, t, k): del t[k] del e[k] verify_state(expected, table) insert_both(expected, table, b'key1', b'value1') verify_state(expected, table) insert_both(expected, table, b'key2', b'value2') verify_state(expected, table) insert_both(expected, table, b'key3', b'value3') verify_state(expected, table) delete_both(expected, table, b'key2') verify_state(expected, table) try: del table[b'key2'] assert False, "del table[\'key2\'] did not raise KeyError" except KeyError: pass verify_state(expected, table) insert_both(expected, table, b'key1', b'value0') verify_state(expected, table) delete_both(expected, table, b'key1') verify_state(expected, table) delete_both(expected, table, b'key3') verify_state(expected, table) assert {} == expected del table # this should unmap the shared memory pool and close the fd sharedstructures.delete_pool(POOL_NAME_PREFIX + allocator_type) # this will fail if the test prints anything after before_lsof is taken since # the stdout/stderr offsets will be different assert before_lsof_count == len(get_current_process_lsof().splitlines())
def main(): try: for allocator_type in ('simple', 'logarithmic'): sharedstructures.delete_pool('test-table') run_basic_test(allocator_type) run_conditional_writes_test(allocator_type) run_reorganization_test(allocator_type) run_types_test(allocator_type) run_complex_types_test(allocator_type) run_incr_test(allocator_type) run_concurrent_readers_test(allocator_type) print('all tests passed') return 0 finally: sharedstructures.delete_pool('test-table')
def main(): try: for allocator_type in ALLOCATOR_TYPES: sharedstructures.delete_pool(POOL_NAME_PREFIX + allocator_type) run_basic_test(allocator_type) sharedstructures.delete_pool(POOL_NAME_PREFIX + allocator_type) run_raw_test(allocator_type) sharedstructures.delete_pool(POOL_NAME_PREFIX + allocator_type) run_concurrent_producers_test(allocator_type) sharedstructures.delete_pool(POOL_NAME_PREFIX + allocator_type) run_concurrent_consumers_test(allocator_type) print('all tests passed') return 0 finally: for allocator_type in ALLOCATOR_TYPES: sharedstructures.delete_pool(POOL_NAME_PREFIX + allocator_type)
def main(): try: for allocator_type in ALLOCATOR_TYPES: sharedstructures.delete_pool(POOL_NAME_PREFIX + allocator_type) run_basic_test(allocator_type) run_conditional_writes_test(allocator_type) run_reorganization_test(allocator_type) run_types_test(allocator_type) run_complex_types_test(allocator_type) run_incr_test(allocator_type) run_concurrent_readers_test(allocator_type) print('all tests passed') return 0 finally: for allocator_type in ALLOCATOR_TYPES: sharedstructures.delete_pool(POOL_NAME_PREFIX + allocator_type)
def main(): try: for allocator_type in ('simple', 'logarithmic'): sharedstructures.delete_pool('test-table') run_basic_test(allocator_type) sharedstructures.delete_pool('test-table') run_conditional_writes_test(allocator_type) sharedstructures.delete_pool('test-table') run_collision_test(allocator_type) # TODO: enable this test again when the python module supports incr # sharedstructures.delete_pool('test-table') # run_incr_test(allocator_type) sharedstructures.delete_pool('test-table') run_concurrent_readers_test(allocator_type) print('all tests passed') return 0 finally: sharedstructures.delete_pool('test-table')
def main(): try: for allocator_type in ALLOCATOR_TYPES: sharedstructures.delete_pool(POOL_NAME_PREFIX + allocator_type) run_basic_test(allocator_type) sharedstructures.delete_pool(POOL_NAME_PREFIX + allocator_type) run_conditional_writes_test(allocator_type) sharedstructures.delete_pool(POOL_NAME_PREFIX + allocator_type) run_collision_test(allocator_type) # TODO: enable this test again when the python module supports incr # sharedstructures.delete_pool(POOL_NAME_PREFIX + allocator_type) # run_incr_test(allocator_type) sharedstructures.delete_pool(POOL_NAME_PREFIX + allocator_type) run_concurrent_readers_test(allocator_type) print('all tests passed') return 0 finally: for allocator_type in ALLOCATOR_TYPES: sharedstructures.delete_pool(POOL_NAME_PREFIX + allocator_type)
def run_basic_test(): print('-- basic') before_lsof_count = len(get_current_process_lsof().splitlines()) v = sharedstructures.IntVector(POOL_NAME) limit = 1024 assert len(v) == 0 v.expand(10) assert len(v) == 10 v.expand(5) assert len(v) == 10 v.expand(limit) assert len(v) == limit # load, store for x in range(limit): assert v.load(x) == 0 for x in range(limit): v.store(x, x) for x in range(limit): assert v.load(x) == x # exchange for x in range(limit): assert v.exchange(x, x + 10) == x for x in range(limit): assert v.load(x) == x + 10 for x in range(limit): assert v.exchange(x, x) == x + 10 for x in range(limit): assert v.load(x) == x # compare_exchange for x in range(limit): assert v.compare_exchange(x, 10, 15) == x for x in range(limit): assert v.load(x) == (15 if (x == 10) else x) v.store(10, 10) # add, subtract for x in range(limit): assert v.add(x, 30) == x for x in range(limit): assert v.load(x) == x + 30 for x in range(limit): assert v.subtract(x, 30) == x + 30 for x in range(limit): assert v.load(x) == x # bitwise_and, bitwise_or for x in range(limit): assert v.bitwise_or(x, 0x7F) == x for x in range(limit): assert v.load(x) == x | 0x7F for x in range(limit): assert v.bitwise_and(x, ~0x7F) == x | 0x7F for x in range(limit): assert v.load(x) == x & ~0x7F # reset for xor test for x in range(limit): v.store(x, x) # bitwise_xor for x in range(limit): assert v.bitwise_xor(x, 0x7F) == x for x in range(limit): assert v.load(x) == x ^ 0x7F for x in range(limit): assert v.bitwise_xor(x, 0x7F) == x ^ 0x7F for x in range(limit): assert v.load(x) == x del v # this should unmap the shared memory pool and close the fd sharedstructures.delete_pool(POOL_NAME) # make sure we didn't leak an fd assert before_lsof_count == len(get_current_process_lsof().splitlines())
def run_basic_test(allocator_type): print('-- [%s] basic' % allocator_type) before_lsof_count = len(get_current_process_lsof().splitlines()) q = sharedstructures.Queue(POOL_NAME_PREFIX + allocator_type, allocator_type) assert len(q) == 0 assert q.bytes() == 0 def test_queue(q, reverse): print('-- [%s] %s queue operation' % (allocator_type, "reverse" if reverse else "forward")) q_push(q, reverse, b"v1") assert 1 == len(q) q_push(q, reverse, "val2") assert 2 == len(q) q_push(q, reverse, 47) assert 3 == len(q) q_push(q, reverse, None) assert 4 == len(q) q_push(q, reverse, (None, False, True, 37, 2.0, ['lol', 'hax'], { 1: 2 })) assert 5 == len(q) assert b"v1" == q_pop(q, not reverse) assert 4 == len(q) assert "val2" == q_pop(q, not reverse) assert 3 == len(q) assert 47 == q_pop(q, not reverse) assert 2 == len(q) assert None == q_pop(q, not reverse) assert 1 == len(q) assert (None, False, True, 37, 2.0, ['lol', 'hax'], { 1: 2 }) == q_pop(q, not reverse) assert 0 == len(q) assert q.bytes() == 0 try: q_pop(q, not reverse) assert False except IndexError: pass test_queue(q, False) test_queue(q, True) def test_stack(q, front): print("-- [%s] %s stack operation" % (allocator_type, "front" if front else "back")) q_push(q, front, b"v1") assert 1 == len(q) q_push(q, front, "val2") assert 2 == len(q) q_push(q, front, 47) assert 3 == len(q) q_push(q, front, None) assert 4 == len(q) q_push(q, front, (None, False, True, 37, 2.0, ['lol', 'hax'], {1: 2})) assert 5 == len(q) assert (None, False, True, 37, 2.0, ['lol', 'hax'], { 1: 2 }) == q_pop(q, front) assert 4 == len(q) assert None == q_pop(q, front) assert 3 == len(q) assert 47 == q_pop(q, front) assert 2 == len(q) assert "val2" == q_pop(q, front) assert 1 == len(q) assert b"v1" == q_pop(q, front) assert 0 == len(q) assert q.bytes() == 0 try: q_pop(q, front) assert False except IndexError: pass test_stack(q, False) test_stack(q, True) del q # this should unmap the shared memory pool and close the fd sharedstructures.delete_pool(POOL_NAME_PREFIX + allocator_type) # make sure we didn't leak an fd assert before_lsof_count == len(get_current_process_lsof().splitlines())