Exemplo n.º 1
0
        /// <summary>
        /// Runs the test and returns the result xml.
        /// </summary>
        /// <returns></returns>
        public XElement RunTestCase(TestCaseMetadata metadata)
        {
            ManagedTestCase testCase   = null;
            object          testObject = null;

            try
            {
                testCase   = Controller.CreateManagedTestCase(metadata);
                testObject = testCase.CreateNewTestObject();
            }
            catch (Exception ex)
            {
                if (ex is TargetInvocationException)
                {
                    ex = ((TargetInvocationException)ex).InnerException;
                }

                throw new Exception("Unit test threw exception while creating test class.", ex);
            }

            // Exec the unit test
            MethodInfo unitTestMethod = testCase.Method;

            object[] unitTestArgs = testCase.Arguments;
            try
            {
                Invoke(testCase, testObject, unitTestMethod, unitTestArgs, testCase.DisplayNameWithArgs);
                if (testCase.ExpectedExceptionType != null)
                {
                    string errMsg = AssertMessagesUtil.FormatAssertionMessage_ExpectedExceptionNotThrown(testCase);
                    return(TestResultUtil.CreateXTestResult(TestResultType.AssertFailure, errMsg, null));
                }
            }
            catch (Exception ex)
            {
                if (ex is TargetInvocationException)
                {
                    ex = ((TargetInvocationException)ex).InnerException;
                }
                Type exType = ex.GetType();

                // Detect expected exceptions and handle Assert exceptions
                if (testCase.ExpectedExceptionType == null || !testCase.ExpectedExceptionType.IsAssignableFrom(exType))
                {
                    // Handle special UnitTest exceptions
                    if (ex is ConcurrencyUnitTestException)
                    {
                        // Pre-defined exceptions can just pass up their messages
                        if (ex is AssertFailedException)
                        {
                            return(TestResultUtil.CreateXTestResult(TestResultType.AssertFailure, ex.Message, ex));
                        }
                        else if (ex is AssertInconclusiveException)
                        {
                            return(TestResultUtil.CreateXTestResult(TestResultType.Inconclusive, ex.Message, ex));
                        }

#if DEBUG
                        // If there's another ex type that we've defined in the framework but haven't handled
                        // by the prev conditions lets warn the developer.
                        Type cutExType = typeof(ConcurrencyUnitTestException);
                        if (exType != cutExType && exType.Assembly.FullName == cutExType.Assembly.FullName)
                        {
                            System.Diagnostics.Trace.TraceWarning("Unhandled ConcurrencyUnitTestException derived type in the CUT assembly: " + exType.Name + ". Custom handling should be added here.");
                        }
#endif

                        // If not a built in exception, then use the regular handling below.
                    }

                    // If not an assert, then it's an unexpected exception
                    if (testCase.ExpectedExceptionType == null)
                    {
                        string errMsg = AssertMessagesUtil.FormatAssertionMessage_UnExpectedExceptionThrown(testCase, ex);
                        // Write the exception to the trace log so a debugger can see it.
                        System.Diagnostics.Trace.TraceError(errMsg + Environment.NewLine + "Stack Trace: " + ex.StackTrace);
                        return(TestResultUtil.CreateXTestResult(TestResultType.Exception, errMsg, ex));
                    }
                    else // Then the exception isn't what's expected
                    {
                        string errMsg = AssertMessagesUtil.FormatAssertionMessage_ExceptionOfWrongTypeThrown(testCase, ex);
                        // Write the exception to the trace log so a debugger can see it.
                        System.Diagnostics.Trace.TraceError(errMsg + Environment.NewLine + "Stack Trace: " + ex.StackTrace);
                        return(TestResultUtil.CreateXTestResult(TestResultType.AssertFailure, errMsg, ex));
                    }
                }
                // else - The exception was expected, so the test succedded, keep going
            }

            return(TestResultUtil.CreateXTestResult(TestResultType.Passed, null, null));
        }
Exemplo n.º 2
0
        private void do_run()
        {
            if (runUnitTest)
            {
                object testObject = null;
                try
                {
                    testObject = unitTestCase.CreateNewTestObject();
                }
                catch (Exception ex)
                {
                    if (ex is TargetInvocationException)
                    {
                        ex = ((TargetInvocationException)ex).InnerException;
                    }

                    ReportErrorAndExit("Unit test threw exception while creating test class.", ChessExitCode.TestFailure, true, ex);
                }

                // Exec the unit test
                MethodInfo unitTestMethod = unitTestCase.Method;
                object[]   unitTestArgs   = unitTestCase.Arguments;
                try
                {
                    unitTestMethod.Invoke(testObject, unitTestArgs);
                    if (unitTestCase.ExpectedExceptionType != null)
                    {
                        string errMsg = AssertMessagesUtil.FormatAssertionMessage_ExpectedExceptionNotThrown(unitTestCase);
                        ReportErrorAndExit(errMsg, ChessExitCode.UnitTestAssertFailure, true, null);
                    }
                }
                catch (Exception ex)
                {
                    if (ex is TargetInvocationException)
                    {
                        ex = ((TargetInvocationException)ex).InnerException;
                    }
                    Type exType = ex.GetType();

                    // Detect expected exceptions and handle Assert exceptions
                    if (unitTestCase.ExpectedExceptionType == null || !unitTestCase.ExpectedExceptionType.IsAssignableFrom(exType))
                    {
                        // Handle special UnitTest exceptions
                        if (ex is ConcurrencyUnitTestException)
                        {
                            // Pre-defined exceptions can just pass up their messages
                            if (ex is AssertFailedException)
                            {
                                ReportErrorAndExit(ex.Message, ChessExitCode.UnitTestAssertFailure, true, ex);
                            }
                            else if (ex is AssertInconclusiveException)
                            {
                                ReportErrorAndExit(ex.Message, ChessExitCode.UnitTestAssertInconclusive, true, ex);
                            }

#if DEBUG
                            // If there's another ex type that we've defined in the framework but haven't handled
                            // by the prev conditions lets warn the developer.
                            Type cutExType = typeof(ConcurrencyUnitTestException);
                            if (exType != cutExType && exType.Assembly.FullName == cutExType.Assembly.FullName)
                            {
                                Trace.TraceWarning("Unhandled ConcurrencyUnitTestException derived type in the CUT assembly: " + exType.Name + ". Custom handling should be added here.");
                            }
#endif

                            // If not a built in exception, then use the regular handling below.
                        }

                        // If not an assert, then it's an unexpected exception
                        if (unitTestCase.ExpectedExceptionType == null)
                        {
                            string errMsg = AssertMessagesUtil.FormatAssertionMessage_UnExpectedExceptionThrown(unitTestCase, ex);
                            // Write the exception to the trace log so a debugger can see it.
                            Trace.TraceError(errMsg + Environment.NewLine + "Stack Trace: " + ex.StackTrace);
                            ReportErrorAndExit(errMsg, ChessExitCode.UnitTestException, true, ex);
                        }
                        else // Then the exception isn't what's expected
                        {
                            string errMsg = AssertMessagesUtil.FormatAssertionMessage_ExceptionOfWrongTypeThrown(unitTestCase, ex);
                            // Write the exception to the trace log so a debugger can see it.
                            Trace.TraceError(errMsg + Environment.NewLine + "Stack Trace: " + ex.StackTrace);
                            ReportErrorAndExit(errMsg, ChessExitCode.UnitTestAssertFailure, true, ex);
                        }
                    }
                    // else - The exception was expected, so the test succeeded, keep going
                }
            }
            else
            {
                // Old code for when using the ChessTest class
                try
                {
                    if (!(bool)run.Invoke(null, null))
                    {
                        if (!manager.BreakDeadlockMode)
                        {
                            ReportErrorAndExit(testclass + ".Run returned false.", ChessExitCode.TestFailure, true, null);
                        }
                    }
                }
                catch (Exception ex)
                {
                    if (ex is TargetInvocationException)
                    {
                        ex = ((TargetInvocationException)ex).InnerException;
                    }

                    if (!manager.BreakDeadlockMode)
                    {
                        string message = testclass + ".Run raised exception";
                        ReportErrorAndExit(message, ChessExitCode.UnitTestException, true, ex);
                    }
                }
            }

            // Always clean up the memory
            GC.Collect();
            GC.WaitForPendingFinalizers();
            manager.RunFinalizers();
        }