private void File_Copy_WithProgress(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
Console.WriteLine();
var tempPath = UnitTestConstants.TempFolder;
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
using (var rootDir = new TemporaryDirectory(tempPath, MethodBase.GetCurrentMethod().Name))
{
// Min: 1 bytes, Max: 10485760 = 10 MB.
var fileLength = new Random().Next(1, 10485760);
var fileSource = UnitTestConstants.CreateFile(rootDir.Directory.FullName, fileLength);
var fileCopy = rootDir.RandomFileFullPath;
Console.WriteLine("Src File Path: [{0:N0} ({1}) [{2}]", fileLength, Alphaleonis.Utils.UnitSizeToText(fileLength), fileSource);
Console.WriteLine("Dst File Path: [{0}]", fileCopy);
Assert.IsTrue(System.IO.File.Exists(fileSource.FullName), "The file does not exists, but is expected to.");
// Allow copy to overwrite an existing file.
const Alphaleonis.Win32.Filesystem.CopyOptions copyOptions = Alphaleonis.Win32.Filesystem.CopyOptions.None;
// The copy progress handler.
var callback = new Alphaleonis.Win32.Filesystem.CopyMoveProgressRoutine(FileCopyProgressHandler);
Console.WriteLine();
// You can pass any piece of data to userProgressData. This data can be accessed from the callback method.
// Specify file length for assertion.
var userProgressData = fileLength;
var copyResult = Alphaleonis.Win32.Filesystem.File.Copy(fileSource.FullName, fileCopy, copyOptions, callback, userProgressData);
UnitTestConstants.Dump(copyResult, -18);
Assert.IsTrue(System.IO.File.Exists(fileCopy), "The file does not exists, but is expected to.");
var fileLen = new System.IO.FileInfo(fileCopy).Length;
Assert.AreEqual(fileLength, fileLen, "The file copy is: {0} bytes, but is expected to be: {1} bytes.", fileLen, fileLength);
Assert.IsTrue(System.IO.File.Exists(fileSource.FullName), "The original file does not exist, but is expected to.");
}
Console.WriteLine();
}
private void File_Delete(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var tempPath = System.IO.Path.GetTempPath();
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
using (var rootDir = new TemporaryDirectory(tempPath, MethodBase.GetCurrentMethod().Name))
{
var file = UnitTestConstants.CreateFile(rootDir.Directory.FullName);
Console.WriteLine("\nInput File Path: [{0}]", file);
Alphaleonis.Win32.Filesystem.File.Delete(file.FullName);
Assert.IsFalse(Alphaleonis.Win32.Filesystem.File.Exists(file.FullName), "The file exists, but is expected not to.");
}
Console.WriteLine();
}
private void File_Move(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var tempPath = System.IO.Path.GetTempPath();
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
using (var rootDir = new TemporaryDirectory(tempPath, "File.Move"))
{
// Min: 1 bytes, Max: 10485760 = 10 MB.
var fileLength = new Random().Next(1, 10485760);
var fileSource = UnitTestConstants.CreateFile(rootDir.Directory.FullName, fileLength);
var fileCopy = rootDir.RandomFileFullPath + ".txt";
Console.WriteLine("\nInput File Path: [{0}] [{1}]", Alphaleonis.Utils.UnitSizeToText(fileLength), fileSource);
Alphaleonis.Win32.Filesystem.File.Move(fileSource.FullName, fileCopy);
Assert.IsFalse(System.IO.File.Exists(fileSource.FullName), "The file does exists, but is expected not to.");
Assert.IsTrue(System.IO.File.Exists(fileCopy), "The file does not exists, but is expected to.");
var fileLen = new System.IO.FileInfo(fileCopy).Length;
Assert.AreEqual(fileLength, fileLen, "The file copy is: {0} bytes, but is expected to be: {1} bytes.", fileLen, fileLength);
Assert.IsFalse(System.IO.File.Exists(fileSource.FullName), "The original file exists, but is expected not to.");
}
Console.WriteLine();
}
private void File_Move(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
Console.WriteLine();
var tempPath = UnitTestConstants.TempFolder;
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
using (var rootDir = new TemporaryDirectory(tempPath, MethodBase.GetCurrentMethod().Name))
{
// Min: 1 byte, Max: 10485760 = 10 MB.
var fileLength = new Random().Next(1, 10485760);
var srcFile = UnitTestConstants.CreateFile(rootDir.Directory.FullName, fileLength);
var dstFile = System.IO.Path.Combine(rootDir.Directory.FullName, srcFile.Name + "-Moved.File");
Console.WriteLine("Src File Path: [{0}] [{1}]", Alphaleonis.Utils.UnitSizeToText(srcFile.Length), srcFile.FullName);
Console.WriteLine("Dst File Path: [{0}]", dstFile);
var moveResult = Alphaleonis.Win32.Filesystem.File.Move(srcFile.FullName, dstFile, Alphaleonis.Win32.Filesystem.PathFormat.FullPath);
UnitTestConstants.Dump(moveResult, -16);
// Test against moveResult results.
Assert.IsFalse(moveResult.IsCopy);
Assert.IsTrue(moveResult.IsMove);
Assert.IsFalse(moveResult.IsDirectory);
Assert.IsTrue(moveResult.IsFile);
Assert.AreEqual(fileLength, moveResult.TotalBytes);
Assert.AreEqual(1, moveResult.TotalFiles);
Assert.AreEqual(0, moveResult.TotalFolders);
Assert.IsFalse(System.IO.File.Exists(srcFile.FullName), "The file does exists, but is expected not to.");
Assert.IsTrue(System.IO.File.Exists(dstFile), "The file does not exists, but is expected to.");
var fileLen = new System.IO.FileInfo(dstFile).Length;
Assert.AreEqual(fileLength, fileLen, "The file copy is: {0} bytes, but is expected to be: {1} bytes.", fileLen, fileLength);
Assert.IsFalse(System.IO.File.Exists(srcFile.FullName), "The original file exists, but is expected not to.");
}
Console.WriteLine();
}
private void File_Copy_Overwrite_DestinationFileAlreadyExists(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
Console.WriteLine();
var tempPath = UnitTestConstants.TempFolder;
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
var gotException = false;
using (var rootDir = new TemporaryDirectory(tempPath, MethodBase.GetCurrentMethod().Name))
{
var srcFile = UnitTestConstants.CreateFile(rootDir.Directory.FullName);
var dstFile = rootDir.RandomFileFullPath;
Console.WriteLine("Src File Path: [{0}]", srcFile);
System.IO.File.Copy(srcFile.FullName, dstFile);
try
{
Alphaleonis.Win32.Filesystem.File.Copy(srcFile.FullName, dstFile);
}
catch (Exception ex)
{
var exType = ex.GetType();
gotException = exType == typeof(Alphaleonis.Win32.Filesystem.AlreadyExistsException);
Console.WriteLine("\n\tCaught {0} Exception: [{1}] {2}", gotException ? "EXPECTED" : "UNEXPECTED", exType.Name, ex.Message);
}
Assert.IsTrue(gotException, "The exception is not caught, but is expected to.");
Alphaleonis.Win32.Filesystem.File.Copy(srcFile.FullName, dstFile, true);
Assert.IsTrue(System.IO.File.Exists(srcFile.FullName), "The file does not exists, but is expected to.");
Assert.IsTrue(System.IO.File.Exists(dstFile), "The file does not exists, but is expected to.");
}
Console.WriteLine();
}
private void File_Copy_CatchUnauthorizedAccessException_DestinationFileIsReadOnly(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
Console.WriteLine();
var tempPath = UnitTestConstants.TempFolder;
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
var gotException = false;
using (var rootDir = new TemporaryDirectory(tempPath, MethodBase.GetCurrentMethod().Name))
{
var srcFile = UnitTestConstants.CreateFile(rootDir.Directory.FullName);
var dstFile = rootDir.RandomFileFullPath;
Console.WriteLine("Src File Path: [{0}]", srcFile);
Console.WriteLine("Dst File Path: [{0}]", dstFile);
System.IO.File.Copy(srcFile.FullName, dstFile);
System.IO.File.SetAttributes(dstFile, System.IO.FileAttributes.ReadOnly);
try
{
Alphaleonis.Win32.Filesystem.File.Copy(srcFile.FullName, dstFile, true);
}
catch (Exception ex)
{
var exType = ex.GetType();
gotException = exType == typeof(UnauthorizedAccessException);
Console.WriteLine("\n\tCaught {0} Exception: [{1}] {2}", gotException ? "EXPECTED" : "UNEXPECTED", exType.Name, ex.Message);
}
finally
{
System.IO.File.SetAttributes(dstFile, System.IO.FileAttributes.Normal);
}
}
Assert.IsTrue(gotException, "The exception is not caught, but is expected to.");
Console.WriteLine();
}
private void File_Move_CatchDirectoryNotFoundException_NonExistingDriveLetter(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var tempPath = System.IO.Path.GetTempPath();
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
using (var rootDir = new TemporaryDirectory(tempPath, "File.Move"))
{
var fileSource = UnitTestConstants.CreateFile(rootDir.Directory.FullName);
var fileCopy = Alphaleonis.Win32.Filesystem.DriveInfo.GetFreeDriveLetter() + @":\NonExistingDriveLetter\" + System.IO.Path.GetRandomFileName();
if (isNetwork)
{
fileCopy = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(fileCopy);
}
Console.WriteLine("\nSrc File Path: [{0}]", fileSource);
Console.WriteLine("Dst File Path: [{0}]", fileCopy);
var gotException = false;
try
{
Alphaleonis.Win32.Filesystem.File.Move(fileSource.FullName, fileCopy);
}
catch (Exception ex)
{
// Local: UnauthorizedAccessException.
// UNC: IOException.
var exName = ex.GetType().Name;
gotException = exName.Equals(isNetwork ? "IOException" : "DirectoryNotFoundException", StringComparison.OrdinalIgnoreCase);
Console.WriteLine("\n\tCaught Exception: [{0}] Message: [{1}]", exName, ex.Message);
}
Assert.IsTrue(gotException, "The exception is not caught, but is expected to.");
}
Console.WriteLine();
}
private void File_Move_Overwrite_DestinationFileAlreadyExists(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var tempPath = System.IO.Path.GetTempPath();
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
using (var rootDir = new TemporaryDirectory(tempPath, MethodBase.GetCurrentMethod().Name))
{
var fileSource = UnitTestConstants.CreateFile(rootDir.Directory.FullName);
var fileCopy = rootDir.RandomFileFullPath;
Console.WriteLine("\nSource File Path: [{0}]", fileSource);
// Copy it.
System.IO.File.Copy(fileSource.FullName, fileCopy);
var gotException = false;
try
{
Alphaleonis.Win32.Filesystem.File.Move(fileSource.FullName, fileCopy);
}
catch (Exception ex)
{
Alphaleonis.Win32.Filesystem.File.Move(fileSource.FullName, fileCopy, Alphaleonis.Win32.Filesystem.MoveOptions.ReplaceExisting);
var exName = ex.GetType().Name;
gotException = exName.Equals("AlreadyExistsException", StringComparison.OrdinalIgnoreCase);
Console.WriteLine("\n\tCaught {0} Exception: [{1}] {2}", gotException ? "EXPECTED" : "UNEXPECTED", exName, ex.Message);
Assert.IsFalse(System.IO.File.Exists(fileSource.FullName), "The file does exists, but is expected not to.");
Assert.IsTrue(System.IO.File.Exists(fileCopy), "The file does not exists, but is expected to.");
}
Assert.IsTrue(gotException, "The exception is not caught, but is expected to.");
}
Console.WriteLine();
}
private void File_Move_DifferentSourceAndDestination(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var tempPath = System.IO.Path.GetTempPath();
using (var rootDir = new TemporaryDirectory(tempPath, "File.Move"))
{
// Min: 1 bytes, Max: 10485760 = 10 MB.
var fileLength = new Random().Next(1, 10485760);
var src = UnitTestConstants.CreateFile(rootDir.Directory.FullName, fileLength).FullName;
var dst = rootDir.RandomFileFullPath + ".txt";
if (isNetwork)
{
src = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(src);
}
else
{
dst = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(dst);
}
Console.WriteLine("\nSRC File Path: [{0}] [{1}]", Alphaleonis.Utils.UnitSizeToText(fileLength), src);
Console.WriteLine("DST File Path: [{0}]", dst);
Alphaleonis.Win32.Filesystem.File.Move(src, dst);
Assert.IsFalse(System.IO.File.Exists(src), "The file does exists, but is expected not to.");
Assert.IsTrue(System.IO.File.Exists(dst), "The file does not exists, but is expected to.");
var fileLen = new System.IO.FileInfo(dst).Length;
Assert.AreEqual(fileLength, fileLen, "The file copy is: {0} bytes, but is expected to be: {1} bytes.", fileLen, fileLength);
Assert.IsFalse(System.IO.File.Exists(src), "The original file exists, but is expected not to.");
}
Console.WriteLine();
}
private void File_Copy_CatchUnauthorizedAccessException_DestinationFileIsReadOnly(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var tempPath = System.IO.Path.GetTempPath();
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
using (var rootDir = new TemporaryDirectory(tempPath, "File.Copy"))
{
var fileSource = UnitTestConstants.CreateFile(rootDir.Directory.FullName);
var fileCopy = rootDir.RandomFileFullPath + ".txt";
Console.WriteLine("\nInput File Path: [{0}]", fileSource);
System.IO.File.Copy(fileSource.FullName, fileCopy);
System.IO.File.SetAttributes(fileCopy, System.IO.FileAttributes.ReadOnly);
var gotException = false;
try
{
Alphaleonis.Win32.Filesystem.File.Copy(fileSource.FullName, fileCopy, true);
}
catch (Exception ex)
{
var exName = ex.GetType().Name;
gotException = exName.Equals("UnauthorizedAccessException", StringComparison.OrdinalIgnoreCase);
Console.WriteLine("\n\tCaught Exception: [{0}] Message: [{1}]", exName, ex.Message);
}
Assert.IsTrue(gotException, "The exception is not caught, but is expected to.");
System.IO.File.SetAttributes(fileCopy, System.IO.FileAttributes.Normal);
}
Console.WriteLine();
}
private void File_Delete_CatchFileReadOnlyException_ReadOnlyFile(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var tempPath = System.IO.Path.GetTempPath();
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
using (var rootDir = new TemporaryDirectory(tempPath, MethodBase.GetCurrentMethod().Name))
{
var file = UnitTestConstants.CreateFile(rootDir.Directory.FullName);
Console.WriteLine("\nInput File Path: [{0}]", file);
System.IO.File.SetAttributes(file.FullName, System.IO.FileAttributes.ReadOnly);
var gotException = false;
try
{
Alphaleonis.Win32.Filesystem.File.Delete(file.FullName);
}
catch (Exception ex)
{
var exName = ex.GetType().Name;
gotException = exName.Equals("FileReadOnlyException", StringComparison.OrdinalIgnoreCase);
Console.WriteLine("\n\tCaught {0} Exception: [{1}] {2}", gotException ? "EXPECTED" : "UNEXPECTED", exName, ex.Message);
}
Assert.IsTrue(gotException, "The exception is not caught, but is expected to.");
System.IO.File.SetAttributes(file.FullName, System.IO.FileAttributes.Normal);
}
Console.WriteLine();
}
private void File_SetTimestampsXxx(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var tempPath = System.IO.Path.GetTempPath();
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
var rnd = new Random();
using (var rootDir = new TemporaryDirectory(tempPath, "File.SetTimestampsXxx"))
{
var file = UnitTestConstants.CreateFile(rootDir.Directory.FullName);
var symlinkPath = System.IO.Path.Combine(rootDir.Directory.FullName, System.IO.Path.GetRandomFileName()) + "-symlink";
Console.WriteLine("\nInput File Path: [{0}]", file);
Alphaleonis.Win32.Filesystem.File.CreateSymbolicLink(symlinkPath, file.FullName, Alphaleonis.Win32.Filesystem.SymbolicLinkTarget.File);
var creationTime = new DateTime(rnd.Next(1971, 2071), rnd.Next(1, 12), rnd.Next(1, 28), rnd.Next(0, 23), rnd.Next(0, 59), rnd.Next(0, 59));
var lastAccessTime = new DateTime(rnd.Next(1971, 2071), rnd.Next(1, 12), rnd.Next(1, 28), rnd.Next(0, 23), rnd.Next(0, 59), rnd.Next(0, 59));
var lastWriteTime = new DateTime(rnd.Next(1971, 2071), rnd.Next(1, 12), rnd.Next(1, 28), rnd.Next(0, 23), rnd.Next(0, 59), rnd.Next(0, 59));
Alphaleonis.Win32.Filesystem.File.SetTimestamps(file.FullName, creationTime, lastAccessTime, lastWriteTime);
Assert.AreEqual(System.IO.File.GetCreationTime(file.FullName), creationTime);
Assert.AreEqual(System.IO.File.GetLastAccessTime(file.FullName), lastAccessTime);
Assert.AreEqual(System.IO.File.GetLastWriteTime(file.FullName), lastWriteTime);
// SymbolicLink
Alphaleonis.Win32.Filesystem.File.SetTimestamps(symlinkPath, creationTime.AddDays(1), lastAccessTime.AddDays(1), lastWriteTime.AddDays(1), true, Alphaleonis.Win32.Filesystem.PathFormat.RelativePath);
Assert.AreEqual(System.IO.File.GetCreationTime(symlinkPath), Alphaleonis.Win32.Filesystem.File.GetCreationTime(symlinkPath));
Assert.AreEqual(System.IO.File.GetLastAccessTime(symlinkPath), Alphaleonis.Win32.Filesystem.File.GetLastAccessTime(symlinkPath));
Assert.AreEqual(System.IO.File.GetLastWriteTime(symlinkPath), Alphaleonis.Win32.Filesystem.File.GetLastWriteTime(symlinkPath));
creationTime = new DateTime(rnd.Next(1971, 2071), rnd.Next(1, 12), rnd.Next(1, 28), rnd.Next(0, 23), rnd.Next(0, 59), rnd.Next(0, 59));
lastAccessTime = new DateTime(rnd.Next(1971, 2071), rnd.Next(1, 12), rnd.Next(1, 28), rnd.Next(0, 23), rnd.Next(0, 59), rnd.Next(0, 59));
lastWriteTime = new DateTime(rnd.Next(1971, 2071), rnd.Next(1, 12), rnd.Next(1, 28), rnd.Next(0, 23), rnd.Next(0, 59), rnd.Next(0, 59));
Alphaleonis.Win32.Filesystem.File.SetTimestampsUtc(file.FullName, creationTime, lastAccessTime, lastWriteTime);
Assert.AreEqual(System.IO.File.GetCreationTimeUtc(file.FullName), creationTime);
Assert.AreEqual(System.IO.File.GetLastAccessTimeUtc(file.FullName), lastAccessTime);
Assert.AreEqual(System.IO.File.GetLastWriteTimeUtc(file.FullName), lastWriteTime);
// SymbolicLink
Alphaleonis.Win32.Filesystem.File.SetTimestampsUtc(symlinkPath, creationTime.AddDays(1), lastAccessTime.AddDays(1), lastWriteTime.AddDays(1), true, Alphaleonis.Win32.Filesystem.PathFormat.RelativePath);
Assert.AreEqual(System.IO.File.GetCreationTimeUtc(symlinkPath), Alphaleonis.Win32.Filesystem.File.GetCreationTimeUtc(symlinkPath));
Assert.AreEqual(System.IO.File.GetLastAccessTimeUtc(symlinkPath), Alphaleonis.Win32.Filesystem.File.GetLastAccessTimeUtc(symlinkPath));
Assert.AreEqual(System.IO.File.GetLastWriteTimeUtc(symlinkPath), Alphaleonis.Win32.Filesystem.File.GetLastWriteTimeUtc(symlinkPath));
}
Console.WriteLine();
}
