private static void displayDifference(TextMessageWriter writer, KeyValuePair <string, Pair> difference) { writer.Write("\t"); writer.Write(difference.Key); writer.Write(" --> "); writer.Write("globalization: "); writer.WriteExpectedValue(difference.Value.First); writer.Write("\t"); writer.Write("configuration: "); writer.WriteActualValue(difference.Value.Second); writer.WriteLine(); }
private void displayCultureInformation(TextMessageWriter writer, CultureCurrencyInfo fromGlobalization, CurrencyInfo fromConfiguration) { CanonicalCultureAttribute attr; CultureInfo configurationCulture = null; if (Enumeration.TryGetAttribute(fromConfiguration.Code, out attr)) { configurationCulture = attr.Culture(); } writer.Write("Globalizaton Currency {0} for culture {1} [{2}] ", fromGlobalization.Info.Code, fromGlobalization.Culture.Name, fromGlobalization.Culture.EnglishName); writer.WriteLine("differs from Configuration Currency {0}", fromConfiguration.Code); writer.WriteMessageLine(1, "Canonical Culture {0}, {1}", configurationCulture != null ? configurationCulture.Name : "NONE", configurationCulture != null ? attr.Overwritten.ToString() : "NA"); }
/// <summary> /// Handles an Ensurance failure for the given constraint. Implementors /// should always call /// <code> /// IEnsuranceResponsibilityChainLink handler = successor; /// if( handler != null ) { /// handler.Handle( constraint, message, args ); /// } /// </code> /// So that the downstream handler can have a chance to process the /// failure. /// </summary> /// <param name="constraint">The constraint.</param> /// <param name="message">The message.</param> /// <param name="args">The args.</param> public void Handle(Constraint constraint, string message, params object[] args) { try { MessageWriter messagewriter = new TextMessageWriter(); messagewriter.WriteLine(); constraint.WriteMessageTo(messagewriter); messagewriter.Write(new StackTraceWriter().ToString()); string tmpMessage = String.Format(CultureInfo.CurrentCulture, "{0}{1}", message, messagewriter); switch (_logger.DefaultLogSeverity) { case LogSeverity.Debug: _logger.Debug(tmpMessage, args); break; case LogSeverity.Info: _logger.Info(tmpMessage, args); break; case LogSeverity.Warn: _logger.Warn(tmpMessage, args); break; case LogSeverity.Error: _logger.Error(tmpMessage, args); break; case LogSeverity.Fatal: _logger.Fatal(tmpMessage, args); break; } } finally { IEnsuranceResponsibilityChainLink handler = _successor; if (handler != null) { handler.Handle(constraint, message, args); } } }
/// <summary> /// Wraps code containing a series of assertions, which should all /// be executed, even if they fail. Failed results are saved and /// reported at the end of the code block. /// </summary> /// <param name="testDelegate">A TestDelegate to be executed in Multiple Assertion mode.</param> public static void Multiple(TestDelegate testDelegate) { TestExecutionContext context = TestExecutionContext.CurrentContext; Guard.OperationValid(context != null, "Assert.Multiple called outside of a valid TestExecutionContext"); context.MultipleAssertLevel++; try { testDelegate(); } finally { context.MultipleAssertLevel--; } if (context.MultipleAssertLevel == 0) { int count = context.CurrentResult.AssertionResults.Count; if (count > 0) { var writer = new TextMessageWriter("Multiple Assert block had {0} failure(s).", count); int counter = 0; foreach (var assertion in context.CurrentResult.AssertionResults) writer.WriteLine(string.Format(" {0}) {1}", ++counter, assertion.Message)); throw new AssertionException(writer.ToString()); } } }