534 lines
18 KiB
C#
534 lines
18 KiB
C#
// ****************************************************************
|
|
// This is free software licensed under the NUnit license. You
|
|
// may obtain a copy of the license as well as information regarding
|
|
// copyright ownership at http://nunit.org/?p=license&r=2.4.
|
|
// ****************************************************************
|
|
|
|
using System;
|
|
using System.Text;
|
|
using System.IO;
|
|
using System.Collections;
|
|
|
|
namespace NUnit.Framework
|
|
{
|
|
/// <summary>
|
|
/// AssertionFailureMessage encapsulates a failure message
|
|
/// issued as a result of an Assert failure.
|
|
/// </summary>
|
|
[Obsolete( "Use MessageWriter for new work" )]
|
|
public class AssertionFailureMessage : StringWriter
|
|
{
|
|
#region Static Constants
|
|
|
|
/// <summary>
|
|
/// Number of characters before a highlighted position before
|
|
/// clipping will occur. Clipped text is replaced with an
|
|
/// elipsis "..."
|
|
/// </summary>
|
|
static public readonly int PreClipLength = 35;
|
|
|
|
/// <summary>
|
|
/// Number of characters after a highlighted position before
|
|
/// clipping will occur. Clipped text is replaced with an
|
|
/// elipsis "..."
|
|
/// </summary>
|
|
static public readonly int PostClipLength = 35;
|
|
|
|
/// <summary>
|
|
/// Prefix used to start an expected value line.
|
|
/// Must be same length as actualPrefix.
|
|
/// </summary>
|
|
static protected readonly string expectedPrefix = "expected:";
|
|
|
|
/// <summary>
|
|
/// Prefix used to start an actual value line.
|
|
/// Must be same length as expectedPrefix.
|
|
/// </summary>
|
|
static protected readonly string actualPrefix = " but was:";
|
|
|
|
static private readonly string expectedAndActualFmt = "\t{0} {1}";
|
|
static private readonly string diffStringLengthsFmt
|
|
= "\tString lengths differ. Expected length={0}, but was length={1}.";
|
|
static private readonly string sameStringLengthsFmt
|
|
= "\tString lengths are both {0}.";
|
|
static private readonly string diffArrayLengthsFmt
|
|
= "Array lengths differ. Expected length={0}, but was length={1}.";
|
|
static private readonly string sameArrayLengthsFmt
|
|
= "Array lengths are both {0}.";
|
|
static private readonly string stringsDifferAtIndexFmt
|
|
= "\tStrings differ at index {0}.";
|
|
static private readonly string arraysDifferAtIndexFmt
|
|
= "Arrays differ at index {0}.";
|
|
|
|
#endregion
|
|
|
|
#region Constructors
|
|
|
|
/// <summary>
|
|
/// Construct an AssertionFailureMessage with a message
|
|
/// and optional arguments.
|
|
/// </summary>
|
|
/// <param name="message"></param>
|
|
/// <param name="args"></param>
|
|
public AssertionFailureMessage( string message, params object[] args )
|
|
{
|
|
if ( message != null && message != string.Empty )
|
|
if ( args != null )
|
|
WriteLine( message, args );
|
|
else
|
|
WriteLine( message );
|
|
}
|
|
|
|
/// <summary>
|
|
/// Construct an empty AssertionFailureMessage
|
|
/// </summary>
|
|
public AssertionFailureMessage() : this( null, null ) { }
|
|
|
|
#endregion
|
|
|
|
/// <summary>
|
|
/// Add an expected value line to the message containing
|
|
/// the text provided as an argument.
|
|
/// </summary>
|
|
/// <param name="text">Text describing what was expected.</param>
|
|
public void WriteExpectedLine( string text )
|
|
{
|
|
WriteLine( string.Format( expectedAndActualFmt, expectedPrefix, text ) );
|
|
}
|
|
|
|
/// <summary>
|
|
/// Add an actual value line to the message containing
|
|
/// the text provided as an argument.
|
|
/// </summary>
|
|
/// <param name="text">Text describing the actual value.</param>
|
|
public void WriteActualLine( string text )
|
|
{
|
|
WriteLine( string.Format( expectedAndActualFmt, actualPrefix, text ) );
|
|
}
|
|
|
|
/// <summary>
|
|
/// Add an expected value line to the message containing
|
|
/// a string representation of the object provided.
|
|
/// </summary>
|
|
/// <param name="expected">An object representing the expected value</param>
|
|
public void DisplayExpectedValue( object expected )
|
|
{
|
|
WriteExpectedLine( FormatObjectForDisplay( expected ) );
|
|
}
|
|
|
|
/// <summary>
|
|
/// Add an expected value line to the message containing a double
|
|
/// and the tolerance used in making the comparison.
|
|
/// </summary>
|
|
/// <param name="expected">The expected value</param>
|
|
/// <param name="tolerance">The tolerance specified in the Assert</param>
|
|
public void DisplayExpectedValue( double expected, double tolerance )
|
|
{
|
|
WriteExpectedLine( FormatObjectForDisplay( expected ) + " +/- " + tolerance.ToString() );
|
|
}
|
|
|
|
/// <summary>
|
|
/// Add an actual value line to the message containing
|
|
/// a string representation of the object provided.
|
|
/// </summary>
|
|
/// <param name="actual">An object representing what was actually found</param>
|
|
public void DisplayActualValue( object actual )
|
|
{
|
|
WriteActualLine( FormatObjectForDisplay( actual ) );
|
|
}
|
|
|
|
/// <summary>
|
|
/// Display two lines that communicate the expected value, and the actual value
|
|
/// </summary>
|
|
/// <param name="expected">The expected value</param>
|
|
/// <param name="actual">The actual value found</param>
|
|
public void DisplayExpectedAndActual( Object expected, Object actual )
|
|
{
|
|
DisplayExpectedValue( expected );
|
|
DisplayActualValue( actual );
|
|
}
|
|
|
|
/// <summary>
|
|
/// Display two lines that communicate the expected value, the actual value and
|
|
/// the tolerance used in comparing two doubles.
|
|
/// </summary>
|
|
/// <param name="expected">The expected value</param>
|
|
/// <param name="actual">The actual value found</param>
|
|
/// <param name="tolerance">The tolerance specified in the Assert</param>
|
|
public void DisplayExpectedAndActual( double expected, double actual, double tolerance )
|
|
{
|
|
DisplayExpectedValue( expected, tolerance );
|
|
DisplayActualValue( actual );
|
|
}
|
|
|
|
/// <summary>
|
|
/// Draws a marker under the expected/actual strings that highlights
|
|
/// where in the string a mismatch occurred.
|
|
/// </summary>
|
|
/// <param name="iPosition">The position of the mismatch</param>
|
|
public void DisplayPositionMarker( int iPosition )
|
|
{
|
|
WriteLine( "\t{0}^", new String( '-', expectedPrefix.Length + iPosition + 3 ) );
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reports whether the string lengths are the same or different, and
|
|
/// what the string lengths are.
|
|
/// </summary>
|
|
/// <param name="sExpected">The expected string</param>
|
|
/// <param name="sActual">The actual string value</param>
|
|
protected void BuildStringLengthReport( string sExpected, string sActual )
|
|
{
|
|
if( sExpected.Length != sActual.Length )
|
|
WriteLine( diffStringLengthsFmt, sExpected.Length, sActual.Length );
|
|
else
|
|
WriteLine( sameStringLengthsFmt, sExpected.Length );
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called to create additional message lines when two objects have been
|
|
/// found to be unequal. If the inputs are strings, a special message is
|
|
/// rendered that can help track down where the strings are different,
|
|
/// based on differences in length, or differences in content.
|
|
///
|
|
/// If the inputs are not strings, the ToString method of the objects
|
|
/// is used to show what is different about them.
|
|
/// </summary>
|
|
/// <param name="expected">The expected value</param>
|
|
/// <param name="actual">The actual value</param>
|
|
/// <param name="caseInsensitive">True if a case-insensitive comparison is being performed</param>
|
|
public void DisplayDifferences( object expected, object actual, bool caseInsensitive )
|
|
{
|
|
if( InputsAreStrings( expected, actual ) )
|
|
{
|
|
DisplayStringDifferences(
|
|
(string)expected,
|
|
(string)actual,
|
|
caseInsensitive );
|
|
}
|
|
else
|
|
{
|
|
DisplayExpectedAndActual( expected, actual );
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called to create additional message lines when two doubles have been
|
|
/// found to be unequal, within the specified tolerance.
|
|
/// </summary>
|
|
public void DisplayDifferencesWithTolerance( double expected, double actual, double tolerance )
|
|
{
|
|
DisplayExpectedAndActual( expected, actual, tolerance );
|
|
}
|
|
|
|
/// <summary>
|
|
/// Constructs a message that can be displayed when the content of two
|
|
/// strings are different, but the string lengths are the same. The
|
|
/// message will clip the strings to a reasonable length, centered
|
|
/// around the first position where they are mismatched, and draw
|
|
/// a line marking the position of the difference to make comparison
|
|
/// quicker.
|
|
/// </summary>
|
|
/// <param name="sExpected">The expected string value</param>
|
|
/// <param name="sActual">The actual string value</param>
|
|
/// <param name="caseInsensitive">True if a case-insensitive comparison is being performed</param>
|
|
protected void DisplayStringDifferences( string sExpected, string sActual, bool caseInsensitive )
|
|
{
|
|
//
|
|
// If they mismatch at a specified position, report the
|
|
// difference.
|
|
//
|
|
int iPosition = caseInsensitive
|
|
? FindMismatchPosition( sExpected.ToLower(), sActual.ToLower(), 0 )
|
|
: FindMismatchPosition( sExpected, sActual, 0 );
|
|
//
|
|
// If the lengths differ, but they match up to the length,
|
|
// show the difference just past the length of the shorter
|
|
// string
|
|
//
|
|
if( iPosition == -1 )
|
|
iPosition = Math.Min( sExpected.Length, sActual.Length );
|
|
|
|
BuildStringLengthReport( sExpected, sActual );
|
|
|
|
WriteLine( stringsDifferAtIndexFmt, iPosition );
|
|
|
|
//
|
|
// Clips the strings, then turns any hidden whitespace into visible
|
|
// characters
|
|
//
|
|
string sClippedExpected = ConvertWhitespace(ClipAroundPosition( sExpected, iPosition ));
|
|
string sClippedActual = ConvertWhitespace(ClipAroundPosition( sActual, iPosition ));
|
|
|
|
DisplayExpectedAndActual(
|
|
sClippedExpected,
|
|
sClippedActual );
|
|
|
|
// Add a line showing where they differ. If the string lengths are
|
|
// different, they start differing just past the length of the
|
|
// shorter string
|
|
DisplayPositionMarker( caseInsensitive
|
|
? FindMismatchPosition( sClippedExpected.ToLower(), sClippedActual.ToLower(), 0 )
|
|
: FindMismatchPosition( sClippedExpected, sClippedActual, 0 ) );
|
|
}
|
|
|
|
/// <summary>
|
|
/// Display a standard message showing the differences found between
|
|
/// two arrays that were expected to be equal.
|
|
/// </summary>
|
|
/// <param name="expected">The expected array value</param>
|
|
/// <param name="actual">The actual array value</param>
|
|
/// <param name="index">The index at which a difference was found</param>
|
|
public void DisplayArrayDifferences( Array expected, Array actual, int index )
|
|
{
|
|
if( expected.Length != actual.Length )
|
|
WriteLine( diffArrayLengthsFmt, expected.Length, actual.Length );
|
|
else
|
|
WriteLine( sameArrayLengthsFmt, expected.Length );
|
|
|
|
WriteLine( arraysDifferAtIndexFmt, index );
|
|
|
|
if ( index < expected.Length && index < actual.Length )
|
|
{
|
|
DisplayDifferences( GetValueFromCollection(expected, index ), GetValueFromCollection(actual, index), false );
|
|
}
|
|
else if( expected.Length < actual.Length )
|
|
DisplayListElements( " extra:", actual, index, 3 );
|
|
else
|
|
DisplayListElements( " missing:", expected, index, 3 );
|
|
}
|
|
|
|
/// <summary>
|
|
/// Display a standard message showing the differences found between
|
|
/// two collections that were expected to be equal.
|
|
/// </summary>
|
|
/// <param name="expected">The expected collection value</param>
|
|
/// <param name="actual">The actual collection value</param>
|
|
/// <param name="index">The index at which a difference was found</param>
|
|
// NOTE: This is a temporary method for use until the code from NUnitLite
|
|
// is integrated into NUnit.
|
|
public void DisplayCollectionDifferences( ICollection expected, ICollection actual, int index )
|
|
{
|
|
if( expected.Count != actual.Count )
|
|
WriteLine( diffArrayLengthsFmt, expected.Count, actual.Count );
|
|
else
|
|
WriteLine( sameArrayLengthsFmt, expected.Count );
|
|
|
|
WriteLine( arraysDifferAtIndexFmt, index );
|
|
|
|
if ( index < expected.Count && index < actual.Count )
|
|
{
|
|
DisplayDifferences( GetValueFromCollection(expected, index ), GetValueFromCollection(actual, index), false );
|
|
}
|
|
// else if( expected.Count < actual.Count )
|
|
// DisplayListElements( " extra:", actual, index, 3 );
|
|
// else
|
|
// DisplayListElements( " missing:", expected, index, 3 );
|
|
}
|
|
|
|
private static object GetValueFromCollection(ICollection collection, int index)
|
|
{
|
|
Array array = collection as Array;
|
|
|
|
if (array != null && array.Rank > 1)
|
|
return array.GetValue(GetArrayIndicesFromCollectionIndex(array, index));
|
|
|
|
if (collection is IList)
|
|
return ((IList)collection)[index];
|
|
|
|
foreach (object obj in collection)
|
|
if (--index < 0)
|
|
return obj;
|
|
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get an array of indices representing the point in a collection or
|
|
/// array corresponding to a single int index into the collection.
|
|
/// </summary>
|
|
/// <param name="collection">The collection to which the indices apply</param>
|
|
/// <param name="index">Index in the collection</param>
|
|
/// <returns>Array of indices</returns>
|
|
private static int[] GetArrayIndicesFromCollectionIndex(ICollection collection, int index)
|
|
{
|
|
Array array = collection as Array;
|
|
int rank = array == null ? 1 : array.Rank;
|
|
int[] result = new int[rank];
|
|
|
|
for (int r = array.Rank; --r > 0; )
|
|
{
|
|
int l = array.GetLength(r);
|
|
result[r] = index % l;
|
|
index /= l;
|
|
}
|
|
|
|
result[0] = index;
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Displays elements from a list on a line
|
|
/// </summary>
|
|
/// <param name="label">Text to prefix the line with</param>
|
|
/// <param name="list">The list of items to display</param>
|
|
/// <param name="index">The index in the list of the first element to display</param>
|
|
/// <param name="max">The maximum number of elements to display</param>
|
|
public void DisplayListElements( string label, IList list, int index, int max )
|
|
{
|
|
Write( "{0}<", label );
|
|
|
|
if ( list == null )
|
|
Write( "null" );
|
|
else if ( list.Count == 0 )
|
|
Write( "empty" );
|
|
else
|
|
{
|
|
for( int i = 0; i < max && index < list.Count; i++ )
|
|
{
|
|
Write( FormatObjectForDisplay( list[index++] ) );
|
|
|
|
if ( index < list.Count )
|
|
Write( "," );
|
|
}
|
|
|
|
if ( index < list.Count )
|
|
Write( "..." );
|
|
}
|
|
|
|
WriteLine( ">" );
|
|
}
|
|
|
|
#region Static Methods
|
|
|
|
/// <summary>
|
|
/// Formats an object for display in a message line
|
|
/// </summary>
|
|
/// <param name="obj">The object to be displayed</param>
|
|
/// <returns></returns>
|
|
static public string FormatObjectForDisplay( object obj )
|
|
{
|
|
if ( obj == null )
|
|
return "<(null)>";
|
|
else if ( obj is string )
|
|
return string.Format( "<\"{0}\">", obj );
|
|
else if ( obj is double )
|
|
return string.Format( "<{0}>", ((double)obj).ToString( "G17" ) );
|
|
else if ( obj is float )
|
|
return string.Format( "<{0}>", ((float)obj).ToString( "G9" ) );
|
|
else
|
|
return string.Format( "<{0}>", obj );
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tests two objects to determine if they are strings.
|
|
/// </summary>
|
|
/// <param name="expected"></param>
|
|
/// <param name="actual"></param>
|
|
/// <returns></returns>
|
|
static protected bool InputsAreStrings( Object expected, Object actual )
|
|
{
|
|
return expected != null && actual != null &&
|
|
expected is string && actual is string;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Renders up to M characters before, and up to N characters after
|
|
/// the specified index position. If leading or trailing text is
|
|
/// clipped, and elipses "..." is added where the missing text would
|
|
/// be.
|
|
///
|
|
/// Clips strings to limit previous or post newline characters,
|
|
/// since these mess up the comparison
|
|
/// </summary>
|
|
/// <param name="sString"></param>
|
|
/// <param name="iPosition"></param>
|
|
/// <returns></returns>
|
|
static protected string ClipAroundPosition( string sString, int iPosition )
|
|
{
|
|
if( sString == null || sString.Length == 0 )
|
|
return "";
|
|
|
|
bool preClip = iPosition > PreClipLength;
|
|
bool postClip = iPosition + PostClipLength < sString.Length;
|
|
|
|
int start = preClip
|
|
? iPosition - PreClipLength : 0;
|
|
int length = postClip
|
|
? iPosition + PostClipLength - start : sString.Length - start;
|
|
|
|
if ( start + length > iPosition + PostClipLength )
|
|
length = iPosition + PostClipLength - start;
|
|
|
|
StringBuilder sb = new StringBuilder();
|
|
if ( preClip ) sb.Append("...");
|
|
sb.Append( sString.Substring( start, length ) );
|
|
if ( postClip ) sb.Append("...");
|
|
|
|
return sb.ToString();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Shows the position two strings start to differ. Comparison
|
|
/// starts at the start index.
|
|
/// </summary>
|
|
/// <param name="sExpected"></param>
|
|
/// <param name="sActual"></param>
|
|
/// <param name="iStart"></param>
|
|
/// <returns>-1 if no mismatch found, or the index where mismatch found</returns>
|
|
static private int FindMismatchPosition( string sExpected, string sActual, int iStart )
|
|
{
|
|
int iLength = Math.Min( sExpected.Length, sActual.Length );
|
|
for( int i=iStart; i<iLength; i++ )
|
|
{
|
|
//
|
|
// If they mismatch at a specified position, report the
|
|
// difference.
|
|
//
|
|
if( sExpected[i] != sActual[i] )
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
//
|
|
// Strings have same content up to the length of the shorter string.
|
|
// Mismatch occurs because string lengths are different, so show
|
|
// that they start differing where the shortest string ends
|
|
//
|
|
if( sExpected.Length != sActual.Length )
|
|
{
|
|
return iLength;
|
|
}
|
|
|
|
//
|
|
// Same strings
|
|
//
|
|
Assert.IsTrue( sExpected.Equals( sActual ) );
|
|
return -1;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Turns CR, LF, or TAB into visual indicator to preserve visual marker
|
|
/// position. This is done by replacing the '\r' into '\\' and 'r'
|
|
/// characters, and the '\n' into '\\' and 'n' characters, and '\t' into
|
|
/// '\\' and 't' characters.
|
|
///
|
|
/// Thus the single character becomes two characters for display.
|
|
/// </summary>
|
|
/// <param name="sInput"></param>
|
|
/// <returns></returns>
|
|
static protected string ConvertWhitespace( string sInput )
|
|
{
|
|
if( null != sInput )
|
|
{
|
|
sInput = sInput.Replace( "\\", "\\\\" );
|
|
sInput = sInput.Replace( "\r", "\\r" );
|
|
sInput = sInput.Replace( "\n", "\\n" );
|
|
sInput = sInput.Replace( "\t", "\\t" );
|
|
}
|
|
return sInput;
|
|
}
|
|
#endregion
|
|
}
|
|
}
|