public void TestGetRecursiveFilesWithSubsetSearch()
{
var tempLongPathFilename = uncDirectory.Combine(Path.GetRandomFileName());
tempLongPathFilename.CreateDirectory();
try {
Assert.IsTrue(tempLongPathFilename.Exists());
var newEmptyFile1 = Util.CreateNewEmptyFile(tempLongPathFilename, "A-file");
var newEmptyFile2 = Util.CreateNewEmptyFile(tempLongPathFilename, "B-file");
try {
var randomFileName = newEmptyFile1.GetFileName();
var di = new DirectoryInfo(uncDirectory);
var files = di.GetFiles("A*", SearchOption.AllDirectories).ToArray();
Assert.AreEqual(1, files.Length);
Assert.IsTrue(files.Any(f => f.Name == newEmptyFile1.GetFileName() && f.DirectoryName == newEmptyFile1.GetDirectoryName()));
Assert.IsFalse(files.Any(f => f.Name == newEmptyFile2.GetFileName() && f.DirectoryName == newEmptyFile2.GetDirectoryName()));
Assert.IsFalse(files.Any(f => f.Name == Filename.GetFileName() && f.DirectoryName == Filename.GetDirectoryName()));
}
finally {
Pri.LongPath.File.Delete(newEmptyFile1);
Pri.LongPath.File.Delete(newEmptyFile2);
}
}
finally {
const Boolean recursive = true;
Pri.LongPath.Directory.Delete(tempLongPathFilename, recursive);
}
}
public void TestGetRecursiveFilesWithAllSearch()
{
var tempLongPathFilename = longPathDirectory.Combine(Path.GetRandomFileName());
tempLongPathFilename.CreateDirectory();
try {
Assert.IsTrue(tempLongPathFilename.Exists());
var newEmptyFile = Util.CreateNewEmptyFile(tempLongPathFilename);
try {
var randomFileName = newEmptyFile.GetFileName();
var di = new DirectoryInfo(longPathDirectory);
var files = di.GetFiles("*", SearchOption.AllDirectories).ToArray();
Assert.AreEqual(2, files.Length);
Assert.IsTrue(files.Any(f => f.Name == Filename));
Assert.IsTrue(files.Any(f => f.Name == randomFileName));
}
finally {
File.Delete(newEmptyFile);
}
}
finally {
const Boolean recursive = true;
Directory.Delete(tempLongPathFilename, recursive);
}
}
public void TestGetAccessControlSections()
{
var tempLongPathFilename = uncDirectory.Combine(Path.GetRandomFileName());
tempLongPathFilename.CreateDirectory();
try {
var di = new DirectoryInfo(tempLongPathFilename);
var security = di.GetAccessControl(AccessControlSections.Access);
Assert.IsNotNull(security);
Assert.AreEqual(typeof(FileSystemRights), security.AccessRightType);
Assert.AreEqual(typeof(FileSystemAccessRule), security.AccessRuleType);
Assert.AreEqual(typeof(FileSystemAuditRule), security.AuditRuleType);
Assert.IsTrue(security.AreAccessRulesCanonical);
Assert.IsTrue(security.AreAuditRulesCanonical);
Assert.IsFalse(security.AreAccessRulesProtected);
Assert.IsFalse(security.AreAuditRulesProtected);
var securityGetAccessRules = security.GetAuditRules(true, true, typeof(NTAccount)).Cast <FileSystemAccessRule>();
Assert.AreEqual(0, securityGetAccessRules.Count());
var perm = security.GetAccessRules(true, true, typeof(NTAccount));
var ntAccount = new NTAccount(WindowsIdentity.GetCurrent().Name);
var rule = perm.Cast <FileSystemAccessRule>().SingleOrDefault(e => ntAccount == e.IdentityReference);
Assert.IsNotNull(rule);
Assert.IsTrue((rule.FileSystemRights & FileSystemRights.FullControl) != 0);
}
finally {
Pri.LongPath.Directory.Delete(tempLongPathFilename);
}
}
public void TestGetFilesWithSearch()
{
var di = new DirectoryInfo(uncDirectory);
var files = di.GetFiles("*").ToArray();
Assert.AreEqual(1, files.Length);
}
public void TestGetFilesWithSearchWithNoResults()
{
var di = new DirectoryInfo(uncDirectory);
var files = di.GetFiles("giberish").ToArray();
Assert.AreEqual(0, files.Length);
}
public void TestParentOnRoot()
{
var di = new DirectoryInfo(@"C:\");
var parent = di.Parent;
Assert.IsNull(parent);
}
public void TestMoveToNullPath()
{
var randomDirectoryName = Path.GetRandomFileName();
var tempLongPathDirectory = uncDirectory.Combine(randomDirectoryName);
var di = new DirectoryInfo(tempLongPathDirectory);
Assert.Throws <ArgumentNullException>(() => di.MoveTo(null));
}
public void TestMoveToDifferentRoot()
{
var randomDirectoryName = Path.GetRandomFileName();
var tempLongPathDirectory = uncDirectory.Combine(randomDirectoryName);
var di = new DirectoryInfo(tempLongPathDirectory);
Assert.Throws <IOException>(() => di.MoveTo(@"D:\"));
}
public void TestParentPathEndingWithSlash()
{
var di = new DirectoryInfo(uncDirectory + @"\");
var parent = di.Parent;
Assert.IsNotNull(parent);
Assert.AreEqual(uncDirectory.GetDirectoryName(), parent.FullName);
}
public void TestRoot()
{
var di = new DirectoryInfo(uncDirectory);
var root = di.Root;
Assert.IsNotNull(root);
Assert.AreEqual(new System.IO.DirectoryInfo(uncDirectory).Root.FullName, root.FullName);
}
public void TestCreateInvalidSubdirectory()
{
var di = new DirectoryInfo(uncDirectory);
Assert.Throws <ArgumentException>(() => {
var newDi = di.CreateSubdirectory(@"\");
});
}
public void TestParent()
{
var di = new DirectoryInfo(uncDirectory);
var parent = di.Parent;
Assert.IsNotNull(parent);
Assert.AreEqual(uncDirectory.GetDirectoryName(), parent.FullName);
}
public void TestGetFiles()
{
var di = new DirectoryInfo(uncDirectory);
var files = di.GetFiles().ToArray();
Assert.AreEqual(1, files.Length);
Assert.IsTrue(files.Any(f => f.Name == Filename));
}
public void TestSetLastAccessTimeMissingFile()
{
var filename = longPathDirectory.Combine("gibberish.ext");
var dateTime = DateTime.Now.AddDays(1);
var di = new DirectoryInfo(filename);
Assert.Throws <FileNotFoundException>(() => di.LastAccessTime = dateTime);
}
public void TestMoveToEmptyPath()
{
var randomDirectoryName = Path.GetRandomFileName();
var tempLongPathDirectory = longPathDirectory.Combine(randomDirectoryName);
var di = new DirectoryInfo(tempLongPathDirectory);
Assert.Throws <ArgumentException>(() => di.MoveTo(String.Empty));
}
public void TestMoveToSamePathWithSlash()
{
var randomDirectoryName = Path.GetRandomFileName();
var tempLongPathDirectory = uncDirectory.Combine(randomDirectoryName) + @"\";
var di = new DirectoryInfo(tempLongPathDirectory);
Assert.Throws <IOException>(() => di.MoveTo(tempLongPathDirectory));
}
private void CreateDirectoryStructure(Pri.LongPath.DirectoryInfo directory)
{
if (!directory.Parent.Exists)
{
CreateDirectoryStructure(directory.Parent);
}
directory.Create();
}
public void TestSetLastWriteTimeUtcMissingFile()
{
var filename = uncDirectory.Combine("gibberish.ext");
var dateTime = DateTime.UtcNow.AddDays(1);
var di = new DirectoryInfo(filename);
Assert.Throws <FileNotFoundException>(() => di.LastWriteTimeUtc = dateTime);
}
public IEnumerable <FileInfo> GetFileChangesSince(DateTime time, string directory)
{
Pri.LongPath.DirectoryInfo dInf = new Pri.LongPath.DirectoryInfo(directory);
foreach (var fileInfo in dInf.GetFiles("*", System.IO.SearchOption.AllDirectories))
{
if (fileInfo.CreationTimeUtc >= time || fileInfo.LastWriteTimeUtc >= time)
{
yield return(fileInfo);
}
}
}
public void TestCreateWithFileSecurity()
{
var tempLongPathFilename = uncDirectory.Combine(Path.GetRandomFileName());
var di = new DirectoryInfo(tempLongPathFilename);
try {
di.Create(new DirectorySecurity());
Assert.IsTrue(tempLongPathFilename.Exists());
}
finally {
di.Delete();
}
}
public void TestReplaceIgnoreMergeWithReadonlyBackupPath()
{
var tempLongPathFilename = new StringBuilder(uncDirectory).Append(@"\").Append("filename.ext").ToString();
var tempBackupPathName = new StringBuilder(uncDirectory).Append(@"\readonly").ToString();
var di = new DirectoryInfo(tempBackupPathName);
di.Create();
var attr = di.Attributes;
di.Attributes = attr | FileAttributes.ReadOnly;
var tempBackupLongPathFilename = new StringBuilder(tempBackupPathName).Append(@"\").Append("backup").ToString();
using (var fileStream = File.Create(tempLongPathFilename)) {
fileStream.WriteByte(42);
}
var tempLongPathFilename2 = new StringBuilder(uncDirectory).Append(@"\").Append("filename2.ext").ToString();
using (var fileStream = File.Create(tempLongPathFilename2)) {
fileStream.WriteByte(52);
}
try {
const Boolean ignoreMetadataErrors = true;
File.Replace(tempLongPathFilename, tempLongPathFilename2, tempBackupLongPathFilename, ignoreMetadataErrors);
using (var fileStream = File.OpenRead(tempLongPathFilename2)) {
Assert.AreEqual(42, fileStream.ReadByte());
}
Assert.IsFalse(File.Exists(tempLongPathFilename));
Assert.IsTrue(File.Exists(tempBackupLongPathFilename));
}
finally {
di.Attributes = attr;
if (File.Exists(tempLongPathFilename))
{
File.Delete(tempLongPathFilename);
}
File.Delete(tempLongPathFilename2);
File.Delete(tempBackupLongPathFilename);
if (tempBackupPathName.Exists())
{
Pri.LongPath.Directory.Delete(tempBackupPathName);
}
}
}
public void TestEnumerateFilesSearchWithNoResults()
{
var tempLongPathFilename = uncDirectory.Combine(Path.GetRandomFileName());
tempLongPathFilename.CreateDirectory();
try {
var di = new DirectoryInfo(uncDirectory);
Assert.AreEqual(0, di.EnumerateFiles("gibberish*").Count());
}
finally {
Pri.LongPath.Directory.Delete(tempLongPathFilename);
}
}
public void TestEnumerateDirectoriesWithWildcardSearchAndOptionNoResults()
{
var tempLongPathFilename = longPathDirectory.Combine(Path.GetRandomFileName());
tempLongPathFilename.CreateDirectory();
try {
var di = new DirectoryInfo(longPathDirectory);
Assert.AreEqual(0, di.EnumerateDirectories("gibberish*", SearchOption.TopDirectoryOnly).Count());
}
finally {
Directory.Delete(tempLongPathFilename);
}
}
public void TestCreateSubdirectory()
{
var di = new DirectoryInfo(uncDirectory);
var randomFileName = Path.GetRandomFileName();
var newDi = di.CreateSubdirectory(randomFileName);
try {
Assert.IsNotNull(newDi);
Assert.IsTrue(di.Exists);
}
finally {
newDi.Delete();
}
}
public void TestCreate()
{
var tempLongPathFilename = uncDirectory.Combine(Path.GetRandomFileName());
var di = new DirectoryInfo(tempLongPathFilename);
di.Create();
try {
Assert.IsTrue(di.Exists);
}
finally {
Pri.LongPath.Directory.Delete(tempLongPathFilename);
}
}
public void TestCreateSubdirectoryWithFileSecurity()
{
var di = new DirectoryInfo(uncDirectory);
var randomFileName = Path.GetRandomFileName();
DirectoryInfo newDi = null;
try {
newDi = di.CreateSubdirectory(randomFileName, new DirectorySecurity());
Assert.IsNotNull(newDi);
Assert.IsTrue(di.Exists);
}
finally {
newDi?.Delete();
}
}
public void TestGetLastWriteTimeUtc()
{
var tempLongPathFilename = longPathDirectory.Combine(Pri.LongPath.Path.GetRandomFileName());
tempLongPathFilename.CreateDirectory();
try {
var dateTime = Directory.GetLastWriteTimeUtc(tempLongPathFilename);
var fi = new DirectoryInfo(tempLongPathFilename);
Assert.AreEqual(fi.LastWriteTimeUtc, dateTime);
}
finally {
Directory.Delete(tempLongPathFilename);
}
}
public void TestGetLastAccessTime()
{
var tempLongPathFilename = uncDirectory.Combine(Pri.LongPath.Path.GetRandomFileName());
tempLongPathFilename.CreateDirectory();
try {
var dateTime = Pri.LongPath.Directory.GetLastAccessTime(tempLongPathFilename);
var fi = new DirectoryInfo(tempLongPathFilename);
Assert.AreEqual(fi.LastAccessTime, dateTime);
}
finally {
Pri.LongPath.Directory.Delete(tempLongPathFilename);
}
}
public void TestEnumerateFilesSearchWithResults()
{
var tempLongPathFilename = uncDirectory.Combine(Path.GetRandomFileName());
tempLongPathFilename.CreateDirectory();
try {
var di = new DirectoryInfo(uncDirectory);
var files = di.EnumerateFiles("*").ToArray();
Assert.AreEqual(1, files.Length);
Assert.IsTrue(files.Any(f => f.Name == Filename));
}
finally {
Pri.LongPath.Directory.Delete(tempLongPathFilename);
}
}
public void TestSetLastAccessTime()
{
var tempLongPathFilename = longPathDirectory.Combine(Pri.LongPath.Path.GetRandomFileName());
tempLongPathFilename.CreateDirectory();
try {
var dateTime = DateTime.Now.AddDays(1);
Directory.SetLastAccessTime(tempLongPathFilename, dateTime);
var fi = new DirectoryInfo(tempLongPathFilename);
Assert.AreEqual(fi.LastAccessTime, dateTime);
}
finally {
Directory.Delete(tempLongPathFilename);
}
}
public static DateTime GetLastWriteTimeUtc(String path)
{
var di = new DirectoryInfo(path);
return di.LastWriteTimeUtc;
}
public static DateTime GetCreationTimeUtc(String path)
{
var di = new DirectoryInfo(path);
return di.CreationTimeUtc;
}
public IEnumerable<FileInfo> GetFileChangesSince(DateTime time, string directory)
{
Pri.LongPath.DirectoryInfo dInf = new Pri.LongPath.DirectoryInfo(directory);
foreach (var fileInfo in dInf.GetFiles("*", System.IO.SearchOption.AllDirectories))
{
if (fileInfo.CreationTimeUtc >= time || fileInfo.LastWriteTimeUtc >= time)
{
yield return fileInfo;
}
}
}
public void TestSetCreationTime()
{
var tempLongPathFilename = Path.Combine(longPathRoot, Path.GetRandomFileName());
Directory.CreateDirectory(tempLongPathFilename);
Assert.IsTrue(Directory.Exists(tempLongPathFilename));
try
{
DateTime dateTime = DateTime.Now.AddDays(1);
Directory.SetCreationTime(tempLongPathFilename, dateTime);
var di = new DirectoryInfo(tempLongPathFilename);
Assert.AreEqual(di.CreationTime, dateTime);
}
finally
{
Directory.Delete(tempLongPathFilename);
}
}
private List<string> GetFileNames()
{
List<string> list = new List<string>();
DirectoryInfo di = new DirectoryInfo(GetDirectory());
if (di != null)
{
foreach (FileInfo fi in di.GetFiles())
{
list.Add(fi.Name);
}
}
return list;
}
public void TestGetLastWriteTimeUtc()
{
var tempLongPathFilename = Path.Combine(longPathDirectory, Path.GetRandomFileName());
Directory.CreateDirectory(tempLongPathFilename);
try
{
var dateTime = Directory.GetLastWriteTimeUtc(tempLongPathFilename);
var fi = new DirectoryInfo(tempLongPathFilename);
Assert.AreEqual(fi.LastWriteTimeUtc, dateTime);
}
finally
{
Directory.Delete(tempLongPathFilename);
}
}
public void TestSetLastAccessTimeUtc()
{
var tempLongPathFilename = Path.Combine(longPathDirectory, Path.GetRandomFileName());
Directory.CreateDirectory(tempLongPathFilename);
try
{
DateTime dateTime = DateTime.UtcNow.AddDays(1);
Directory.SetLastAccessTimeUtc(tempLongPathFilename, dateTime);
var fi = new DirectoryInfo(tempLongPathFilename);
Assert.AreEqual(fi.LastAccessTimeUtc, dateTime);
}
finally
{
Directory.Delete(tempLongPathFilename);
}
}
public void TestCurrentDirectory()
{
var di = new DirectoryInfo(".");
Assert.AreEqual(di.FullName, Directory.GetCurrentDirectory());
}
