C# LogMessage.HasDecorator方法代码示例

        /// <summary>
        /// Display a LogMessage in the debug output window.
        /// </summary>
        /// <param name="logMessage">Message object.</param>
        public override void Process(LogMessage logMessage)
        {
            if (logMessage == null)
            {
                throw new ArgumentNullException("logMessage");
            }

            if ((logMessage.MessageType != LogMessageType.Debug) && !ShowEverything)
            {
                if (!ShowAllFailures)
                {
                    return;
                }
                
                if (logMessage.HasDecorator(LogDecorator.TestOutcome))
                {
                    TestOutcome outcome = (TestOutcome)logMessage[LogDecorator.TestOutcome];
                    if (outcome == TestOutcome.Passed)
                    {
                        return;
                    }
                }
            }

            // Skip Finishing messages, they're always duplicates
            if (logMessage.HasDecorator(LogDecorator.TestStage))
            {
                if ((TestStage)logMessage[LogDecorator.TestStage] == TestStage.Finishing)
                {
                    return;
                }
            }

            Debug.WriteLine(logMessage.ToString());
        }

 /// <summary>
 /// Determines whether a log message meets a specific condition or set 
 /// of conditions.
 /// </summary>
 /// <param name="message">The log message object.</param>
 /// <returns>Returns true if the condition is met.</returns>
 public static bool HasUnitTestOutcome(LogMessage message)
 {
     if (!IsUnitTestMessage(message))
     {
         return false;
     }
     return message.HasDecorator(LogDecorator.TestOutcome);
 }

 /// <summary>
 /// Determines whether a log message meets a specific condition or set 
 /// of conditions.
 /// </summary>
 /// <param name="message">The log message object.</param>
 /// <returns>Returns true if the condition is met.</returns>
 public static bool IsIncorrectExceptionLogMessage(LogMessage message)
 {
     if (!IsUnitTestMessage(message))
     {
         return false;
     }
     return message.HasDecorator(UnitTestLogDecorator.IncorrectExceptionMessage);
 }

 /// <summary>
 /// Determines whether a log message meets a specific condition or set 
 /// of conditions.
 /// </summary>
 /// <param name="message">The log message object.</param>
 /// <returns>Returns true if the condition is met.</returns>
 public static bool IsExceptionLogMessage(LogMessage message)
 {
     if (!IsUnitTestMessage(message))
     {
         return false;
     }
     return message.HasDecorator(UnitTestLogDecorator.ActualException);
 }

 public override void Process(LogMessage logMessage) {
     if(isFirstMessage) {
         isFirstMessage = false;
         ProcessStartMessage();
     } else
         if(logMessage.HasDecorator(LogDecorator.TestOutcome))
             ProcessResultMessage(logMessage);
 }

 /// <summary>
 /// Process a UTF result message.
 /// </summary>
 /// <param name="logMessage">The log message object.</param>
 private void ProcessResult(LogMessage logMessage)
 {
     if (logMessage.HasDecorator(UnitTestLogDecorator.TestMethodMetadata))
     {
         ScenarioResult sr = (ScenarioResult)logMessage[UnitTestLogDecorator.ScenarioResult];
         if (sr.Result != TestOutcome.Passed)
         {
             _failures.Add(sr);
         }
     }
 }

            public override void Process(LogMessage logMessage)
            {
                if (logMessage.HasDecorator(LogDecorator.TestStage))
                {
                    var stage = (TestStage)logMessage[LogDecorator.TestStage];
                    if (stage == TestStage.Starting)
                    {
                        if (logMessage.HasDecorator(UnitTestLogDecorator.TestMethodMetadata))
                        {
                            var methodInfo = (TestMethod)logMessage[UnitTestLogDecorator.TestMethodMetadata];
                            var wc = new WebClient();
                            wc.UploadStringAsync(new Uri(baseUrl, "/TestMethodStarting?method=" + methodInfo.Name), "");
                        }
                        else if (logMessage.HasDecorator(UnitTestLogDecorator.TestClassMetadata))
                        {
                            var classInfo = (TestClass)logMessage[UnitTestLogDecorator.TestClassMetadata];
                            var wc = new WebClient();
                            wc.UploadStringAsync(new Uri(baseUrl, "/TestClassStarting?class=" + classInfo.Type.FullName), "");
                        }
                    }
                }

                if (logMessage.HasDecorator(UnitTestLogDecorator.ScenarioResult))
                {
                    var result = (ScenarioResult)logMessage[UnitTestLogDecorator.ScenarioResult];
                    var wc = new WebClient();
                    StringBuilder uri = new StringBuilder();
                    uri.Append("/TestMethodCompleted?result=" + result.Result);
                    if (result.TestClass != null)
                    {
                        uri.Append("&class=").Append(result.TestClass.Type.FullName);
                    }
                    if (result.TestMethod != null)
                    {
                        uri.Append("&method=").Append(result.TestMethod.Name);
                    }
                    wc.UploadStringAsync(new Uri(baseUrl, uri.ToString()), "");
                }
            }

            public override void Process(LogMessage logMessage)
            {
                if (logMessage.HasDecorator(UnitTestLogDecorator.ScenarioResult))
                {
                    var result = (ScenarioResult)logMessage[UnitTestLogDecorator.ScenarioResult];

                    InvokeDomMethod("scenarioResult",
                                           result.Started.Ticks,
                                           result.Finished.Ticks,
                                           (result.TestClass != null) ? result.TestClass.Type.FullName : null,
                                           (result.TestMethod != null) ? result.TestMethod.Name : null,
                                           result.Result.ToString(),
                                           (result.Exception != null) ? result.Exception.ToString() : null);
                }
            }

 /// <summary>
 /// Determines whether a log message meets a specific condition or set 
 /// of conditions.
 /// </summary>
 /// <param name="message">The log message object.</param>
 /// <returns>Returns true if the condition is met.</returns>
 public static bool IsUnitTestEndMessage(LogMessage message)
 {
     if (!IsUnitTestMessage(message))
     {
         return false;
     }
     if (message.HasDecorator(LogDecorator.TestStage))
     {
         TestStage ts = (TestStage)message[LogDecorator.TestStage];
         return ts == TestStage.Finishing;
     }
     else
     {
         return false;
     }
 }

        /// <summary>
        /// Process a UTF result message.
        /// </summary>
        /// <param name="logMessage">The log message object.</param>
        private void ProcessResult(LogMessage logMessage)
        {
            if (logMessage.HasDecorator(UnitTestLogDecorator.TestMethodMetadata))
            {
                TestOutcome result = (TestOutcome)logMessage[LogDecorator.TestOutcome];
                ITestMethod method = (ITestMethod)logMessage[UnitTestLogDecorator.TestMethodMetadata];
                ITestClass test = (ITestClass)logMessage[UnitTestLogDecorator.TestClassMetadata];
                ScenarioResult sr = (ScenarioResult)logMessage[UnitTestLogDecorator.ScenarioResult];

                string storage = CurrentAssemblyName;
                string codeBase = CurrentAssemblyName;
                string adapterTypeName = TestAdapterTypeName;
                string className = test.Name;
                string testListName = TestListName;
                string computerName = ComputerName;
                DateTime startTime = sr.Started;
                DateTime endTime = sr.Finished;
                _writer.AddTestMethodResult(method, storage, codeBase, adapterTypeName, className, testListName, computerName, startTime, endTime, result);
                _writer.IncrementResults(result);
            }
        }

 /// <summary>
 /// Determines whether a log message has an attached TestRunFilter.
 /// </summary>
 /// <param name="message">The log message object.</param>
 /// <returns>Returns a value indicating whether the condition is met.</returns>
 public static bool IsTestRunFilterMessage(LogMessage message)
 {
     return message.HasDecorator(UnitTestLogDecorator.TestRunFilter);
 }

 /// <summary>
 /// Determines whether a log message meets a specific condition or set 
 /// of conditions.
 /// </summary>
 /// <param name="message">The log message object.</param>
 /// <returns>Returns true if the condition is met.</returns>
 public static bool IsIgnoreMessage(LogMessage message)
 {
     return message.HasDecorator(UnitTestLogDecorator.IgnoreMessage);
 }

 /// <summary>
 /// Returns a value indicating whether the message is marked as a unit
 /// test system message.
 /// </summary>
 /// <param name="message">The message.</param>
 /// <returns>Returns true if the message is a unit test system-marked 
 /// message.</returns>
 private static bool IsUnitTestMessage(LogMessage message)
 {
     return message.HasDecorator(UnitTestLogDecorator.IsUnitTestMessage);
 }

 /// <summary>
 /// Conditional check, if the message has results and the current state 
 /// of the run, as tracked by this provider, is "pass".
 /// </summary>
 /// <param name="message">The log message.</param>
 /// <returns>Returns true when the conditions are met.</returns>
 private bool NotFailedButWithResults(LogMessage message)
 {
     // A. Must be in a passing state
     // B. Must have results
     return (!_hasFailed && message.HasDecorator(LogDecorator.TestOutcome));
 }

 /// <summary>
 /// Conditional check for the granularity decorator.
 /// </summary>
 /// <param name="message">The log message.</param>
 /// <returns>Returns true if the condition is met.</returns>
 private bool IsGranularMessage(LogMessage message)
 {
     return (message.HasDecorator(LogDecorator.TestGranularity));
 }