public void TestBlockStoragePersistent()
{
using (var ms = new MemoryStream())
{
var storage = new BlockStorage(ms);
using (var firstBlock = storage.CreateNew())
using (var secondBlock = storage.CreateNew())
using (var thirdBlock = storage.CreateNew())
{
Assert.AreEqual(0, firstBlock.Id);
Assert.AreEqual(1, secondBlock.Id);
secondBlock.SetHeader(1, 100);
secondBlock.SetHeader(2, 200);
Assert.AreEqual(2, thirdBlock.Id);
Assert.AreEqual(storage.BlockSize * 3, ms.Length);
}
// Test to make sure our creation persists
var storage2 = new BlockStorage(ms);
Assert.AreEqual(0, storage2.Find(0).Id);
Assert.AreEqual(1, storage2.Find(1).Id);
Assert.AreEqual(2, storage2.Find(2).Id);
Assert.AreEqual(100, storage2.Find(1).GetHeader(1));
Assert.AreEqual(200, storage2.Find(1).GetHeader(2));
}
}
public void TestManangingBlockInstances()
{
var manager = new BlockStorage(new MemoryStream());
var a = manager.CreateNew();
var b = manager.CreateNew();
Assert.AreSame(a, manager.Find(0));
Assert.AreSame(b, manager.Find(1));
Assert.AreNotSame(a, b);
a.Dispose();
Assert.AreNotSame(a, manager.Find(0));
}
public void Test8KBlock()
{
using (var ms = new MemoryStream())
{
var blockStorage = new BlockStorage(ms, 12288, 48);
using (var block = blockStorage.CreateNew())
{
Assert.Throws <ArgumentOutOfRangeException>(delegate
{
block.Write(new byte[4048], 0, 1, 8192);
});
Assert.Throws <ArgumentOutOfRangeException>(delegate
{
block.Write(new byte[4048], 0, 0, 8193);
});
}
// Test data
var data = UnitTestHelper.RandomData(8192);
var ex0 = new byte[blockStorage.BlockContentSize];
var ex1 = new byte[2381];
var ex2 = new byte[37];
var ex3 = new byte[137];
var ex4 = new byte[6028];
var ex5 = new byte[1000];
Buffer.BlockCopy(src: data, srcOffset: 16, dst: ex0, dstOffset: 1294, count: 2381);
Buffer.BlockCopy(src: data, srcOffset: 16, dst: ex1, dstOffset: 0, count: 2381);
Buffer.BlockCopy(src: data, srcOffset: 16, dst: ex2, dstOffset: 0, count: 37);
Buffer.BlockCopy(src: data, srcOffset: 32, dst: ex3, dstOffset: 0, count: 137);
Buffer.BlockCopy(src: data, srcOffset: 32, dst: ex4, dstOffset: 0, count: 6028);
Buffer.BlockCopy(src: data, srcOffset: 32, dst: ex5, dstOffset: 0, count: 1000);
// Test
using (var a = blockStorage.CreateNew())
using (var b = blockStorage.CreateNew())
using (var c = blockStorage.CreateNew())
using (var d = blockStorage.CreateNew())
using (var e = blockStorage.CreateNew())
{
// Write
a.Write(src: data, srcOffset: 16, dstOffset: 1294, count: 2381);
b.Write(src: data, srcOffset: 16, dstOffset: 12, count: 37);
c.Write(src: data, srcOffset: 32, dstOffset: 4078, count: 137);
d.Write(src: data, srcOffset: 32, dstOffset: 4048, count: 6028);
e.Write(src: data, srcOffset: 32, dstOffset: 4096 - 1000 - 48, count: 1000);
// Assert
var t0 = new byte[blockStorage.BlockContentSize];
var t1 = new byte[2381];
var t2 = new byte[37];
var t3 = new byte[137];
var t4 = new byte[6028];
var t5 = new byte[1000];
a.Read(dst: t0, dstOffset: 0, srcOffset: 0, count: t0.Length);
a.Read(dst: t1, dstOffset: 0, srcOffset: 1294, count: 2381);
b.Read(dst: t2, dstOffset: 0, srcOffset: 12, count: 37);
c.Read(dst: t3, dstOffset: 0, srcOffset: 4078, count: 137);
d.Read(dst: t4, dstOffset: 0, srcOffset: 4048, count: 6028);
e.Read(dst: t5, dstOffset: 0, srcOffset: 4096 - 1000 - 48, count: 1000);
Assert.IsTrue(ex0.SequenceEqual(t0));
Assert.IsTrue(ex1.SequenceEqual(t1));
Assert.IsTrue(ex2.SequenceEqual(t2));
Assert.IsTrue(ex3.SequenceEqual(t3));
Assert.IsTrue(ex4.SequenceEqual(t4));
Assert.IsTrue(ex5.SequenceEqual(t5));
}
// Test persistent
blockStorage = new BlockStorage(new MemoryStream(ms.ToArray()), 12288, 48);
using (var a = blockStorage.Find(1))
using (var b = blockStorage.Find(2))
using (var c = blockStorage.Find(3))
using (var d = blockStorage.Find(4))
using (var e = blockStorage.Find(5))
{
// Assert
var t1 = new byte[2381];
var t2 = new byte[37];
var t3 = new byte[137];
var t4 = new byte[6028];
var t5 = new byte[1000];
a.Read(dst: t1, dstOffset: 0, srcOffset: 1294, count: 2381);
b.Read(dst: t2, dstOffset: 0, srcOffset: 12, count: 37);
c.Read(dst: t3, dstOffset: 0, srcOffset: 4078, count: 137);
d.Read(dst: t4, dstOffset: 0, srcOffset: 4048, count: 6028);
e.Read(dst: t5, dstOffset: 0, srcOffset: 4096 - 1000 - 48, count: 1000);
Assert.IsTrue(ex1.SequenceEqual(t1));
Assert.IsTrue(ex2.SequenceEqual(t2));
Assert.IsTrue(ex3.SequenceEqual(t3));
Assert.IsTrue(ex4.SequenceEqual(t4));
Assert.IsTrue(ex5.SequenceEqual(t5));
}
}
}
public void Test4kBlock()
{
using (var ms = new MemoryStream())
{
var blockStorage = new BlockStorage(ms, 4096, 48);
using (var block = blockStorage.CreateNew())
{
Assert.Throws <ArgumentOutOfRangeException>(delegate
{
block.Write(new byte[4048], 0, 1, 4048);
});
Assert.Throws <ArgumentOutOfRangeException>(delegate
{
block.Write(new byte[4048], 0, 0, 4049);
});
}
// Generate random data
var d1 = UnitTestHelper.RandomData(4048);
var d2 = UnitTestHelper.RandomData(1294);
var d3 = UnitTestHelper.RandomData(4048);
// Write
using (var a = blockStorage.CreateNew())
using (var b = blockStorage.CreateNew())
using (var c = blockStorage.CreateNew())
{
// Write
a.Write(d1, 0, 0, 4048);
b.Write(d2, 0, 0, 1294);
c.Write(d3, 0, 0, 4048);
var r1 = new byte[4048];
a.Read(r1, 0, 0, 4048);
var r2 = new byte[1294];
b.Read(r2, 0, 0, 1294);
var r3 = new byte[4048];
c.Read(r3, 0, 0, 4048);
Assert.True(d1.SequenceEqual(r1));
Assert.True(d2.SequenceEqual(r2));
Assert.True(d3.SequenceEqual(r3));
}
// Test persistence
blockStorage = new BlockStorage(new MemoryStream(ms.ToArray()), 4096, 48);
using (var a = blockStorage.Find(1u))
using (var b = blockStorage.Find(2u))
using (var c = blockStorage.Find(3u))
{
var r1 = new byte[4048];
a.Read(r1, 0, 0, 4048);
var r2 = new byte[1294];
b.Read(r2, 0, 0, 1294);
var r3 = new byte[4048];
c.Read(r3, 0, 0, 4048);
Assert.True(d1.SequenceEqual(r1));
Assert.True(d2.SequenceEqual(r2));
Assert.True(d3.SequenceEqual(r3));
}
}
}