def test_merge(self):
mem = MockMemory(self.unit * 4)
chunk = memory.Chunk(mem, 0, mem.size, self.stream_ptr)
head, tail = self.pool._split(chunk, self.unit * 2)
head_ptr, tail_ptr = head.ptr, tail.ptr
head_of_head, tail_of_head = self.pool._split(head, self.unit)
head_of_tail, tail_of_tail = self.pool._split(tail, self.unit)
merged_head = self.pool._merge(head_of_head, tail_of_head)
self.assertEqual(merged_head.ptr, head.ptr)
self.assertEqual(merged_head.offset, head.offset)
self.assertEqual(merged_head.size, head.size)
self.assertEqual(merged_head.prev, None)
self.assertEqual(merged_head.next.ptr, tail_ptr)
self.assertEqual(merged_head.stream_ptr, self.stream_ptr)
merged_tail = self.pool._merge(head_of_tail, tail_of_tail)
self.assertEqual(merged_tail.ptr, tail.ptr)
self.assertEqual(merged_tail.offset, tail.offset)
self.assertEqual(merged_tail.size, tail.size)
self.assertEqual(merged_tail.prev.ptr, head_ptr)
self.assertEqual(merged_tail.next, None)
self.assertEqual(merged_tail.stream_ptr, self.stream_ptr)
merged = self.pool._merge(merged_head, merged_tail)
self.assertEqual(merged.ptr, chunk.ptr)
self.assertEqual(merged.offset, chunk.offset)
self.assertEqual(merged.size, chunk.size)
self.assertEqual(merged.prev, None)
self.assertEqual(merged.next, None)
self.assertEqual(merged.stream_ptr, self.stream_ptr)
def test_split(self):
mem = MockMemory(self.unit * 4)
chunk = memory.Chunk(mem, 0, mem.size, self.stream_ptr)
head, tail = self.pool._split(chunk, self.unit * 2)
self.assertEqual(head.ptr, chunk.ptr)
self.assertEqual(head.offset, 0)
self.assertEqual(head.size, self.unit * 2)
self.assertEqual(head.prev, None)
self.assertEqual(head.next.ptr, tail.ptr)
self.assertEqual(head.stream_ptr, self.stream_ptr)
self.assertEqual(tail.ptr, chunk.ptr + self.unit * 2)
self.assertEqual(tail.offset, self.unit * 2)
self.assertEqual(tail.size, self.unit * 2)
self.assertEqual(tail.prev.ptr, head.ptr)
self.assertEqual(tail.next, None)
self.assertEqual(tail.stream_ptr, self.stream_ptr)
head_of_head, tail_of_head = self.pool._split(head, self.unit)
self.assertEqual(head_of_head.ptr, chunk.ptr)
self.assertEqual(head_of_head.offset, 0)
self.assertEqual(head_of_head.size, self.unit)
self.assertEqual(head_of_head.prev, None)
self.assertEqual(head_of_head.next.ptr, tail_of_head.ptr)
self.assertEqual(head_of_head.stream_ptr, self.stream_ptr)
self.assertEqual(tail_of_head.ptr, chunk.ptr + self.unit)
self.assertEqual(tail_of_head.offset, self.unit)
self.assertEqual(tail_of_head.size, self.unit)
self.assertEqual(tail_of_head.prev.ptr, head_of_head.ptr)
self.assertEqual(tail_of_head.next.ptr, tail.ptr)
self.assertEqual(tail_of_head.stream_ptr, self.stream_ptr)
head_of_tail, tail_of_tail = self.pool._split(tail, self.unit)
self.assertEqual(head_of_tail.ptr, chunk.ptr + self.unit * 2)
self.assertEqual(head_of_tail.offset, self.unit * 2)
self.assertEqual(head_of_tail.size, self.unit)
self.assertEqual(head_of_tail.prev.ptr, tail_of_head.ptr)
self.assertEqual(head_of_tail.next.ptr, tail_of_tail.ptr)
self.assertEqual(head_of_tail.stream_ptr, self.stream_ptr)
self.assertEqual(tail_of_tail.ptr, chunk.ptr + self.unit * 3)
self.assertEqual(tail_of_tail.offset, self.unit * 3)
self.assertEqual(tail_of_tail.size, self.unit)
self.assertEqual(tail_of_tail.prev.ptr, head_of_tail.ptr)
self.assertEqual(tail_of_tail.next, None)
self.assertEqual(tail_of_tail.stream_ptr, self.stream_ptr)
