public void FillFileSystemTest()
{
ConfigurationTest.Initialize();
Random r = new Random(1234);
using (var io = ConfigurationTest.CreateMemoryIO()) {
FileSystem fs = FileSystem.Create(io);
byte[] data = new byte[1024 * 1024];
Directory d = fs.RootDirectory;
File f = fs.CreateFile(d, "TEST");
int totalBytesWritten = 0;
using (FileIO fio = new FileIO(fs, f)) {
int bytesWritten = 0;
do
{
r.NextBytes(data);
bytesWritten = fio.WriteFile(data, f.Length);
totalBytesWritten += bytesWritten;
} while (bytesWritten != 0);
}
fs.Dispose();
CryptoSettings cryptoSettings = Configuration.CryptoSettings;
Options options = Configuration.Options;
Configuration.Reset();
Configuration.CryptoSettings = cryptoSettings;
Configuration.Options = options;
fs = FileSystem.Mount(io);
r = new Random(1234);
f = fs.GetContainedFiles(fs.RootDirectory)["TEST"];
Assert.AreEqual(f.Length, totalBytesWritten);
int totalBytesRead = 0;
byte[] compare = new byte[1024 * 1024];
using (FileIO fio = new FileIO(fs, f)) {
int bytesRead = 0;
do
{
r.NextBytes(data);
bytesRead = fio.ReadFile(compare, totalBytesRead);
totalBytesRead += bytesRead;
for (int i = 0; i < bytesRead; i++)
{
Assert.AreEqual(compare[i], data[i]);
}
} while (bytesRead != 0);
}
Assert.AreEqual(totalBytesRead, totalBytesWritten);
fs.Dispose();
}
}
public void FileDeleteTest()
{
ConfigurationTest.Initialize();
Random r = new Random(1234);
using (var io = ConfigurationTest.CreateMemoryIO()) {
FileSystem fs = FileSystem.Create(io);
byte[] data = new byte[1024 * 1024];
r.NextBytes(data);
Directory d = fs.RootDirectory;
File f = fs.CreateFile(d, "TEST");
using (FileIO fio = new FileIO(fs, f)) {
Assert.AreEqual(data.Length, fio.WriteFile(data, 0));
}
fs.Dispose();
CryptoSettings cryptoSettings = Configuration.CryptoSettings;
Options options = Configuration.Options;
Configuration.Reset();
Configuration.CryptoSettings = cryptoSettings;
Configuration.Options = options;
fs = FileSystem.Mount(io);
byte[] data2 = new byte[data.Length];
File f2 = fs.GetContainedFiles(fs.RootDirectory)["TEST"];
fs.RemoveFile(f2);
Assert.AreEqual(0, (from s in fs.ClusterStates where (s & ClusterState.Used) != 0 && (s & ClusterState.System) == 0 select s).Count());
Assert.AreEqual(0, fs.GetContainedFiles(fs.RootDirectory).Count);
fs.Dispose();
}
}
public void FileIOTest()
{
ConfigurationTest.Initialize();
Random r = new Random(1234);
using (var io = ConfigurationTest.CreateMemoryIO()) {
FileSystem fs = FileSystem.Create(io);
byte[] data = new byte[1024 * 1024];
r.NextBytes(data);
Directory d = fs.RootDirectory;
File f = fs.CreateFile(d, "TEST");
using (FileIO fio = new FileIO(fs, f)) {
Assert.AreEqual(data.Length, fio.WriteFile(data, 0));
for (int j = 0; j < 100; j++)
{
switch (r.Next(3))
{
case 0: {
// Internal Overwrite
int offset = r.Next(data.Length);
int count = r.Next(data.Length - offset);
if (count != 0)
{
byte[] newData = new byte[count];
r.NextBytes(newData);
Assert.AreEqual(newData.Length, fio.WriteFile(newData, offset));
Buffer.BlockCopy(newData, 0, data, offset, count);
Assert.AreEqual(data.Length, f.Length);
}
break;
}
case 1: {
// Append
int count = r.Next(2 * 1024 * 1024 - (int)f.Length);
if (count != 0)
{
int offset = (int)f.Length;
byte[] newData = new byte[count];
r.NextBytes(newData);
Assert.AreEqual(newData.Length, fio.WriteFile(newData, offset));
byte[] dt = new byte[count + data.Length];
Buffer.BlockCopy(data, 0, dt, 0, offset);
Buffer.BlockCopy(newData, 0, dt, offset, count);
data = dt;
Assert.AreEqual(data.Length, f.Length);
}
break;
}
case 2: {
// Set Length
int count = r.Next(2 * 1024 * 1024);
fio.SetEndOfFile(count);
byte[] newData = new byte[count];
Buffer.BlockCopy(data, 0, newData, 0, Math.Min(count, data.Length));
data = newData;
Assert.AreEqual(data.Length, f.Length);
break;
}
}
}
}
int length = (int)f.Length;
int clusters = length <= FileHeaderCluster.DataSize ? 1 :
(length - FileHeaderCluster.DataSize + FileDataCluster.DataSize - 1) / FileDataCluster.DataSize + 1;
Assert.AreEqual(clusters, (from s in fs.ClusterStates where (s & ClusterState.Used) != 0 && (s & ClusterState.System) == 0 select s).Count());
fs.Dispose();
CryptoSettings cryptoSettings = Configuration.CryptoSettings;
Options options = Configuration.Options;
Configuration.Reset();
Configuration.CryptoSettings = cryptoSettings;
Configuration.Options = options;
fs = FileSystem.Mount(io);
byte[] data2 = new byte[data.Length];
File f2 = fs.GetContainedFiles(fs.RootDirectory)["TEST"];
Assert.AreEqual(f.Length, f2.Length);
using (FileIO fio = new FileIO(fs, f2)) {
Assert.AreEqual(data2.Length, fio.ReadFile(data2, 0));
Assert.AreEqual(0, fio.ReadFile(data2, data2.Length));
}
Assert.IsTrue(data.SequenceEqual(data2));
length = (int)f2.Length;
clusters = length <= FileHeaderCluster.DataSize ? 1 :
(length - FileHeaderCluster.DataSize + FileDataCluster.DataSize - 1) / FileDataCluster.DataSize + 1;
Assert.AreEqual(clusters, (from s in fs.ClusterStates where (s & ClusterState.Used) != 0 && (s & ClusterState.System) == 0 select s).Count());
using (FileIO fio = new FileIO(fs, f2)) {
fio.SetEndOfFile(0);
}
Assert.AreEqual(0, f2.Length);
Assert.AreEqual(0, (from s in fs.ClusterStates where (s & ClusterState.Used) != 0 && (s & ClusterState.System) == 0 select s).Count());
fs.Dispose();
Configuration.Reset();
Configuration.CryptoSettings = cryptoSettings;
Configuration.Options = options;
fs = FileSystem.Mount(io);
File f3 = fs.GetContainedFiles(fs.RootDirectory)["TEST"];
Assert.AreEqual(0, f3.Length);
Assert.AreEqual(0, (from s in fs.ClusterStates where (s & ClusterState.Used) != 0 && (s & ClusterState.System) == 0 select s).Count());
}
}
public void FileSystemCreateTest()
{
ConfigurationTest.Initialize();
Random r = new Random(1234);
using (var io = ConfigurationTest.CreateMemoryIO()) {
FileSystem fs = FileSystem.Create(io);
fs.Flush();
ClusterState[] clusterStateArray = new ClusterState[Configuration.Geometry.DataClustersPerTrack * Configuration.Geometry.TrackCount];
for (int i = 0; i < clusterStateArray.Length; i++)
{
if ((fs.GetClusterState(i) & ClusterState.System) == 0)
{
ClusterState c = (ClusterState)r.Next(16);
clusterStateArray[i] = c;
fs.SetClusterState(i, c);
}
else
{
clusterStateArray[i] = fs.GetClusterState(i);
}
}
int[] nextClusterArray = new int[Configuration.Geometry.DataClustersPerTrack * Configuration.Geometry.TrackCount];
for (int i = 0; i < nextClusterArray.Length; i++)
{
if ((fs.GetClusterState(i) & ClusterState.System) == 0)
{
int c = r.Next();
nextClusterArray[i] = c;
fs.SetNextClusterAddress(i, c);
}
else
{
nextClusterArray[i] = fs.GetNextClusterAddress(i);
}
}
int[] bytesUsedArray = new int[Configuration.Geometry.DataClustersPerTrack * Configuration.Geometry.TrackCount];
for (int i = 0; i < bytesUsedArray.Length; i++)
{
if ((fs.GetClusterState(i) & ClusterState.System) == 0)
{
int c = r.Next();
bytesUsedArray[i] = c;
fs.SetBytesUsed(i, c);
}
else
{
bytesUsedArray[i] = fs.GetBytesUsed(i);
}
}
DateTime[] verifyTimeArray = new DateTime[Configuration.Geometry.ClustersPerTrack * Configuration.Geometry.TrackCount];
for (int i = 0; i < verifyTimeArray.Length; i++)
{
if (i >= Configuration.Geometry.DataClustersPerTrack * Configuration.Geometry.TrackCount ||
(fs.GetClusterState(i) & ClusterState.System) == 0)
{
DateTime c = new DateTime(r.Next());
verifyTimeArray[i] = c;
fs.SetVerifyTime(i, c);
}
else
{
verifyTimeArray[i] = fs.GetVerifyTime(i);
}
}
fs.Dispose();
string volumeName = Configuration.VolumeName;
Geometry geometry = Configuration.Geometry;
CryptoSettings cryptoSettings = Configuration.CryptoSettings;
Options options = Configuration.Options;
Guid guid = Configuration.FileSystemID;
Configuration.Reset();
Configuration.CryptoSettings = cryptoSettings;
Configuration.Options = options;
fs = FileSystem.Mount(io);
Assert.AreEqual(volumeName, Configuration.VolumeName);
Assert.AreEqual(geometry, Configuration.Geometry);
Assert.AreEqual(guid, Configuration.FileSystemID);
for (int i = 0; i < clusterStateArray.Length; i++)
{
Assert.AreEqual(clusterStateArray[i], fs.GetClusterState(i));
}
for (int i = 0; i < nextClusterArray.Length; i++)
{
Assert.AreEqual(nextClusterArray[i], fs.GetNextClusterAddress(i));
}
for (int i = 0; i < bytesUsedArray.Length; i++)
{
Assert.AreEqual(bytesUsedArray[i], fs.GetBytesUsed(i));
}
for (int i = 0; i < verifyTimeArray.Length; i++)
{
Assert.AreEqual(verifyTimeArray[i], fs.GetVerifyTime(i));
}
fs.Dispose();
}
}
public void FileSystemPopulate()
{
ConfigurationTest.Initialize();
Random r = new Random(1234);
using (var io = ConfigurationTest.CreateMemoryIO()) {
FileSystem fs = FileSystem.Create(io);
fs.Flush();
SortedList <int, DirInfo> dirs = new SortedList <int, DirInfo>();
SortedList <int, FileInfo> files = new SortedList <int, FileInfo>();
Directory d = fs.RootDirectory;
dirs.Add(fs.RootDirectory.ID, new DirInfo(d));
for (int i = 0; i < 1000; i++)
{
var parent = dirs.Values[r.Next(dirs.Count)];
d = fs.CreateDirectory(parent.Directory, $"dir{nextID}");
nextID++;
DirInfo info = new DirInfo(d);
dirs.Add(d.ID, info);
dirs[d.ParentID].Subdirs.Add(d.ID);
FileSystemAccessRule accessRule = new FileSystemAccessRule(
WindowsIdentity.GetCurrent().User, FileSystemRights.FullControl, InheritanceFlags.None,
PropagationFlags.None, AccessControlType.Allow);
fs.AddAccessRule(d, accessRule);
info.AccessRules.Add(accessRule);
FileSystemAuditRule auditRule = new FileSystemAuditRule(
WindowsIdentity.GetCurrent().User, FileSystemRights.FullControl, InheritanceFlags.None,
PropagationFlags.None, AuditFlags.Success);
fs.AddAuditRule(d, auditRule);
info.AuditRules.Add(auditRule);
}
for (int i = 0; i < 1000; i++)
{
var parent = dirs.Values[r.Next(dirs.Count)];
File f = fs.CreateFile(parent.Directory, $"file{nextID}");
nextID++;
FileInfo info = new FileInfo(f);
files.Add(f.ID, info);
dirs[f.ParentID].Files.Add(f.ID);
FileSystemAccessRule accessRule = new FileSystemAccessRule(
WindowsIdentity.GetCurrent().User, FileSystemRights.FullControl, InheritanceFlags.None,
PropagationFlags.None, AccessControlType.Allow);
fs.AddAccessRule(f, accessRule);
info.AccessRules.Add(accessRule);
FileSystemAuditRule auditRule = new FileSystemAuditRule(
WindowsIdentity.GetCurrent().User, FileSystemRights.FullControl, InheritanceFlags.None,
PropagationFlags.None, AuditFlags.Success);
fs.AddAuditRule(f, auditRule);
info.AuditRules.Add(auditRule);
}
checkDirectories(fs, fs.RootDirectory, dirs, files);
fs.Dispose();
CryptoSettings cryptoSettings = Configuration.CryptoSettings;
Options options = Configuration.Options;
Configuration.Reset();
Configuration.CryptoSettings = cryptoSettings;
Configuration.Options = options;
fs = FileSystem.Mount(io);
checkDirectories(fs, fs.RootDirectory, dirs, files);
}
}
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);
}
}
