private static void DumpClassFileInfo(bool isLocal)
{
#region Setup
Console.WriteLine("\n=== TEST {0} ===", isLocal ? Local : Network);
string tempPath = Path.Combine(Path.GetTempPath(), "FileInfo()-" + Path.GetRandomFileName());
if (!isLocal) tempPath = Path.LocalToUnc(tempPath);
int expectedLastError;
string expectedException;
string nonExistingFile = SysRoot32 + @"\NonExistingFile-" + Path.GetRandomFileName();
if (!isLocal) nonExistingFile = Path.LocalToUnc(nonExistingFile);
string sysDrive = SysDrive;
if (!isLocal) sysDrive = Path.LocalToUnc(sysDrive);
string sysRoot = SysRoot;
if (!isLocal) sysRoot = Path.LocalToUnc(sysRoot);
string letter = DriveInfo.GetFreeDriveLetter() + @":\";
if (!isLocal) letter = Path.LocalToUnc(letter);
#endregion // Setup
#region NotSupportedException
expectedLastError = (int) (isLocal ? Win32Errors.ERROR_ENVVAR_NOT_FOUND : Win32Errors.NERR_UseNotFound);
expectedException = "System.NotSupportedException";
bool exception = false;
try
{
Console.WriteLine("\nCatch: [{0}]: The given path's format is not supported.", expectedException);
string invalidPath = SysDrive + @"\:a";
if (!isLocal) invalidPath = Path.LocalToUnc(invalidPath) + @":a";
FileInfo fi = new FileInfo(invalidPath);
}
catch (Exception ex)
{
// Not reliable.
//var win32Error = new Win32Exception("", ex);
//Assert.IsTrue(win32Error.NativeErrorCode == expectedLastError, string.Format("Expected Win32Exception error should be: [{0}], got: [{1}]", expectedLastError, win32Error.NativeErrorCode));
//Assert.IsTrue(ex.Message.StartsWith("(" + expectedLastError + ")"), string.Format("Expected Win32Exception error is: [{0}]", expectedLastError));
string exceptionTypeName = ex.GetType().FullName;
if (exceptionTypeName.Equals(expectedException))
{
exception = true;
Console.WriteLine("\n\t[{0}]: [{1}]", exceptionTypeName, ex.Message.Replace(Environment.NewLine, " "));
}
else
Console.WriteLine("\n\tCaught Unexpected Exception: [{0}]: [{1}]", exceptionTypeName, ex.Message.Replace(Environment.NewLine, " "));
}
Assert.IsTrue(exception, "[{0}] should have been caught.", expectedException);
Console.WriteLine();
#endregion // NotSupportedException
#region Length Property
#region FileNotFoundException #1
expectedLastError = (int) Win32Errors.ERROR_FILE_NOT_FOUND;
expectedException = "System.IO.FileNotFoundException";
exception = false;
try
{
Console.WriteLine("\nCatch: [{0}]: Length property is called, the file does not exist.", expectedException);
Console.WriteLine(new FileInfo(nonExistingFile).Length);
}
catch (Exception ex)
{
var win32Error = new Win32Exception("", ex);
Assert.IsTrue(win32Error.NativeErrorCode == expectedLastError, string.Format("Expected Win32Exception error should be: [{0}], got: [{1}]", expectedLastError, win32Error.NativeErrorCode));
Assert.IsTrue(ex.Message.StartsWith("(" + expectedLastError + ")"), string.Format("Expected Win32Exception error is: [{0}]", expectedLastError));
string exceptionTypeName = ex.GetType().FullName;
if (exceptionTypeName.Equals(expectedException))
{
exception = true;
Console.WriteLine("\n\t[{0}]: [{1}]", exceptionTypeName, ex.Message.Replace(Environment.NewLine, " "));
}
else
Console.WriteLine("\n\tCaught Unexpected Exception: [{0}]: [{1}]", exceptionTypeName, ex.Message.Replace(Environment.NewLine, " "));
}
Assert.IsTrue(exception, "[{0}] should have been caught.", expectedException);
Console.WriteLine();
#endregion // FileNotFoundException #1
#region FileNotFoundException #2
expectedLastError = (int) (isLocal ? Win32Errors.ERROR_PATH_NOT_FOUND : Win32Errors.ERROR_BAD_NET_NAME);
expectedException = isLocal ? "System.IO.FileNotFoundException" : "System.IO.IOException";
exception = false;
try
{
Console.WriteLine("\nCatch: [{0}]: Length property is called, the file does not exist (Unmapped drive).", expectedException);
Console.WriteLine(new FileInfo(nonExistingFile.Replace(sysDrive + @"\", letter)).Length);
}
catch (Exception ex)
{
var win32Error = new Win32Exception("", ex);
Assert.IsTrue(win32Error.NativeErrorCode == expectedLastError, string.Format("Expected Win32Exception error should be: [{0}], got: [{1}]", expectedLastError, win32Error.NativeErrorCode));
//Assert.IsTrue(ex.Message.StartsWith("(" + expectedLastError + ")"), string.Format("Expected Win32Exception error is: [{0}]", expectedLastError));
string exceptionTypeName = ex.GetType().FullName;
if (exceptionTypeName.Equals(expectedException))
{
exception = true;
Console.WriteLine("\n\t[{0}]: [{1}]", exceptionTypeName, ex.Message.Replace(Environment.NewLine, " "));
}
else
Console.WriteLine("\n\tCaught Unexpected Exception: [{0}]: [{1}]", exceptionTypeName, ex.Message.Replace(Environment.NewLine, " "));
}
Assert.IsTrue(exception, "[{0}] should have been caught.", expectedException);
Console.WriteLine();
#endregion // FileNotFoundException #1
#region FileNotFoundException #3
expectedLastError = (int) Win32Errors.ERROR_FILE_NOT_FOUND;
expectedException = "System.IO.FileNotFoundException";
exception = false;
try
{
Console.WriteLine("\nCatch: [{0}]: Length property is called, the file is a directory.", expectedException);
Console.WriteLine(new FileInfo(sysRoot).Length);
}
catch (Exception ex)
{
// win32Error is always 0
//var win32Error = new Win32Exception("", ex);
//Assert.IsTrue(win32Error.NativeErrorCode == expectedLastError, string.Format("Expected Win32Exception error should be: [{0}], got: [{1}]", expectedLastError, win32Error.NativeErrorCode));
Assert.IsTrue(ex.Message.StartsWith("(" + expectedLastError + ")"), string.Format("Expected Win32Exception error is: [{0}]", expectedLastError));
string exceptionTypeName = ex.GetType().FullName;
if (exceptionTypeName.Equals(expectedException))
{
exception = true;
Console.WriteLine("\n\t[{0}]: [{1}]", exceptionTypeName, ex.Message.Replace(Environment.NewLine, " "));
}
else
Console.WriteLine("\n\tCaught Unexpected Exception: [{0}]: [{1}]", exceptionTypeName, ex.Message.Replace(Environment.NewLine, " "));
}
Assert.IsTrue(exception, "[{0}] should have been caught.", expectedException);
Console.WriteLine();
#endregion // FileNotFoundException #3
#endregion // Length Property
#region Current Directory
tempPath = Path.CurrentDirectoryPrefix;
if (!isLocal) tempPath = Path.LocalToUnc(tempPath);
Console.WriteLine("\nInput File Path (Current directory): [{0}]\n", tempPath);
StopWatcher(true);
System.IO.FileInfo expected = new System.IO.FileInfo(tempPath);
Console.WriteLine("\tSystem.IO FileInfo(){0}", Reporter());
StopWatcher(true);
FileInfo actual = new FileInfo(tempPath);
Console.WriteLine("\tAlphaFS FileInfo(){0}", Reporter());
// Compare values of both instances.
CompareFileInfos(expected, actual);
#endregion // Current Directory
#region Non-Existing File
Console.WriteLine("\nInput File Path: [{0}]\n", nonExistingFile);
StopWatcher(true);
expected = new System.IO.FileInfo(nonExistingFile);
Console.WriteLine("\tSystem.IO FileInfo(){0}", Reporter());
StopWatcher(true);
actual = new FileInfo(nonExistingFile);
Console.WriteLine("\tAlphaFS FileInfo(){0}", Reporter());
// Compare values of both instances.
CompareFileInfos(expected, actual);
#endregion // Non-Existing File
#region Existing File
tempPath = Path.Combine(Path.GetTempPath(), "FileInfo()-File-" + Path.GetRandomFileName());
if (!isLocal) tempPath = Path.LocalToUnc(tempPath);
try
{
using (File.Create(tempPath)) {}
Console.WriteLine("\nInput File Path: [{0}]\n", tempPath);
StopWatcher(true);
expected = new System.IO.FileInfo(tempPath);
Console.WriteLine("\tSystem.IO FileInfo(){0}", Reporter());
StopWatcher(true);
actual = new FileInfo(tempPath);
Console.WriteLine("\tAlphaFS FileInfo(){0}", Reporter());
// Compare values of both instances.
CompareFileInfos(expected, actual);
}
finally
{
File.Delete(tempPath);
Assert.IsFalse(File.Exists(tempPath), "Cleanup failed: File should have been removed.");
}
#endregion // Existing File
#region Method .ToString()
Console.WriteLine("\nMethod .ToString()");
Console.WriteLine("Both strings should be the same.\n");
expected = new System.IO.FileInfo("ToString()-TestFile");
actual = new FileInfo("ToString()-TestFile");
string expectedToString = expected.ToString();
string actualToString = actual.ToString();
Console.WriteLine("\tSystem.IO: [{0}]", expectedToString);
Console.WriteLine("\tAlphaFS : [{0}]", actualToString);
Assert.AreEqual(expectedToString, actualToString, false);
Console.WriteLine();
#endregion Method .ToString()
}
private void DumpRefresh(bool isLocal)
{
#region Setup
Console.WriteLine("\n=== TEST {0} ===", isLocal ? Local : Network);
string tempPathSysIo = Path.GetTempPath("FileInfo.Refresh()-file-SysIo-" + Path.GetRandomFileName());
string tempPath = Path.GetTempPath("FileInfo.Refresh()-file-AlphaFS-" + Path.GetRandomFileName());
if (!isLocal)
{
tempPathSysIo = Path.LocalToUnc(tempPathSysIo);
}
if (!isLocal)
{
tempPath = Path.LocalToUnc(tempPath);
}
Console.WriteLine("\nInput File Path: [{0}]", tempPath);
#endregion // Setup
#region Refresh
try
{
System.IO.FileInfo fiSysIo = new System.IO.FileInfo(tempPathSysIo);
FileInfo fi = new FileInfo(tempPath);
bool existsSysIo = fiSysIo.Exists;
bool exists = fi.Exists;
Console.WriteLine("\nnew FileInfo(): Exists (Should be {0}): [{1}]", existsSysIo, exists); // false
Assert.AreEqual(existsSysIo, exists);
FileStream fsSysIo = fiSysIo.Create();
FileStream fs = fi.Create();
existsSysIo = fiSysIo.Exists;
exists = fi.Exists;
Console.WriteLine("\nfi.Create(): Exists (Should be {0}): [{1}]", existsSysIo, exists); // false
Assert.AreEqual(existsSysIo, exists);
fiSysIo.Refresh();
fi.Refresh();
existsSysIo = fiSysIo.Exists;
exists = fi.Exists;
Console.WriteLine("\nfi.Refresh(): Exists (Should be {0}): [{1}]", existsSysIo, exists); // true
Assert.AreEqual(existsSysIo, exists);
fsSysIo.Close();
fs.Close();
existsSysIo = fiSysIo.Exists;
exists = fi.Exists;
Console.WriteLine("\nfi.Close(): Exists (Should be {0}): [{1}]", existsSysIo, exists); // true
Assert.AreEqual(existsSysIo, exists);
fiSysIo.Delete();
fi.Delete();
existsSysIo = fiSysIo.Exists;
exists = fi.Exists;
Console.WriteLine("\nfi.Delete(): Exists (Should be {0}): [{1}]", existsSysIo, exists); // true
Assert.AreEqual(existsSysIo, exists);
fiSysIo.Refresh();
fi.Refresh();
existsSysIo = fiSysIo.Exists;
exists = fi.Exists;
Console.WriteLine("\nfi.Refresh(): Exists (Should be False): [{0}]", exists); // false
Assert.AreEqual(existsSysIo, exists);
}
finally
{
File.Delete(tempPath);
Assert.IsFalse(File.Exists(tempPath), "Cleanup failed: File should have been removed.");
File.Delete(tempPathSysIo);
Assert.IsFalse(File.Exists(tempPath), "Cleanup failed: File should have been removed.");
Console.WriteLine();
}
#endregion // Refresh
}
public void SetAccessControl()
{
Console.WriteLine("File.SetAccessControl()");
if (!IsAdmin())
Assert.Fail();
string path = SysDrive + @"\AlphaFile-" + Path.GetRandomFileName();
string pathAlpha = path;
Console.WriteLine("\n\tFile: [{0}]", path);
try
{
using (File.Create(pathAlpha))
{
}
// Initial read.
Console.WriteLine("\n\tInitial read.");
FileSecurity dsSystem = System.IO.File.GetAccessControl(path, AccessControlSections.Access);
FileSecurity dsAlpha = File.GetAccessControl(pathAlpha, AccessControlSections.Access);
AuthorizationRuleCollection accessRulesSystem = dsSystem.GetAccessRules(true, true, typeof(NTAccount));
AuthorizationRuleCollection accessRulesAlpha = dsAlpha.GetAccessRules(true, true, typeof(NTAccount));
Console.WriteLine("\t System.IO.File.GetAccessControl() rules found: [{0}]", accessRulesSystem.Count);
Console.WriteLine("\t\t\t File.GetAccessControl() rules found: [{0}]", accessRulesAlpha.Count);
Assert.AreEqual(accessRulesSystem.Count, accessRulesAlpha.Count);
// Sanity check.
DumpAccessRules(1, dsSystem, dsAlpha);
// Remove inherited properties.
// Passing true for first parameter protects the new permission from inheritance, and second parameter removes the existing inherited permissions
Console.WriteLine("\n\tRemove inherited properties and persist it.");
dsAlpha.SetAccessRuleProtection(true, false);
File.SetAccessControl(pathAlpha, dsAlpha, AccessControlSections.Access);
// Re-read, using instance methods.
System.IO.FileInfo fiSystem = new System.IO.FileInfo(Path.LocalToUnc(path));
FileInfo fiAlpha = new FileInfo(Path.LocalToUnc(path));
dsSystem = fiSystem.GetAccessControl(AccessControlSections.Access);
dsAlpha = fiAlpha.GetAccessControl(AccessControlSections.Access);
// Sanity check.
DumpAccessRules(2, dsSystem, dsAlpha);
// Restore inherited properties.
Console.WriteLine("\n\tRestore inherited properties and persist it.");
dsAlpha.SetAccessRuleProtection(false, true);
File.SetAccessControl(pathAlpha, dsAlpha, AccessControlSections.Access);
// Re-read.
dsSystem = System.IO.File.GetAccessControl(path, AccessControlSections.Access);
dsAlpha = File.GetAccessControl(pathAlpha, AccessControlSections.Access);
// Sanity check.
DumpAccessRules(3, dsSystem, dsAlpha);
fiSystem.Delete();
fiSystem.Refresh(); // Must Refresh() to get actual state.
fiAlpha.Delete();
fiAlpha.Refresh(); // Must Refresh() to get actual state.
Assert.IsFalse(fiAlpha.Exists);
}
catch (Exception ex)
{
Console.WriteLine("\nCaught Exception: [{0}]\n", ex.Message.Replace(Environment.NewLine, " "));
}
}
private void DumpRefresh(bool isLocal)
{
#region Setup
Console.WriteLine("\n=== TEST {0} ===", isLocal ? Local : Network);
string tempPathSysIo = Path.GetTempPath("FileInfo.Refresh()-file-SysIo-" + Path.GetRandomFileName());
string tempPath = Path.GetTempPath("FileInfo.Refresh()-file-AlphaFS-" + Path.GetRandomFileName());
if (!isLocal) tempPathSysIo = Path.LocalToUnc(tempPathSysIo);
if (!isLocal) tempPath = Path.LocalToUnc(tempPath);
Console.WriteLine("\nInput File Path: [{0}]", tempPath);
#endregion // Setup
#region Refresh
try
{
System.IO.FileInfo fiSysIo = new System.IO.FileInfo(tempPathSysIo);
FileInfo fi = new FileInfo(tempPath);
bool existsSysIo = fiSysIo.Exists;
bool exists = fi.Exists;
Console.WriteLine("\nnew FileInfo(): Exists (Should be {0}): [{1}]", existsSysIo, exists); // false
Assert.AreEqual(existsSysIo, exists);
FileStream fsSysIo = fiSysIo.Create();
FileStream fs = fi.Create();
existsSysIo = fiSysIo.Exists;
exists = fi.Exists;
Console.WriteLine("\nfi.Create(): Exists (Should be {0}): [{1}]", existsSysIo, exists); // false
Assert.AreEqual(existsSysIo, exists);
fiSysIo.Refresh();
fi.Refresh();
existsSysIo = fiSysIo.Exists;
exists = fi.Exists;
Console.WriteLine("\nfi.Refresh(): Exists (Should be {0}): [{1}]", existsSysIo, exists); // true
Assert.AreEqual(existsSysIo, exists);
fsSysIo.Close();
fs.Close();
existsSysIo = fiSysIo.Exists;
exists = fi.Exists;
Console.WriteLine("\nfi.Close(): Exists (Should be {0}): [{1}]", existsSysIo, exists); // true
Assert.AreEqual(existsSysIo, exists);
fiSysIo.Delete();
fi.Delete();
existsSysIo = fiSysIo.Exists;
exists = fi.Exists;
Console.WriteLine("\nfi.Delete(): Exists (Should be {0}): [{1}]", existsSysIo, exists); // true
Assert.AreEqual(existsSysIo, exists);
fiSysIo.Refresh();
fi.Refresh();
existsSysIo = fiSysIo.Exists;
exists = fi.Exists;
Console.WriteLine("\nfi.Refresh(): Exists (Should be False): [{0}]", exists); // false
Assert.AreEqual(existsSysIo, exists);
}
finally
{
File.Delete(tempPath);
Assert.IsFalse(File.Exists(tempPath), "Cleanup failed: File should have been removed.");
File.Delete(tempPathSysIo);
Assert.IsFalse(File.Exists(tempPath), "Cleanup failed: File should have been removed.");
Console.WriteLine();
}
#endregion // Refresh
}
private void DumpFileTrailingDotSpace(bool isLocal)
{
Console.WriteLine("\n=== TEST {0} ===\n", isLocal ? Local : Network);
const string characterDot = ".";
const string characterSpace = " ";
string random = Path.GetRandomFileName();
string tempPathDot = Path.GetTempPath("File.Create()-" + random + "-file-with-dot-" + characterDot);
string tempPathSpace = Path.GetTempPath("File.Create()-" + random + "-file-with-space-" + characterSpace);
if (!isLocal) tempPathDot = Path.LocalToUnc(tempPathDot);
if (!isLocal) tempPathSpace = Path.LocalToUnc(tempPathSpace);
Console.WriteLine("Input File Path (with dot) : [{0}]", tempPathDot);
Console.WriteLine("Input File Path (with space): [{0}]", tempPathSpace);
Assert.IsTrue(tempPathDot.EndsWith(characterDot), "Path should have a trailing dot.");
Assert.IsTrue(tempPathSpace.EndsWith(characterSpace), "Path should have a trailing space.");
#region Path.GetFullPath(), Path Normalization
string sysIo = System.IO.Path.GetFullPath(tempPathDot);
Assert.IsFalse(sysIo.EndsWith(characterDot), "Path should not have a trailing dot.");
sysIo = System.IO.Path.GetFullPath(tempPathSpace);
Assert.IsFalse(sysIo.EndsWith(characterSpace), "Path should not have a trailing space.");
string alphaFs = Path.GetFullPath(tempPathDot);
Assert.IsFalse(alphaFs.EndsWith(characterDot), "Path should not have a trailing dot.");
alphaFs = Path.GetFullPath(tempPathSpace);
Assert.IsFalse(alphaFs.EndsWith(characterSpace), "Path should not have a trailing space.");
Assert.AreEqual(sysIo, alphaFs, "Paths should be the same.");
#endregion // Path.GetFullPath(), Path Normalization
#region Path.GetLongPath(), No Path Normalization
alphaFs = Path.GetLongPath(tempPathDot);
Assert.IsTrue(alphaFs.EndsWith(characterDot), "Path should have a trailing dot.");
alphaFs = Path.GetLongPath(tempPathSpace);
Assert.IsTrue(alphaFs.EndsWith(characterSpace), "Path should have a trailing space.");
Assert.AreNotEqual(alphaFs, sysIo, "Paths should not be the same.");
#endregion // Path.GetLongPath(), No Path Normalization
#region Path.GetRegularPath(), No Path Normalization
alphaFs = Path.GetRegularPath(tempPathDot);
Assert.IsTrue(alphaFs.EndsWith(characterDot), "Path should have a trailing dot.");
alphaFs = Path.GetRegularPath(tempPathSpace);
Assert.IsTrue(alphaFs.EndsWith(characterSpace), "Path should have a trailing space.");
Assert.AreNotEqual(alphaFs, sysIo, "Paths should not be the same.");
#endregion // Path.GetRegularPath(), No Path Normalization
Console.WriteLine();
#region File() Class
StopWatcher(true);
#region TrailingDot
#region System.IO
// tempPathDot contains a trailing dot but gets stripped on path normalization.
// System.IO handles the file without the trailing dot. Therefore, the file exists.
// AlphaFS has the same behaviour as .NET for default methods.
using (FileStream fs = System.IO.File.Create(tempPathDot)) { fs.WriteByte(1); }
Assert.IsTrue(System.IO.File.Exists(tempPathDot), "File should exist.");
Assert.IsTrue(File.Exists(tempPathDot), "File should be visible to AlphaFS.");
Assert.IsFalse(File.Exists(tempPathDot, PathFormat.FullPath), "File should be invisible to AlphaFS.");
using (StreamWriter sw = System.IO.File.AppendText(tempPathDot))
sw.WriteLine(TextHelloWorld);
string lineSysIo;
using (StreamReader sr = System.IO.File.OpenText(tempPathDot))
lineSysIo = sr.ReadToEnd();
System.IO.File.Delete(tempPathDot);
Assert.IsFalse(System.IO.File.Exists(tempPathDot), "File should not exist.");
#endregion // System.IO
#region AlphaFS
using (FileStream fs = File.Create(tempPathDot, PathFormat.FullPath)) { fs.WriteByte(1); } // Create file without path normalization.
Assert.IsTrue(File.Exists(tempPathDot, PathFormat.FullPath), "File should exist and visible to AlphaFS.");
Assert.IsFalse(System.IO.File.Exists(tempPathDot), "File should be invisible to System.IO.");
using (StreamWriter sw = File.AppendText(tempPathDot, PathFormat.FullPath))
sw.WriteLine(TextHelloWorld);
string lineAlphaFs;
using (StreamReader sr = File.OpenText(tempPathDot, PathFormat.FullPath))
lineAlphaFs = sr.ReadToEnd();
File.Delete(tempPathDot, true, PathFormat.FullPath); // Delete file without path normalization.
Assert.IsFalse(File.Exists(tempPathDot, PathFormat.FullPath), "File should not exist.");
#endregion // AlphaFS
Assert.AreEqual(lineSysIo, lineAlphaFs);
#endregion // TrailingDot
#region TrailingSpace
#region System.IO
// tempPathSpace contains a trailing space but gets stripped on path normalization.
// System.IO handles the file without the trailing space. Therefore, the file exists.
// AlphaFS has the same behaviour as .NET for default methods.
using (FileStream fs = System.IO.File.Create(tempPathSpace)) { fs.WriteByte(1); }
Assert.IsTrue(System.IO.File.Exists(tempPathSpace), "File should exist.");
Assert.IsTrue(File.Exists(tempPathSpace), "File should be visible to AlphaFS.");
Assert.IsFalse(File.Exists(tempPathSpace, PathFormat.FullPath), "File should be invisible to AlphaFS.");
using (StreamWriter sw = System.IO.File.AppendText(tempPathSpace))
sw.WriteLine(TextHelloWorld);
using (StreamReader sr = System.IO.File.OpenText(tempPathSpace))
lineSysIo = sr.ReadToEnd();
System.IO.File.Delete(tempPathSpace);
Assert.IsFalse(System.IO.File.Exists(tempPathSpace), "File should not exist.");
#endregion // System.IO
#region AlphaFS
using (FileStream fs = File.Create(tempPathSpace, PathFormat.FullPath)) { fs.WriteByte(1); } // Create file without path normalization.
Assert.IsTrue(File.Exists(tempPathSpace, PathFormat.FullPath), "File should exist and visible to AlphaFS.");
Assert.IsFalse(System.IO.File.Exists(tempPathSpace), "File should be invisible to System.IO.");
using (StreamWriter sw = File.AppendText(tempPathSpace, PathFormat.FullPath))
sw.WriteLine(TextHelloWorld);
using (StreamReader sr = File.OpenText(tempPathSpace, PathFormat.FullPath))
lineAlphaFs = sr.ReadToEnd();
File.Delete(tempPathSpace, true, PathFormat.FullPath); // Delete file without path normalization.
Assert.IsFalse(File.Exists(tempPathSpace, PathFormat.FullPath), "File should not exist.");
#endregion // AlphaFS
Assert.AreEqual(lineSysIo, lineAlphaFs);
#endregion // TrailingSpace
Console.WriteLine("\tClass File(){0}", Reporter());
#endregion // File() Class
#region FileInfo() Class
StopWatcher(true);
#region TrailingDot
#region System.IO
// tempPathDot contains a trailing dot but gets stripped on path normalization.
// System.IO handles the file without the trailing dot. Therefore, the file exists.
// AlphaFS has the same behaviour as .NET for default methods.
System.IO.FileInfo sysIoFi = new System.IO.FileInfo(tempPathDot);
Assert.IsTrue(sysIoFi.Name.EndsWith(characterDot), "Path should have a trailing dot.");
using (FileStream fs = sysIoFi.Create())
{
fs.WriteByte(100);
Assert.IsTrue(sysIoFi.Exists, "File should exist.");
Assert.IsTrue(File.Exists(tempPathDot), "File should be visible to AlphaFS.");
Assert.IsFalse(File.Exists(tempPathDot, PathFormat.FullPath), "File should be invisible to AlphaFS.");
}
using (StreamWriter sw = sysIoFi.AppendText())
sw.WriteLine(TextHelloWorld);
using (StreamReader sr = System.IO.File.OpenText(tempPathDot))
lineSysIo = sr.ReadToEnd();
sysIoFi.Delete();
Assert.IsFalse(System.IO.File.Exists(tempPathDot), "File should not exist.");
#endregion // System.IO
#region AlphaFS
FileInfo alphaFsFi = new FileInfo(tempPathDot, PathFormat.FullPath);
Assert.IsTrue(alphaFsFi.Name.EndsWith(characterDot), "Path should have a trailing dot.");
using (FileStream fs = alphaFsFi.Create())
{
fs.WriteByte(100);
Assert.IsTrue(alphaFsFi.Exists, "File should exist.");
Assert.IsTrue(File.Exists(tempPathDot, PathFormat.FullPath), "File should be visible to AlphaFS.");
Assert.IsFalse(File.Exists(tempPathDot), "File should be invisible to AlphaFS.");
}
using (StreamWriter sw = alphaFsFi.AppendText())
sw.WriteLine(TextHelloWorld);
using (StreamReader sr = File.OpenText(tempPathDot, PathFormat.FullPath))
lineAlphaFs = sr.ReadToEnd();
alphaFsFi.Delete();
alphaFsFi.Refresh(); // Must Refresh() to get actual state.
Assert.IsFalse(File.Exists(tempPathDot, PathFormat.FullPath), "File should not exist.");
#endregion // AlphaFS
Assert.AreEqual(lineSysIo, lineAlphaFs);
#endregion // TrailingDot
#region TrailingSpace
#region System.IO
// tempPathSpace contains a trailing space but gets stripped on path normalization.
// System.IO handles the file without the trailing space. Therefore, the file exists.
// AlphaFS has the same behaviour as .NET for default methods.
sysIoFi = new System.IO.FileInfo(tempPathSpace);
Assert.IsTrue(sysIoFi.Name.EndsWith(characterSpace), "Path should have a trailing space.");
using (FileStream fs = sysIoFi.Create())
{
fs.WriteByte(100);
Assert.IsTrue(sysIoFi.Exists, "File should exist.");
Assert.IsTrue(File.Exists(tempPathSpace), "File should be visible to AlphaFS.");
Assert.IsFalse(File.Exists(tempPathSpace, PathFormat.FullPath), "File should be invisible to AlphaFS.");
}
using (StreamWriter sw = sysIoFi.AppendText())
sw.WriteLine(TextHelloWorld);
using (StreamReader sr = System.IO.File.OpenText(tempPathSpace))
lineSysIo = sr.ReadToEnd();
sysIoFi.Delete();
Assert.IsFalse(System.IO.File.Exists(tempPathSpace), "File should not exist.");
#endregion // System.IO
#region AlphaFS
alphaFsFi = new FileInfo(tempPathSpace, PathFormat.FullPath);
Assert.IsTrue(alphaFsFi.Name.EndsWith(characterSpace), "Path should have a trailing space.");
using (FileStream fs = alphaFsFi.Create())
{
fs.WriteByte(100);
Assert.IsTrue(alphaFsFi.Exists, "File should exist.");
Assert.IsTrue(File.Exists(tempPathSpace, PathFormat.FullPath), "File should be visible to AlphaFS.");
Assert.IsFalse(File.Exists(tempPathSpace), "File should be invisible to AlphaFS.");
}
using (StreamWriter sw = alphaFsFi.AppendText())
sw.WriteLine(TextHelloWorld);
using (StreamReader sr = File.OpenText(tempPathSpace, PathFormat.FullPath))
lineAlphaFs = sr.ReadToEnd();
alphaFsFi.Delete();
alphaFsFi.Refresh(); // Must Refresh() to get actual state.
Assert.IsFalse(File.Exists(tempPathSpace, PathFormat.FullPath), "File should not exist.");
#endregion // AlphaFS
Assert.AreEqual(lineSysIo, lineAlphaFs);
#endregion // TrailingSpace
Console.WriteLine("\tClass FileInfo(){0}", Reporter());
#endregion // FileInfo() Class
Console.WriteLine();
}
