/// <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> /// 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); } } }
/// <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> /// Perform any needed operations to log the message. /// </summary> /// <param name="logMessage">Instance of LogMessage type.</param> public virtual void Process(LogMessage logMessage) { // 1st: The more advanced conditionals. foreach (KeyValuePair<Func<LogMessage, bool>, Action<LogMessage>> pair in _conditionalHandlers) { if (pair.Value != null && pair.Key(logMessage)) { pair.Value(logMessage); return; } } // 2nd: The LogMessageType handlers. LogMessageType type = logMessage.MessageType; Action<LogMessage> action = null; if (_definedHandlers.TryGetValue(type, out action) && action != null) { action(logMessage); return; } // 3rd: Do nothing with the message, unless overloaded ProcessRemainder(logMessage); }
/// <summary> /// Process an Exception that is logged or stored. /// </summary> /// <param name="l">The log message object.</param> private void ProcessException(LogMessage l) { Exception e = (Exception)l[UnitTestLogDecorator.ActualException]; _writer.AddPendingException(e); }
/// <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> /// Assembly start code. /// </summary> /// <param name="l">The log message.</param> private void TestAssemblyStart(LogMessage l) { IAssembly assembly = (IAssembly)l[UnitTestLogDecorator.TestAssemblyMetadata]; _writer.Started = DateTime.Now; CurrentAssemblyName = assembly.Name; // For now, we assume the log works best with a single test // assembly and with undefined behavior when there are more. SetTestRunConfiguration(assembly); }
/// <summary> /// Process an Exception that was not the expected Exception type. /// </summary> /// <param name="l">The log message.</param> private void ProcessIncorrectException(LogMessage l) { _writer.AddPendingErrorMessage(l.ToString()); }
/// <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> /// Method that processes any messages not handled any other way. /// </summary> /// <param name="message">The log message.</param> protected virtual void ProcessRemainder(LogMessage message) { }
/// <summary> /// Decorate the log message object with a name. /// </summary> /// <param name="message">The log message object.</param> /// <param name="name">Name property value.</param> protected static void DecorateNameProperty(LogMessage message, string name) { Decorate(message, LogDecorator.NameProperty, name); }
/// <summary> /// Decorate a log message with a value. /// </summary> /// <param name="message">The log message to decorate.</param> /// <param name="key">The key for this decoration.</param> /// <param name="value">The value of this decoration.</param> protected static void Decorate(LogMessage message, object key, object value) { message.Decorators[key] = value; }
/// <summary> /// Logs a new message. /// </summary> /// <param name="message">Message object.</param> protected void LogMessage(LogMessage message) { LogWriter.Enqueue(message); }
/// <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> /// 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 IsKnownBug(LogMessage message) { return (message.MessageType == LogMessageType.KnownIssue); }
/// <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); }
/// <summary> /// Process [Bug(...)]. /// </summary> /// <param name="l">A KnownBugLogMessage object.</param> private void ProcessBug(LogMessage l) { _writer.AddPendingWriteLine(l.Message); }
/// <summary> /// Decorate the log message object with a test outcome object. /// </summary> /// <param name="message">The log message object.</param> /// <param name="outcome">Test outcome object.</param> protected static void DecorateTestOutcome(LogMessage message, TestOutcome outcome) { Decorate(message, LogDecorator.TestOutcome, outcome); }
/// <summary> /// The run filter has been selected. /// </summary> /// <param name="logMessage">The log message object.</param> private void TestRunFilterSelected(LogMessage logMessage) { TestRunFilter filter = (TestRunFilter)logMessage[UnitTestLogDecorator.TestRunFilter]; TestListName = filter.TestRunName; }
/// <summary> /// Sets the type of the log message. /// </summary> /// <param name="message">The log message object.</param> /// <param name="type">The new value to set the message type to.</param> protected static void SetType(LogMessage message, LogMessageType type) { message.MessageType = type; }
/// <summary> /// Decorate the log message object with an Exception object. /// </summary> /// <param name="message">The log message object.</param> /// <param name="exception">The Exception.</param> protected static void DecorateException(LogMessage message, Exception exception) { Decorate(message, LogDecorator.ExceptionObject, exception); }
/// <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> /// Decorate the log message object with a test stage value. /// </summary> /// <param name="message">The log message object.</param> /// <param name="stage">Test stage value.</param> protected static void DecorateTestStage(LogMessage message, TestStage stage) { Decorate(message, LogDecorator.TestStage, stage); }
/// <summary> /// Enqueue a log message object for processing by the log providers. /// </summary> /// <param name="message">The log message object.</param> public void QueueLogMessage(LogMessage message) { _queuedLogMessages.Enqueue(message); }
/// <summary> /// Decorate the log message object with a test granularity object. /// </summary> /// <param name="message">The log message object.</param> /// <param name="granularity">Test granularity object.</param> protected static void DecorateTestGranularity(LogMessage message, TestGranularity granularity) { Decorate(message, LogDecorator.TestGranularity, granularity); }
/// <summary> /// Immediately sets the overall status using a log message and /// processes the message queue. /// </summary> /// <param name="message">The message to set.</param> private void SetOverallStatus(string message) { LogMessage lm = new LogMessage(LogMessageType.TestInfrastructure); lm.Message = message; lm.Decorators["UpdateOverallStatus"] = true; LogWriter.Enqueue(lm); ProcessLogMessages(); }
/// <summary> /// Posts a log message to the test harness queue for processing. /// </summary> /// <param name="message">The log message object.</param> public void Enqueue(LogMessage message) { _testHarness.QueueLogMessage(message); }
/// <summary> /// Marks a message as a unit test system-specific message. /// </summary> /// <param name="message">The log message object.</param> private static void MarkUnitTestMessage(LogMessage message) { message[UnitTestLogDecorator.IsUnitTestMessage] = true; }