private void saveLoadTest <T>(Func <ObjectArrayCluster <T> > clusterFactory, Func <int, T> elementFactory,
Func <DataBlock, int, T> elementReader, int elementLength) where T : class
{
ConfigurationTest.Initialize();
using (var io = ConfigurationTest.CreateMemoryIO()) {
SimpleClusterIO cio = new SimpleClusterIO(io);
var csc = clusterFactory();
csc.Initialize();
for (int i = 0; i < csc.Count; i++)
{
csc[i] = elementFactory(i);
}
csc.NextClusterAddress = NextClusterAddress;
cio.Save(csc);
int offset = 0;
DataBlock b = new DataBlock(io.Bytes,
Address * Configuration.Geometry.BytesPerCluster, Configuration.Geometry.BytesPerCluster);
offset = verifyProperties(b, offset, csc.Type);
T[] cs = new T[csc.Count];
for (int i = 0; i < csc.Count; i++)
{
if (b.ToBoolean(offset))
{
offset += sizeof(bool);
cs[i] = elementReader(b, offset);
}
else
{
offset += sizeof(bool);
cs[i] = null;
}
offset += elementLength;
}
Assert.IsTrue(cs.SequenceEqual(csc));
var csc2 = clusterFactory();
cio.Load(csc2);
Assert.AreEqual(csc.VolumeID, csc2.VolumeID);
Assert.AreEqual(csc.Type, csc2.Type);
Assert.AreEqual(csc.NextClusterAddress, csc2.NextClusterAddress);
Assert.IsTrue(csc.SequenceEqual(csc2));
}
}
public void FileHeaderSaveLoadTest()
{
ConfigurationTest.Initialize();
using (var io = ConfigurationTest.CreateMemoryIO()) {
SimpleClusterIO cio = new SimpleClusterIO(io);
Random r = new Random(Seed);
FileHeaderCluster csc = new FileHeaderCluster(Address);
csc.Initialize();
int fileID = r.Next();
int nextClusterAddress = r.Next();
int bytesUsed = r.Next();
DateTime writeTime = new DateTime(2005, 1, 1);
int parentID = r.Next();
string name = r.Next().ToString();
// File System Cluster fields
csc.FileID = fileID;
csc.NextClusterAddress = nextClusterAddress;
csc.BytesUsed = bytesUsed;
csc.WriteTime = writeTime;
// File Header fields
csc.ParentID = parentID;
csc.Name = name;
byte[] data = new byte[FileHeaderCluster.DataSize];
for (int i = 0; i < data.Length; i++)
{
data[i] = (byte)(r.Next() & byte.MaxValue);
}
csc.Data.Set(0, data);
cio.Save(csc);
int offset = 0;
DataBlock b = new DataBlock(
io.Bytes,
Address * Configuration.Geometry.BytesPerCluster,
Configuration.Geometry.BytesPerCluster);
byte[] marker = b.ToByteArray(offset, Constants.SrfsMarker.Length);
Assert.IsTrue(marker.SequenceEqual(Constants.SrfsMarker));
offset += marker.Length;
byte[] version = b.ToByteArray(offset, Constants.CurrentVersion.Length);
Assert.IsTrue(version.SequenceEqual(Constants.CurrentVersion));
offset += version.Length;
Guid guid = new Guid(b.ToByteArray(offset, Constants.GuidLength));
Assert.AreEqual(guid, Configuration.FileSystemID);
offset += Constants.GuidLength;
byte[] signatureBytes = b.ToByteArray(offset, Signature.Length);
offset += Signature.Length;
byte[] thumbprintBytes = b.ToByteArray(offset, KeyThumbprint.Length);
Assert.IsTrue(thumbprintBytes.SequenceEqual(Configuration.CryptoSettings.SigningKeyThumbprint.Bytes));
offset += KeyThumbprint.Length;
byte[] hashBytes = b.ToByteArray(offset, 32);
offset += 32;
ClusterType clusterType = (ClusterType)b.ToByte(offset);
Assert.AreEqual(clusterType, ClusterType.FileHeader);
offset += sizeof(ClusterType);
Assert.AreEqual(fileID, b.ToInt32(offset));
offset += sizeof(int);
Assert.AreEqual(nextClusterAddress, b.ToInt32(offset));
offset += sizeof(int);
Assert.AreEqual(bytesUsed, b.ToInt32(offset));
offset += sizeof(int);
Assert.AreEqual(writeTime, new DateTime(b.ToInt64(offset)));
offset += sizeof(long);
Assert.AreEqual(parentID, b.ToInt32(offset));
offset += sizeof(int);
int nameLength = b.ToByte(offset);
offset += sizeof(byte);
Assert.AreEqual(name, b.ToString(offset, nameLength));
offset += Constants.MaximumNameLength * sizeof(char);
byte[] encryptionThumbprintBytes = b.ToByteArray(offset, KeyThumbprint.Length);
Assert.IsTrue(encryptionThumbprintBytes.SequenceEqual(Configuration.CryptoSettings.EncryptionKeyThumbprint.Bytes));
offset += KeyThumbprint.Length;
byte[] publicKeyBytes = b.ToByteArray(offset, PublicKey.Length);
offset += PublicKey.Length;
int dataLength = Configuration.Geometry.BytesPerCluster - offset;
int padding = dataLength % 16;
dataLength -= padding;
Assert.AreEqual(data.Length, dataLength);
offset += padding;
using (ECDiffieHellmanCng dest = new ECDiffieHellmanCng(Configuration.CryptoSettings.DecryptionKey))
using (AesCng aes = new AesCng()) {
aes.KeySize = 256;
aes.BlockSize = 128;
aes.Mode = CipherMode.CBC;
aes.Padding = PaddingMode.None;
aes.Key = dest.DeriveKeyMaterial(new PublicKey(publicKeyBytes).GetCngKey());
aes.IV = new byte[16];
using (var decryptor = aes.CreateDecryptor()) {
byte[] decryptedData = b.TransformFinalBlock(decryptor, offset, dataLength);
for (int i = 0; i < dataLength; i++)
{
Assert.AreEqual(data[i], decryptedData[i]);
}
}
}
FileHeaderCluster csc2 = new FileHeaderCluster(Address);
cio.Load(csc2);
Assert.IsTrue(csc2.Marker.SequenceEqual(Constants.SrfsMarker));
Assert.IsTrue(csc2.Version.SequenceEqual(Constants.CurrentVersion));
Assert.AreEqual(csc2.VolumeID, Configuration.FileSystemID);
Assert.AreEqual(csc2.Type, ClusterType.FileHeader);
Assert.AreEqual(csc2.FileID, fileID);
Assert.AreEqual(csc2.NextClusterAddress, nextClusterAddress);
Assert.AreEqual(csc2.BytesUsed, bytesUsed);
Assert.AreEqual(csc2.WriteTime, writeTime);
Assert.AreEqual(csc2.ParentID, parentID);
Assert.AreEqual(csc2.Name, name);
for (int i = 0; i < dataLength; i++)
{
Assert.AreEqual(data[i], csc2.Data.ToByte(i));
}
}
}
public void IntArraySaveLoadTest()
{
ConfigurationTest.Initialize();
using (var io = ConfigurationTest.CreateMemoryIO()) {
SimpleClusterIO cio = new SimpleClusterIO(io);
Random r = new Random();
Int32ArrayCluster csc = new Int32ArrayCluster(2);
csc.Initialize();
for (int i = 0; i < csc.Count; i++)
{
csc[i] = r.Next();
}
csc.NextClusterAddress = Constants.NoAddress;
csc.Type = ClusterType.NextClusterAddressTable;
cio.Save(csc);
int offset = 0;
DataBlock b = new DataBlock(io.Bytes, 2 * Configuration.Geometry.BytesPerCluster, Configuration.Geometry.BytesPerCluster);
byte[] marker = b.ToByteArray(offset, Constants.SrfsMarker.Length);
Assert.IsTrue(marker.SequenceEqual(Constants.SrfsMarker));
offset += marker.Length;
byte[] version = b.ToByteArray(offset, Constants.CurrentVersion.Length);
Assert.IsTrue(version.SequenceEqual(Constants.CurrentVersion));
offset += version.Length;
Guid guid = new Guid(b.ToByteArray(offset, Constants.GuidLength));
Assert.AreEqual(guid, Configuration.FileSystemID);
offset += Constants.GuidLength;
byte[] signatureBytes = b.ToByteArray(offset, Signature.Length);
offset += Signature.Length;
byte[] thumbprintBytes = b.ToByteArray(offset, KeyThumbprint.Length);
Assert.IsTrue(thumbprintBytes.SequenceEqual(Configuration.CryptoSettings.SigningKeyThumbprint.Bytes));
offset += KeyThumbprint.Length;
byte[] hashBytes = b.ToByteArray(offset, 32);
offset += 32;
ClusterType clusterType = (ClusterType)b.ToByte(offset);
Assert.AreEqual(clusterType, ClusterType.NextClusterAddressTable);
offset += sizeof(ClusterType);
int nextClusterAddress = b.ToInt32(offset);
Assert.AreEqual(nextClusterAddress, Constants.NoAddress);
offset += sizeof(int);
int[] cs = new int[csc.Count];
for (int i = 0; i < csc.Count; i++)
{
cs[i] = b.ToInt32(offset + i * sizeof(int));
}
Assert.IsTrue(cs.SequenceEqual(csc));
Int32ArrayCluster csc2 = new Int32ArrayCluster(2);
cio.Load(csc2);
Assert.AreEqual(csc.VolumeID, csc2.VolumeID);
Assert.AreEqual(csc.Type, csc2.Type);
Assert.AreEqual(csc.NextClusterAddress, csc2.NextClusterAddress);
Assert.IsTrue(csc.SequenceEqual(csc2));
}
}
public void IntClusterTableTest()
{
ConfigurationTest.Initialize();
using (var io = ConfigurationTest.CreateMemoryIO()) {
SimpleClusterIO cio = new SimpleClusterIO(io);
Random r = new Random();
ClusterTable <int> ct = new ClusterTable <int>(
new int[] { 2, 4 },
sizeof(int),
(address) => new IntArrayCluster(address)
{
Type = ClusterType.BytesUsedTable
});
ClusterTable <int> ct2 = new ClusterTable <int>(
new int[] { 2, 4 },
sizeof(int),
(address) => new IntArrayCluster(address)
{
Type = ClusterType.BytesUsedTable
});
ct.Flush(cio);
ct2.Load(cio);
// Check that the cluster is written and everything is zeroed
DataBlock b = new DataBlock(io.Bytes, 2 * Configuration.Geometry.BytesPerCluster, Configuration.Geometry.BytesPerCluster);
int offset = verifyProperties(b, ClusterType.BytesUsedTable, 4);
for (int i = 0; i < ArrayCluster.CalculateElementCount(sizeof(int)); i++)
{
Assert.AreEqual(b.ToInt32(offset + i * sizeof(int)), 0);
}
b = new DataBlock(io.Bytes, 4 * Configuration.Geometry.BytesPerCluster, Configuration.Geometry.BytesPerCluster);
offset = verifyProperties(b, ClusterType.BytesUsedTable, Constants.NoAddress);
for (int i = 0; i < ArrayCluster.CalculateElementCount(sizeof(int)); i++)
{
Assert.AreEqual(b.ToInt32(offset + i * sizeof(int)), 0);
}
for (int i = 0; i < ct2.Count; i++)
{
Assert.AreEqual(ct2[i], 0);
}
// Now randomize the contents
for (int i = 0; i < ct.Count; i++)
{
ct[i] = r.Next();
}
ct.Flush(cio);
b = new DataBlock(io.Bytes, 2 * Configuration.Geometry.BytesPerCluster, Configuration.Geometry.BytesPerCluster);
offset = verifyProperties(b, ClusterType.BytesUsedTable, 4);
int index = 0;
for (int i = 0; i < ArrayCluster.CalculateElementCount(sizeof(int)); i++, index++)
{
Assert.AreEqual(b.ToInt32(offset + i * sizeof(int)), ct[index]);
}
b = new DataBlock(io.Bytes, 4 * Configuration.Geometry.BytesPerCluster, Configuration.Geometry.BytesPerCluster);
offset = verifyProperties(b, ClusterType.BytesUsedTable, Constants.NoAddress);
for (int i = 0; i < ArrayCluster.CalculateElementCount(sizeof(int)); i++, index++)
{
Assert.AreEqual(b.ToInt32(offset + i * sizeof(int)), ct[index]);
}
ct2.Load(cio);
for (int i = 0; i < ct2.Count; i++)
{
Assert.AreEqual(ct2[i], ct[i]);
}
// Add a cluster
ct.AddCluster(7);
ct2.AddCluster(7);
ct.Flush(cio);
// Make sure that next cluster is updated
b = new DataBlock(io.Bytes, 4 * Configuration.Geometry.BytesPerCluster, Configuration.Geometry.BytesPerCluster);
verifyProperties(b, ClusterType.BytesUsedTable, 7);
// check the new cluster and assure everything is zero
b = new DataBlock(io.Bytes, 7 * Configuration.Geometry.BytesPerCluster, Configuration.Geometry.BytesPerCluster);
offset = verifyProperties(b, ClusterType.BytesUsedTable, Constants.NoAddress);
for (int i = 0; i < ArrayCluster.CalculateElementCount(sizeof(int)); i++)
{
Assert.AreEqual(b.ToInt32(offset + i * sizeof(int)), 0);
}
ct2.Load(cio);
for (int i = 0; i < ct2.Count; i++)
{
Assert.AreEqual(ct2[i], ct[i]);
}
Assert.AreEqual(ct2.Count, 3 * ArrayCluster.CalculateElementCount(sizeof(int)));
// Remove a cluster
ct.RemoveLastCluster();
ct.Flush(cio);
// Make sure that the last cluster is updated
b = new DataBlock(io.Bytes, 4 * Configuration.Geometry.BytesPerCluster, Configuration.Geometry.BytesPerCluster);
verifyProperties(b, ClusterType.BytesUsedTable, Constants.NoAddress);
}
}
