public void T05_ApiRenameTest()
{
using (var f = new TestPhysicalFile())
{
var initialDirectoryName = "TestDirectory";
var initialFileName = "TestFile.txt";
var finalDirectoryName = "RenamedTestDirectory";
var finalFileName = "RenamedTestFile.txt";
var fileContent = "test content";
//check on created FS
using (var api = getEmptyApi(f))
{
api.CreateDirectory(initialDirectoryName);
var file = api.CreateFile($"/{initialDirectoryName}/{initialFileName}");
file.WriteAllText(fileContent);
api.RenameDirectory(initialDirectoryName, finalDirectoryName);
api.RenameFile($"{finalDirectoryName}/{initialFileName}", $"{finalDirectoryName}/{finalFileName}");
}
//check on opened FS
using (var api = getEmptyApi(f))
{
var testDirectory = api.GetRootDirectory().GetDirectories().FirstOrDefault();
Assert.IsNotNull(testDirectory);
var testFile = testDirectory.GetFiles().FirstOrDefault();
Assert.IsNotNull(testFile);
var readContent = testFile.ReadAllText();
Assert.AreEqual($"/{finalDirectoryName}/{finalFileName}", testFile.Name);
Assert.AreEqual(fileContent, readContent);
}
}
}
public async Task T21_ApiImportDirectoryTest()
{
using (var f = new TestPhysicalFile())
using (var f1 = new TestPhysicalFile())
using (var srcApi = getTestApi(f))
using (var api = getEmptyApi(f1))
{
var directoryToImport = srcApi.GetDirectory("a1");
await api.ImportDirectory(directoryToImport, "", args => { }, CancellationToken.None);
var dirs = api.FindDirectories(true, "*").ToList();
foreach (var dir in dirs)
{
var dirName = VirtualPath.GetFileName(dir.Name);
var file = dir.GetFiles(false, $"{dirName}.???").FirstOrDefault();
Assert.IsNotNull(file);
if (dirName.Equals("a1", StringComparison.InvariantCultureIgnoreCase))
{
Assert.AreEqual("0000", file.ReadAllText());
}
else if (dirName.Equals("b1", StringComparison.InvariantCultureIgnoreCase))
{
Assert.AreEqual("1111", file.ReadAllText());
}
else if (dirName.Equals("c1", StringComparison.InvariantCultureIgnoreCase))
{
Assert.AreEqual("2222", file.ReadAllText());
}
}
}
}
public async Task MoveFileTest()
{
using (var f = new TestPhysicalFile())
{
var testString = "1234567890";
var dirAname = "dir_A";
var dirBname = "dir_B";
var filename = "testfile.txt";
using (var fs = new InternalFileSystem(SynchronizationContext.Current, f.Filename, VirtualDriveParameters.Default))
{
var file = fs.GetRoot().CreateDirectory(dirAname).CreateFile(filename);
file.WriteAllText(testString);
var dirB = fs.GetRoot().CreateDirectory(dirBname);
await file.MoveTo(dirB, args => { }, CancellationToken.None);
}
using (var fs = new InternalFileSystem(SynchronizationContext.Current, f.Filename, VirtualDriveParameters.Default))
{
var dirA = fs.GetRoot().GetDirectories(false, dirAname).FirstOrDefault();
Assert.IsNotNull(dirA, "Created directory A not found");
var dirB = fs.GetRoot().GetDirectories(false, dirBname).FirstOrDefault();
Assert.IsNotNull(dirB, "Created directory B not found");
var aFiles = dirA.GetFiles().ToArray();
var bFiles = dirB.GetFiles().ToArray();
Assert.AreEqual(0, aFiles.Length, "Dir A should not contain any files");
Assert.AreEqual(1, bFiles.Length, "Dir B should contain 1 file");
var bFileName = VirtualPath.GetFileName(bFiles[0].Name);
Assert.AreEqual(filename, bFileName, "File names mismatch");
var BfileContent = bFiles[0].ReadAllText();
Assert.AreEqual(testString, BfileContent, "File B content mismatch");
}
}
}
private IVirtualFileSystem getEmptyApi(TestPhysicalFile physicalFile)
{
SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
var retv = new VirtualFileSystem(physicalFile.Filename);
return(retv);
}
public void T01_ApiGetRootTest()
{
using (var f = new TestPhysicalFile())
{
//check on created FS
using (var api = getEmptyApi(f))
{
var root = api.GetRootDirectory();
var rootFromPath = api.GetDirectory(null);
Assert.IsNotNull(root);
Assert.IsNotNull(rootFromPath);
Assert.AreEqual(rootFromPath, root);
}
//check on opened FS
using (var api = getEmptyApi(f))
{
var root = api.GetRootDirectory();
var rootFromPath = api.GetDirectory(null);
Assert.IsNotNull(root);
Assert.IsNotNull(rootFromPath);
Assert.AreEqual(rootFromPath, root);
}
}
}
public void WriteReopenReadTest()
{
using (var f = new TestPhysicalFile())
{
var testString = "TestContent1234567890";
var bytes = Encoding.UTF8.GetBytes(testString);
var length = bytes.Length;
using (var fs = new InternalFileSystem(SynchronizationContext.Current, f.Filename, VirtualDriveParameters.Default))
{
using (var stream = fs.GetRoot().CreateFile("TestFile.txt")
.Open(FileMode.OpenOrCreate, FileAccess.ReadWrite))
{
Assert.IsTrue(stream.CanWrite, "Stream does not allow writing");
stream.Write(bytes, 0, bytes.Length);
Assert.AreEqual(length, stream.Position, "Stream position is wrong");
}
}
using (var fs = new InternalFileSystem(SynchronizationContext.Current, f.Filename, VirtualDriveParameters.Default))
{
using (var stream = fs.GetRoot().GetFiles().First().Open(FileMode.Open, FileAccess.Read))
{
Assert.AreEqual(length, stream.Length, "Stream length is wrong");
Assert.IsFalse(stream.CanWrite, "Stream should not allow writing");
var buffer = new byte[4096];
var readBytesCount = stream.Read(buffer, 0, (int)stream.Length);
Assert.AreEqual(length, readBytesCount, "Wrong bytes number is read");
var readBytes = buffer.Take(readBytesCount).ToArray();
var readString = Encoding.UTF8.GetString(readBytes);
Assert.AreEqual(testString, readString, "Read string is wrong");
}
}
}
}
public void T15_ApiDirectoriesSearchTest()
{
using (var f = new TestPhysicalFile())
using (var api = getTestApi(f))
{
var found = api.FindDirectories(true, "a*").ToList();
Assert.AreEqual(2, found.Count);
}
}
public void T12_ApiFilesSearchTest()
{
using (var f = new TestPhysicalFile())
using (var api = getTestApi(f))
{
var found = api.FindFiles(true, "?1.*").ToList();
Assert.AreEqual(3, found.Count);
}
}
public void T04_CreateFileTest()
{
using (var f = new TestPhysicalFile())
using (var fs = new InternalFileSystem(SynchronizationContext.Current, f.Filename, VirtualDriveParameters.Default))
{
var file = fs.GetRoot().CreateFile("testfile.txt");
Assert.IsNotNull(file, "Unable to create a file");
Assert.AreEqual($"{VirtualPath.Separator}testfile.txt", file.Name, "Created file has wrong name");
}
}
public void T06_CreateDirectoryTest()
{
using (var f = new TestPhysicalFile())
using (var fs = new InternalFileSystem(SynchronizationContext.Current, f.Filename, VirtualDriveParameters.Default))
{
var directory = fs.GetRoot().CreateDirectory("testDirectory");
Assert.IsNotNull(directory, "Unable to create a directory");
Assert.AreEqual($"{VirtualPath.Separator}testDirectory", directory.Name, "Created directory has wrong name");
}
}
public void T02_RootTest()
{
using (var f = new TestPhysicalFile())
using (var fs = new InternalFileSystem(SynchronizationContext.Current, f.Filename, VirtualDriveParameters.Default))
{
var root = fs.GetRoot();
Assert.IsNotNull(root, "Unable to get root directory");
Assert.AreEqual(string.Empty, root.Name, "Root directory has wrong name");
}
}
public void T01_InitializeTest()
{
using (var f = new TestPhysicalFile())
using (var fs = new InternalFileSystem(SynchronizationContext.Current, f.Filename, VirtualDriveParameters.Default))
{
Assert.IsTrue(File.Exists(f.Filename), "FS file was not created");
var file = new FileInfo(f.Filename);
Assert.IsTrue(file.Length > 0, "FS file is empty");
}
}
public void T16_ApiDeleteFileTest()
{
using (var f = new TestPhysicalFile())
using (var api = getTestApi(f))
{
var allFiles = api.FindFiles(true, "*").ToList();
Assert.AreEqual(6, allFiles.Count);
api.DeleteFile("a1/b1/c1/c1.dat");
allFiles = api.FindFiles(true, "*").ToList();
Assert.AreEqual(5, allFiles.Count);
}
}
public async Task T07_ApiCopyDirectoryTest()
{
using (var f = new TestPhysicalFile())
{
var initialContainerDir = "initial";
var finalContainerDir = "final";
var initialDirectoryName = "TestDirectory";
var finalDirectoryName = "RenamedTestDirectory";
var filename = "file.txt";
var fileContent = "test content";
//check on created FS
using (var api = getEmptyApi(f))
{
api.CreateDirectory($"{initialContainerDir}/{initialDirectoryName}");
api.CreateDirectory(finalContainerDir);
var file = api.CreateFile($"/{initialContainerDir}/{initialDirectoryName}/{filename}");
file.WriteAllText(fileContent);
await api.CopyDirectory($"{initialContainerDir}/{initialDirectoryName}",
$"{finalContainerDir}/{finalDirectoryName}",
args => { },
CancellationToken.None);
}
//check on opened FS
using (var api = getEmptyApi(f))
{
var initialFile = api.GetRootDirectory().GetDirectories()
.FirstOrDefault(x => x.Name == $"/{initialContainerDir}")
?.GetDirectories().FirstOrDefault()
?.GetFiles().FirstOrDefault();
Assert.IsNotNull(initialFile);
initialFile.WriteAllText("!!!"); // change initial file's content to make sure we dealing with different files
var containerDir = api.GetRootDirectory().GetDirectories().FirstOrDefault(x => x.Name == $"/{finalContainerDir}");
Assert.IsNotNull(containerDir);
var copiedDir = containerDir.GetDirectories()
.FirstOrDefault(x => x.Name == $"/{finalContainerDir}/{finalDirectoryName}");
Assert.IsNotNull(copiedDir);
var testFile = copiedDir.GetFiles().FirstOrDefault();
Assert.IsNotNull(testFile);
var readContent = testFile.ReadAllText();
Assert.AreEqual($"/{finalContainerDir}/{finalDirectoryName}/{filename}", testFile.Name);
Assert.AreEqual(fileContent, readContent);
}
}
}
public async Task T19_ApiImportFileTest()
{
using (var f = new TestPhysicalFile())
using (var f1 = new TestPhysicalFile())
using (var srcApi = getTestApi(f))
using (var api = getEmptyApi(f1))
{
var fileToImport = srcApi.GetFile("a1/a1.txt");
await api.ImportFile(fileToImport, "", args => { }, CancellationToken.None);
var importedFile = api.GetRootDirectory().GetFiles().FirstOrDefault();
Assert.IsNotNull(importedFile);
var importedContent = importedFile.ReadAllText();
Assert.AreEqual("0000", importedContent);
}
}
private IVirtualFileSystem getTestApi(TestPhysicalFile physicalFile)
{
SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
var retv = new VirtualFileSystem(physicalFile.Filename);
retv.CreateDirectory("A1/B1/C1");
retv.CreateDirectory("A2/B2/C2");
retv.CreateFile("A1/a1.txt").WriteAllText("0000");
retv.CreateFile("A1/B1/b1.txt").WriteAllText("1111");
retv.CreateFile("A1/B1/C1/c1.dat").WriteAllText("2222");
retv.CreateFile("A2/a2.txt").WriteAllText("3333");
retv.CreateFile("A2/B2/b2.txt").WriteAllText("4444");
retv.CreateFile("A2/B2/C2/c2.dat").WriteAllText("5555");
return(retv);
}
public void T17_ApiDeleteDirectoryTest()
{
using (var f = new TestPhysicalFile())
using (var api = getTestApi(f))
{
var allDirectories = api.FindDirectories(true, "*").ToList();
var allFiles = api.FindFiles(true, "*").ToList();
Assert.AreEqual(6, allDirectories.Count);
Assert.AreEqual(6, allFiles.Count);
api.DeleteDirectory("a1");
allDirectories = api.FindDirectories(true, "*").ToList();
allFiles = api.FindFiles(true, "*").ToList();
Assert.AreEqual(3, allDirectories.Count);
Assert.AreEqual(3, allFiles.Count);
}
}
public void T11_RenameDirectoryReopenTest()
{
using (var f = new TestPhysicalFile())
{
using (var fs = new InternalFileSystem(SynchronizationContext.Current, f.Filename, VirtualDriveParameters.Default))
{
var directory = fs.GetRoot().CreateDirectory("testDirectory");
directory.Name = "renamedDirectory";
}
using (var fs = new InternalFileSystem(SynchronizationContext.Current, f.Filename, VirtualDriveParameters.Default))
{
var directory = fs.GetRoot().GetDirectories().FirstOrDefault();
Assert.IsNotNull(directory, "Unable to get saved directory");
Assert.AreEqual($"{VirtualPath.Separator}renamedDirectory", directory.Name, "Saved directory has wrong name");
}
}
}
public void T09_RenameFileReopenTest()
{
using (var f = new TestPhysicalFile())
{
using (var fs = new InternalFileSystem(SynchronizationContext.Current, f.Filename, VirtualDriveParameters.Default))
{
var file = fs.GetRoot().CreateFile("testfile.txt");
file.Name = "renamedfile.txt";
}
using (var fs = new InternalFileSystem(SynchronizationContext.Current, f.Filename, VirtualDriveParameters.Default))
{
var file = fs.GetRoot().GetFiles().FirstOrDefault();
Assert.IsNotNull(file, "Unable to get saved file");
Assert.AreEqual($"{VirtualPath.Separator}renamedfile.txt", file.Name, "Saved file has wrong name");
}
}
}
public async Task T25_ApiWatcherNameChangedTest()
{
using (var f = new TestPhysicalFile())
using (var api = getEmptyApi(f))
{
var root = api.GetRootDirectory();
var dir = root.CreateDirectory("testDirectory");
using (var watcher = api.Watch(dir))
{
var eventFired = false;
watcher.NameChanged += (s, e) => eventFired = true;
dir.Name = "testDirectoryRenamed";
await Task.Delay(50); // event requires some time to fire
Assert.IsTrue(eventFired);
}
}
}
public async Task T08_ApiMoveFileTest()
{
using (var f = new TestPhysicalFile())
{
var initialDirectoryName = "TestDirectory";
var initialFileName = "TestFile.txt";
var finalDirectoryName = "RenamedTestDirectory";
var finalFileName = "RenamedTestFile.txt";
var fileContent = "test content";
//check on created FS
using (var api = getEmptyApi(f))
{
api.CreateDirectory(initialDirectoryName);
api.CreateDirectory(finalDirectoryName);
var file = api.CreateFile($"/{initialDirectoryName}/{initialFileName}");
file.WriteAllText(fileContent);
await api.MoveFile($"{initialDirectoryName}/{initialFileName}", $"{finalDirectoryName}/{finalFileName}",
args => { }, CancellationToken.None);
}
//check on opened FS
using (var api = getEmptyApi(f))
{
var initialDirectory = api.GetRootDirectory().GetDirectories().FirstOrDefault(x => x.Name == $"/{initialDirectoryName}");
Assert.IsNotNull(initialDirectory);
var initialFile = initialDirectory.GetFiles().FirstOrDefault();
Assert.IsNull(initialFile);
var testDirectory = api.GetRootDirectory().GetDirectories().FirstOrDefault(x => x.Name == $"/{finalDirectoryName}");
Assert.IsNotNull(testDirectory);
var testFile = testDirectory.GetFiles().FirstOrDefault();
Assert.IsNotNull(testFile);
var readContent = testFile.ReadAllText();
Assert.AreEqual($"/{finalDirectoryName}/{finalFileName}", testFile.Name);
Assert.AreEqual(fileContent, readContent);
}
}
}
public async Task T18_ApiImportFileTest()
{
var importFileName = "testImport.txt";
var imnportFileContent = "1234567890";
File.Create(importFileName).Dispose();
File.WriteAllText(importFileName, imnportFileContent);
using (var f = new TestPhysicalFile())
using (var api = getEmptyApi(f))
{
var fileInfo = new FileInfo(importFileName);
await api.ImportFile(fileInfo, "", args => { }, CancellationToken.None);
var importedFile = api.GetRootDirectory().GetFiles().FirstOrDefault();
Assert.IsNotNull(importedFile);
var importedContent = importedFile.ReadAllText();
Assert.AreEqual(imnportFileContent, importedContent);
}
File.Delete(importFileName);
}
public async Task T23_ApiWatcherUpdatedTest()
{
using (var f = new TestPhysicalFile())
using (var api = getEmptyApi(f))
{
var root = api.GetRootDirectory();
using (var watcher = api.Watch(root))
{
VirtualDirectory directoryFromEvent = null;
VirtualFile fileFromEvent = null;
watcher.DirectoryEvent += (s, e) =>
{
if (e.Event == WatcherEvent.Updated)
{
directoryFromEvent = e.Directory;
}
};
watcher.FileEvent += (s, e) =>
{
if (e.Event == WatcherEvent.Updated)
{
fileFromEvent = e.File;
}
};
var createdDir = root.CreateDirectory("testDirectory");
var createdFile = root.CreateFile("testDirectory/testFile.txt");
createdDir.Name = "testDirectoryRenamed";
createdFile.Name = "testFileRenamed.txt";
await Task.Delay(50); // event requires some time to fire
Assert.AreEqual("/testDirectoryRenamed", createdDir.Name);
Assert.AreEqual("/testFileRenamed.txt", createdFile.Name);
Assert.AreEqual(createdDir, directoryFromEvent);
Assert.AreEqual(createdFile, fileFromEvent);
}
}
}
public async Task T20_ApiImportDirectoryTest()
{
var importDirectoryName = "importDirectory";
Directory.CreateDirectory($"{importDirectoryName}\\nestedDirectory");
File.Create($"{importDirectoryName}\\0.txt").Dispose();
File.Create($"{importDirectoryName}\\nestedDirectory\\1.txt").Dispose();
File.WriteAllText($"{importDirectoryName}\\0.txt", "1234567890");
File.WriteAllText($"{importDirectoryName}\\nestedDirectory\\1.txt", "0987654321");
using (var f = new TestPhysicalFile())
using (var api = getEmptyApi(f))
{
var directoryToImport = new DirectoryInfo("importDirectory");
await api.ImportDirectory(directoryToImport, "", args => { }, CancellationToken.None);
var file0 = api.GetRootDirectory()
.GetDirectories(false, "importDirectory")
.FirstOrDefault()
?.GetFiles(false, "0.txt")
.FirstOrDefault();
Assert.IsNotNull(file0);
var file1 = api.GetRootDirectory()
.GetDirectories(false, "importDirectory")
.FirstOrDefault()
?.GetDirectories(false, "nestedDirectory")
.FirstOrDefault()
?.GetFiles(false, "1.txt")
.FirstOrDefault();
Assert.IsNotNull(file1);
Assert.AreEqual("1234567890", file0.ReadAllText());
Assert.AreEqual("0987654321", file1.ReadAllText());
}
Directory.Delete($"{importDirectoryName}\\nestedDirectory", true);
}
public void T03_ApiCreateDirectoryRecursiveTest()
{
using (var f = new TestPhysicalFile())
{
var directoryName_L1 = "TestDirectory1";
var directoryName_L2 = "TestDirectory2";
var directoryName_L3 = "TestDirectory3";
//check on created FS
using (var api = getEmptyApi(f))
{
api.CreateDirectory($"{directoryName_L1}/{directoryName_L2}/{directoryName_L3}");
var nestedDir_L1 = api.GetRootDirectory().GetDirectories().FirstOrDefault();
Assert.IsNotNull(nestedDir_L1);
var nestedDir_L2 = nestedDir_L1.GetDirectories().FirstOrDefault();
Assert.IsNotNull(nestedDir_L2);
var nestedDir_L3 = nestedDir_L2.GetDirectories().FirstOrDefault();
Assert.IsNotNull(nestedDir_L3);
Assert.AreEqual($"/{directoryName_L1}", nestedDir_L1.Name);
Assert.AreEqual($"/{directoryName_L1}/{directoryName_L2}", nestedDir_L2.Name);
Assert.AreEqual($"/{directoryName_L1}/{directoryName_L2}/{directoryName_L3}", nestedDir_L3.Name);
}
//check on opened FS
using (var api = getEmptyApi(f))
{
var nestedDir_L1 = api.GetRootDirectory().GetDirectories().FirstOrDefault();
Assert.IsNotNull(nestedDir_L1);
var nestedDir_L2 = nestedDir_L1.GetDirectories().FirstOrDefault();
Assert.IsNotNull(nestedDir_L2);
var nestedDir_L3 = nestedDir_L2.GetDirectories().FirstOrDefault();
Assert.IsNotNull(nestedDir_L3);
Assert.AreEqual($"/{directoryName_L1}", nestedDir_L1.Name);
Assert.AreEqual($"/{directoryName_L1}/{directoryName_L2}", nestedDir_L2.Name);
Assert.AreEqual($"/{directoryName_L1}/{directoryName_L2}/{directoryName_L3}", nestedDir_L3.Name);
}
}
}
public void T02_ApiCreateDirectoryTest()
{
using (var f = new TestPhysicalFile())
{
var directoryName = "TestDirectory";
//check on created FS
using (var api = getEmptyApi(f))
{
api.CreateDirectory(directoryName);
var nestedDirs = api.GetRootDirectory().GetDirectories().ToArray();
Assert.AreEqual(1, nestedDirs.Length);
Assert.AreEqual($"{VirtualPath.Separator}{directoryName}", nestedDirs[0].Name);
}
//check on opened FS
using (var api = getEmptyApi(f))
{
var nestedDirs = api.GetRootDirectory().GetDirectories().ToArray();
Assert.AreEqual(1, nestedDirs.Length);
Assert.AreEqual($"{VirtualPath.Separator}{directoryName}", nestedDirs[0].Name);
}
}
}
public void T05_CreateFilesAndReopenTest()
{
using (var f = new TestPhysicalFile())
{
using (var fs = new InternalFileSystem(SynchronizationContext.Current, f.Filename, VirtualDriveParameters.Default))
{
for (var i = 0; i < 100; i++)
{
fs.GetRoot().CreateFile($"testfile{i}.txt");
}
}
using (var fs = new InternalFileSystem(SynchronizationContext.Current, f.Filename, VirtualDriveParameters.Default))
{
var files = fs.GetRoot().GetFiles().ToList();
Assert.AreEqual(100, files.Count, "Unable to get saved files");
for (var i = 0; i < 100; i++)
{
var file = files[i];
Assert.AreEqual($"{VirtualPath.Separator}testfile{i}.txt", file.Name, "Created file has wrong name");
}
}
}
}
