public void MoveFile(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
DiscFileInfo fi = fs.GetFileInfo("foo.txt");
using (Stream s = fi.Create())
{
for (int i = 0; i < 10; ++i)
{
s.Write(new byte[111], 0, 111);
}
}
fi.Attributes = FileAttributes.Hidden | FileAttributes.System;
fi.MoveTo("foo2.txt");
fi = fs.GetFileInfo("foo2.txt");
Assert.IsTrue(fi.Exists);
Assert.AreEqual(1110, fi.Length);
Assert.AreEqual(FileAttributes.Hidden | FileAttributes.System, fi.Attributes);
fi = fs.GetFileInfo("foo.txt");
Assert.IsFalse(fi.Exists);
}
public void Name(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
Assert.AreEqual("foo.txt", fs.GetFileInfo("foo.txt").Name);
Assert.AreEqual("foo.txt", fs.GetFileInfo(@"path\foo.txt").Name);
Assert.AreEqual("foo.txt", fs.GetFileInfo(@"\foo.txt").Name);
}
public void Length(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
using (Stream s = fs.GetFileInfo("foo.txt").Open(FileMode.Create, FileAccess.ReadWrite))
{
s.SetLength(3128);
}
Assert.AreEqual(3128, fs.GetFileInfo("foo.txt").Length);
using (Stream s = fs.OpenFile("foo.txt", FileMode.Open, FileAccess.ReadWrite))
{
s.SetLength(3);
Assert.AreEqual(3, s.Length);
}
Assert.AreEqual(3, fs.GetFileInfo("foo.txt").Length);
using (Stream s = fs.OpenFile("foo.txt", FileMode.Open, FileAccess.ReadWrite))
{
s.SetLength(3333);
byte[] buffer = new byte[512];
for (int i = 0; i < buffer.Length; ++i)
{
buffer[i] = (byte)i;
}
s.Write(buffer, 0, buffer.Length);
s.Write(buffer, 0, buffer.Length);
Assert.AreEqual(1024, s.Position);
Assert.AreEqual(3333, s.Length);
s.SetLength(512);
Assert.AreEqual(512, s.Length);
}
using (Stream s = fs.OpenFile("foo.txt", FileMode.Open, FileAccess.ReadWrite))
{
byte[] buffer = new byte[512];
int numRead = s.Read(buffer, 0, buffer.Length);
int totalRead = 0;
while (numRead != 0)
{
totalRead += numRead;
numRead = s.Read(buffer, totalRead, buffer.Length - totalRead);
}
for (int i = 0; i < buffer.Length; ++i)
{
Assert.AreEqual((byte)i, buffer[i]);
}
}
}
public void CreationTime(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
using (Stream s = fs.OpenFile("foo.txt", FileMode.Create)) { }
Assert.GreaterOrEqual(DateTime.Now, fs.GetFileInfo("foo.txt").CreationTime);
Assert.LessOrEqual(DateTime.Now.Subtract(TimeSpan.FromSeconds(10)), fs.GetFileInfo("foo.txt").CreationTime);
}
public void DeleteFile(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
using (Stream s = fs.GetFileInfo("foo.txt").Open(FileMode.Create, FileAccess.ReadWrite)) { }
Assert.AreEqual(1, fs.Root.GetFiles().Length);
DiscFileInfo fi = fs.GetFileInfo("foo.txt");
fi.Delete();
Assert.AreEqual(0, fs.Root.GetFiles().Length);
}
public void Exists(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
DiscFileInfo fi = fs.GetFileInfo("foo.txt");
Assert.IsFalse(fi.Exists);
using (Stream s = fi.Open(FileMode.Create)) { }
Assert.IsTrue(fi.Exists);
fs.CreateDirectory("dir.txt");
Assert.IsFalse(fs.GetFileInfo("dir.txt").Exists);
}
public void Delete_Dir(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
fs.CreateDirectory("foo.txt");
fs.GetFileInfo("foo.txt").Delete();
}
public void Open_FileNotFound(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
DiscFileInfo di = fs.GetFileInfo("foo.txt");
using (Stream s = di.Open(FileMode.Open)) { }
}
public void Delete(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
using (Stream s = fs.OpenFile("foo.txt", FileMode.Create)) { }
fs.GetFileInfo("foo.txt").Delete();
Assert.IsFalse(fs.FileExists("foo.txt"));
}
public void CreateFileInvalid_Long(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
using (Stream s = fs.GetFileInfo(new string('X', 256)).Open(FileMode.Create, FileAccess.ReadWrite))
{
s.WriteByte(1);
}
}
public void CreateFileInvalid_Characters(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
using (Stream s = fs.GetFileInfo("A\0File").Open(FileMode.Create, FileAccess.ReadWrite))
{
s.WriteByte(1);
}
}
public void Open_DirExists(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
fs.CreateDirectory("FOO.TXT");
DiscFileInfo di = fs.GetFileInfo("foo.txt");
using (Stream s = di.Open(FileMode.Create)) { s.WriteByte(1); }
}
public void Open_FileExists(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
DiscFileInfo di = fs.GetFileInfo("foo.txt");
using (Stream s = di.Open(FileMode.Create)) { s.WriteByte(1); }
using (Stream s = di.Open(FileMode.CreateNew)) { }
}
public void Attributes_ChangeType(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
DiscFileInfo fi = fs.GetFileInfo("foo.txt");
using (Stream s = fi.Open(FileMode.Create)) { }
fi.Attributes = fi.Attributes | FileAttributes.Directory;
}
public void Open_Read_Fail(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
DiscFileInfo di = fs.GetFileInfo("foo.txt");
using (Stream s = di.Open(FileMode.Create, FileAccess.Read))
{
s.WriteByte(1);
}
}
public void Attributes(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
DiscFileInfo fi = fs.GetFileInfo("foo.txt");
using (Stream s = fi.Open(FileMode.Create)) { }
// Check default attributes
Assert.AreEqual(FileAttributes.Archive, fi.Attributes);
// Check round-trip
FileAttributes newAttrs = FileAttributes.Hidden | FileAttributes.ReadOnly | FileAttributes.System;
fi.Attributes = newAttrs;
Assert.AreEqual(newAttrs, fi.Attributes);
// And check persistence to disk
Assert.AreEqual(newAttrs, fs.GetFileInfo("foo.txt").Attributes);
}
public void CreateFile(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
using (Stream s = fs.GetFileInfo("foo.txt").Open(FileMode.Create, FileAccess.ReadWrite))
{
s.WriteByte(1);
}
DiscFileInfo fi = fs.GetFileInfo("foo.txt");
Assert.IsTrue(fi.Exists);
Assert.AreEqual(FileAttributes.Archive, fi.Attributes);
Assert.AreEqual(1, fi.Length);
using (Stream s = fs.OpenFile("Foo.txt", FileMode.Open, FileAccess.Read))
{
Assert.AreEqual(1, s.ReadByte());
}
}
public void Parent(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
fs.CreateDirectory(@"SOMEDIR\ADIR");
using (Stream s = fs.OpenFile(@"SOMEDIR\ADIR\FILE.TXT", FileMode.Create)) { }
DiscFileInfo fi = fs.GetFileInfo(@"SOMEDIR\ADIR\FILE.TXT");
Assert.AreEqual(fs.GetDirectoryInfo(@"SOMEDIR\ADIR"), fi.Parent);
Assert.AreEqual(fs.GetDirectoryInfo(@"SOMEDIR\ADIR"), fi.Directory);
}
public void Open_Write(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
DiscFileInfo di = fs.GetFileInfo("foo.txt");
using (Stream s = di.Open(FileMode.Create, FileAccess.Write))
{
Assert.IsTrue(s.CanWrite);
Assert.IsFalse(s.CanRead);
s.WriteByte(1);
}
}
public void MoveFile_Overwrite(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
DiscFileInfo fi = fs.GetFileInfo("foo.txt");
using (Stream s = fi.Create())
{
s.WriteByte(1);
}
DiscFileInfo fi2 = fs.GetFileInfo("foo2.txt");
using (Stream s = fi2.Create())
{
}
fs.MoveFile("foo.txt", "foo2.txt", true);
Assert.IsFalse(fi.Exists);
Assert.IsTrue(fi2.Exists);
Assert.AreEqual(1, fi2.Length);
}
public void LastAccessTime(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
using (Stream s = fs.OpenFile("foo.txt", FileMode.Create)) { }
DiscFileInfo fi = fs.GetFileInfo("foo.txt");
DateTime baseTime = DateTime.Now - TimeSpan.FromDays(2);
fi.LastAccessTime = baseTime;
using (Stream s = fs.OpenFile("foo.txt", FileMode.Open, FileAccess.Read)) { }
Assert.Less(baseTime, fi.LastAccessTime);
}
public void LastWriteTime(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
using (Stream s = fs.OpenFile("foo.txt", FileMode.Create)) { }
DiscFileInfo fi = fs.GetFileInfo("foo.txt");
DateTime baseTime = DateTime.Now - TimeSpan.FromMinutes(10);
fi.LastWriteTime = baseTime;
using (Stream s = fs.OpenFile("foo.txt", FileMode.Open)) { s.WriteByte(1); }
Assert.Less(baseTime, fi.LastWriteTime);
}
public void Delete_NoFile(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
fs.GetFileInfo("foo.txt").Delete();
}
// private static WellKnownPartitionType GetPartitionType(PartitionInfo Partition)
// {
// switch (Partition.BiosType)
// {
// case BiosPartitionTypes.Fat16:
// case BiosPartitionTypes.Fat32:
// case BiosPartitionTypes.Fat32Lba:
// return WellKnownPartitionType.WindowsFat;
// case BiosPartitionTypes.Ntfs:
// return WellKnownPartitionType.WindowsNtfs;
// case BiosPartitionTypes.LinuxNative:
// return WellKnownPartitionType.Linux;
// case BiosPartitionTypes.LinuxSwap:
// return WellKnownPartitionType.LinuxSwap;
// case BiosPartitionTypes.LinuxLvm:
// return WellKnownPartitionType.LinuxLvm;
// default:
// throw new ArgumentException(
// String.Format("Unsupported partition type: '{0}'", BiosPartitionTypes.ToString(Partition.BiosType)), "Partition");
// }
// }
//
// private static DiscFileSystem DetectFileSystem(PartitionInfo Partition)
// {
// using (var stream = Partition.Open())
// {
// if (NtfsFileSystem.Detect(stream))
// return new NtfsFileSystem(Partition.Open());
// stream.Seek(0, SeekOrigin.Begin);
// if (FatFileSystem.Detect(stream))
// return new FatFileSystem(Partition.Open());
//
// /* Ext2/3/4 file system - when Ext becomes fully writable
//
// stream.Seek(0, SeekOrigin.Begin);
// if (ExtFileSystem.Detect(stream))
// return new ExtFileSystem(Partition.Open());
// */
//
// return null;
// }
// }
private static void DiffPart(DiscFileSystem PartA, DiscFileSystem PartB, DiscFileSystem Output, ComparisonStyle Style = ComparisonStyle.DateTimeOnly, CopyQueue WriteQueue = null)
{
if (PartA == null) throw new ArgumentNullException("PartA");
if (PartB == null) throw new ArgumentNullException("PartB");
if (Output == null) throw new ArgumentNullException("Output");
if (PartA is NtfsFileSystem)
{
((NtfsFileSystem) PartA).NtfsOptions.HideHiddenFiles = false;
((NtfsFileSystem) PartA).NtfsOptions.HideSystemFiles = false;
}
if (PartB is NtfsFileSystem)
{
((NtfsFileSystem) PartB).NtfsOptions.HideHiddenFiles = false;
((NtfsFileSystem) PartB).NtfsOptions.HideSystemFiles = false;
}
if (Output is NtfsFileSystem)
{
((NtfsFileSystem) Output).NtfsOptions.HideHiddenFiles = false;
((NtfsFileSystem) Output).NtfsOptions.HideSystemFiles = false;
}
if (WriteQueue == null) WriteQueue = new CopyQueue();
var RootA = PartA.Root;
var RootB = PartB.Root;
var OutRoot = Output.Root;
var OutFileRoot = Output.GetDirectoryInfo(RootFiles);
if (!OutFileRoot.Exists) OutFileRoot.Create();
CompareTree(RootA, RootB, OutFileRoot, WriteQueue, Style);
WriteQueue.Go();
// Now handle registry files (if any)
ParallelQuery<DiscFileInfo> Ofiles;
lock(OutFileRoot.FileSystem)
Ofiles = OutFileRoot.GetFiles("*.*", SearchOption.AllDirectories).AsParallel();
Ofiles = Ofiles.Where(dfi =>
SystemRegistryFiles.Contains(dfi.FullName, StringComparer.CurrentCultureIgnoreCase));
foreach (var file in Ofiles)
{
var A = PartA.GetFileInfo(file.FullName.Substring(RootFiles.Length + 1));
if (!A.Exists)
{
file.FileSystem.MoveFile(file.FullName, String.Concat(RootSystemRegistry, A.FullName));
continue;
}
//else
MemoryStream SideA = new MemoryStream();
using (var tmp = A.OpenRead()) tmp.CopyTo(SideA);
MemoryStream SideB = new MemoryStream();
using (var tmp = file.OpenRead()) tmp.CopyTo(SideB);
var comp = new RegistryComparison(SideA, SideB, RegistryComparison.Side.B);
comp.DoCompare();
var diff = new RegDiff(comp, RegistryComparison.Side.B);
var outFile = Output.GetFileInfo(Path.Combine(RootSystemRegistry, file.FullName));
if (!outFile.Directory.Exists)
{
outFile.Directory.Create();
}
using (var OUT = outFile.Open(outFile.Exists ? FileMode.Truncate : FileMode.CreateNew, FileAccess.ReadWrite))
diff.WriteToStream(OUT);
file.Delete(); // remove this file from the set of file to copy and overwrite
}
lock (OutFileRoot.FileSystem)
Ofiles = OutFileRoot.GetFiles("*.*", SearchOption.AllDirectories).AsParallel();
Ofiles = Ofiles.Where(dfi => UserRegisrtyFiles.IsMatch(dfi.FullName));
foreach (var file in Ofiles)
{
var match = UserRegisrtyFiles.Match(file.FullName);
var A = PartA.GetFileInfo(file.FullName.Substring(RootFiles.Length + 1));
if (!A.Exists)
{
file.FileSystem.MoveFile(file.FullName,
Path.Combine(RootUserRegistry, match.Groups["user"].Value, A.Name));
continue;
}
//else
MemoryStream SideA = new MemoryStream();
using (var tmp = A.OpenRead()) tmp.CopyTo(SideA);
MemoryStream SideB = new MemoryStream();
using (var tmp = file.OpenRead()) tmp.CopyTo(SideB);
var comp = new RegistryComparison(SideA, SideB, RegistryComparison.Side.B);
comp.DoCompare();
var diff = new RegDiff(comp, RegistryComparison.Side.B);
var outFile =
Output.GetFileInfo(Path.Combine(RootUserRegistry, match.Groups["user"].Value, file.FullName));
if (!outFile.Directory.Exists)
{
outFile.Directory.Create();
}
using (var OUT = outFile.Open(outFile.Exists ? FileMode.Truncate : FileMode.CreateNew, FileAccess.ReadWrite))
diff.WriteToStream(OUT);
file.Delete(); // remove this file from the set of file to copy and overwrite
}
}
public void Equals(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
Assert.AreEqual(fs.GetFileInfo("foo.txt"), fs.GetFileInfo("foo.txt"));
}
