Return original path from Mock*Info.ToString() (#406)

updateaman · fgreinacher · commit c0da0c0e57bb · 2018-12-03T20:15:26.000+01:00
Contributes to #400
diff --git a/System.IO.Abstractions.TestingHelpers.Tests/MockDirectoryInfoTests.cs b/System.IO.Abstractions.TestingHelpers.Tests/MockDirectoryInfoTests.cs
@@ -36,8 +36,8 @@ public static IEnumerable<object[]> MockDirectoryInfo_Exists_Cases
         {
             get
             {
-                yield return new object[]{ XFS.Path(@"c:\temp\folder"), true };
-                yield return new object[]{ XFS.Path(@"c:\temp\folder\notExistant"), false };
+                yield return new object[] { XFS.Path(@"c:\temp\folder"), true };
+                yield return new object[] { XFS.Path(@"c:\temp\folder\notExistant"), false };
             }
         }
 
@@ -152,8 +152,8 @@ public void MockDirectoryInfo_GetParent_ShouldReturnDirectoriesAndNamesWithSearc
         [Test]
         public void MockDirectoryInfo_EnumerateFiles_ShouldReturnAllFiles()
         {
-          // Arrange
-          var fileSystem = new MockFileSystem(new Dictionary<string, MockFileData>
+            // Arrange
+            var fileSystem = new MockFileSystem(new Dictionary<string, MockFileData>
             {
                 //Files "above" in folder we're querying
                 { XFS.Path(@"c:\temp\a.txt"), "" },
@@ -166,11 +166,11 @@ public void MockDirectoryInfo_EnumerateFiles_ShouldReturnAllFiles()
                 { XFS.Path(@"c:\temp\folder\deeper\d.txt"), "" }
             });
 
-          // Act
-          var directoryInfo = new MockDirectoryInfo(fileSystem, XFS.Path(@"c:\temp\folder"));
+            // Act
+            var directoryInfo = new MockDirectoryInfo(fileSystem, XFS.Path(@"c:\temp\folder"));
 
-          // Assert
-          Assert.AreEqual(new[]{"b.txt", "c.txt"}, directoryInfo.EnumerateFiles().ToList().Select(x => x.Name).ToArray());
+            // Assert
+            Assert.AreEqual(new[] { "b.txt", "c.txt" }, directoryInfo.EnumerateFiles().ToList().Select(x => x.Name).ToArray());
         }
 
         [Test]
@@ -238,7 +238,7 @@ public void MockDirectoryInfo_Constructor_ShouldThrowArgumentNullException_IfArg
             var fileSystem = new MockFileSystem();
 
             // Act
-           TestDelegate action = () => new MockDirectoryInfo(fileSystem, null);
+            TestDelegate action = () => new MockDirectoryInfo(fileSystem, null);
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(action);
@@ -272,20 +272,18 @@ public void MockDirectoryInfo_Constructor_ShouldThrowArgumentException_IfArgumen
             Assert.That(exception.Message, Does.StartWith("The path is not of a legal form."));
         }
 
-        [Test]
-        public void MockDirectoryInfo_ToString_ShouldReturnDirectoryName()
+        [TestCase(@"c:\temp\folder\folder")]
+        [TestCase(@"..\..\..\Desktop")]
+        public void MockDirectoryInfo_ToString_ShouldReturnDirectoryName(string directoryName)
         {
-            var directoryPath = XFS.Path(@"c:\temp\folder\folder");
-
             // Arrange
-            var fileSystem = new MockFileSystem();
-            var directoryInfo = new MockDirectoryInfo(fileSystem, directoryPath);
+            var directoryPath = XFS.Path(directoryName);
 
             // Act
-            var str = directoryInfo.ToString();
+            var mockDirectoryInfo = new MockDirectoryInfo(new MockFileSystem(), directoryPath);
 
             // Assert
-            Assert.AreEqual(directoryPath, str);
+            Assert.AreEqual(directoryPath, mockDirectoryInfo.ToString());
         }
     }
 }
diff --git a/System.IO.Abstractions.TestingHelpers.Tests/MockDriveInfoFactoryTests.cs b/System.IO.Abstractions.TestingHelpers.Tests/MockDriveInfoFactoryTests.cs
@@ -26,7 +26,7 @@ public void MockDriveInfoFactory_GetDrives_ShouldReturnDrives()
             var actualNames = actualResults.Select(d => d.Name);
 
             // Assert
-            Assert.That(actualNames, Is.EquivalentTo(new[] { @"C:\", @"Z:\", @"D:\" }));
+            Assert.That(actualNames, Is.EquivalentTo(new[] { @"C:\", @"Z:\", @"d:\" }));
         }
 
         [Test]
@@ -47,7 +47,7 @@ public void MockDriveInfoFactory_GetDrives_ShouldReturnDrivesWithNoDuplicates()
             var actualNames = actualResults.Select(d => d.Name);
 
             // Assert
-            Assert.That(actualNames, Is.EquivalentTo(new[] { @"C:\", @"Z:\", @"D:\" }));
+            Assert.That(actualNames, Is.EquivalentTo(new[] { @"C:\", @"Z:\", @"d:\" }));
         }
 
         [Test]
@@ -67,7 +67,7 @@ public void MockDriveInfoFactory_GetDrives_ShouldReturnOnlyLocalDrives()
             var actualNames = actualResults.Select(d => d.Name);
 
             // Assert
-            Assert.That(actualNames, Is.EquivalentTo(new[] { @"C:\", @"Z:\", @"D:\" }));
+            Assert.That(actualNames, Is.EquivalentTo(new[] { @"C:\", @"Z:\", @"d:\" }));
         }
 
         [Test]
diff --git a/System.IO.Abstractions.TestingHelpers.Tests/MockDriveInfoTests.cs b/System.IO.Abstractions.TestingHelpers.Tests/MockDriveInfoTests.cs
@@ -21,7 +21,7 @@ public void MockDriveInfo_Constructor_ShouldInitializeLocalWindowsDrives(string
             var driveInfo = new MockDriveInfo(fileSystem, path);
 
             // Assert
-            Assert.AreEqual(@"C:\", driveInfo.Name);
+            Assert.AreEqual(@"c:\", driveInfo.Name);
         }
 
         [Test]
@@ -35,7 +35,7 @@ public void MockDriveInfo_Constructor_ShouldInitializeLocalWindowsDrives_Special
             var driveInfo = new MockDriveInfo(fileSystem, "c");
 
             // Assert
-            Assert.AreEqual(@"C:\", driveInfo.Name);
+            Assert.AreEqual(@"c:\", driveInfo.Name);
         }
 
         [TestCase(@"\\unc\share")]
@@ -59,13 +59,30 @@ public void MockDriveInfo_RootDirectory_ShouldReturnTheDirectoryBase()
             var fileSystem = new MockFileSystem();
             fileSystem.AddDirectory(XFS.Path(@"c:\Test"));
             var driveInfo = new MockDriveInfo(fileSystem, "c:");
-            var expectedDirectory = XFS.Path(@"C:\");
+            var expectedDirectory = XFS.Path(@"c:\");
 
             // Act
             var actualDirectory = driveInfo.RootDirectory;
 
             // Assert
             Assert.AreEqual(expectedDirectory, actualDirectory.FullName);
         }
+
+        [TestCase("c:","c:\\")]
+        [TestCase("C:","C:\\")]
+        [TestCase("d:","d:\\")]
+        [TestCase("e:","e:\\")]
+        [TestCase("f:","f:\\")]
+        public void MockDriveInfo_ToString_ShouldReturnTheDrivePath(string path, string expectedPath)
+        {
+            // Arrange
+            var directoryPath = XFS.Path(path);
+            
+            // Act
+            var mockDriveInfo = new MockDriveInfo(new MockFileSystem(), directoryPath);
+
+            // Assert
+            Assert.AreEqual(expectedPath, mockDriveInfo.ToString());
+        }
     }
 }
diff --git a/System.IO.Abstractions.TestingHelpers.Tests/MockFileInfoTests.cs b/System.IO.Abstractions.TestingHelpers.Tests/MockFileInfoTests.cs
@@ -167,7 +167,7 @@ public void MockFileInfo_IsReadOnly_ShouldSetReadOnlyAttributeOfFileInMemoryFile
         [Test]
         public void MockFileInfo_IsReadOnly_ShouldSetNotReadOnlyAttributeOfFileInMemoryFileSystem()
         {
-            var fileData = new MockFileData("Demo text content") {Attributes = FileAttributes.ReadOnly};
+            var fileData = new MockFileData("Demo text content") { Attributes = FileAttributes.ReadOnly };
             var fileSystem = new MockFileSystem(new Dictionary<string, MockFileData>
             {
                 { XFS.Path(@"c:\a.txt"), fileData }
@@ -210,7 +210,7 @@ public void MockFileInfo_OpenWrite_ShouldAddDataToFileInMemoryFileSystem()
                 { XFS.Path(@"c:\a.txt"), fileData }
             });
             var fileInfo = new MockFileInfo(fileSystem, XFS.Path(@"c:\a.txt"));
-            var bytesToAdd = new byte[] {65, 66, 67, 68, 69};
+            var bytesToAdd = new byte[] { 65, 66, 67, 68, 69 };
 
 
             using (var file = fileInfo.OpenWrite())
@@ -491,6 +491,22 @@ public void MockFileInfo_CopyTo_ThrowsExceptionIfSourceDoesntExist()
             Assert.Throws<FileNotFoundException>(action);
         }
 
+        [TestCase(@"..\..\..\c.txt")]
+        [TestCase(@"c:\a\b\c.txt")]
+        [TestCase(@"c:\a\c.txt")]
+        [TestCase(@"c:\c.txt")]
+        public void MockFileInfo_ToString_ShouldReturnOriginalFilePath(string path)
+        {
+            //Arrange
+            var filePath = XFS.Path(path);
+
+            //Act
+            var mockFileInfo = new MockFileInfo(new MockFileSystem(), filePath);
+
+            //Assert
+            Assert.AreEqual(filePath, mockFileInfo.ToString());
+        }
+
 #if NET40
         [Test]
         public void MockFileInfo_Replace_ShouldReplaceFileContents()
diff --git a/System.IO.Abstractions.TestingHelpers/MockDirectoryInfo.cs b/System.IO.Abstractions.TestingHelpers/MockDirectoryInfo.cs
@@ -1,5 +1,4 @@
 ﻿using System.Collections.Generic;
-using System.Globalization;
 using System.Linq;
 using System.Security.AccessControl;
 
@@ -10,6 +9,7 @@ public class MockDirectoryInfo : DirectoryInfoBase
     {
         private readonly IMockFileDataAccessor mockFileDataAccessor;
         private readonly string directoryPath;
+        private readonly string originalPath;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="MockDirectoryInfo"/> class.
@@ -21,6 +21,7 @@ public MockDirectoryInfo(IMockFileDataAccessor mockFileDataAccessor, string dire
         {
             this.mockFileDataAccessor = mockFileDataAccessor ?? throw new ArgumentNullException(nameof(mockFileDataAccessor));
 
+            originalPath = directoryPath;
             directoryPath = mockFileDataAccessor.Path.GetFullPath(directoryPath);
 
             this.directoryPath = directoryPath.TrimSlashes();
@@ -283,11 +284,6 @@ public override DirectoryInfoBase Root
             }
         }
 
-        public override string ToString()
-        {
-            return FullName;
-        }
-
         private MockFileData GetMockFileDataForRead()
         {
             return mockFileDataAccessor.GetFile(directoryPath) ?? MockFileData.NullObject;
@@ -298,5 +294,10 @@ private MockFileData GetMockFileDataForWrite()
             return mockFileDataAccessor.GetFile(directoryPath)
                 ?? throw new FileNotFoundException(StringResources.Manager.GetString("COULD_NOT_FIND_FILE_EXCEPTION"), directoryPath);
         }
+
+        public override string ToString()
+        {
+            return originalPath;
+        }
     }
 }
diff --git a/System.IO.Abstractions.TestingHelpers/MockDriveInfo.cs b/System.IO.Abstractions.TestingHelpers/MockDriveInfo.cs
@@ -20,15 +20,15 @@ public MockDriveInfo(IMockFileDataAccessor mockFileDataAccessor, string name) :
             const string DRIVE_SEPARATOR = @":\";
             if (name.Length == 1)
             {
-                name = char.ToUpperInvariant(name[0]) + DRIVE_SEPARATOR;
+                name = name[0] + DRIVE_SEPARATOR;
             }
             else if (name.Length == 2 && name[1] == ':')
             {
-                name = char.ToUpperInvariant(name[0]) + DRIVE_SEPARATOR;
+                name = name[0] + DRIVE_SEPARATOR;
             }
             else if (name.Length == 3 && name.EndsWith(DRIVE_SEPARATOR, StringComparison.Ordinal))
             {
-                name = char.ToUpperInvariant(name[0]) + DRIVE_SEPARATOR;
+                name = name[0] + DRIVE_SEPARATOR;
             }
             else
             {
@@ -63,6 +63,11 @@ public override DirectoryInfoBase RootDirectory
             }
         }
 
+        public override string ToString()
+        {
+            return Name;
+        }
+
         public new long TotalFreeSpace { get; protected set; }
         public new long TotalSize { get; protected set; }
         public override string VolumeLabel { get; set; }
diff --git a/System.IO.Abstractions.TestingHelpers/MockFileInfo.cs b/System.IO.Abstractions.TestingHelpers/MockFileInfo.cs
@@ -242,7 +242,7 @@ public override Stream OpenRead()
 
         public override StreamReader OpenText()
         {
-          return new StreamReader(OpenRead());
+            return new StreamReader(OpenRead());
         }
 
         public override Stream OpenWrite()
@@ -296,7 +296,7 @@ public override bool IsReadOnly
             set
             {
                 if (MockFileData == null) throw new FileNotFoundException("File not found", path);
-                if(value)
+                if (value)
                     MockFileData.Attributes |= FileAttributes.ReadOnly;
                 else
                     MockFileData.Attributes &= ~FileAttributes.ReadOnly;
@@ -311,5 +311,10 @@ public override long Length
                 return MockFileData.Contents.Length;
             }
         }
+
+        public override string ToString()
+        {
+            return path;
+        }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -36,8 +36,8 @@ public static IEnumerable<object[]> MockDirectoryInfo_Exists_Cases`
`36`	`36`	`{`
`37`	`37`	`get`
`38`	`38`	`{`
`39`		`- yield return new object[]{ XFS.Path(@"c:\temp\folder"), true };`
`40`		`- yield return new object[]{ XFS.Path(@"c:\temp\folder\notExistant"), false };`
	`39`	`+ yield return new object[] { XFS.Path(@"c:\temp\folder"), true };`
	`40`	`+ yield return new object[] { XFS.Path(@"c:\temp\folder\notExistant"), false };`
`41`	`41`	`}`
`42`	`42`	`}`
`43`	`43`
`@@ -152,8 +152,8 @@ public void MockDirectoryInfo_GetParent_ShouldReturnDirectoriesAndNamesWithSearc`
`152`	`152`	`[Test]`
`153`	`153`	`public void MockDirectoryInfo_EnumerateFiles_ShouldReturnAllFiles()`
`154`	`154`	`{`
`155`		`- // Arrange`
`156`		`- var fileSystem = new MockFileSystem(new Dictionary<string, MockFileData>`
	`155`	`+ // Arrange`
	`156`	`+ var fileSystem = new MockFileSystem(new Dictionary<string, MockFileData>`
`157`	`157`	`{`
`158`	`158`	`//Files "above" in folder we're querying`
`159`	`159`	`{ XFS.Path(@"c:\temp\a.txt"), "" },`
`@@ -166,11 +166,11 @@ public void MockDirectoryInfo_EnumerateFiles_ShouldReturnAllFiles()`
`166`	`166`	`{ XFS.Path(@"c:\temp\folder\deeper\d.txt"), "" }`
`167`	`167`	`});`
`168`	`168`
`169`		`- // Act`
`170`		`- var directoryInfo = new MockDirectoryInfo(fileSystem, XFS.Path(@"c:\temp\folder"));`
	`169`	`+ // Act`
	`170`	`+ var directoryInfo = new MockDirectoryInfo(fileSystem, XFS.Path(@"c:\temp\folder"));`
`171`	`171`
`172`		`- // Assert`
`173`		`- Assert.AreEqual(new[]{"b.txt", "c.txt"}, directoryInfo.EnumerateFiles().ToList().Select(x => x.Name).ToArray());`
	`172`	`+ // Assert`
	`173`	`+ Assert.AreEqual(new[] { "b.txt", "c.txt" }, directoryInfo.EnumerateFiles().ToList().Select(x => x.Name).ToArray());`
`174`	`174`	`}`
`175`	`175`
`176`	`176`	`[Test]`
`@@ -238,7 +238,7 @@ public void MockDirectoryInfo_Constructor_ShouldThrowArgumentNullException_IfArg`
`238`	`238`	`var fileSystem = new MockFileSystem();`
`239`	`239`
`240`	`240`	`// Act`
`241`		`- TestDelegate action = () => new MockDirectoryInfo(fileSystem, null);`
	`241`	`+ TestDelegate action = () => new MockDirectoryInfo(fileSystem, null);`
`242`	`242`
`243`	`243`	`// Assert`
`244`	`244`	`var exception = Assert.Throws<ArgumentNullException>(action);`
`@@ -272,20 +272,18 @@ public void MockDirectoryInfo_Constructor_ShouldThrowArgumentException_IfArgumen`
`272`	`272`	`Assert.That(exception.Message, Does.StartWith("The path is not of a legal form."));`
`273`	`273`	`}`
`274`	`274`
`275`		`- [Test]`
`276`		`- public void MockDirectoryInfo_ToString_ShouldReturnDirectoryName()`
	`275`	`+ [TestCase(@"c:\temp\folder\folder")]`
	`276`	`+ [TestCase(@"..\..\..\Desktop")]`
	`277`	`+ public void MockDirectoryInfo_ToString_ShouldReturnDirectoryName(string directoryName)`
`277`	`278`	`{`
`278`		`- var directoryPath = XFS.Path(@"c:\temp\folder\folder");`
`279`		`-`
`280`	`279`	`// Arrange`
`281`		`- var fileSystem = new MockFileSystem();`
`282`		`- var directoryInfo = new MockDirectoryInfo(fileSystem, directoryPath);`
	`280`	`+ var directoryPath = XFS.Path(directoryName);`
`283`	`281`
`284`	`282`	`// Act`
`285`		`- var str = directoryInfo.ToString();`
	`283`	`+ var mockDirectoryInfo = new MockDirectoryInfo(new MockFileSystem(), directoryPath);`
`286`	`284`
`287`	`285`	`// Assert`
`288`		`- Assert.AreEqual(directoryPath, str);`
	`286`	`+ Assert.AreEqual(directoryPath, mockDirectoryInfo.ToString());`
`289`	`287`	`}`
`290`	`288`	`}`
`291`	`289`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ public void MockDriveInfoFactory_GetDrives_ShouldReturnDrives()`
`26`	`26`	`var actualNames = actualResults.Select(d => d.Name);`
`27`	`27`
`28`	`28`	`// Assert`
`29`		`- Assert.That(actualNames, Is.EquivalentTo(new[] { @"C:\", @"Z:\", @"D:\" }));`
	`29`	`+ Assert.That(actualNames, Is.EquivalentTo(new[] { @"C:\", @"Z:\", @"d:\" }));`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`[Test]`
`@@ -47,7 +47,7 @@ public void MockDriveInfoFactory_GetDrives_ShouldReturnDrivesWithNoDuplicates()`
`47`	`47`	`var actualNames = actualResults.Select(d => d.Name);`
`48`	`48`
`49`	`49`	`// Assert`
`50`		`- Assert.That(actualNames, Is.EquivalentTo(new[] { @"C:\", @"Z:\", @"D:\" }));`
	`50`	`+ Assert.That(actualNames, Is.EquivalentTo(new[] { @"C:\", @"Z:\", @"d:\" }));`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`[Test]`
`@@ -67,7 +67,7 @@ public void MockDriveInfoFactory_GetDrives_ShouldReturnOnlyLocalDrives()`
`67`	`67`	`var actualNames = actualResults.Select(d => d.Name);`
`68`	`68`
`69`	`69`	`// Assert`
`70`		`- Assert.That(actualNames, Is.EquivalentTo(new[] { @"C:\", @"Z:\", @"D:\" }));`
	`70`	`+ Assert.That(actualNames, Is.EquivalentTo(new[] { @"C:\", @"Z:\", @"d:\" }));`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`[Test]`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,4 @@`
`1`	`1`	`using System.Collections.Generic;`
`2`		`-using System.Globalization;`
`3`	`2`	`using System.Linq;`
`4`	`3`	`using System.Security.AccessControl;`
`5`	`4`
`@@ -10,6 +9,7 @@ public class MockDirectoryInfo : DirectoryInfoBase`
`10`	`9`	`{`
`11`	`10`	`private readonly IMockFileDataAccessor mockFileDataAccessor;`
`12`	`11`	`private readonly string directoryPath;`
	`12`	`+ private readonly string originalPath;`
`13`	`13`
`14`	`14`	`/// <summary>`
`15`	`15`	`/// Initializes a new instance of the <see cref="MockDirectoryInfo"/> class.`
`@@ -21,6 +21,7 @@ public MockDirectoryInfo(IMockFileDataAccessor mockFileDataAccessor, string dire`
`21`	`21`	`{`
`22`	`22`	`this.mockFileDataAccessor = mockFileDataAccessor ?? throw new ArgumentNullException(nameof(mockFileDataAccessor));`
`23`	`23`
	`24`	`+ originalPath = directoryPath;`
`24`	`25`	`directoryPath = mockFileDataAccessor.Path.GetFullPath(directoryPath);`
`25`	`26`
`26`	`27`	`this.directoryPath = directoryPath.TrimSlashes();`
`@@ -283,11 +284,6 @@ public override DirectoryInfoBase Root`
`283`	`284`	`}`
`284`	`285`	`}`
`285`	`286`
`286`		`- public override string ToString()`
`287`		`- {`
`288`		`- return FullName;`
`289`		`- }`
`290`		`-`
`291`	`287`	`private MockFileData GetMockFileDataForRead()`
`292`	`288`	`{`
`293`	`289`	`return mockFileDataAccessor.GetFile(directoryPath) ?? MockFileData.NullObject;`
`@@ -298,5 +294,10 @@ private MockFileData GetMockFileDataForWrite()`
`298`	`294`	`return mockFileDataAccessor.GetFile(directoryPath)`
`299`	`295`	`?? throw new FileNotFoundException(StringResources.Manager.GetString("COULD_NOT_FIND_FILE_EXCEPTION"), directoryPath);`
`300`	`296`	`}`
	`297`	`+`
	`298`	`+ public override string ToString()`
	`299`	`+ {`
	`300`	`+ return originalPath;`
	`301`	`+ }`
`301`	`302`	`}`
`302`	`303`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,15 +20,15 @@ public MockDriveInfo(IMockFileDataAccessor mockFileDataAccessor, string name) :`
`20`	`20`	`const string DRIVE_SEPARATOR = @":\";`
`21`	`21`	`if (name.Length == 1)`
`22`	`22`	`{`
`23`		`- name = char.ToUpperInvariant(name[0]) + DRIVE_SEPARATOR;`
	`23`	`+ name = name[0] + DRIVE_SEPARATOR;`
`24`	`24`	`}`
`25`	`25`	`else if (name.Length == 2 && name[1] == ':')`
`26`	`26`	`{`
`27`		`- name = char.ToUpperInvariant(name[0]) + DRIVE_SEPARATOR;`
	`27`	`+ name = name[0] + DRIVE_SEPARATOR;`
`28`	`28`	`}`
`29`	`29`	`else if (name.Length == 3 && name.EndsWith(DRIVE_SEPARATOR, StringComparison.Ordinal))`
`30`	`30`	`{`
`31`		`- name = char.ToUpperInvariant(name[0]) + DRIVE_SEPARATOR;`
	`31`	`+ name = name[0] + DRIVE_SEPARATOR;`
`32`	`32`	`}`
`33`	`33`	`else`
`34`	`34`	`{`
`@@ -63,6 +63,11 @@ public override DirectoryInfoBase RootDirectory`
`63`	`63`	`}`
`64`	`64`	`}`
`65`	`65`
	`66`	`+ public override string ToString()`
	`67`	`+ {`
	`68`	`+ return Name;`
	`69`	`+ }`
	`70`	`+`
`66`	`71`	`public new long TotalFreeSpace { get; protected set; }`
`67`	`72`	`public new long TotalSize { get; protected set; }`
`68`	`73`	`public override string VolumeLabel { get; set; }`
Original file line number	Diff line number	Diff line change
`@@ -242,7 +242,7 @@ public override Stream OpenRead()`
`242`	`242`
`243`	`243`	`public override StreamReader OpenText()`
`244`	`244`	`{`
`245`		`- return new StreamReader(OpenRead());`
	`245`	`+ return new StreamReader(OpenRead());`
`246`	`246`	`}`
`247`	`247`
`248`	`248`	`public override Stream OpenWrite()`
`@@ -296,7 +296,7 @@ public override bool IsReadOnly`
`296`	`296`	`set`
`297`	`297`	`{`
`298`	`298`	`if (MockFileData == null) throw new FileNotFoundException("File not found", path);`
`299`		`- if(value)`
	`299`	`+ if (value)`
`300`	`300`	`MockFileData.Attributes \|= FileAttributes.ReadOnly;`
`301`	`301`	`else`
`302`	`302`	`MockFileData.Attributes &= ~FileAttributes.ReadOnly;`
`@@ -311,5 +311,10 @@ public override long Length`
`311`	`311`	`return MockFileData.Contents.Length;`
`312`	`312`	`}`
`313`	`313`	`}`
	`314`	`+`
	`315`	`+ public override string ToString()`
	`316`	`+ {`
	`317`	`+ return path;`
	`318`	`+ }`
`314`	`319`	`}`
`315`	`320`	`}`