/// <summary>
/// Using the supplied Startup class attempts to correctly locate our project root. We traverse the ancestor tree in case
/// the integration tests derives from the application's startup class
/// </summary>
/// <param name="projectRelativePath">The project relative path.</param>
/// <param name="startupType">Type of the startup.</param>
/// <returns></returns>
private static string GetProjectPathFromAncestors(string projectRelativePath, Type startupType)
{
//get all ansectors type from current type
Type type = startupType;
DirectoryNotFoundException lastException = null;
while (type != null)
{
try
{
var path = GetProjectPath(projectRelativePath, type.Assembly);
return(path);
}
catch (DirectoryNotFoundException d)
{
lastException = d;
}
type = type.BaseType;
}
if (lastException != null)
{
throw lastException;
}
return(null);
}
public void SaveFile(Action <Exception> callback, IEnumerable <string> data, string nameFile)
{
Exception error = null;
if (Directory.Exists(Path.GetDirectoryName(Path.GetFullPath(nameFile))))
{
try
{
using (StreamWriter sw = new StreamWriter(File.OpenWrite(nameFile), Encoding.Default))
{
foreach (var item in data)
{
sw.WriteLine(item);
}
}
}
catch (Exception ex)
{
error = ex;
}
}
else
{
error = new DirectoryNotFoundException();
}
callback(error);
}
void IPscxErrorHandler.WriteDirectoryNotFoundError(string path)
{
string msg = string.Format(Resources.Errors.DirectoryNotFound, path);
Exception ex = new DirectoryNotFoundException(msg);
ErrorHandler.WriteFileError(path, ex);
}
private void DirectoryeNotFoundMessage(DirectoryNotFoundException e)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Директория не найдена");
Console.WriteLine(e.Message);
Console.ResetColor();
}
/// <summary>
/// Метод для сохранения данных в файл
/// </summary>
/// <param name="callback">Функция обратного вызова, с параметром ошибка</param>
/// <param name="data">Множество данных для записи</param>
/// <param name="file">Файл куда записывать</param>
public void SaveData(Action <Exception> callback, IEnumerable <string> data, string file)
{
Exception error = null;
try
{
if (Directory.Exists(Path.GetDirectoryName(file)))
{
// utf-8 с Bom не читается системой, приходится так
Encoding utf = new UTF8Encoding(false);
using (StreamWriter sw = new StreamWriter(File.Create(file), utf))
{
foreach (var item in data)
{
sw.WriteLine(item);
}
}
}
else
{
error = new DirectoryNotFoundException();
}
}
catch (Exception ex)
{
error = ex;
}
callback(error);
}
public void Send_SpecifiedPickupDirectory_PickupDirectoryLocation_DirectoryNotFound()
{
Directory.Delete(tempFolder);
smtp.DeliveryMethod = SmtpDeliveryMethod.SpecifiedPickupDirectory;
smtp.PickupDirectoryLocation = tempFolder;
try {
smtp.Send("*****@*****.**", "*****@*****.**",
"introduction", "hello");
Assert.Fail("#1");
} catch (SmtpException ex) {
// Failure sending email
Assert.AreEqual(typeof(SmtpException), ex.GetType(), "#2");
Assert.IsNotNull(ex.InnerException, "#3");
Assert.AreEqual(typeof(DirectoryNotFoundException), ex.InnerException.GetType(), "#4");
Assert.IsNotNull(ex.Message, "#5");
Assert.AreEqual(SmtpStatusCode.GeneralFailure, ex.StatusCode, "#6");
// Could not find a part of the path '...'
DirectoryNotFoundException inner = (DirectoryNotFoundException)ex.InnerException;
Assert.IsNull(inner.InnerException, "#7");
Assert.IsNotNull(inner.Message, "#8");
Assert.IsTrue(inner.Message.IndexOf(tempFolder) != -1, "#9");
}
}
/// <summary>
///
/// </summary>
/// <param name="action"></param>
/// <returns>True if directory existed. If it was created - returns false</returns>
public static bool CreateDirectoryIfItDoesntExistForFile(string fileName, Action action)
{
try
{
action();
return(true);
}
catch (DirectoryNotFoundException)
{
if (CreateDirectoryForFile(fileName, checkExistense: false))
{
action();
}
}
catch (Exception ex)
{
Exception innerException = ex.InnerException;
while (innerException != null)
{
DirectoryNotFoundException directoryNotFoundException = innerException as DirectoryNotFoundException;
if (directoryNotFoundException != null)
{
if (CreateDirectoryForFile(fileName))
{
action();
}
return(false);
}
innerException = innerException.InnerException;
}
throw ex;
}
return(false);
}
public static void Ctor_String()
{
string message = "That page was missing from the directory.";
var exception = new DirectoryNotFoundException(message);
ExceptionUtility.ValidateExceptionProperties(exception, hResult: HResults.COR_E_DIRECTORYNOTFOUND, message: message);
}
private bool ValidateJobDefinition(ScheduledJobDefinition definition)
{
Exception exception = null;
try
{
definition.SyncWithWTS();
}
catch (DirectoryNotFoundException directoryNotFoundException1)
{
DirectoryNotFoundException directoryNotFoundException = directoryNotFoundException1;
exception = directoryNotFoundException;
}
catch (FileNotFoundException fileNotFoundException1)
{
FileNotFoundException fileNotFoundException = fileNotFoundException1;
exception = fileNotFoundException;
}
catch (ArgumentNullException argumentNullException1)
{
ArgumentNullException argumentNullException = argumentNullException1;
exception = argumentNullException;
}
if (exception != null)
{
this.WriteErrorLoadingDefinition(definition.Name, exception);
}
return(exception == null);
}
static void Application_ThreadException(object sender, System.Threading.ThreadExceptionEventArgs e)
{
if (e.Exception is DirectoryNotFoundException)
{
DirectoryNotFoundException theException = (DirectoryNotFoundException)e.Exception;
BLIO.WriteError(theException, "Folder not found.");
ShowError(e.Exception, e.Exception.GetType().ToString(), theException.Message);
}
if (e.Exception is UnauthorizedAccessException)
{
UnauthorizedAccessException theException = (UnauthorizedAccessException)e.Exception;
BLIO.WriteError(e.Exception, "Unauthorized!");
ShowError(e.Exception, "Unauthorized!", "not authorized for this action.\r\nThis can be resolved by running in administrator-mode.");
}
//Here we just filter out some type of exceptions and give different messages, at the bottom is the super Exception, which can be anything.
else if (e.Exception is FileNotFoundException)
{
FileNotFoundException theException = (FileNotFoundException)e.Exception; //needs in instance to call .FileName
BLIO.WriteError(theException, "converteruld not find the file located at \"" + theException.FileName);
ShowError(e.Exception, "File not found.", "Could not find the file located at \"" + theException.FileName + "\"\r\nHave you moved,renamed or deleted the file?");
}
else if (e.Exception is System.Data.Entity.Core.EntityException)
{
BLIO.WriteError(e.Exception, "System.Data.Entity.Core.EntityException");
ShowError(e.Exception, "System.Data.Entity.Core.EntityException", "There was a problem executing SQL!");
}
else if (e.Exception is ArgumentNullException)
{
BLIO.WriteError(e.Exception, "Null argument");
ShowError(e.Exception, "Null argument", "Null argument exception! Whoops! this is not on your end!");
}
else if (e.Exception is NullReferenceException)
{
BLIO.WriteError(e.Exception, "Null reference");
ShowError(e.Exception, "Null reference", "Null reference exception! Whoops! this is not on your end!");
}
else if (e.Exception is SQLiteException)
{
BLIO.WriteError(e.Exception, "SQLite Database exception");
ShowError(e.Exception, "SQLite Database exception", "encountered a database error!\r\nThis might or might not be on your end. It can be on your end if you modified the database file");
}
else if (e.Exception is PathTooLongException)
{
BLIO.WriteError(e.Exception, "The path to the file is too long.");
ShowError(e.Exception, "File Path too long.", "The path to the file is too long!.");
}
else if (e.Exception is Exception)
{
BLIO.WriteError(e.Exception, "Unknown exception in main.");
}
}
public IEnumerable <string> FilterFilePathsFromFolder(
string folderPath,
FileExtensions fileExtensionsToCollect,
bool isIncludingSubdirectories)
{
if (!Directory.Exists(folderPath))
{
var folderNotFoundException =
new DirectoryNotFoundException("The following directory couldn't be found: " + folderPath);
folderNotFoundException.Data.Add("folder", folderPath);
throw folderNotFoundException;
}
SearchOption currentDirectorySearchOption =
isIncludingSubdirectories ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly;
if (fileExtensionsToCollect.HasFlag(FileExtensions.Any))
{
return(CollectAllFilePathsIgnoreFileExtension(folderPath, currentDirectorySearchOption));
}
return(CollectFilePathsFromFolderByFileExtension(
folderPath,
fileExtensionsToCollect,
currentDirectorySearchOption));
}
/// <summary>
/// Displays an error message when DirectoryNotFoundException is thrown.
/// </summary>
/// <param name="ex">The exception</param>
private static void ShowException(DirectoryNotFoundException ex)
{
PrepareToShow();
string errorMessage = Util.CombineMessageParts(SharedStrings.DIRECTORY_NOT_FOUND, ex.Message);
ShowError(errorMessage, false);
}
public bool PosTest1()
{
bool retVal = true;
TestLibrary.TestFramework.BeginScenario("PosTest1: Create a new DirectoryNotFoundException instance.");
try
{
string expectString = "This is an error";
DirectoryNotFoundException myException = new DirectoryNotFoundException(expectString);
if (myException.Message != expectString)
{
TestLibrary.TestFramework.LogError("001.1", "the DirectoryNotFoundException ctor error occurred.the message should be " + expectString);
retVal = false;
}
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("001.2", "Unexpected exception: " + e);
retVal = false;
}
return retVal;
}
public bool PosTest3()
{
bool retVal = true;
TestLibrary.TestFramework.BeginScenario("PosTest3: Create a new DirectoryNotFoundException instance,string is null.");
try
{
string expectString = null;
DirectoryNotFoundException myException = new DirectoryNotFoundException(expectString);
if (myException == null)
{
TestLibrary.TestFramework.LogError("003.1", "the DirectoryNotFoundException ctor error occurred. the message should be null");
retVal = false;
}
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("003.2", "Unexpected exception: " + e);
retVal = false;
}
return retVal;
}
// 何かやって例外出た時に、調べられる限り原因を調べる
public static Exception InspectIoError(string path, string toPath, Exception originalException)
{
Exception ret = originalException;
try
{
var info = new FileInfo(path);
if (!info.Exists) // ファイルなくなってる
{
ret = new FileNotFoundException("File not found: " + path);
}
else if (toPath != null)
{
var toInfo = new FileInfo(toPath);
if (toInfo.Exists)
{
ret = new IOException("destination path already exists. " + toPath);
}
else if (!toInfo.Directory.Exists)
{
ret = new DirectoryNotFoundException("destination directory not found: " + toPath);
}
}
}
catch (Exception e)
{
ret = e;
}
return(ret);
}
public static void HandleException(Window window, DirectoryNotFoundException ex)
{
try
{
string message = string.Format(Properties.Resources.MessageDirectoryNotFoundException);
TaskDialog dialog = new TaskDialog();
dialog.InstructionText = message;
//dialog.Text
dialog.Icon = TaskDialogStandardIcon.Error;
dialog.StandardButtons = TaskDialogStandardButtons.Ok;
dialog.DetailsExpandedText = ex.Message;
dialog.Caption = App.Current.ApplicationTitle;
if (window != null)
{
dialog.OwnerWindowHandle = new WindowInteropHelper(window).Handle;
}
dialog.Show();
}
catch (PlatformNotSupportedException)
{
MessageBox.Show(ex.Message);
}
}
public void ShouldIgnoreException_IgnoreErrorMessages(bool hasIgnoreError)
{
var ignoreErrorMessages = new Dictionary <string, IEnumerable <string> >
{
{ "System.IO.DirectoryNotFoundException", new List <string>()
{
"error message 1", "error message 2"
} }
};
if (hasIgnoreError)
{
SetupConfiguration(null, null, ignoreErrorMessages, null, false, null, null, null, errorCollectorEnabled: true);
}
var ignoreException1 = new DirectoryNotFoundException("this is error message 1 ");
var ignoreException2 = new DirectoryNotFoundException("this is error message 2 ");
if (hasIgnoreError)
{
Assert.True(_errorService.ShouldIgnoreException(ignoreException1));
Assert.True(_errorService.ShouldIgnoreException(ignoreException2));
}
else
{
Assert.False(_errorService.ShouldIgnoreException(ignoreException1));
Assert.False(_errorService.ShouldIgnoreException(ignoreException2));
}
}
public static DirectoryNotFoundException /*!*/ Create(RubyClass /*!*/ self, [DefaultProtocol, DefaultParameterValue(null)] MutableString message)
{
DirectoryNotFoundException result = new DirectoryNotFoundException(RubyExceptions.MakeMessage(ref message, "Not a directory"));
RubyExceptionData.InitializeException(result, message);
return(result);
}
public static void From_HR(int hr)
{
DirectoryNotFoundException exception = Assert.IsAssignableFrom <DirectoryNotFoundException>(Marshal.GetExceptionForHR(hr));
// Don't validate the message. Currently .NET Native does not produce HR-specific messages
ExceptionUtility.ValidateExceptionProperties(exception, hResult: hr, validateMessage: false);
}
public void GetFriendlyName_NonGeneric_ShouldEqualTypeName()
{
var item = new DirectoryNotFoundException();
var result = item.GetType().GetFriendlyName();
result.ShouldBe("DirectoryNotFoundException");
}
/// <summary>
/// Serialise the CDA document to an XML file
/// </summary>
/// <param name="fileLocation">filename of the XML file to be created</param>
public void CreateXML(string fileLocation)
{
FileInfo tagetInfo = new FileInfo(fileLocation);
if (tagetInfo.Directory.Exists)
{
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
settings.IndentChars = (" ");
using (XmlWriter writer = XmlWriter.Create(fileLocation, settings))
{
writeXmlCommentBlock(writer);
writer.WriteStartElement("ClinicalDocument", "urn:hl7-org:v3");
writeXml(writer);
writer.WriteEndElement();
writer.Flush();
}
}
else
{
ApplicationException exInner = new ApplicationException(tagetInfo.DirectoryName);
DirectoryNotFoundException ex = new DirectoryNotFoundException("Target Directory does not exist", exInner);
throw ex;
}
}
public static void DirectoryNotFoundException_ctor_string()
{
string message = "That page was missing from the directory.";
DirectoryNotFoundException dnfe = new DirectoryNotFoundException(message);
Utility.ValidateExceptionProperties(dnfe, hResult: HResults.COR_E_DIRECTORYNOTFOUND, message: message);
}
private Task <FileInfo> FindFile(DirectoryInfo directory, string name)
{
if (!directory.Exists)
{
Exception directoryException = new DirectoryNotFoundException("The journal directory does not exist");
directoryException.Data.Add("Directory", directory.FullName);
directoryException.Data.Add("File", name);
throw directoryException;
}
var files = directory.GetFiles(name);
if (files.Length > 0)
{
return(Task.FromResult(files.First()));
}
if (name == "Status.json")
{
var path = Path.Combine(directory.FullName, name);
var fileException = new FileNotFoundException("The file does not exist", path);
fileException.Data.Add("Directory", directory.FullName);
fileException.Data.Add("File", name);
throw fileException;
}
return(Task.FromResult <FileInfo>(null));
}
public static void DirectoryNotFoundException_ctor_string_exception()
{
string message = "That page was missing from the directory.";
Exception innerException = new Exception("Inner exception");
DirectoryNotFoundException dnfe = new DirectoryNotFoundException(message, innerException);
Utility.ValidateExceptionProperties(dnfe, hResult: HResults.COR_E_DIRECTORYNOTFOUND, innerException: innerException, message: message);
}
public void FromException_MarkErrorDataAsExpected_ExpectedErrorMessages(bool hasExpectedError)
{
var expectedMessages = new Dictionary <string, IEnumerable <string> >
{
{ "System.IO.DirectoryNotFoundException", new List <string>()
{
"error message 1", "error message 2"
} }
};
if (hasExpectedError)
{
SetupConfiguration(null, null, null, null, false, null, expectedMessages, null, errorCollectorEnabled: true);
}
var expectedException1 = new DirectoryNotFoundException("this is error message 1 ");
var expectedException2 = new DirectoryNotFoundException("this is error message 2 ");
var errorData1 = _errorService.FromException(expectedException1);
var errorData2 = _errorService.FromException(expectedException2);
if (hasExpectedError)
{
Assert.IsTrue(errorData1.IsExpected);
Assert.IsTrue(errorData2.IsExpected);
}
else
{
Assert.IsFalse(errorData1.IsExpected);
Assert.IsFalse(errorData2.IsExpected);
}
}
public Stream DownloadFileContentAsStream(string fileShareName, string fileName = "")
{
CloudFileClient fileClient = new CloudFileClient(fileURI, creds);
// Create a CloudFileClient object for credentialed access to Azure Files.
Stream s = null;
// Get a reference to the file share we created previously.
CloudFileShare share = fileClient.GetShareReference(fileShareName);
// Ensure that the share exists.
if (share.Exists())
{
try
{
// Get a reference to the root directory for the share.
CloudFileDirectory rootDir = share.GetRootDirectoryReference();
CloudFile cloudFile = rootDir.GetFileReference(fileName);
cloudFile.DownloadToStream(s);
return(s);
}
catch (Exception e)
{
throw new StorageAccountException("Error while attempting to get contents", e);
}
}
else
{
DirectoryNotFoundException e = new DirectoryNotFoundException(string.Format("The file share '{0}' does not exist.", fileShareName));
throw new StorageAccountException("Error while attempting to get content", e);
}
}
public static void Ctor_String_Exception()
{
string message = "That page was missing from the directory.";
var innerException = new Exception("Inner exception");
var exception = new DirectoryNotFoundException(message, innerException);
ExceptionHelpers.ValidateExceptionProperties(exception, hResult: HResults.COR_E_DIRECTORYNOTFOUND, innerException: innerException, message: message);
}
private static string GetDirectory(this DirectoryNotFoundException exception)
{
var message = exception.Message;
var beginPos = message.IndexOf('"');
var endPos = message.IndexOf('"', beginPos + 1);
return(Path.GetDirectoryName(message.Substring(beginPos + 1, endPos - beginPos - 1)));
}
private static InvalidRepositoryConfigurationException CreateDirectoryNotFoundException(string directory)
{
var innerException =
new DirectoryNotFoundException(
$"The specified repository in the configuration file was not found: {directory}");
return(CreateInvalidRepositoryConfigurationException(innerException));
}
public ExceptionsCollection()
{
ex[0] = new DivideByZeroException();
ex[1] = new DirectoryNotFoundException();
ex[2] = new ArgumentException();
ex[3] = new MyException("Моё исключение.");
ex[4] = new ArgumentNullException();
}
public void DownloadFileToLocalPath(string fileShareName, string localPath, FileMode mode, string fileName = "")
{
CloudFileClient fileClient = new CloudFileClient(fileURI, creds);
// Create a CloudFileClient object for credentialed access to Azure Files.
// Get a reference to the file share we created previously.
CloudFileShare share = fileClient.GetShareReference(fileShareName);
// Ensure that the share exists.
if (share.Exists())
{
try
{
// Get a reference to the root directory for the share.
CloudFileDirectory rootDir = share.GetRootDirectoryReference();
CloudFile cloudFile = rootDir.GetFileReference(fileName);
switch (mode)
{
case FileMode.Append:
cloudFile.DownloadToFile(localPath, FileMode.Append);
break;
case FileMode.Create:
cloudFile.DownloadToFile(localPath, FileMode.Create);
break;
case FileMode.CreateNew:
cloudFile.DownloadToFile(localPath, FileMode.CreateNew);
break;
case FileMode.Open:
cloudFile.DownloadToFile(localPath, FileMode.Open);
break;
case FileMode.OpenOrCreate:
cloudFile.DownloadToFile(localPath, FileMode.OpenOrCreate);
break;
case FileMode.Truncate:
cloudFile.DownloadToFile(localPath, FileMode.Truncate);
break;
default:
break;
}
}
catch (Exception e)
{
throw new StorageAccountException("Error while attempting to get contents", e);
}
}
else
{
DirectoryNotFoundException e = new DirectoryNotFoundException(string.Format("The file share '{0}' does not exist.", fileShareName));
throw new StorageAccountException("Error while attempting to get content", e);
}
}
internal static NativeMethods.WIN32_FIND_DATA GetExtendedNonRootDirectoryInfo(string path, out Exception exception)
{
exception = null;
NativeMethods.WIN32_FIND_DATA win32_FIND_DATA = default(NativeMethods.WIN32_FIND_DATA);
DirectoryInfo di = null;
exception = MountPointUtil.HandleIOExceptions(delegate
{
di = new DirectoryInfo(path);
});
if (exception != null)
{
return(win32_FIND_DATA);
}
if (!di.Exists)
{
exception = new DirectoryNotFoundException();
return(win32_FIND_DATA);
}
if (di.Parent == null)
{
DiagCore.RetailAssert(false, "An invalid root path was passed in: {0}", new object[]
{
path
});
exception = new IOException(string.Format("An invalid root path was passed in: {0}", path));
return(win32_FIND_DATA);
}
NativeMethods.WIN32_FIND_DATA result;
using (DirectoryEnumerator dirEnum = new DirectoryEnumerator(di.Parent, false, false))
{
bool foundNext = false;
NativeMethods.WIN32_FIND_DATA tempFindData = default(NativeMethods.WIN32_FIND_DATA);
string dirName;
exception = MountPointUtil.HandleIOExceptions(delegate
{
foundNext = dirEnum.GetNextDirectoryExtendedInfo(di.Name, out dirName, out tempFindData);
});
if (exception != null)
{
result = win32_FIND_DATA;
}
else if (!foundNext)
{
exception = new DirectoryNotFoundException();
result = win32_FIND_DATA;
}
else
{
exception = null;
result = tempFindData;
}
}
return(result);
}
private List <FileInfo> GetFilesFromDirectory(DirectoryInfo directory, bool includeSubDirectories)
{
List <FileInfo> fileInfos;
FileInfo[] filesArray = directory.GetFiles("*.*");
List <FileInfo> files = new List <FileInfo>();
FileInfo[] fileInfoArray = filesArray;
for (int i = 0; i < (int)fileInfoArray.Length; i++)
{
FileInfo f = fileInfoArray[i];
try
{
string fullName = f.FullName;
files.Add(f);
}
catch (PathTooLongException pathTooLongException)
{
string[] str = new string[] { "Directory: ", directory.ToString(), " File: ", f.ToString(), " Excluded from selection as path too long " };
Log.WriteLog(string.Concat(str), "Error", this.GetType().Name, this.AppConfig);
}
}
try
{
if (includeSubDirectories)
{
DirectoryInfo[] directories = directory.GetDirectories();
for (int j = 0; j < (int)directories.Length; j++)
{
DirectoryInfo aDirectory = directories[j];
try
{
files.AddRange(this.GetFilesFromDirectory(aDirectory, true));
}
catch
{
}
}
}
fileInfos = files;
}
catch (UnauthorizedAccessException unauthorizedAccessException)
{
UnauthorizedAccessException e = unauthorizedAccessException;
Log.WriteLog(e.Message, "Error", this.GetType().Name, this.AppConfig);
throw e;
}
catch (DirectoryNotFoundException directoryNotFoundException)
{
DirectoryNotFoundException e = directoryNotFoundException;
Log.WriteLog(e.Message, "Error", this.GetType().Name, this.AppConfig);
throw e;
}
return(fileInfos);
}
public bool PosTest1()
{
bool retVal = true;
TestLibrary.TestFramework.BeginScenario("PosTest1: Create a new DirectoryNotFoundException instance.");
try
{
DirectoryNotFoundException myException = new DirectoryNotFoundException();
if (myException==null)
{
TestLibrary.TestFramework.LogError("001.1", "the DirectoryNotFoundException ctor error occurred. ");
retVal = false;
}
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("001.2", "Unexpected exception: " + e);
retVal = false;
}
return retVal;
}
public static void DirectoryNotFoundException_ctor()
{
DirectoryNotFoundException dnfe = new DirectoryNotFoundException();
Utility.ValidateExceptionProperties(dnfe, hResult: HResults.COR_E_DIRECTORYNOTFOUND, validateMessage: false);
}
