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(); }
private void DumpGetXxxTimeXxx(bool isLocal) { #region Setup Console.WriteLine("\n=== TEST {0} ===", isLocal ? Local : Network); string path = NotepadExe; if (!isLocal) path = Path.LocalToUnc(path); Console.WriteLine("\nInput File Path: [{0}]\n", path); #endregion // Setup StopWatcher(true); #region GetCreationTimeXxx DateTime actual = File.GetCreationTime(path); DateTime expected = System.IO.File.GetCreationTime(path); Console.WriteLine("\tGetCreationTime() : [{0}] System.IO: [{1}]", actual, expected); Assert.AreEqual(expected, actual, "AlphaFS != System.IO"); actual = File.GetCreationTimeUtc(path); expected = System.IO.File.GetCreationTimeUtc(path); Console.WriteLine("\tGetCreationTimeUtc() : [{0}] System.IO: [{1}]\n", actual, expected); Assert.AreEqual(expected, actual, "AlphaFS != System.IO"); #endregion // GetCreationTimeXxx #region GetLastAccessTimeXxx actual = File.GetLastAccessTime(path); expected = System.IO.File.GetLastAccessTime(path); Console.WriteLine("\tGetLastAccessTime() : [{0}] System.IO: [{1}]", actual, expected); Assert.AreEqual(expected, actual, "AlphaFS != System.IO"); actual = File.GetLastAccessTimeUtc(path); expected = System.IO.File.GetLastAccessTimeUtc(path); Console.WriteLine("\tGetLastAccessTimeUtc(): [{0}] System.IO: [{1}]\n", actual, expected); Assert.AreEqual(expected, actual, "AlphaFS != System.IO"); #endregion // GetLastAccessTimeXxx #region GetLastWriteTimeXxx actual = File.GetLastWriteTime(path); expected = System.IO.File.GetLastWriteTime(path); Console.WriteLine("\tGetLastWriteTime() : [{0}] System.IO: [{1}]", actual, expected); Assert.AreEqual(expected, actual, "AlphaFS != System.IO"); actual = File.GetLastWriteTimeUtc(path); expected = System.IO.File.GetLastWriteTimeUtc(path); Console.WriteLine("\tGetLastWriteTimeUtc() : [{0}] System.IO: [{1}]\n", actual, expected); Assert.AreEqual(expected, actual, "AlphaFS != System.IO"); #endregion // GetLastWriteTimeXxx #region GetChangeTimeXxx Console.WriteLine("\tGetChangeTime() : [{0}] System.IO: [N/A]", File.GetChangeTime(path)); Console.WriteLine("\tGetChangeTimeUtc() : [{0}] System.IO: [N/A]", File.GetChangeTimeUtc(path)); #endregion // GetChangeTimeXxx Console.WriteLine(); Console.WriteLine(Reporter()); Console.WriteLine(); #region Trigger GetChangeTimeXxx // We can not compare ChangeTime against .NET because it does not exist. // Creating a file and renaming it triggers ChangeTime, so test for that. path = Path.GetTempPath("File-GetChangeTimeXxx()-file-" + Path.GetRandomFileName()); if (!isLocal) path = Path.LocalToUnc(path); FileInfo fi = new FileInfo(path); using (fi.Create()) { } string fileName = fi.Name; DateTime lastAccessTimeActual = File.GetLastAccessTime(path); DateTime lastAccessTimeUtcActual = File.GetLastAccessTimeUtc(path); DateTime changeTimeActual = File.GetChangeTime(path); DateTime changeTimeUtcActual = File.GetChangeTimeUtc(path); Console.WriteLine("\nTesting ChangeTime on a temp file."); Console.WriteLine("\nInput File Path: [{0}]\n", path); Console.WriteLine("\tGetChangeTime() : [{0}]\t", changeTimeActual); Console.WriteLine("\tGetChangeTimeUtc() : [{0}]\t", changeTimeUtcActual); fi.MoveTo(fi.FullName.Replace(fileName, fileName + "-Renamed")); // Pause for at least a second so that the difference in time can be seen. int sleep = new Random().Next(2000, 4000); Thread.Sleep(sleep); fi.MoveTo(fi.FullName.Replace(fileName + "-Renamed", fileName)); DateTime lastAccessTimeExpected = File.GetLastAccessTime(path); DateTime lastAccessTimeUtcExpected = File.GetLastAccessTimeUtc(path); DateTime changeTimeExpected = File.GetChangeTime(path); DateTime changeTimeUtcExpected = File.GetChangeTimeUtc(path); Console.WriteLine("\nTrigger ChangeTime by renaming the file."); Console.WriteLine("For Unit Test, ChangeTime should differ approximately: [{0}] seconds.\n", sleep / 1000); Console.WriteLine("\tGetChangeTime() : [{0}]\t", changeTimeExpected); Console.WriteLine("\tGetChangeTimeUtc() : [{0}]\t\n", changeTimeUtcExpected); Assert.AreNotEqual(changeTimeActual, changeTimeExpected); Assert.AreNotEqual(changeTimeUtcActual, changeTimeUtcExpected); Assert.AreEqual(lastAccessTimeExpected, lastAccessTimeActual); Assert.AreEqual(lastAccessTimeUtcExpected, lastAccessTimeUtcActual); #endregion // Trigger GetChangeTimeXxx fi.Delete(); fi.Refresh(); // Must Refresh() to get actual state. Assert.IsFalse(fi.Exists, "Cleanup failed: File should have been removed."); Console.WriteLine(); }