Beispiel #1
0
        /// <summary>
        /// Resolve the test method. The function will try to
        /// find a function that has the method name with 0 parameters. If the function
        /// cannot be found, or a function is found that returns non-void, the result is
        /// set to error.
        /// </summary>
        /// <param name="testMethod"> The test Method. </param>
        /// <param name="testClassInfo"> The test Class Info. </param>
        /// <param name="testContext"> The test Context. </param>
        /// <param name="captureDebugTraces"> Indicates whether the test method should capture debug traces.</param>
        /// <returns>
        /// The TestMethodInfo for the given test method. Null if the test method could not be found.
        /// </returns>
        private TestMethodInfo ResolveTestMethod(TestMethod testMethod, TestClassInfo testClassInfo, ITestContext testContext, bool captureDebugTraces)
        {
            Debug.Assert(testMethod != null, "testMethod is Null");
            Debug.Assert(testClassInfo != null, "testClassInfo is Null");

            var methodInfo = this.GetMethodInfoForTestMethod(testMethod, testClassInfo);

            if (methodInfo == null)
            {
                // Means the specified test method could not be found.
                return(null);
            }

            var expectedExceptionAttribute = this.reflectionHelper.ResolveExpectedExceptionHelper(methodInfo, testMethod);
            var timeout = this.GetTestTimeout(methodInfo, testMethod);

            var testMethodOptions = new TestMethodOptions()
            {
                Timeout = timeout, Executor = this.GetTestMethodAttribute(methodInfo, testClassInfo), ExpectedException = expectedExceptionAttribute, TestContext = testContext, CaptureDebugTraces = captureDebugTraces
            };
            var testMethodInfo = new TestMethodInfo(methodInfo, testClassInfo, testMethodOptions);

            this.SetCustomProperties(testMethodInfo, testContext);

            return(testMethodInfo);
        }
Beispiel #2
0
        /// <summary>
        /// Whether the given testMethod is runnable
        /// </summary>
        /// <param name="testMethod">The testMethod</param>
        /// <param name="testMethodInfo">The testMethodInfo</param>
        /// <param name="notRunnableResult">The results to return if the test method is not runnable</param>
        /// <returns>whether the given testMethod is runnable</returns>
        private bool IsTestMethodRunnable(
            TestMethod testMethod,
            TestMethodInfo testMethodInfo,
            out UnitTestResult[] notRunnableResult)
        {
            // If the specified TestMethod could not be found, return a NotFound result.
            if (testMethodInfo == null)
            {
                {
                    notRunnableResult = new UnitTestResult[]
                    {
                        new UnitTestResult(
                            ObjectModel.UnitTestOutcome.NotFound,
                            string.Format(CultureInfo.CurrentCulture, Resource.TestNotFound, testMethod.Name))
                    };
                    return(false);
                }
            }

            // If test cannot be executed, then bail out.
            if (!testMethodInfo.IsRunnable)
            {
                {
                    notRunnableResult = new UnitTestResult[]
                    { new UnitTestResult(ObjectModel.UnitTestOutcome.NotRunnable, testMethodInfo.NotRunnableReason) };
                    return(false);
                }
            }

            string ignoreMessage            = null;
            var    isIgnoreAttributeOnClass =
                this.reflectHelper.IsAttributeDefined(testMethodInfo.Parent.ClassType, typeof(UTF.IgnoreAttribute), false);
            var isIgnoreAttributeOnMethod =
                this.reflectHelper.IsAttributeDefined(testMethodInfo.TestMethod, typeof(UTF.IgnoreAttribute), false);

            if (isIgnoreAttributeOnClass)
            {
                ignoreMessage = this.reflectHelper.GetIgnoreMessage(testMethodInfo.Parent.ClassType.GetTypeInfo());
            }

            if (string.IsNullOrEmpty(ignoreMessage) && isIgnoreAttributeOnMethod)
            {
                ignoreMessage = this.reflectHelper.GetIgnoreMessage(testMethodInfo.TestMethod);
            }

            if (isIgnoreAttributeOnClass || isIgnoreAttributeOnMethod)
            {
                {
                    notRunnableResult = new[] { new UnitTestResult(ObjectModel.UnitTestOutcome.Ignored, ignoreMessage) };
                    return(false);
                }
            }

            notRunnableResult = null;
            return(true);
        }
Beispiel #3
0
        /// <summary>
        /// Initializes a new instance of the <see cref="TestMethodRunner"/> class.
        /// </summary>
        /// <param name="testMethodInfo">
        /// The test method info.
        /// </param>
        /// <param name="testMethod">
        /// The test method.
        /// </param>
        /// <param name="testContext">
        /// The test context.
        /// </param>
        /// <param name="captureDebugTraces">
        /// The capture debug traces.
        /// </param>
        /// <param name="reflectHelper">
        /// The reflect Helper object.
        /// </param>
        public TestMethodRunner(TestMethodInfo testMethodInfo, TestMethod testMethod, ITestContext testContext, bool captureDebugTraces, ReflectHelper reflectHelper)
        {
            Debug.Assert(testMethodInfo != null, "testMethodInfo should not be null");
            Debug.Assert(testMethod != null, "testMethod should not be null");
            Debug.Assert(testContext != null, "testContext should not be null");

            this.testMethodInfo     = testMethodInfo;
            this.test               = testMethod;
            this.testContext        = testContext;
            this.captureDebugTraces = captureDebugTraces;
            this.reflectHelper      = reflectHelper;
        }
Beispiel #4
0
            public void MarkTestComplete(TestMethodInfo testMethod, out bool shouldCleanup)
            {
                shouldCleanup = false;
                var testsByClass = this.remainingTestsByClass[testMethod.TestClassName];

                lock (testsByClass)
                {
                    testsByClass.Remove(testMethod.TestMethodName);
                    if (testsByClass.Count == 0 && testMethod.Parent.HasExecutableCleanupMethod)
                    {
                        var cleanupLifecycle = this.reflectHelper.GetClassCleanupSequence(testMethod.Parent.ClassType.GetTypeInfo())
                                               ?? this.lifecycleFromMsTest ?? this.lifecycleFromAssembly;
                        shouldCleanup = cleanupLifecycle == ClassCleanupLifecycle.EndOfClass;
                    }
                }
            }
Beispiel #5
0
        /// <summary>
        /// Set custom properties
        /// </summary>
        /// <param name="testMethodInfo"> The test Method Info. </param>
        /// <param name="testContext"> The test Context. </param>
        private void SetCustomProperties(TestMethodInfo testMethodInfo, ITestContext testContext)
        {
            Debug.Assert(testMethodInfo != null, "testMethodInfo is Null");
            Debug.Assert(testMethodInfo.TestMethod != null, "testMethodInfo.TestMethod is Null");

            var attributes = testMethodInfo.TestMethod.GetCustomAttributes(typeof(TestPropertyAttribute), false);

            Debug.Assert(attributes != null, "attributes is null");

            foreach (TestPropertyAttribute attribute in attributes)
            {
                if (!this.ValidateAndAssignTestProperty(testMethodInfo, testContext, attribute.Name, attribute.Value))
                {
                    break;
                }
            }
        }
Beispiel #6
0
 private UTF.TestResult[] ExecuteTest(TestMethodInfo testMethodInfo)
 {
     try
     {
         return(this.testMethodInfo.TestMethodOptions.Executor.Execute(testMethodInfo));
     }
     catch (Exception ex)
     {
         return(new[]
         {
             new UTF.TestResult()
             {
                 TestFailureException = new Exception(string.Format(CultureInfo.CurrentCulture, Resource.UTA_ExecuteThrewException, ex?.Message, ex?.StackTrace), ex)
             }
         });
     }
 }
Beispiel #7
0
        /// <summary>
        /// Validates If a Custom test property is valid and then adds it to the TestContext property list.
        /// </summary>
        /// <param name="testMethodInfo"> The test method info. </param>
        /// <param name="testContext"> The test context. </param>
        /// <param name="propertyName"> The property name. </param>
        /// <param name="propertyValue"> The property value. </param>
        /// <returns> True if its a valid Test Property. </returns>
        private bool ValidateAndAssignTestProperty(
            TestMethodInfo testMethodInfo,
            ITestContext testContext,
            string propertyName,
            string propertyValue)
        {
            if (PredefinedNames.Any(predefinedProp => predefinedProp == propertyName))
            {
                testMethodInfo.NotRunnableReason = string.Format(
                    CultureInfo.CurrentCulture,
                    Resource.UTA_ErrorPredefinedTestProperty,
                    testMethodInfo.TestMethod.DeclaringType.FullName,
                    testMethodInfo.TestMethod.Name,
                    propertyName);

                return(false);
            }

            if (string.IsNullOrEmpty(propertyName))
            {
                testMethodInfo.NotRunnableReason = string.Format(
                    CultureInfo.CurrentCulture,
                    Resource.UTA_ErrorTestPropertyNullOrEmpty,
                    testMethodInfo.TestMethod.DeclaringType.FullName,
                    testMethodInfo.TestMethod.Name);

                return(false);
            }

            object existingValue;

            if (testContext.TryGetPropertyValue(propertyName, out existingValue))
            {
                // Do not add to the test context because it would conflict with an already existing value.
                // We were at one point reporting a warning here. However with extensibility centered around TestProperty where
                // users can have multiple WorkItemAttributes(say) we cannot throw a warning here. Users would have multiple of these attributes
                // so that it shows up in reporting rather than seeing them in TestContext properties.
            }
            else
            {
                testContext.AddProperty(propertyName, propertyValue);
            }

            return(true);
        }
Beispiel #8
0
        private void RunClassCleanupIfEndOfClass(TestMethodInfo testMethodInfo, TestMethod testMethod, UnitTestResult[] results)
        {
            bool shouldRunClassCleanup = false;

            this.classCleanupManager?.MarkTestComplete(testMethodInfo, testMethod, out shouldRunClassCleanup);
            if (shouldRunClassCleanup)
            {
                string cleanupLogs      = string.Empty;
                string cleanupTrace     = string.Empty;
                string cleanupErrorLogs = string.Empty;

                try
                {
                    using (LogMessageListener logListener =
                               new LogMessageListener(MSTestSettings.CurrentSettings.CaptureDebugTraces))
                    {
                        try
                        {
                            // Class cleanup can throw exceptions in which case we need to ensure that we fail the test.
                            testMethodInfo.Parent.RunClassCleanup(ClassCleanupBehavior.EndOfClass);
                        }
                        finally
                        {
                            cleanupLogs      = logListener.StandardOutput;
                            cleanupTrace     = logListener.DebugTrace;
                            cleanupErrorLogs = logListener.StandardError;
                            var lastResult = results[results.Length - 1];
                            lastResult.StandardOut   = lastResult.StandardOut + cleanupLogs;
                            lastResult.StandardError = lastResult.StandardError + cleanupErrorLogs;
                            lastResult.DebugTrace    = lastResult.DebugTrace + cleanupTrace;
                        }
                    }
                }
                catch (Exception e)
                {
                    results[results.Length - 1].Outcome         = ObjectModel.UnitTestOutcome.Failed;
                    results[results.Length - 1].ErrorMessage    = e.Message;
                    results[results.Length - 1].ErrorStackTrace = e.StackTrace;
                }
            }
        }
Beispiel #9
0
 /// <summary>
 /// Initializes a new instance of the <see cref="TestMethodRunner"/> class.
 /// </summary>
 /// <param name="testMethodInfo">
 /// The test method info.
 /// </param>
 /// <param name="testMethod">
 /// The test method.
 /// </param>
 /// <param name="testContext">
 /// The test context.
 /// </param>
 /// <param name="captureDebugTraces">
 /// The capture debug traces.
 /// </param>
 public TestMethodRunner(TestMethodInfo testMethodInfo, TestMethod testMethod, ITestContext testContext, bool captureDebugTraces)
     : this(testMethodInfo, testMethod, testContext, captureDebugTraces, ReflectHelper.Instance)
 {
 }