public void SetUp()
{
longPathDirectory = Util.MakeLongPath(TestContext.CurrentContext.TestDirectory);
longPathRoot = longPathDirectory.Substring(0, TestContext.CurrentContext.TestDirectory.Length + 1 + longPathDirectory.Substring(TestContext.CurrentContext.TestDirectory.Length + 1).IndexOf('\\'));
Directory.CreateDirectory(longPathDirectory);
Debug.Assert(Directory.Exists(longPathDirectory));
}
/// <summary>
/// Creates a junction point from the specified directory to the specified target directory.
/// </summary>
/// <remarks>
/// Only works on NTFS.
/// </remarks>
/// <param name="junctionPoint">The junction point path</param>
/// <param name="targetDir">The target directory</param>
/// <param name="overwrite">If true overwrites an existing reparse point or empty directory</param>
/// <exception cref="IOException">Thrown when the junction point could not be created or when
/// an existing directory was found and <paramref name="overwrite" /> if false</exception>
public static void Create(string junctionPoint, string targetDir, bool overwrite)
{
targetDir = Path.GetFullPath(targetDir);
if (!Directory.Exists(targetDir))
{
throw new IOException("Target path does not exist or is not a directory.");
}
if (Directory.Exists(junctionPoint))
{
if (!overwrite)
{
throw new IOException("Directory already exists and overwrite parameter is false.");
}
}
else
{
Directory.CreateDirectory(junctionPoint);
}
using (SafeFileHandle handle = OpenReparsePoint(junctionPoint, EFileAccess.GenericWrite))
{
byte[] targetDirBytes = Encoding.Unicode.GetBytes(NonInterpretedPathPrefix + Path.GetFullPath(targetDir));
var reparseDataBuffer = new REPARSE_DATA_BUFFER
{
ReparseTag = IO_REPARSE_TAG_MOUNT_POINT,
ReparseDataLength = (ushort)(targetDirBytes.Length + 12),
SubstituteNameOffset = 0,
SubstituteNameLength = (ushort)targetDirBytes.Length,
PrintNameOffset = (ushort)(targetDirBytes.Length + 2),
PrintNameLength = 0,
PathBuffer = new byte[0x3ff0]
};
Array.Copy(targetDirBytes, reparseDataBuffer.PathBuffer, targetDirBytes.Length);
int inBufferSize = Marshal.SizeOf(reparseDataBuffer);
IntPtr inBuffer = Marshal.AllocHGlobal(inBufferSize);
try
{
Marshal.StructureToPtr(reparseDataBuffer, inBuffer, false);
int bytesReturned;
bool result = DeviceIoControl(handle.DangerousGetHandle(), FSCTL_SET_REPARSE_POINT,
inBuffer, targetDirBytes.Length + 20, IntPtr.Zero, 0, out bytesReturned, IntPtr.Zero);
if (!result)
{
ThrowLastWin32Error("Unable to create junction point.");
}
}
finally
{
Marshal.FreeHGlobal(inBuffer);
}
}
}
public void TestEnumerateFilesWithSearchWithNoResults()
{
var files = Directory.EnumerateFiles(uncDirectory, "giberish").ToArray();
Assert.AreEqual(0, files.Length);
Assert.IsFalse(files.Contains(uncFilePath));
}
public static string GetSystemComplianceItemResultFileName <T>()
{
var folder = System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), ApplicationInfo.ApplicationName);
Directory.CreateDirectory(folder);
return(System.IO.Path.Combine(folder, $@"System-{typeof(T).Name}.json"));
}
private static bool DownloadFile(string sourceURL, string fileName)
{
try
{
if (File.Exists(fileName))
{
return(true);
}
using (Stream stream = Misc.DownloadWebBinary(sourceURL))
{
if (stream == null)
{
return(false);
}
string destinationFolder = Directory.GetParent(fileName).FullName;
if (!Directory.Exists(destinationFolder))
{
Directory.CreateDirectory(destinationFolder);
}
using (var fileStream = File.Create(fileName))
{
CopyStream(stream, fileStream);
}
}
return(true);
}
catch
{
return(false);
}
}
public static string GetBaseImagesPath()
{
lock (assemblyLock)
{
bool overrideFolder = false;
if (!AppSettings.BaseImagesPathIsDefault)
{
if (!string.IsNullOrEmpty(AppSettings.BaseImagesPath))
{
if (Directory.Exists(AppSettings.BaseImagesPath))
{
overrideFolder = true;
}
}
}
string filePath = "";
if (overrideFolder)
{
filePath = AppSettings.BaseImagesPath;
}
else
{
filePath = Path.Combine(Utils.GetAppPath(), "Images");
}
if (!Directory.Exists(filePath))
{
Directory.CreateDirectory(filePath);
}
return(filePath);
}
}
public static void ClassInitialize(TestContext context)
{
longPathDirectory = Util.MakeLongPath(context.TestDir);
longPathRoot = longPathDirectory.Substring(0, context.TestDir.Length + 1 + longPathDirectory.Substring(context.TestDir.Length + 1).IndexOf('\\'));
Directory.CreateDirectory(longPathDirectory);
Debug.Assert(Directory.Exists(longPathDirectory));
}
public static void RenameFileExtension(string iPath, string src, string dest)
{
if (!Directory.Exists(iPath))
{
return;
}
// rename subDir
string[] dirPaths = Directory.GetDirectories(iPath);
for (int i = 0; i < dirPaths.Length; i++)
{
RenameFileExtension(dirPaths[i], src, dest);
}
// rename files
string[] filePaths = Directory.GetFiles(iPath);
for (int i = 0; i < filePaths.Length; ++i)
{
string extension = Path.GetExtension(filePaths[i]);
if (extension == src)
{
string dir = Path.GetDirectoryName(filePaths[i]);
string name = Path.GetFileNameWithoutExtension(filePaths[i]);
string destFile = dir + name + dest;
MoveWithReplace(filePaths[i], destFile);
}
}
}
public void TestSetCreationTimeUtcNonExistentDir()
{
var tempLongPathFilename = Path.Combine(uncDirectory, Path.GetRandomFileName());
DateTime dateTime = DateTime.UtcNow.AddDays(1);
Directory.SetCreationTimeUtc(tempLongPathFilename, dateTime);
}
/*public static void GetFilesForImportFolder(string folderLocation, ref List<string> fileList)
* {
* if (Directory.Exists(folderLocation))
* {
* // get root level files
* fileList.AddRange(Directory.GetFiles(folderLocation, "*.*", SearchOption.TopDirectoryOnly));
*
* // search sub folders
* foreach (string dirName in Directory.GetDirectories(folderLocation))
* {
* try
* {
* if (dirName.ToUpper().Contains("RECYCLE.BIN")) continue;
*
* fileList.AddRange(Directory.GetFiles(dirName, "*.*", SearchOption.AllDirectories));
* }
* catch (Exception ex)
* {
* logger.Warn("Error accessing: {0} - {1}", dirName, ex.Message);
* }
* }
* }
* }*/
public static void GetFilesForImportFolder(string sDir, ref List <string> fileList)
{
try
{
// get root level files
fileList.AddRange(Directory.GetFiles(sDir, "*.*", SearchOption.TopDirectoryOnly));
// search sub folders
foreach (string d in Directory.GetDirectories(sDir))
{
DirectoryInfo di = new DirectoryInfo(d);
bool isSystem = (di.Attributes & FileAttributes.System) == FileAttributes.System;
if (isSystem)
{
continue;
}
//fileList.AddRange(Directory.GetFiles(d, "*.*", SearchOption.TopDirectoryOnly));
GetFilesForImportFolder(d, ref fileList);
}
}
catch (System.Exception excpt)
{
Console.WriteLine(excpt.Message);
}
}
public void TestGetAccessControlSections()
{
var tempLongPathFilename = Path.Combine(uncDirectory, Path.GetRandomFileName());
Directory.CreateDirectory(tempLongPathFilename);
try
{
var security = Directory.GetAccessControl(tempLongPathFilename, 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(System.Security.Principal.NTAccount)).Cast <FileSystemAccessRule>();
Assert.AreEqual(0, securityGetAccessRules.Count());
AuthorizationRuleCollection perm = security.GetAccessRules(true, true, typeof(System.Security.Principal.NTAccount));
var ntAccount = new System.Security.Principal.NTAccount(System.Security.Principal.WindowsIdentity.GetCurrent().Name);
FileSystemAccessRule rule = perm.Cast <FileSystemAccessRule>().SingleOrDefault(e => ntAccount == e.IdentityReference);
Assert.IsNotNull(rule);
Assert.IsTrue((rule.FileSystemRights & FileSystemRights.FullControl) != 0);
}
finally
{
Directory.Delete(tempLongPathFilename);
}
}
//static void Unmount()
//{
// Console.WriteLine("Unmounting G:");
// StartProcess(@"C:\Program Files\PowerISO\piso.exe", "unmount G:");
//}
public static void CategorizeLibraryFolders()
{
var folders = Directory.EnumerateDirectories(Paths.OutputPath, "*", SearchOption.TopDirectoryOnly);
foreach (var folder in folders)
{
if (Path.GetFileName(folder) == "_Kontakt" || Path.GetFileName(folder) == "_Loops")
{
continue;
}
var files = Directory.EnumerateFiles(folder, "*.nki", SearchOption.AllDirectories).ToArray();
if (files.Length > 0)
{
Directory.Move(folder, Paths.OutputPath + @"\_Kontakt\" + Path.GetFileName(folder));
}
else
{
files = Directory.EnumerateFiles(folder, "*.iso", SearchOption.AllDirectories).ToArray();
files = files.Concat(Directory.EnumerateFiles(folder, "*.bin", SearchOption.AllDirectories)).ToArray();
if (files.Length > 0)
{
Directory.Move(folder, Paths.OutputPath + @"\_Iso\" + Path.GetFileName(folder));
}
else
{
Directory.Move(folder, Paths.OutputPath + @"\_Loops\" + Path.GetFileName(folder));
}
}
}
}
/// <summary>
/// Get a relative path to the file
/// </summary>
/// <param name="fileName">Name of the file.</param>
/// <param name="basePath">The base path.</param>
/// <returns>
/// A relative path if possible
/// </returns>
public static string GetRelativePath(this string fileName, string basePath)
{
if (string.IsNullOrEmpty(fileName) || fileName.StartsWith(".", StringComparison.Ordinal) ||
fileName.IndexOf("\\", StringComparison.Ordinal) == -1)
{
return(fileName);
}
if (string.IsNullOrEmpty(basePath))
{
basePath = Directory.GetCurrentDirectory();
}
if (fileName.Equals(basePath, StringComparison.OrdinalIgnoreCase))
{
return(".");
}
if (fileName.StartsWith(basePath, StringComparison.OrdinalIgnoreCase))
{
return(fileName.Substring(basePath.Length + 1));
}
var otherDir = Path.GetFullPath(fileName).RemovePrefix();
return(GetRelativePathQuick(otherDir, basePath));
}
public void TestCreateTextAndWrite()
{
Assert.IsTrue(Directory.Exists(longPathDirectory));
string tempLongPathFilename;
do
{
tempLongPathFilename = Path.Combine(longPathDirectory, Path.GetRandomFileName());
} while (File.Exists(tempLongPathFilename));
Assert.IsFalse(File.Exists(tempLongPathFilename));
const string fileText = "test";
using (var writer = File.CreateText(tempLongPathFilename))
{
writer.WriteLine(fileText);
}
try
{
Assert.IsTrue(File.Exists(tempLongPathFilename));
var fileInfo = new FileInfo(tempLongPathFilename);
Assert.AreEqual(fileText.Length + Environment.NewLine.Length, fileInfo.Length);
}
finally
{
File.Delete(tempLongPathFilename);
}
}
public void TestCreateDirectoryThatAlreadyExists()
{
var di = Directory.CreateDirectory(uncDirectory);
Assert.IsNotNull(di);
Assert.IsTrue(Directory.Exists(uncDirectory));
}
public void TestGetParentAtRoot()
{
string path = "c:\\";
Pri.LongPath.DirectoryInfo parent = Directory.GetParent(path);
Assert.IsNull(parent);
}
public void TestGetFileSystemEntriesWithSearchWithNoResults()
{
var entries = Directory.GetFileSystemEntries(uncDirectory, "giberish").ToArray();
Assert.AreEqual(0, entries.Length);
Assert.IsFalse(entries.Contains(uncFilePath));
}
public void TestSetCreationTimeUtcNonExistentDir()
{
var tempLongPathFilename = Path.Combine(uncDirectory, Path.GetRandomFileName());
DateTime dateTime = DateTime.UtcNow.AddDays(1);
Assert.Throws <FileNotFoundException>(() => Directory.SetCreationTimeUtc(tempLongPathFilename, dateTime));
}
public void TestEnumerateFileSystemEntries()
{
var entries = Directory.EnumerateFileSystemEntries(uncDirectory).ToArray();
Assert.AreEqual(1, entries.Length);
Assert.IsTrue(entries.Contains(uncFilePath));
}
public void TestGetFileSystemEntriesWithSearch()
{
var entries = Directory.GetFileSystemEntries(uncDirectory, "*").ToArray();
Assert.AreEqual(1, entries.Length);
Assert.IsTrue(entries.Contains(uncFilePath));
}
public IResult <Result.InternalTypes.Void> RenameDirectory(string basePath, string oldName, string newName)
{
var oldPathResult = _pathManager.Combine(basePath, oldName);
if (!oldPathResult.IsSuccess)
{
return(new FailureResult(oldPathResult.Exception));
}
var newPathResult = _pathManager.Combine(basePath, newName);
if (!newPathResult.IsSuccess)
{
return(new FailureResult(newPathResult.Exception));
}
try
{
ValidateNameLength(newPathResult.Data);
Directory.Move(oldPathResult.Data, newPathResult.Data);
return(new SuccessResult());
}
catch (Exception e)
{
return(new FailureResult(e));
}
}
public void TestEnumerateFilesWithSearch()
{
var files = Directory.EnumerateFiles(uncDirectory, "*").ToArray();
Assert.AreEqual(1, files.Length);
Assert.IsTrue(files.Contains(uncFilePath));
}
public void FileInfoReturnsCorrectDirectoryNameForLongPathFile()
{
Assert.IsTrue(Directory.Exists(longPathDirectory));
string tempLongPathFilename;
do
{
tempLongPathFilename = Path.Combine(longPathDirectory, Path.GetRandomFileName());
} while (File.Exists(tempLongPathFilename));
Assert.IsFalse(File.Exists(tempLongPathFilename));
using (var writer = File.CreateText(tempLongPathFilename))
{
writer.WriteLine("test");
}
try
{
Assert.IsTrue(File.Exists(tempLongPathFilename));
var fileInfo = new FileInfo(tempLongPathFilename);
Assert.AreEqual(longPathDirectory, fileInfo.DirectoryName);
}
finally
{
File.Delete(tempLongPathFilename);
}
}
public void CreateDirectory(string path)
{
var name = path.Split('\\').Last();
ValidateNameLength(name);
Directory.CreateDirectory(path);
}
public void TestInUseMove()
{
const bool recursive = true;
#if SHORT_SOURCE
var tempPathFilename1 = System.IO.Path.Combine(System.IO.Directory.GetCurrentDirectory(), System.IO.Path.GetRandomFileName());
System.IO.Directory.CreateDirectory(tempPathFilename1);
Assert.IsTrue(System.IO.Directory.Exists(Path.GetFullPath(tempPathFilename1)));
var tempPathFilename2 = System.IO.Path.Combine(System.IO.Directory.GetCurrentDirectory(), System.IO.Path.GetRandomFileName());
System.IO.Directory.CreateDirectory(tempPathFilename2);
Assert.IsTrue(System.IO.Directory.Exists(System.IO.Path.GetFullPath(tempPathFilename2)));
try
{
using (
var writer = System.IO.File.CreateText(System.IO.Path.Combine(tempPathFilename2, "TestInUseMove")))
{
string destinationPath =
System.IO.Path.GetFullPath(System.IO.Path.Combine(tempPathFilename1, System.IO.Path.GetFileName(tempPathFilename2)));
System.IO.Directory.Move(tempPathFilename2, destinationPath);
Assert.IsTrue(System.IO.Directory.Exists(System.IO.Path.GetFullPath(tempPathFilename1)));
Assert.IsFalse(System.IO.Directory.Exists(System.IO.Path.GetFullPath(tempPathFilename2)));
Assert.IsTrue(System.IO.Directory.Exists(destinationPath));
}
}
catch (Exception e)
{
throw;
}
finally
{
Directory.Delete(tempPathFilename1, recursive);
Directory.Delete(tempPathFilename2, recursive);
}
#endif
var tempLongPathFilename1 = Path.Combine(uncDirectory, Path.GetRandomFileName());
Directory.CreateDirectory(tempLongPathFilename1);
Assert.IsTrue(Directory.Exists(Path.GetFullPath(tempLongPathFilename1)));
var tempLongPathFilename2 = Path.Combine(uncDirectory, Path.GetRandomFileName());
Directory.CreateDirectory(tempLongPathFilename2);
Assert.IsTrue(Directory.Exists(Path.GetFullPath(tempLongPathFilename2)));
try
{
using (
var writer = File.CreateText(Path.Combine(tempLongPathFilename2, "TestInUseMove")))
{
string destinationPath =
Path.GetFullPath(Path.Combine(tempLongPathFilename1, Path.GetFileName(tempLongPathFilename2)));
Directory.Move(tempLongPathFilename2, destinationPath);
Assert.IsTrue(Directory.Exists(Path.GetFullPath(tempLongPathFilename1)));
Assert.IsFalse(Directory.Exists(Path.GetFullPath(tempLongPathFilename2)));
Assert.IsTrue(Directory.Exists(destinationPath));
}
}
finally
{
Directory.Delete(tempLongPathFilename1, recursive);
Directory.Delete(tempLongPathFilename2, recursive);
}
}
public override FileInfo[] GetFiles()
{
if (_directory == null)
{
return(new FileInfo[0]);
}
return(Directory.GetFiles(FullName).Select(a => new FileInfo(a)).ToArray());
}
public void TestDirectoryCreateNearMaxPathLimit()
{
var uncPathNearMaxPathLimit = Path.Combine(uncDirectory, new string('x', Pri.LongPath.NativeMethods.MAX_PATH - uncDirectory.Length - 2));
Directory.CreateDirectory(uncPathNearMaxPathLimit);
Assert.That(Directory.Exists(uncPathNearMaxPathLimit));
Directory.Delete(uncPathNearMaxPathLimit);
}
public Form1()
{
path = Directory.GetCurrentDirectory() + @"\Documents\";
InitializeComponent();
InitNodes();
LoadTreeView();
tabControl1.Resize += ResizeTab;
tabControl1.SelectedIndexChanged += UpdateSelected;
}
public static void CreateDirectory(string directoryName)
{
if (string.IsNullOrEmpty(directoryName))
{
return;
}
Directory.CreateDirectory(directoryName);
}
public static bool DirectoryExists(string directoryName)
{
if (string.IsNullOrEmpty(directoryName))
{
return(false);
}
return(Directory.Exists(directoryName));
}
