def test_copy_dirty_progress():
size = 1024
chunk_size = size // 4
def fake_extents(context="zero"):
return [
image.DirtyExtent(0 * chunk_size, chunk_size, True),
image.DirtyExtent(1 * chunk_size, chunk_size, False),
image.DirtyExtent(2 * chunk_size, chunk_size, True),
image.DirtyExtent(3 * chunk_size, chunk_size, False),
]
src = memory.Backend("r", (b"x" * chunk_size + b"\0" * chunk_size +
b"x" * chunk_size + b"\0" * chunk_size))
src.extents = fake_extents
dst = memory.Backend("r+", b"\0" * size)
p = FakeProgress()
io.copy(src, dst, dirty=True, progress=p)
# Report at least every extent.
assert len(p.updates) >= 4
# Report entire image size.
assert sum(p.updates) == size
def test_close_error():
def close():
raise IOError("backend error")
with pytest.raises(IOError):
with memory.Backend("r+") as m:
m.close = close
def test_size():
m = memory.Backend("r+", b"data")
assert m.size() == 4
assert m.tell() == 0
m.zero(5)
m.seek(3)
assert m.size() == 5
assert m.tell() == 3
def test_create_with_bytes():
m = memory.Backend("r", b"data")
assert m.readable()
assert not m.writable()
b = bytearray(5)
assert m.readinto(b) == 4
assert b[:] == b"data\0"
def test_close():
m = memory.Backend("r+")
m.close()
# All operations should fail now with:
# ValueError: I/O operation on closed file
with pytest.raises(ValueError):
m.write("more")
with pytest.raises(ValueError):
m.readinto(bytearray(10))
def test_write_to():
size = 128
src = memory.WriterTo("r", b"x" * size)
dst = memory.Backend("r+", b"y" * size)
buf = bytearray(32)
src.write_to(dst, size, buf)
assert src.tell() == size
assert dst.tell() == size
assert src.data() == dst.data()
def test_copy_generic(zero):
size = 1024
chunk_size = size // 2
def fake_extents(context="zero"):
return [
image.ZeroExtent(0 * chunk_size, chunk_size, False),
image.ZeroExtent(1 * chunk_size, chunk_size, True),
]
src = memory.Backend("r", b"x" * chunk_size + b"\0" * chunk_size)
src.extents = fake_extents
dst = memory.Backend("r+", (b"y" if zero else b"\0") * size)
io.copy(src, dst, buffer_size=128, zero=zero)
assert dst.size() == src.size()
assert dst.data() == src.data()
def test_read_from():
size = 128
src = memory.Backend("r", b"x" * size)
dst = memory.ReaderFrom("r+", b"y" * size)
buf = bytearray(32)
dst.read_from(src, size, buf)
assert src.tell() == size
assert dst.tell() == size
assert src.data() == dst.data()
def test_propagate_user_error():
class UserError(Exception):
pass
def close():
raise IOError("backend error")
with pytest.raises(UserError):
with memory.Backend("r+") as m:
m.close = close
raise UserError("user error")
def test_open_writeonly():
m = memory.Backend("w")
assert not m.readable()
assert m.writable()
data = b"data"
m.write(data)
assert m.tell() == len(data)
with pytest.raises(IOError):
m.readinto(bytearray(10))
m.flush()
def test_read_from_some():
src = memory.Backend("r", b"x" * 128)
dst = memory.ReaderFrom("r+", b"y" * 128)
buf = bytearray(32)
src.seek(32)
dst.seek(32)
dst.read_from(src, 64, buf)
assert src.tell() == 96
assert dst.tell() == 96
assert dst.data() == b"y" * 32 + b"x" * 64 + b"y" * 32
def test_copy_dirty():
size = 1024
chunk_size = size // 4
def fake_extents(context="zero"):
return [
image.DirtyExtent(0 * chunk_size, chunk_size, True),
image.DirtyExtent(1 * chunk_size, chunk_size, False),
image.DirtyExtent(2 * chunk_size, chunk_size, True),
image.DirtyExtent(3 * chunk_size, chunk_size, False),
]
src = memory.Backend("r", (b"a" * chunk_size + b"b" * chunk_size +
b"c" * chunk_size + b"d" * chunk_size))
src.extents = fake_extents
dst = memory.Backend("r+", b"\0" * size)
io.copy(src, dst, dirty=True)
assert dst.data() == (b"a" * chunk_size + b"\0" * chunk_size +
b"c" * chunk_size + b"\0" * chunk_size)
def test_open_readonly():
m = memory.Backend("r")
assert m.readable()
assert not m.writable()
with pytest.raises(IOError):
m.write(b"data")
with pytest.raises(IOError):
m.zero(4)
assert m.tell() == 0
b = bytearray(b"before")
assert m.readinto(b) == 0
assert b == b"before"
def test_write_to_some():
size = 128
src = memory.WriterTo("r", b"x" * size)
dst = memory.Backend("r+", b"y" * size)
buf = bytearray(32)
src.seek(32)
dst.seek(32)
src.write_to(dst, 64, buf)
assert src.tell() == 96
assert dst.tell() == 96
assert dst.data() == b"y" * 32 + b"x" * 64 + b"y" * 32
def test_open_read_write():
m = memory.Backend("r+")
assert m.readable()
assert m.writable()
assert not m.sparse
data = b"data"
m.write(data)
assert m.tell() == len(data)
m.zero(4)
size = len(data) + 4
assert m.tell() == size
content = data + b"\0" * 4
b = bytearray(size)
m.seek(0)
assert m.readinto(b) == size
assert b == content
def test_dirty():
# backend created clean
m = memory.Backend("r+", b"data")
assert not m.dirty
# write ans zero dirty the backend
m.write(b"01234")
assert m.dirty
m.flush()
assert not m.dirty
m.zero(5)
assert m.dirty
m.flush()
assert not m.dirty
# readinto, seek do not affect dirty.
b = bytearray(10)
m.seek(0)
assert not m.dirty
m.readinto(b)
assert not m.dirty
def test_context_manager():
with memory.Backend("r+") as m:
m.write(b"data")
with pytest.raises(ValueError):
m.write("more")
def test_invalid_mode():
with pytest.raises(ValueError):
memory.Backend("invalid")
def test_extents():
m = memory.Backend("r+", b"data")
assert list(m.extents()) == [image.ZeroExtent(0, 4, False)]
def test_extents_zero():
m = memory.Backend("r+", b"data")
with pytest.raises(errors.UnsupportedOperation):
list(m.extents(context="dirty"))