/// <summary>
/// The execute.
/// </summary>
/// <param name="executionObject">
/// The execution object.
/// </param>
public static void Execute(ExecutionObject executionObject)
{
Log.Enter(LogInfo.Namespace(MethodBase.GetCurrentMethod()), MethodBase.GetCurrentMethod().Name);
try
{
if (executionObject.ExecutionData.Method.GetCustomAttributesData().Count > 0)
{
foreach (var attributeData in executionObject.ExecutionData.Method.GetCustomAttributesData())
{
executionObject.ExecutionData.AttributeData = attributeData;
if (executionObject.ExecutionData.AttributeData.ConstructorArguments.Count > 0)
{
if (attributeData.ConstructorArguments[0].Value.Equals(executionObject.ExecutionData.SearchedGuid))
{
MethodHandler.Execute(executionObject);
}
}
}
}
else
{
Log.Error(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "No attributeData available");
}
}
catch (Exception exception)
{
Log.Error(LogInfo.Namespace(MethodBase.GetCurrentMethod()), exception.Message);
PCPS.TestAutomation.Common.Tools.Log.Error(LogInfo.Namespace(MethodBase.GetCurrentMethod()), exception.Message);
throw;
}
}
/// <summary>
/// The execute.
/// </summary>
/// <param name="executionObject">
/// The execution object.
/// </param>
public static void Execute(ExecutionObject executionObject)
{
Log.Enter(LogInfo.Namespace(MethodBase.GetCurrentMethod()), MethodBase.GetCurrentMethod().Name);
try
{
if (executionObject.ExecutionData.Assembly.GetTypes().Length > 0)
{
foreach (var type in executionObject.ExecutionData.Assembly.GetTypes())
{
executionObject.ExecutionData.Type = type;
MethodInfoHandler.Execute(executionObject);
}
}
else
{
Log.Error(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "No types available");
}
}
catch (Exception exception)
{
Log.Error(LogInfo.Namespace(MethodBase.GetCurrentMethod()), exception.Message);
PCPS.TestAutomation.Common.Tools.Log.Error(LogInfo.Namespace(MethodBase.GetCurrentMethod()), exception.Message);
throw;
}
}
/// <summary>
/// The relative path to test case.
/// </summary>
/// <param name="basePath">
/// The base path.
/// </param>
/// <param name="fullPath">
/// The full path.
/// </param>
/// <returns>
/// The <see cref="string"/>.
/// </returns>
public static string RelativePathToTestCase(string basePath, string fullPath)
{
Log.Enter(LogInfo.Namespace(MethodBase.GetCurrentMethod()), MethodBase.GetCurrentMethod().Name);
string buffer = fullPath.Replace(basePath, string.Empty);
return(buffer.Remove(0, 1));
}
/// <summary>
/// The create reporting.
/// </summary>
/// <param name="executionObject">
/// The execution object.
/// </param>
public static void CreateReporting(ExecutionObject executionObject)
{
Log.Enter(LogInfo.Namespace(MethodBase.GetCurrentMethod()), MethodBase.GetCurrentMethod().Name);
if (executionObject.TestReportInfos != null)
{
foreach (TestReportInfo testReportInfo in executionObject.TestReportInfos)
{
if (testReportInfo.TestSuiteName.Equals(string.Empty))
{
foreach (TestCaseInfo testCaseInfo in testReportInfo.TestCaseInfos)
{
string relativePathToTestCase = FileNameHandler.RelativePathToTestCase(executionObject.ReportFolderOverview, testCaseInfo.TestCasePathAndName);
Report.LogHtml(testCaseInfo.GetReportLevel(), testCaseInfo.TestCaseResult.ToString(), @"<a href='" + relativePathToTestCase + "'>" + GetTestCaseNameWithoutTimeStamp(testCaseInfo.TestCaseName) + "</a>");
}
}
else
{
Report.Info("Begin of Testsuite: ", testReportInfo.TestSuiteName);
foreach (TestCaseInfo testCaseInfo in testReportInfo.TestCaseInfos)
{
string relativePathToTestCase = FileNameHandler.RelativePathToTestCase(executionObject.ReportFolderOverview, testCaseInfo.TestCasePathAndName);
Report.LogHtml(testCaseInfo.GetReportLevel(), testCaseInfo.TestCaseResult.ToString(), @"<a href='" + relativePathToTestCase + "'>" + GetTestCaseNameWithoutTimeStamp(testCaseInfo.TestCaseName) + "</a>");
}
Report.Info("End of Testsuite: ", testReportInfo.TestSuiteName);
}
}
}
}
/// <summary>
/// The finish reporting.
/// </summary>
/// <param name="executionObject">
/// The execution object.
/// </param>
/// <param name="testCaseInfo">
/// The test Case Info.
/// </param>
public static void FinishReporting(ref ExecutionObject executionObject, ref TestCaseInfo testCaseInfo)
{
Log.Enter(LogInfo.Namespace(MethodBase.GetCurrentMethod()), MethodBase.GetCurrentMethod().Name);
try
{
testCaseInfo.TestCaseName = currentTestCase; // executionObject.TestCaseName;
testCaseInfo.TestCasePath = executionObject.ReportFolderTestCases;
testCaseInfo.TestCaseResult = (TestResult)TestReport.CurrentTestModuleActivity.Status;
executionObject.CurrentTestReportInfo.TestCaseInfos.Add(testCaseInfo);
// Finish testcase logfile
TestReport.EndTestModule();
TestReport.SetCurrentTestResult(testCaseInfo.TestCaseResult);
TestReport.EndTestCase();
TestReport.SetCurrentTestResult(testCaseInfo.TestCaseResult);
TestReport.EndTestCaseSetup();
TestReport.SetCurrentTestResult(testCaseInfo.TestCaseResult);
TestReport.SaveReport();
TestReport.Clear();
}
catch (Exception exception)
{
Log.Enter(LogInfo.Namespace(MethodBase.GetCurrentMethod()), exception.Message);
}
}
/// <summary>
/// The export test result.
/// </summary>
/// <param name="assemblyLocation">
/// The assembly location.
/// </param>
/// <param name="pathToReport">
/// The path to report.
/// </param>
/// <param name="testName">
/// The test name.
/// </param>
/// <param name="dtmStudioTestTempData">
/// The dt mstudio test temp data.
/// </param>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
public bool ExportTestResult(FileInfo assemblyLocation, string pathToReport, string testName, DTMstudioTestData dtmStudioTestTempData)
{
var directory = new DirectoryInfo(assemblyLocation.Directory.FullName);
var result = false;
ResolveEventHandler resolveEventHandler = (s, e) => { return(this.OnResolve(e, directory)); };
AppDomain.CurrentDomain.AssemblyResolve += resolveEventHandler;
Assembly.LoadFrom(assemblyLocation.FullName);
var assemblies = AppDomain.CurrentDomain.GetAssemblies();
var assembly = assemblies.First(a => a.Location == assemblyLocation.FullName);
var instances = from t in assembly.GetTypes() where t.GetInterfaces().Contains(typeof(IExportResultToTestManagement)) && t.GetConstructor(Type.EmptyTypes) != null select Activator.CreateInstance(t) as IExportResultToTestManagement;
foreach (var instance in instances)
{
try
{
result = instance.ExportTestResult(pathToReport, testName, dtmStudioTestTempData);
break;
}
catch (Exception ex)
{
Log.ErrorEx(this, ex, MethodBase.GetCurrentMethod().Name);
return(result);
}
}
AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve -= resolveEventHandler;
return(result);
}
/// <summary>
/// The finish execution.
/// </summary>
/// <param name="testResult">
/// The test Result.
/// </param>
public static void FinishReporting(TestResult testResult)
{
Log.Enter(LogInfo.Namespace(MethodBase.GetCurrentMethod()), MethodBase.GetCurrentMethod().Name);
// Finish testcase logfile
TestReport.EndTestModule();
TestReport.SetCurrentTestResult(testResult);
TestReport.EndTestCase();
TestReport.SetCurrentTestResult(testResult);
TestReport.EndTestCaseSetup();
TestReport.SetCurrentTestResult(testResult);
TestReport.SaveReport();
TestReport.Clear();
}
/// <summary>
/// The prepare reporting.
/// </summary>
/// <param name="executionObject">
/// The execution object.
/// </param>
/// <param name="testSuite">
/// The test suite.
/// </param>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
public static bool PrepareReporting(ExecutionObject executionObject, string testSuite)
{
Log.Enter(LogInfo.Namespace(MethodBase.GetCurrentMethod()), MethodBase.GetCurrentMethod().Name);
if (!Directory.Exists(executionObject.ReportFolderOverview + @"\Temp"))
{
Directory.CreateDirectory(executionObject.ReportFolderOverview + @"\Temp");
}
TestReport.Setup(ReportLevel.Debug, executionObject.ReportPathAndFileOverviewTemp, true);
TestReport.BeginTestSuite(testSuite, executionObject.DtmStudioTestData.DeviceTypeProject.FDTDeviceTypeName);
TestReport.BeginTestCase(testSuite, string.Empty);
TestReport.BeginTestModule("Details");
return(true);
}
/// <summary>
/// The get relative path to overview.
/// </summary>
/// <param name="baseFolder">
/// The base folder.
/// </param>
/// <param name="currentFolder">
/// The current folder.
/// </param>
/// <returns>
/// The <see cref="string"/>.
/// </returns>
public static string GetRelativePathToOverview(string baseFolder, string currentFolder)
{
Log.Enter(LogInfo.Namespace(MethodBase.GetCurrentMethod()), MethodBase.GetCurrentMethod().Name);
string buffer = currentFolder.Replace(baseFolder, string.Empty);
string[] parts = buffer.Split(Convert.ToChar("\\"));
buffer = string.Empty;
foreach (var part in parts)
{
if (part != string.Empty)
{
string value = part;
value = value.Replace(value, "\\..");
buffer = buffer + value;
}
}
buffer = buffer.Remove(0, 1);
return(buffer);
}
/// <summary>
/// The execute new.
/// </summary>
/// <param name="executionObject">
/// The execution object.
/// </param>
/// <returns>
/// The <see cref="ExecutionObject"/>.
/// </returns>
public ExecutionObject Execute(ExecutionObject executionObject)
{
Log.Enter(this, MethodBase.GetCurrentMethod().Name);
if (executionObject != null)
{
// Create a copy from origin
var currentExecutionObject = new ExecutionObject(executionObject);
// Get all available testobjects from testconfiguration (= control document)
TestObjectCollection testObjectCollection = currentExecutionObject.TestConfiguration.AvailableTestObjects;
// More than one testObjectCollection is possible. In fact there´s only one. It´s the top layer in control document.
foreach (var testObject in testObjectCollection)
{
if (testObject is TestCollection)
{
// Add new TestReportInfos without related TestSuites
var testReportInfo = new TestReportInfo(string.Empty);
currentExecutionObject.TestReportInfos.Add(testReportInfo);
currentExecutionObject.CurrentTestReportInfo = testReportInfo;
// Recursvive call
currentExecutionObject.CurrentTestObject = testObject;
currentExecutionObject.ExecutionData.TestMethods = ((TestCollection)testObject).TestObjects;
currentExecutionObject = this.ReadByObject(currentExecutionObject);
}
}
return(currentExecutionObject);
}
Log.Error(this, "ExecutionObject is Null before execution");
PCPS.TestAutomation.Common.Tools.Log.Error(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "ExecutionObject is Null before execution");
Console.WriteLine("ExecutionObject is Null before execution");
return(null);
}
/// <summary>
/// The initialize execution object.
/// </summary>
/// <param name="executionObject">
/// The execution object.
/// </param>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
public static bool InitializeExecutionObject(ExecutionObject executionObject)
{
Log.Enter(LogInfo.Namespace(MethodBase.GetCurrentMethod()), MethodBase.GetCurrentMethod().Name);
string currentDateAndTime = DateTime.Now.ToString("yyyyMMdd_HHmmss");
// Prüfung 1: läuft das Projekt im usprünglichen Verzeichnis.
// => Dann werden die Projektspezifischen Daten verwendet.
// => Unter dem Ordner Report\Output\ werden alle Verzeichnisse und Dateien abgelegt
// Alternative:
// => Aktuelles Ausführungsverzeichnis wird ermittelt
// => Unter dem Ordner Report\Output\ werden alle Verzeichnisse und Dateien abgelegt
// DONE
// Prüfung 2: ist der Pfad für die Ausgabe absolut?
// => Dann geschieht die komplette Ausgabe in diesem Verzeichnis.
// => Verzeichnisse müssen vorbereitend angepasst werden.
// Alternative:
// => Unter dem Ordner Report\Output\ werden alle Verzeichnisse und Dateien abgelegt
// DONE
// Prüfung 3: hat der Pfad eine gültige Länge und lässt er noch x Zeichen übrig?
// => Es geht normal weiter
// Alternative:
// Die Programausführung wird mit einem Hinweis auf die Pfadlänge abgebrochen.
ReportHelper.ReportPath = executionObject.DtmStudioTestData.DeviceTypeTestProject.ReportOutputPath;
if (!ReportHelper.ReportPath.Contains(":"))
{
if (executionObject.DtmStudioTestData.DeviceTypeTestProject.ExecutionPath != null)
{
// Normierung des ReportOutputPath => Entfernen von führenden und nachfolgenden "\"
executionObject.DtmStudioTestData.DeviceTypeTestProject.ReportOutputPath = RemoveFromFirstAndLastPosition(executionObject.DtmStudioTestData.DeviceTypeTestProject.ReportOutputPath, @"\");
executionObject.ReportFolderOverview = executionObject.DtmStudioTestData.DeviceTypeTestProject.ExecutionPath + @"\" + executionObject.DtmStudioTestData.DeviceTypeTestProject.ReportOutputPath + @"\" + currentDateAndTime;
executionObject.ReportFolderTestCases = executionObject.ReportFolderOverview + @"\" + executionObject.DtmStudioTestData.DeviceTypeTestProject.Name;
executionObject.ReportNameOverview = currentDateAndTime + @"_" + executionObject.DtmStudioTestData.DeviceTypeTestProject.Name + executionObject.FileExtension;
executionObject.ReportPathAndFileOverview = executionObject.ReportFolderOverview + @"\" + executionObject.ReportNameOverview;
executionObject.ReportPathAndFileOverviewTemp = executionObject.ReportFolderOverview + @"\Temp\" + executionObject.ReportNameOverview;
ReportHelper.ReportPath = executionObject.ReportFolderOverview;
// Main Report folder consists of path to reports and current target sub folder
if (Directory.Exists(executionObject.ReportFolderOverview) == false)
{
Directory.CreateDirectory(executionObject.ReportFolderOverview);
}
}
}
else
{
executionObject.ReportFolderOverview = executionObject.DtmStudioTestData.DeviceTypeTestProject.ReportOutputPath + currentDateAndTime;
executionObject.ReportFolderTestCases = executionObject.ReportFolderOverview + @"\" + executionObject.DtmStudioTestData.DeviceTypeTestProject.Name;
executionObject.ReportNameOverview = currentDateAndTime + @"_" + executionObject.DtmStudioTestData.DeviceTypeTestProject.Name + executionObject.FileExtension;
executionObject.ReportPathAndFileOverview = executionObject.ReportFolderOverview + @"\" + executionObject.ReportNameOverview;
executionObject.ReportPathAndFileOverviewTemp = executionObject.ReportFolderOverview + @"\Temp\" + executionObject.ReportNameOverview;
}
// Check for reportFileName length
if (executionObject.ReportPathAndFileOverview.Length > ConstLenghts.MaxPathLengthByOperatingSystem)
{
string caption = "Error: Project path is too long.";
string message = "Problem:\t Project path is to long. ReportFileName [" + executionObject.ReportPathAndFileOverview + "] has more than " + ConstLenghts.MaxPathLengthByOperatingSystem + " charakters (" + executionObject.ReportPathAndFileOverview.Length + "). \n\nSolution: \tPlease copy ControlDocument from this project into a new project with a shorter project path.\n\nTest will be aborted!";
Console.ForegroundColor = ConsoleColor.Magenta;
Console.Write(message);
Console.ResetColor();
System.Windows.Forms.MessageBox.Show(message, caption);
return(false);
}
return(true);
}
/// <summary>
/// Executes the invoke for a method depending it´s number of parameters
/// </summary>
/// <param name="executionObject">
/// The execution object.
/// </param>
public static void Execute(ExecutionObject executionObject)
{
Log.Enter(LogInfo.Namespace(MethodBase.GetCurrentMethod()), MethodBase.GetCurrentMethod().Name);
try
{
if (executionObject.ExecutionData.Method.GetParameters().Length > 0)
{
if (executionObject.ExecutionData.Parameters.Count == executionObject.ExecutionData.Method.GetParameters().Length)
{
var parameterObjects = new object[executionObject.ExecutionData.Parameters.Count];
parameterObjects.Initialize();
for (var index = 0; index < executionObject.ExecutionData.Parameters.Count; index++)
{
var parameterType = executionObject.ExecutionData.Parameters[index].ParameterType;
switch (parameterType)
{
case "System.Int32":
{
Log.Info(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Return: System.Int32");
parameterObjects[index] = int.Parse(executionObject.ExecutionData.Parameters[index].ParameterValue);
break;
}
case "System.Single":
{
Log.Info(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Return: System.Single");
parameterObjects[index] = float.Parse(executionObject.ExecutionData.Parameters[index].ParameterValue);
break;
}
case "System.String":
{
Log.Info(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Return: System.String");
parameterObjects[index] = executionObject.ExecutionData.Parameters[index].ParameterValue;
break;
}
case "System.Boolean":
{
Log.Info(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Return: System.Boolean");
parameterObjects[index] = bool.Parse(executionObject.ExecutionData.Parameters[index].ParameterValue);
break;
}
default:
Log.Error(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "EH.DTMstudioTest.TestScriptEngine.Execution.MethodHandler: Unknown type " + parameterType + " for cast.");
break;
}
}
executionObject.ExecutionData.Method.Invoke(null, parameterObjects);
// Cleanup
executionObject.ExecutionData.Parameter = null;
}
else
{
PCPS.TestAutomation.Common.Tools.Log.Failure(LogInfo.Namespace(MethodBase.GetCurrentMethod()), string.Format("Number of parameters from control document and expected number of parameters are not equal. Please contact developer. TestCase: [{0}]", executionObject.TestCaseName));
}
}
else
{
executionObject.ExecutionData.Method.Invoke(null, null);
}
}
catch (Exception exception)
{
Log.Error(LogInfo.Namespace(MethodBase.GetCurrentMethod()), exception.Message);
PCPS.TestAutomation.Common.Tools.Log.Error(LogInfo.Namespace(MethodBase.GetCurrentMethod()), exception.Message);
throw;
}
}
/// <summary>
/// The prepare reporting.
/// </summary>
/// <param name="executionObject">
/// The execution object.
/// </param>
/// <returns>
/// The <see cref="string"/>.
/// </returns>
public static string PrepareReporting(ref ExecutionObject executionObject)
{
Log.Enter(LogInfo.Namespace(MethodBase.GetCurrentMethod()), MethodBase.GetCurrentMethod().Name);
if (!Directory.Exists(executionObject.ReportFolderTestCases))
{
Directory.CreateDirectory(executionObject.ReportFolderTestCases);
}
var currentDateAndTime = DateTime.Now.ToString("yyyyMMdd_HHmmss");
// currentTestCase contains the current testcase namen + date-time-stamp
currentTestCase = currentDateAndTime + "_" + executionObject.TestCaseName;
// filename contains the whole path
// it´s number of characters must be less then 255-5 (5 from .data by creating the file)
var fileName = executionObject.ReportFolderTestCases + @"\" + currentTestCase;
var testCasePathAndFile = fileName + executionObject.FileExtension; // originFileName;
// check path length of all parts
// Check path length for creating ranorex report
// if ranorexReportLength > 92
// shorten name of ranorex report
// log info about shortening ranorexReport
// if completePathLength > 250
// shorten name of ranorex report
// log info about shortening ranorexReport
// if shortenig is not enought
// log info about ranorexReport which wont be available due path length issues
try
{
string testSuiteName = executionObject.CurrentTestReportInfo.TestSuiteName;
// Check currentTestCase length if filename is too long for ranorex setup function.
// If filename is too long, cut of characters for valid number of characters.
int currentTestCaseLength = currentTestCase.Length;
if (currentTestCaseLength > ConstLenghts.MaxFileLengthByRanorex)
{
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine("TestCaseName [" + currentTestCase + "] has more than " + ConstLenghts.MaxFileLengthByRanorex + " (" + currentTestCaseLength.ToString(CultureInfo.InvariantCulture) + ") characters and has been reduced to a valid length.");
Console.ResetColor();
currentTestCase = currentTestCase.Remove(ConstLenghts.MaxFileLengthByRanorex, currentTestCaseLength - ConstLenghts.MaxFileLengthByRanorex);
testCasePathAndFile = executionObject.ReportFolderTestCases + @"\" + currentTestCase + executionObject.FileExtension;
currentTestCaseLength = currentTestCase.Length;
}
// Check reportFileName length if path is too long for file system.
// If filename is too long and if it is possible to cut of characters from currentTestCase filename
// cut of characters for valid number of characters.
int reportFileNameLength = testCasePathAndFile.Length;
if (reportFileNameLength > ConstLenghts.MaxPathLengthForTempararyPostfix)
{
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine("ReportFileName [" + testCasePathAndFile + "] has more than " + (ConstLenghts.MaxPathLengthByOperatingSystem - 1) + " (" + testCasePathAndFile.Length + ") characters.");
Console.ResetColor();
int availableCharacters = ConstLenghts.MaxPathLengthForTempararyPostfix - reportFileNameLength + currentTestCaseLength;
// Shorten currentTestCase name to the length of available characters
if (availableCharacters - DateTimeLength - executionObject.FileExtension.Length > 0)
{
currentTestCase = currentTestCase.Remove(availableCharacters, currentTestCaseLength - availableCharacters);
testCasePathAndFile = executionObject.ReportFolderTestCases + @"\" + currentTestCase + executionObject.FileExtension;
reportFileNameLength = testCasePathAndFile.Length;
}
else
{
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine("ReportFileName [" + testCasePathAndFile + "] could not be trimmed. There are less characters left for a filename with a length of one character + file extension.");
Console.ResetColor();
}
}
if (reportFileNameLength > ConstLenghts.MaxPathLengthForTempararyPostfix)
{
// Create Report Object
executionObject.CurrentTestCaseInfo.TestCaseName = currentTestCase + ": The TestCaseReport [" + currentTestCase + "] is not available due to exceeded path length = " + testCasePathAndFile.Length.ToString(CultureInfo.InvariantCulture) + ".";
executionObject.CurrentTestCaseInfo.TestCasePath = string.Empty;
executionObject.CurrentTestCaseInfo.TestCaseResult = TestResult.Failed;
executionObject.CurrentTestReportInfo.TestCaseInfos.Add(executionObject.CurrentTestCaseInfo);
}
else
{
TestReport.Setup(ReportLevel.Debug, testCasePathAndFile, true);
TestReport.BeginTestSuite(executionObject.CurrentTestCase.DisplayName, testSuiteName);
TestReport.BeginTestCase(executionObject.CurrentTestCase.DisplayName);
TestReport.BeginTestModule("Details");
string backToOverview = FileNameHandler.GetRelativePathToOverview(executionObject.ReportFolderOverview, executionObject.ReportFolderTestCases);
backToOverview = backToOverview + @"\" + executionObject.ReportNameOverview;
Report.LogHtml(ReportLevel.Debug, string.Empty, @"<a href='" + backToOverview + "'>" + @"Back to Overview" + "</a>");
}
}
catch (Exception exception)
{
Log.Enter(LogInfo.Namespace(MethodBase.GetCurrentMethod()), exception.Message);
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine(LogInfo.Namespace(MethodBase.GetCurrentMethod()) + ": " + exception.Message);
Console.ResetColor();
}
return(testCasePathAndFile);
}
/// <summary>
/// Recursive method to read by object.
/// </summary>
/// <param name="executionObject">
/// The execution object.
/// </param>
/// <returns>
/// The <see cref="ExecutionObject"/>.
/// </returns>
private ExecutionObject ReadByObject(ExecutionObject executionObject)
{
Log.Enter(this, MethodBase.GetCurrentMethod().Name);
if (executionObject != null)
{
var currentExecutionObject = new ExecutionObject(executionObject);
foreach (var testObject in currentExecutionObject.ExecutionData.TestMethods)
{
if (testObject.GetType() == typeof(TestSuite))
{
// Add new TestReportInfos with related TestSuiteName
var testReportInfo = new TestReportInfo(testObject.DisplayName);
currentExecutionObject.TestReportInfos.Add(testReportInfo);
currentExecutionObject.CurrentTestReportInfo = testReportInfo;
// Recursvive call
currentExecutionObject.CurrentTestObject = testObject;
currentExecutionObject.ExecutionData.TestMethods = ((TestCollection)testObject).TestObjects;
currentExecutionObject = this.ReadByObject(currentExecutionObject);
}
else if (testObject.GetType() == typeof(TestFolder) && testObject.Parent.GetType() == typeof(TestSuite))
{
// Recursvive call
currentExecutionObject.CurrentTestObject = testObject;
currentExecutionObject.ExecutionData.TestMethods = ((TestCollection)testObject).TestObjects;
currentExecutionObject = this.ReadByObject(currentExecutionObject);
}
else if (testObject.GetType() == typeof(TestFolder) && testObject.Parent.GetType() != typeof(TestSuite) && testObject.Parent != null)
{
string targetFolder = currentExecutionObject.ReportFolderTestCases;
if (!Directory.Exists(targetFolder))
{
Directory.CreateDirectory(targetFolder);
}
// Add new TestReportInfos without related TestSuites
var testReportInfo = new TestReportInfo(string.Empty);
currentExecutionObject.TestReportInfos.Add(testReportInfo);
currentExecutionObject.CurrentTestReportInfo = testReportInfo;
// Recursvive call
currentExecutionObject.CurrentTestObject = testObject;
currentExecutionObject.ExecutionData.TestMethods = ((TestCollection)testObject).TestObjects;
currentExecutionObject = this.ReadByObject(currentExecutionObject);
}
else if (testObject.GetType() == typeof(TestCase))
{
this.reportFileName = string.Empty;
try
{
currentExecutionObject.TestCaseName = testObject.DisplayName;
currentExecutionObject.CurrentTestCase = (TestCase)testObject;
/* Manipulation der Ausgabe bevor der Bericht abgeschlossen ist, weil die Ausführung
* abgebrochen werden können soll, ohne dass dabei die neue Formatierung "vergessen" wird.
* Neue Styles ersetzen die Ranorex Styles */
this.reportFileName = TestCaseReportHandler.PrepareReporting(ref currentExecutionObject);
InfrastructureHandler.ManipulateDetailReportLayout(this.reportFileName);
InfrastructureHandler.ReplaceReportStyleSheet(this.reportFileName, "EHReportDetails");
string source = Path.Combine(currentExecutionObject.DtmStudioTestData.DeviceTypeTestProject.ExecutionPath, "Report");
string target = currentExecutionObject.ReportFolderTestCases;
const string FileName = "EHReportDetails";
InfrastructureHandler.CopyCustomizedReportDefaultStyle(source, target, FileName);
InfrastructureHandler.DeleteRanorexStyle(currentExecutionObject.ReportFolderTestCases);
InfrastructureHandler.InsertHTMLCodeToReport(Path.Combine(currentExecutionObject.ReportFolderTestCases, "EHReportDetails.xsl"), currentExecutionObject.DtmStudioTestData.DeviceTypeProject.DeviceFunctions, currentExecutionObject.DtmStudioTestData.ReportData.FirmwareInformation.AdditionalInformation);
// Ende des Kommentars
if (testObject.IsActive)
{
Log.Info(this, "Execute active Testobject -> TestCase");
TestObjectHandler.Execute(currentExecutionObject, testObject.Guid);
}
else
{
Log.Info(this, "Log inactive Testobject -> TestCase");
TestReport.SetCurrentTestResult(TestResult.Skipped);
}
}
catch (Exception exception)
{
Log.ErrorEx(this, exception, "A Critical Error Occured");
Console.WriteLine("A Critical Error Occured: " + exception.Message);
TestReport.SetCurrentTestResult(TestResult.Failed);
}
finally
{
var testCaseInfo = new TestCaseInfo();
TestCaseReportHandler.FinishReporting(ref currentExecutionObject, ref testCaseInfo);
currentExecutionObject.DtmStudioTestData.ReportData.ResultOfTest = testCaseInfo.TestCaseResult.ToString();
// Nachbearbeitung notwendig, da Ranorex mit jedem Schritt die Styledaten neu hineinkopiert
InfrastructureHandler.InsertReportData(testCaseInfo.TestCasePathAndName, currentExecutionObject.DtmStudioTestData);
InfrastructureHandler.ManipulateDetailReportLayout(this.reportFileName);
InfrastructureHandler.ReplaceReportStyleSheet(this.reportFileName, "EHReportDetails");
InfrastructureHandler.DeleteRanorexStyle(currentExecutionObject.ReportFolderTestCases);
InfrastructureHandler.InsertHTMLCodeToReport(Path.Combine(currentExecutionObject.ReportFolderTestCases, "EHReportDetails.xsl"), currentExecutionObject.DtmStudioTestData.DeviceTypeProject.DeviceFunctions, currentExecutionObject.DtmStudioTestData.ReportData.FirmwareInformation.AdditionalInformation);
// Ende des Kommentars
// Datenbank Aufruf
InfrastructureHandler.ExportTestResult(testCaseInfo.TestCasePathAndName, currentExecutionObject.TestCaseName, currentExecutionObject.DtmStudioTestData);
}
}
else
{
Log.Info(this, "Unhandled Type: " + typeof(TestObject));
Console.WriteLine("Unhandled Type:" + typeof(TestObject));
}
}
return(currentExecutionObject);
}
Log.Error(this, "ExecutionObject is Null before execution");
Console.WriteLine("ExecutionObject is Null before execution");
return(null);
}
/// <summary>
/// The get test case name without time stamp.
/// </summary>
/// <param name="testCaseName">
/// The test case name.
/// </param>
/// <returns>
/// The <see cref="string"/>.
/// </returns>
private static string GetTestCaseNameWithoutTimeStamp(string testCaseName)
{
Log.Enter(LogInfo.Namespace(MethodBase.GetCurrentMethod()), MethodBase.GetCurrentMethod().Name);
return(testCaseName.Remove(0, 16));
}
/// <summary>
/// The get methods infos.
/// </summary>
/// <param name="directoryName">
/// The directory name.
/// </param>
/// <param name="assemblyFileName">
/// The assembly file name.
/// </param>
/// <returns>
/// The <see cref="EhMethodInfo"/>.
/// </returns>
internal EhMethodInfoCollection GetTestScriptInformationMethodsInfos(string directoryName, string assemblyFileName)
{
var methodInfos = new EhMethodInfoCollection();
var directory = new DirectoryInfo(directoryName);
ResolveEventHandler resolveEventHandler = (s, e) => { return(this.OnReflectionOnlyResolve(e, directory)); };
AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve += resolveEventHandler;
Assembly reflectionOnlyAssembly = AppDomain.CurrentDomain.ReflectionOnlyGetAssemblies().First();
foreach (Type type in reflectionOnlyAssembly.GetTypes())
{
try
{
ObjectHandle oh = Activator.CreateInstanceFrom(assemblyFileName, type.ToString());
object o = oh.Unwrap();
Type to = o.GetType();
foreach (var methodInfo in to.GetMethods())
{
var customAttributes = methodInfo.GetCustomAttributes(false);
if (customAttributes.Length > 0)
{
foreach (var customAttribut in customAttributes)
{
if (customAttribut is TestScriptInformation)
{
var ehMethodInfo = new EhMethodInfo();
ehMethodInfo.ParameterInfo = this.GetParameterInfos(methodInfo);
ehMethodInfo.CustomAttributGuid = (customAttribut as TestScriptInformation).Guid;
ehMethodInfo.CustomAttributTestDefinition = (customAttribut as TestScriptInformation).TestDefinition.ToString();
ehMethodInfo.CustomAttributTestScript = (customAttribut as TestScriptInformation).TestScript;
ehMethodInfo.MethodFullName = methodInfo.DeclaringType.FullName;
// ehMethodInfo.AssemblyFullPath = methodInfo.DeclaringType.Assembly.Location;
ehMethodInfo.AssemblyFullPath = assemblyFileName;
ehMethodInfo.MethodName = methodInfo.Name;
ehMethodInfo.MethodDisplayName = this.GetDisplayName(methodInfo);
ehMethodInfo.Namespace = methodInfo.DeclaringType.Namespace;
ehMethodInfo.ClassName = methodInfo.ReflectedType.Name;
ehMethodInfo.MemberType = methodInfo.MemberType.ToString();
methodInfos.Add(ehMethodInfo);
}
}
}
}
}
catch (Exception ex)
{
Log.ErrorEx(this, ex, MethodBase.GetCurrentMethod().Name);
string test = string.Empty;
}
}
AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve -= resolveEventHandler;
return(methodInfos);
}
/// <summary>
/// The execute.
/// </summary>
/// <param name="executionObject">
/// The execution object.
/// </param>
/// <param name="guid">
/// The guid.
/// </param>
public static void Execute(ExecutionObject executionObject, string guid)
{
Log.Enter(LogInfo.Namespace(MethodBase.GetCurrentMethod()), MethodBase.GetCurrentMethod().Name);
try
{
TestObject testObject = executionObject.TestConfiguration.GetTestObject(executionObject.TestConfiguration.AvailableTestObjects, guid);
if (testObject != null)
{
executionObject.ExecutionData.Parameters = executionObject.TestConfiguration.GetTestObjectParameters(testObject);
executionObject.CurrentTestCase = testObject as TestCase;
if (executionObject.CurrentTestCase != null)
{
if (executionObject.ExecutionData.ParentGuid == null)
{
executionObject.ExecutionData.ParentGuid = executionObject.CurrentTestCase.Parent.Guid;
executionObject.ExecutionData.TestSuiteBaseFolder = executionObject.ReportFolderOverview;
}
if (!string.Equals(executionObject.ExecutionData.ParentGuid, executionObject.CurrentTestCase.Parent.Guid))
{
executionObject.ExecutionData.ParentGuid = executionObject.CurrentTestCase.Parent.Guid;
executionObject.ExecutionData.TestSuiteBaseFolder = executionObject.ReportFolderOverview;
}
executionObject.ExecutionData.AssemblyName = executionObject.CurrentTestCase.AssemblyName;
executionObject.ExecutionData.SearchedGuid = executionObject.CurrentTestCase.AssemblyMethodRefId;
// ToDo: Der Pfad muss auf etwas Konfigurierbares angepasst werden
// Wird die TestLibrary verwendet, muss auf das Installationsverzeichnis referenziert werden
// Wird die UserDefined verwendet, muss auf das entsprechende Verzeichnis referenziert werden
// try path to installed testframework
string pathToAssembly = ConfiguratorDialog.SelectedConfiguration.TestFramework.PathToAssemblies + @"\" + executionObject.ExecutionData.AssemblyName;
if (!File.Exists(pathToAssembly))
{
// try path to userdefined assembly within running project
pathToAssembly = Directory.GetCurrentDirectory() + @"\" + executionObject.ExecutionData.AssemblyName;
if (!File.Exists(pathToAssembly))
{
Exception exception = new Exception("Assembly " + executionObject.ExecutionData.AssemblyName + "not found.");
Log.Error(LogInfo.Namespace(MethodBase.GetCurrentMethod()), exception.Message);
throw exception;
}
}
executionObject.ExecutionData.Assembly = Assembly.LoadFrom(pathToAssembly);
if (executionObject.ExecutionData.Assembly != null)
{
TypeHandler.Execute(executionObject);
}
}
}
}
catch (Exception exception)
{
Log.Error(LogInfo.Namespace(MethodBase.GetCurrentMethod()), exception.Message);
PCPS.TestAutomation.Common.Tools.Log.Error(LogInfo.Namespace(MethodBase.GetCurrentMethod()), exception.Message);
throw;
}
}
