public void GetFiles_UnknownDates_CallsApiCorrectly()
{
var supportsPatternSearch = bool.Parse((string)TestContext.DataRow["SupportsPatternSearch"]);
var fixture = DokanOperationsFixture.Instance;
var path = fixture.DirectoryName.AsRootedPath();
#if LOGONLY
fixture.SetupAny();
#else
fixture.ExpectOpenDirectory(path);
//Remove all dates
var files = DokanOperationsFixture.RemoveDatesFromFileInformations(fixture.DirectoryItems);
if (supportsPatternSearch)
{
fixture.ExpectFindFilesWithPattern(path, "*", files);
}
else
{
fixture.ExpectFindFilesWithPatternToFail(path, "*", DokanResult.NotImplemented);
fixture.ExpectFindFiles(path, files);
}
#endif
var sut = new DirectoryInfo(fixture.DirectoryName.AsDriveBasedPath());
#if LOGONLY
Assert.IsNotNull(sut.GetFiles(), nameof(sut.GetFiles));
Console.WriteLine(sut.GetFiles().Length);
#else
var receivedFiles = sut.GetFiles();
// As DirectoryInfo does not handle uninitialized DateTime values correctly
// it has to be provided with DateTime.FromFileTime(0) as default minimum date
var defaultDate = DateTime.FromFileTime(0);
var expectedDateCollection = Enumerable.Repeat(defaultDate, receivedFiles.Length).ToArray();
CollectionAssert.AreEqual(
receivedFiles.Select(f => f.Name).ToArray(),
fixture.DirectoryItems.Where(i => i.Attributes.HasFlag(FileAttributes.Normal)).Select(i => i.FileName).ToArray(),
nameof(sut.GetFiles));
CollectionAssert.AreEqual(
expectedDateCollection,
receivedFiles.Select(x => x.CreationTime).ToArray(),
nameof(FileInformation.CreationTime));
CollectionAssert.AreEqual(
expectedDateCollection,
receivedFiles.Select(x => x.LastWriteTime).ToArray(),
nameof(FileInformation.LastWriteTime));
CollectionAssert.AreEqual(
expectedDateCollection,
receivedFiles.Select(x => x.LastAccessTime).ToArray(),
nameof(FileInformation.LastAccessTime));
fixture.Verify();
#endif
}
public void Cleanup()
{
var hasUnmatchedInvocations = false;
DokanOperationsFixture.ClearInstance(out hasUnmatchedInvocations);
Assert.IsFalse(hasUnmatchedInvocations, "Found Mock invocations without corresponding setups");
}
public void OpenRead_WithVariableSizes_Overlapped_CallsApiCorrectly()
{
var bufferSize = int.Parse((string) TestContext.DataRow["BufferSize"]);
var fileSize = int.Parse((string) TestContext.DataRow["FileSize"]);
var fixture = DokanOperationsFixture.Instance;
var path = fixture.FileName.AsRootedPath();
var testData = DokanOperationsFixture.InitBlockTestData(bufferSize, fileSize);
#if LOGONLY
fixture.PermitAny();
#else
fixture.ExpectCreateFile(path, ReadAccess, ReadShare, FileMode.Open, context: testData);
fixture.ExpectReadFileInChunks(path, testData, bufferSize, context: testData, synchronousIo: false);
#endif
var outputs = NativeMethods.ReadEx(fixture.FileName.AsDriveBasedPath(), bufferSize, testData.Length);
#if !LOGONLY
for (var i = 0; i < outputs.Length; ++i)
{
Assert.AreEqual(0, outputs[i].Win32Error, $"Unexpected Win32 error in output {i} for BufferSize={bufferSize}, FileSize={fileSize}");
Assert.AreEqual(NativeMethods.BufferSize(bufferSize, fileSize, i), outputs[i].BytesTransferred, $"Unexpected number of bytes read in output {i} for BufferSize={bufferSize}, FileSize={fileSize}");
Assert.IsTrue(Enumerable.All(outputs[i].Buffer, b => b == (byte) i + 1), $"Unexpected data in output {i} for BufferSize={bufferSize}, FileSize={fileSize}");
}
fixture.Verify();
}
public void Delete_WhereRecurseIsTrueAndDirectoryIsNonempty_CallsApiCorrectly()
{
var fixture = DokanOperationsFixture.Instance;
string path = DokanOperationsFixture.DirectoryName.AsRootedPath(),
subFileName = "SubFile.ext",
subFilePath = Path.DirectorySeparatorChar + subFileName;
#if LOGONLY
fixture.SetupAny();
#else
fixture.SetupCreateFile(path, ReadAttributesAccess, ReadWriteShare, FileMode.Open);
fixture.SetupGetFileInformation(path, FileAttributes.Directory);
fixture.SetupOpenDirectory(path);
fixture.SetupFindFiles(path, DokanOperationsFixture.GetEmptyDirectoryDefaultFiles().Concat(new[] {
new FileInformation()
{
FileName = subFileName, Attributes = FileAttributes.Normal, Length = 100, CreationTime = DateTime.Today, LastWriteTime = DateTime.Today, LastAccessTime = DateTime.Today
}
}).ToArray());
fixture.SetupCreateFile(path + subFilePath, DeleteAccess, ReadWriteShare, FileMode.Open, deleteOnClose: true);
fixture.SetupGetFileInformation(path + subFilePath, FileAttributes.Normal);
fixture.SetupDeleteFile(path + subFilePath);
fixture.SetupDeleteDirectory(path, true);
#endif
var sut = new DirectoryInfo(DokanOperationsFixture.DirectoryName.AsDriveBasedPath());
sut.Delete(true);
#if !LOGONLY
fixture.VerifyAll();
#endif
}
public void Delete_WhereRecurseIsTrueAndDirectoryIsEmpty_CallsApiCorrectly(bool supportsPatternSearch)
{
var fixture = DokanOperationsFixture.Instance;
var path = fixture.DirectoryName.AsRootedPath();
#if LOGONLY
fixture.SetupAny();
#else
fixture.ExpectCreateFile(path, ReadAttributesAccess, ReadWriteShare, FileMode.Open);
fixture.ExpectGetFileInformation(path, FileAttributes.Directory);
fixture.ExpectOpenDirectory(path);
if (supportsPatternSearch)
{
fixture.ExpectFindFilesWithPattern(path, "*", DokanOperationsFixture.GetEmptyDirectoryDefaultFiles());
}
else
{
fixture.ExpectFindFilesWithPatternToFail(path, "*", DokanResult.NotImplemented);
fixture.ExpectFindFiles(path, DokanOperationsFixture.GetEmptyDirectoryDefaultFiles());
}
fixture.ExpectOpenDirectory(path, DeleteFromDirectoryAccess);
fixture.ExpectDeleteDirectory(path);
#endif
var sut = new DirectoryInfo(fixture.DirectoryName.AsDriveBasedPath());
sut.Delete(true);
#if !LOGONLY
fixture.Verify();
#endif
}
public void Delete_WhereRecurseIsTrueAndDirectoryIsNonempty_CallsApiCorrectly()
{
var supportsPatternSearch = bool.Parse((string)TestContext.DataRow["SupportsPatternSearch"]);
var fixture = DokanOperationsFixture.Instance;
string path = fixture.DirectoryName.AsRootedPath(),
subFileName = "SubFile.ext",
subFilePath = Path.DirectorySeparatorChar + subFileName;
#if LOGONLY
fixture.SetupAny();
#else
fixture.ExpectCreateFile(path, ReadAttributesAccess, ReadWriteShare, FileMode.Open);
fixture.ExpectGetFileInformation(path, FileAttributes.Directory);
fixture.ExpectOpenDirectory(path);
if (supportsPatternSearch)
{
fixture.ExpectFindFilesWithPattern(path, "*", DokanOperationsFixture.GetEmptyDirectoryDefaultFiles().Concat(new[]
{
new FileInformation()
{
FileName = subFileName, Attributes = FileAttributes.Normal,
Length = 100,
CreationTime = DateTime.Today, LastWriteTime = DateTime.Today, LastAccessTime = DateTime.Today
}
}).ToArray());
}
else
{
fixture.ExpectFindFilesWithPatternToFail(path, "*", DokanResult.NotImplemented);
fixture.ExpectFindFiles(path, DokanOperationsFixture.GetEmptyDirectoryDefaultFiles().Concat(new[]
{
new FileInformation()
{
FileName = subFileName, Attributes = FileAttributes.Normal,
Length = 100,
CreationTime = DateTime.Today, LastWriteTime = DateTime.Today, LastAccessTime = DateTime.Today
}
}).ToArray());
}
fixture.ExpectCreateFile(path + subFilePath, DeleteAccess, ReadWriteShare, FileMode.Open, deleteOnClose: true);
fixture.ExpectGetFileInformation(path + subFilePath, FileAttributes.Normal);
fixture.ExpectDeleteFile(path + subFilePath);
fixture.ExpectOpenDirectory(path, DeleteFromDirectoryAccess);
fixture.ExpectDeleteDirectory(path);
#endif
var sut = new DirectoryInfo(fixture.DirectoryName.AsDriveBasedPath());
sut.Delete(true);
#if !LOGONLY
fixture.Verify();
#endif
}
public void GetFileSystemInfos_OnRootDirectory_WhereSearchOptionIsAllDirectories_CallsApiCorrectly()
{
var fixture = DokanOperationsFixture.Instance;
var pathsAndItems = new[]
{
new {
Path = DokanOperationsFixture.RootName,
Items = DokanOperationsFixture.RootDirectoryItems
},
new {
Path = DokanOperationsFixture.DirectoryName.AsRootedPath(),
Items = DokanOperationsFixture.GetEmptyDirectoryDefaultFiles().Concat(DokanOperationsFixture.DirectoryItems).ToArray()
},
new {
Path = Path.Combine(DokanOperationsFixture.DirectoryName, DokanOperationsFixture.SubDirectoryName).AsRootedPath(),
Items = DokanOperationsFixture.GetEmptyDirectoryDefaultFiles().Concat(DokanOperationsFixture.SubDirectoryItems).ToArray()
},
new {
Path = DokanOperationsFixture.Directory2Name.AsRootedPath(),
Items = DokanOperationsFixture.GetEmptyDirectoryDefaultFiles().Concat(DokanOperationsFixture.Directory2Items).ToArray()
},
new {
Path = Path.Combine(DokanOperationsFixture.Directory2Name, DokanOperationsFixture.SubDirectory2Name).AsRootedPath(),
Items = DokanOperationsFixture.GetEmptyDirectoryDefaultFiles().ToArray()
}
};
#if LOGONLY
fixture.SetupAny();
#else
foreach (var pathAndItem in pathsAndItems)
{
fixture.SetupOpenDirectory(pathAndItem.Path);
fixture.SetupFindFiles(pathAndItem.Path, pathAndItem.Items);
}
#endif
var sut = new DirectoryInfo(DokanOperationsFixture.RootName.AsDriveBasedPath());
#if LOGONLY
Assert.IsNotNull(sut.GetFileSystemInfos(), nameof(sut.GetFileSystemInfos));
Console.WriteLine(sut.GetFileSystemInfos().Length);
#else
CollectionAssert.AreEqual(
pathsAndItems.Select(p => p.Items.Where(f => !f.FileName.All(c => c == '.')))
.Aggregate((i1, i2) => i1.Union(i2).ToArray())
.Select(i => i.FileName).ToArray(),
sut.GetFileSystemInfos("*", SearchOption.AllDirectories).Select(f => f.Name).ToArray(),
nameof(sut.GetFileSystemInfos));
fixture.VerifyAll();
#endif
}
public void GetFileSystemInfos_OnRootDirectory_WhereSearchOptionIsAllDirectories_CallsApiCorrectly()
{
var supportsPatternSearch = bool.Parse((string)TestContext.DataRow["SupportsPatternSearch"]);
var fixture = DokanOperationsFixture.Instance;
var pathsAndItems = new[]
{
new { Path = DokanOperationsFixture.RootName, Items = fixture.RootDirectoryItems },
new { Path = fixture.DirectoryName.AsRootedPath(), Items = DokanOperationsFixture.GetEmptyDirectoryDefaultFiles().Concat(fixture.DirectoryItems).ToArray() },
new { Path = Path.Combine(fixture.DirectoryName, fixture.SubDirectoryName).AsRootedPath(), Items = DokanOperationsFixture.GetEmptyDirectoryDefaultFiles().Concat(fixture.SubDirectoryItems).ToArray() },
new { Path = fixture.Directory2Name.AsRootedPath(), Items = DokanOperationsFixture.GetEmptyDirectoryDefaultFiles().Concat(fixture.Directory2Items).ToArray() },
new { Path = Path.Combine(fixture.Directory2Name, fixture.SubDirectory2Name).AsRootedPath(), Items = DokanOperationsFixture.GetEmptyDirectoryDefaultFiles().ToArray() }
};
#if LOGONLY
fixture.SetupAny();
#else
foreach (var pathAndItem in pathsAndItems)
{
fixture.ExpectOpenDirectory(pathAndItem.Path);
if (supportsPatternSearch)
{
fixture.ExpectFindFilesWithPattern(pathAndItem.Path, "*", pathAndItem.Items);
}
else
{
fixture.ExpectFindFilesWithPatternToFail(pathAndItem.Path, "*", DokanResult.NotImplemented);
fixture.ExpectFindFiles(pathAndItem.Path, pathAndItem.Items);
}
}
#endif
var sut = new DirectoryInfo(DokanOperationsFixture.RootName.AsDriveBasedPath());
#if LOGONLY
Assert.IsNotNull(sut.GetFileSystemInfos(), nameof(sut.GetFileSystemInfos));
Console.WriteLine(sut.GetFileSystemInfos().Length);
#else
CollectionAssert.AreEqual(
pathsAndItems.Select(p => p.Items.Where(f => f.FileName.Any(c => c != '.'))).Aggregate((i1, i2) => i1.Union(i2).ToArray()).Select(i => i.FileName).ToArray(),
sut.GetFileSystemInfos("*", SearchOption.AllDirectories).Select(f => f.Name).ToArray(),
nameof(sut.GetFileSystemInfos));
fixture.Verify();
#endif
}
public void OpenWrite_WithVariableSizes_Overlapped_CallsApiCorrectly()
{
var bufferSize = int.Parse((string)TestContext.DataRow["BufferSize"]);
var fileSize = int.Parse((string)TestContext.DataRow["FileSize"]);
var fixture = DokanOperationsFixture.Instance;
var path = fixture.FileName.AsRootedPath();
var testData = DokanOperationsFixture.InitBlockTestData(bufferSize, fileSize);
#if LOGONLY
fixture.SetupAny();
#else
fixture.ExpectCreateFile(path, WriteAccess, WriteShare, FileMode.Open, context: testData);
fixture.ExpectSetAllocationSize(path, testData.Length);
fixture.ExpectSetEndOfFile(path, testData.Length);
#if NETWORK_DRIVE
fixture.SetupWriteFileInChunks(path, testData, bufferSize, context: testData, synchronousIo: false);
#else
fixture.ExpectWriteFileInChunks(path, testData, bufferSize, context: testData);
#endif
#endif
var inputs =
Enumerable.Range(0, NativeMethods.NumberOfChunks(bufferSize, fileSize))
.Select(
i =>
new NativeMethods.OverlappedChunk(
Enumerable.Repeat((byte)(i + 1),
NativeMethods.BufferSize(bufferSize, testData.Length, i)).ToArray()))
.ToArray();
NativeMethods.WriteEx(fixture.FileName.AsDriveBasedPath(), bufferSize, testData.Length, inputs);
#if !LOGONLY
for (var i = 0; i < inputs.Length; ++i)
{
Assert.AreEqual(0, inputs[i].Win32Error,
$"Unexpected Win32 error in input {i} for BufferSize={bufferSize}, FileSize={fileSize}");
Assert.AreEqual(NativeMethods.BufferSize(bufferSize, fileSize, i), inputs[i].BytesTransferred,
$"Unexpected number of bytes written in input {i} for BufferSize={bufferSize}, FileSize={fileSize}");
}
fixture.Verify();
#endif
}
public void OpenWrite_WithLargeFile_InParallel_PassesContextCorrectly()
{
var fixture = DokanOperationsFixture.Instance;
var path = fixture.FileName.AsRootedPath();
var context = new object();
#if LOGONLY
fixture.SetupAny();
#else
fixture.ExpectCreateFile(path, WriteAccess, WriteShare, FileMode.OpenOrCreate, FileOptions.None,
context: context);
fixture.ExpectWriteFileInChunks(path, largeData, FILE_BUFFER_SIZE, context: context);
fixture.PermitProbeFile(path, largeData);
#endif
var sut = new FileInfo(fixture.FileName.AsDriveBasedPath());
using (var stream = sut.OpenWrite())
{
var totalWrittenBytes = 0;
Parallel.For(0, DokanOperationsFixture.NumberOfChunks(FILE_BUFFER_SIZE, largeData.Length), i =>
{
var origin = i * FILE_BUFFER_SIZE;
var count = Math.Min(FILE_BUFFER_SIZE, largeData.Length - origin);
lock (stream)
{
stream.Seek(origin, SeekOrigin.Begin);
stream.Write(largeData, origin, count);
totalWrittenBytes += count;
}
});
}
#if !LOGONLY
fixture.VerifyContextWriteInvocations(path, 6);
#endif
}
public void OpenRead_WithLargeFile_InParallel_PassesContextCorrectly()
{
var fixture = DokanOperationsFixture.Instance;
var path = fixture.FileName.AsRootedPath();
var context = new object();
#if LOGONLY
fixture.SetupAny();
#else
fixture.ExpectCreateFile(path, ReadAccess, ReadOnlyShare, FileMode.Open, FileOptions.None, context: context);
fixture.ExpectReadFileInChunks(path, largeData, FILE_BUFFER_SIZE, context: context);
#endif
var sut = new FileInfo(fixture.FileName.AsDriveBasedPath());
using (var stream = sut.OpenRead())
{
var target = new byte[largeData.Length];
var totalReadBytes = 0;
Parallel.For(0, DokanOperationsFixture.NumberOfChunks(FILE_BUFFER_SIZE, largeData.Length), i =>
{
var origin = i * FILE_BUFFER_SIZE;
var count = Math.Min(FILE_BUFFER_SIZE, target.Length - origin);
lock (stream)
{
stream.Seek(origin, SeekOrigin.Begin);
totalReadBytes += stream.Read(target, origin, count);
}
});
}
#if !LOGONLY
fixture.VerifyContextReadInvocations(path, 6);
#endif
}
public void Delete_WhereRecurseIsTrueAndDirectoryIsEmpty_CallsApiCorrectly()
{
var fixture = DokanOperationsFixture.Instance;
string path = DokanOperationsFixture.DirectoryName.AsRootedPath();
#if LOGONLY
fixture.SetupAny();
#else
fixture.SetupCreateFile(path, ReadAttributesAccess, ReadWriteShare, FileMode.Open);
fixture.SetupGetFileInformation(path, FileAttributes.Directory);
fixture.SetupOpenDirectory(path);
fixture.SetupFindFiles(path, DokanOperationsFixture.GetEmptyDirectoryDefaultFiles());
fixture.SetupDeleteDirectory(path, true);
#endif
var sut = new DirectoryInfo(DokanOperationsFixture.DirectoryName.AsDriveBasedPath());
sut.Delete(true);
#if !LOGONLY
fixture.VerifyAll();
#endif
}
public void Initialize()
{
DokanOperationsFixture.InitInstance(TestContext.TestName);
}
public static void ClassInitialize(TestContext context)
{
testData = DokanOperationsFixture.InitBlockTestData(FILE_BUFFER_SIZE, 5*FILE_BUFFER_SIZE + 65536);
}
public static string AsDriveBasedPath(this string path) => DokanOperationsFixture.DriveBasedPath(path);
public static string AsRootedPath(this string path) => DokanOperationsFixture.RootedPath(path);
public void Initialize()
{
DokanOperationsFixture.InitInstance();
}
public override void Initialize()
{
// Clear the buffer pool (so we can validate in Cleanup()) and init test fixture.
BufferPool.Default.Clear();
DokanOperationsFixture.InitInstance(TestContext.TestName, unsafeOperations: true);
}
