def test_split(self):
mem = MockMemory(self.unit * 4)
chunk = memory._Chunk(mem, 0, mem.size, self.stream_ptr)
tail = chunk.split(self.unit * 2)
self.assertEqual(chunk.ptr(), mem.ptr)
self.assertEqual(chunk.offset, 0)
self.assertEqual(chunk.size, self.unit * 2)
self.assertEqual(chunk.prev, None)
self.assertEqual(chunk.next.ptr(), tail.ptr())
self.assertEqual(chunk.stream_ptr, self.stream_ptr)
self.assertEqual(tail.ptr(), mem.ptr + self.unit * 2)
self.assertEqual(tail.offset, self.unit * 2)
self.assertEqual(tail.size, self.unit * 2)
self.assertEqual(tail.prev.ptr(), chunk.ptr())
self.assertEqual(tail.next, None)
self.assertEqual(tail.stream_ptr, self.stream_ptr)
tail_of_head = chunk.split(self.unit)
self.assertEqual(chunk.ptr(), mem.ptr)
self.assertEqual(chunk.offset, 0)
self.assertEqual(chunk.size, self.unit)
self.assertEqual(chunk.prev, None)
self.assertEqual(chunk.next.ptr(), tail_of_head.ptr())
self.assertEqual(chunk.stream_ptr, self.stream_ptr)
self.assertEqual(tail_of_head.ptr(), mem.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(), chunk.ptr())
self.assertEqual(tail_of_head.next.ptr(), tail.ptr())
self.assertEqual(tail_of_head.stream_ptr, self.stream_ptr)
tail_of_tail = tail.split(self.unit)
self.assertEqual(tail.ptr(), chunk.ptr() + self.unit * 2)
self.assertEqual(tail.offset, self.unit * 2)
self.assertEqual(tail.size, self.unit)
self.assertEqual(tail.prev.ptr(), tail_of_head.ptr())
self.assertEqual(tail.next.ptr(), tail_of_tail.ptr())
self.assertEqual(tail.stream_ptr, self.stream_ptr)
self.assertEqual(tail_of_tail.ptr(), mem.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(), tail.ptr())
self.assertEqual(tail_of_tail.next, None)
self.assertEqual(tail_of_tail.stream_ptr, self.stream_ptr)
def test_split(self):
mem = MockMemory(self.unit * 4)
chunk = memory._Chunk(mem, 0, mem.size, self.stream_ptr)
tail = chunk.split(self.unit * 2)
assert chunk.ptr() == mem.ptr
assert chunk.offset == 0
assert chunk.size == self.unit * 2
assert chunk.prev is None
assert chunk.next.ptr() == tail.ptr()
assert chunk.stream_ptr == self.stream_ptr
assert tail.ptr() == mem.ptr + self.unit * 2
assert tail.offset == self.unit * 2
assert tail.size == self.unit * 2
assert tail.prev.ptr() == chunk.ptr()
assert tail.next is None
assert tail.stream_ptr == self.stream_ptr
tail_of_head = chunk.split(self.unit)
assert chunk.ptr() == mem.ptr
assert chunk.offset == 0
assert chunk.size == self.unit
assert chunk.prev is None
assert chunk.next.ptr() == tail_of_head.ptr()
assert chunk.stream_ptr == self.stream_ptr
assert tail_of_head.ptr() == mem.ptr + self.unit
assert tail_of_head.offset == self.unit
assert tail_of_head.size == self.unit
assert tail_of_head.prev.ptr() == chunk.ptr()
assert tail_of_head.next.ptr() == tail.ptr()
assert tail_of_head.stream_ptr == self.stream_ptr
tail_of_tail = tail.split(self.unit)
assert tail.ptr() == chunk.ptr() + self.unit * 2
assert tail.offset == self.unit * 2
assert tail.size == self.unit
assert tail.prev.ptr() == tail_of_head.ptr()
assert tail.next.ptr() == tail_of_tail.ptr()
assert tail.stream_ptr == self.stream_ptr
assert tail_of_tail.ptr() == mem.ptr + self.unit * 3
assert tail_of_tail.offset == self.unit * 3
assert tail_of_tail.size == self.unit
assert tail_of_tail.prev.ptr() == tail.ptr()
assert tail_of_tail.next is None
assert tail_of_tail.stream_ptr == self.stream_ptr
def test_merge(self):
mem = MockMemory(self.unit * 4)
chunk = memory._Chunk(mem, 0, mem.size, self.stream_ptr)
chunk_ptr = chunk.ptr()
chunk_offset = chunk.offset
chunk_size = chunk.size
tail = chunk.split(self.unit * 2)
head = chunk
head_ptr = head.ptr()
head_offset = head.offset
head_size = head.size
tail_ptr = tail.ptr()
tail_offset = tail.offset
tail_size = tail.size
tail_of_head = head.split(self.unit)
tail_of_tail = tail.split(self.unit)
head.merge(tail_of_head)
self.assertEqual(head.ptr(), head_ptr)
self.assertEqual(head.offset, head_offset)
self.assertEqual(head.size, head_size)
self.assertEqual(head.prev, None)
self.assertEqual(head.next.ptr(), tail_ptr)
self.assertEqual(head.stream_ptr, self.stream_ptr)
tail.merge(tail_of_tail)
self.assertEqual(tail.ptr(), tail_ptr)
self.assertEqual(tail.offset, tail_offset)
self.assertEqual(tail.size, tail_size)
self.assertEqual(tail.prev.ptr(), head_ptr)
self.assertEqual(tail.next, None)
self.assertEqual(tail.stream_ptr, self.stream_ptr)
head.merge(tail)
self.assertEqual(head.ptr(), chunk_ptr)
self.assertEqual(head.offset, chunk_offset)
self.assertEqual(head.size, chunk_size)
self.assertEqual(head.prev, None)
self.assertEqual(head.next, None)
self.assertEqual(head.stream_ptr, self.stream_ptr)
def test_merge(self):
mem = MockMemory(self.unit * 4)
chunk = memory._Chunk(mem, 0, mem.size, self.stream_ptr)
chunk_ptr = chunk.ptr()
chunk_offset = chunk.offset
chunk_size = chunk.size
tail = chunk.split(self.unit * 2)
head = chunk
head_ptr = head.ptr()
head_offset = head.offset
head_size = head.size
tail_ptr = tail.ptr()
tail_offset = tail.offset
tail_size = tail.size
tail_of_head = head.split(self.unit)
tail_of_tail = tail.split(self.unit)
head.merge(tail_of_head)
assert head.ptr() == head_ptr
assert head.offset == head_offset
assert head.size == head_size
assert head.prev is None
assert head.next.ptr() == tail_ptr
assert head.stream_ptr == self.stream_ptr
tail.merge(tail_of_tail)
assert tail.ptr() == tail_ptr
assert tail.offset == tail_offset
assert tail.size == tail_size
assert tail.prev.ptr() == head_ptr
assert tail.next is None
assert tail.stream_ptr == self.stream_ptr
head.merge(tail)
assert head.ptr() == chunk_ptr
assert head.offset == chunk_offset
assert head.size == chunk_size
assert head.prev is None
assert head.next is None
assert head.stream_ptr == self.stream_ptr
