//Overloads public override void Fail(string message, string details) { //Handle the assert, treat it as an error. Exception e = new TestException(TestResult.Assert, message, details, null, null); e.Source = "Debug.Assert"; //Note: We don't throw the exception (by default), since we want to continue on Asserts //(as many of them are benign or simply a valid runtime error). if (this.ShouldThrow) { throw e; } StackTrace stack = new StackTrace(); TestLog.Error(TestResult.Assert, details, null, "Debug.Assert", message, stack.ToString(), null, 0); }
public TestModule(string name, string desc) : base(name, desc, TestType.TestModule) { this.Guid = GetType().ToString(); //Population //DetermineChildren(); try { DetermineIncludes(); DetermineFilters(); } catch (Exception e) { //Don't completely block construction, otherwise it won't be able to be loaded from COM TestLog.HandleException(e); } }
public static bool Warning(object actual, object expected, string message, Exception inner) { //See if these are equal bool equal = InternalEquals(actual, expected); if (equal) { return(true); } try { throw new TestWarningException(message, actual, expected, inner); } catch (Exception e) { //Warning should continue - not halt test progress TestLog.HandleException(e); return(false); } }
public ITestItem CreateTest(String assembly, String type) { try { // this.Log = new LtmContext() as ITestLog; // this.Properties = new LtmContext() as ITestProperties; //Create an instance //Note: Assembly.CreateInstance returns null for type not found TestModule test = (TestModule)Assembly.LoadFrom(assembly).CreateInstance(type); if (test == null) { throw new TypeLoadException( String.Format("Unable to find type: '{0}' in assembly: '{1}'", type, assembly) ); } return(test); } catch (Exception e) { TestLog.HandleException(e); throw new TestFailedException(e.Message, null, null, e); } }
public override void Write(string text) { //Delegate TestLog.Write(pflags, text); }
protected virtual TestResult HandleException(Exception e) { //Note: override this if your product has specilized exceptions (ie: nesting or collections) //that you need to recurse over of print out differently return(TestLog.HandleException(e)); }
TestResult ITestItem.Terminate() { //Enter OnEnter(TestMethod.Terminate); TestResult result = TestResult.Passed; //NOTE: Since exceptions are a way-of-life in C#, and the fact that they are just //caught by the runtime before passed back to LTM, we lose the entire stack and just //an unknown error code is returned. //To help solve this we will wrap the call in a try catch and actually //log the exception to the LTM output window... try { //Skipped if (this.Skipped || !this.Implemented) { result = TestResult.Skipped; } else { this.Terminate(); } //Before exiting make sure we reset our CurChild to null, to prevent incorrect uses if (Parent != null) { Parent.CurrentChild = null; } } catch (Exception e) { HandleException(e); } try { //Clear any previous existing info (in the static class). if (_testtype == TestType.TestModule) { //Note: We actually have to clear these "statics" since they are not cleaned up //until the process exits. Which means that if you run again, in an apartment model //thread it will try to release these when setting them which is not allowed to //call a method on an object created in another apartment TestInput.Dispose(); TestLog.Dispose(); } } catch (Exception e) { result = HandleException(e); } //This is also a good point to hint to the GC to free up any unused memory //at the end of each TestCase and the end of each module. GC.Collect(); GC.WaitForPendingFinalizers(); //Leave OnLeave(TestMethod.Terminate); return(result); }
public static TestResult HandleException(Exception e) { TestResult result = TestResult.Failed; Exception inner = e; //If reflection was used check for test skipped/passed exception while (inner is TargetInvocationException) { inner = inner.InnerException; } if (!(inner is TestException) || ((inner as TestException).Result != TestResult.Skipped && (inner as TestException).Result != TestResult.Passed && (inner as TestException).Result != TestResult.Warning)) { inner = e; //start over so we do not loose the stack trace } while (inner != null) { //Need to handle Loader exceptions seperatly if (inner is ReflectionTypeLoadException) { //Recurse foreach (Exception loaderexception in ((ReflectionTypeLoadException)inner).LoaderExceptions) { HandleException(loaderexception); } } //Source String source = inner.Source; //Message String message = inner.Message; if (inner != e) { message = "Inner Exception -> " + message; } //Expected / Actual Object actual = inner.GetType(); Object expected = null; String details = inner.StackTrace; String filename = null; int line = 0; if (inner is TestException) { TestException testinner = (TestException)inner; //Setup more meaningful info actual = testinner.Actual; expected = testinner.Expected; result = testinner.Result; switch (result) { case TestResult.Passed: case TestResult.Skipped: WriteLine(message); return(result); //were done } ; } //Log TestLog.Error(result, actual, expected, source, message, details, filename, line); //Next inner = inner.InnerException; } return(result); }