示例#1
0
 /// <summary>
 /// Creates a new instance of <see cref="Assertion"/>.
 /// </summary>
 /// <param name="state">Is this fact true or false?</param>
 /// <param name="name">The name of the function that generated the state.</param>
 /// <param name="message">Explains the state's value.</param>
 /// <param name="context">Gets the originator of that issued the state.</param>
 private Assertion(bool state, string name, string message, StackTraceContext context)
 {
     State      = state;
     Name       = name;
     Message    = message;
     StackFrame = state ? null : context.First();
 }
示例#2
0
 /// <summary>
 /// Creates a new instance of <see cref="Test"/>.
 /// </summary>
 protected Test()
 {
     Log     = new Log(false);
     Context = new StackTraceContext(GetType());
 }
示例#3
0
 /// <summary>
 /// Is the given condition true?
 /// </summary>
 /// <param name="condition">Condition.</param>
 /// <param name="context">Gets the originator of that issued the state.</param>
 /// <returns>True if the condition is true; otherwise, false.</returns>
 internal static Assertion IsTrue(bool condition, StackTraceContext context)
 {
     return(AreEqual(true, condition, nameof(IsTrue), context));
 }
示例#4
0
 /// <summary>
 /// Are the given unexpected and actual values unequal?
 /// </summary>
 /// <param name="unexpected">Unexpected value.</param>
 /// <param name="actual">Actual value.</param>
 /// <param name="context">Gets the originator of that issued the state.</param>
 /// <typeparam name="TValue">Value type.</typeparam>
 /// <returns>True if expected and actual are unequal; otherwise, false.</returns>
 internal static Assertion AreNotEqual <TValue>(TValue unexpected, TValue actual, StackTraceContext context)
 {
     return(AreNotEqual(unexpected, actual, nameof(AreNotEqual), context));
 }
示例#5
0
 /// <summary>
 /// Is the given expected type assignable to the given actual type?
 /// </summary>
 /// <param name="expected">Expected type.</param>
 /// <param name="actual">Actual type.</param>
 /// <param name="name">Function name.</param>
 /// <param name="context">Gets the originator of that issued the state.</param>
 /// <returns>True if the expected type is assignable to the actual type; otherwise, false.</returns>
 private static Assertion IsAssignableTo(Type expected, Type actual, string name, StackTraceContext context)
 {
     return(actual != null && actual.IsAssignableFrom(expected)
         ? new Assertion(true, name, $"The type {ToString(expected)} can be assigned to the type {ToString(actual)}.", context)
         : new Assertion(false, name, $"The type {ToString(expected)} cannot be assigned to the type {ToString(actual)}.", context));
 }
示例#6
0
 /// <summary>
 /// Are the given unexpected and actual values unequal?
 /// </summary>
 /// <param name="unexpected">Unexpected value.</param>
 /// <param name="actual">Actual value.</param>
 /// <param name="name">Function name.</param>
 /// <param name="context">Gets the originator of that issued the state.</param>
 /// <typeparam name="TValue">Value type.</typeparam>
 /// <returns>True if expected and actual are unequal; otherwise, false.</returns>
 private static Assertion AreNotEqual <TValue>(TValue unexpected, TValue actual, string name, StackTraceContext context)
 {
     return(!Equals(unexpected, actual)
         ? new Assertion(true, name, $"Did not expect {ToString(unexpected)} and got {ToString(actual)}.", context)
         : new Assertion(false, name, $"Did not expect {ToString(unexpected)} but got {ToString(actual)}.", context));
 }
示例#7
0
 /// <summary>
 /// Is the given value's type assignable to the given type?
 /// </summary>
 /// <param name="value">Value.</param>
 /// <param name="type">Type.</param>
 /// <param name="context">Gets the originator of that issued the state.</param>
 /// <typeparam name="TValue">Value type.</typeparam>
 /// <returns>True if the value's type is assignable to the type; otherwise, false.</returns>
 internal static Assertion IsInstanceOfType <TValue>(TValue value, Type type, StackTraceContext context)
 {
     return(IsAssignableTo(value?.GetType(), type, nameof(IsInstanceOfType), context));
 }
示例#8
0
 /// <summary>
 /// Is the given expected type assignable to the given actual type?
 /// </summary>
 /// <param name="expected">Expected type.</param>
 /// <param name="actual">Actual type.</param>
 /// <param name="context">Gets the originator of that issued the state.</param>
 /// <returns>True if the expected type is assignable to the actual type; otherwise, false.</returns>
 internal static Assertion IsAssignableTo(Type expected, Type actual, StackTraceContext context)
 {
     return(IsAssignableTo(expected, actual, nameof(IsAssignableTo), context));
 }
示例#9
0
 /// <summary>
 /// Is the given collection not empty?
 /// </summary>
 /// <param name="elements">Elements.</param>
 /// <param name="context">Gets the originator of that issued the state.</param>
 /// <typeparam name="TValue">Value type.</typeparam>
 /// <returns>True if the collection is not empty; otherwise, false.</returns>
 internal static Assertion IsNotEmpty <TValue>(IEnumerable <TValue> elements, StackTraceContext context)
 {
     return(elements.Any()
         ? new Assertion(true, nameof(IsNotEmpty), "Collection is not empty.", context)
         : new Assertion(false, nameof(IsNotEmpty), "Collection is empty.", context));
 }
示例#10
0
 /// <summary>
 /// Are the sequences of the given collections the same?
 /// </summary>
 /// <param name="expected">Expected sequence.</param>
 /// <param name="actual">Actual sequence.</param>
 /// <param name="context">Gets the originator of that issued the state.</param>
 /// <typeparam name="TValue">Value type.</typeparam>
 /// <returns>True if the sequences are the same; otherwise, false.</returns>
 internal static Assertion SequenceEqual <TValue>(IEnumerable <TValue> expected, IEnumerable <TValue> actual, StackTraceContext context)
 {
     return(expected.SequenceEqual(actual)
         ? new Assertion(true, nameof(SequenceEqual), "The two sequences are equal.", context)
         : new Assertion(false, nameof(SequenceEqual), "The two sequences are not equal.", context));
 }
示例#11
0
 /// <summary>
 /// Does the given collection of elements not contain the given element?
 /// </summary>
 /// <param name="elements">Elements.</param>
 /// <param name="element">Element.</param>
 /// <param name="context">Gets the originator of that issued the state.</param>
 /// <typeparam name="TValue">Value type.</typeparam>
 /// <returns>True if the collection of elements does not contain the element; otherwise, false.</returns>
 internal static Assertion DoesNotContain <TValue>(IEnumerable <TValue> elements, TValue element, StackTraceContext context)
 {
     return(!elements.Contains(element)
         ? new Assertion(true, nameof(DoesNotContain), $"{ToString(element)} was not found.", context)
         : new Assertion(false, nameof(DoesNotContain), $"{ToString(element)} was found.", context));
 }
示例#12
0
 /// <summary>
 /// Is the given left hand side value less than or equal to the given right hand side value?
 /// </summary>
 /// <param name="lhs">Left hand side.</param>
 /// <param name="rhs">Right hand side.</param>
 /// <param name="context">Gets the originator of that issued the state.</param>
 /// <typeparam name="TValue">Comparable type.</typeparam>
 /// <returns>True if the left hand side value is less than or equal to the right hand side value; otherwise, false.</returns>
 internal static Assertion IsLessThanOrEqualTo <TValue>(TValue lhs, TValue rhs, StackTraceContext context) where TValue : IComparable
 {
     return(Default.Compare(lhs, rhs) <= 0
         ? new Assertion(true, nameof(IsLessThanOrEqualTo), $"{ToString(lhs)} is less than or equal to {ToString(rhs)}", context)
         : new Assertion(false, nameof(IsLessThanOrEqualTo), $"{ToString(lhs)} is not less than nor equal to {ToString(rhs)}", context));
 }
示例#13
0
 /// <summary>
 /// Is the given left hand side value greater than the given right hand side value?
 /// </summary>
 /// <param name="lhs">Left hand side.</param>
 /// <param name="rhs">Right hand side.</param>
 /// <param name="context">Gets the originator of that issued the state.</param>
 /// <typeparam name="TValue">Comparable type.</typeparam>
 /// <returns>True if the left hand side value is greater than the right hand side value; otherwise, false.</returns>
 internal static Assertion IsGreaterThan <TValue>(TValue lhs, TValue rhs, StackTraceContext context) where TValue : IComparable
 {
     return(Default.Compare(lhs, rhs) > 0
         ? new Assertion(true, nameof(IsGreaterThan), $"{ToString(lhs)} is greater than {ToString(rhs)}", context)
         : new Assertion(false, nameof(IsGreaterThan), $"{ToString(lhs)} is not greater than {ToString(rhs)}", context));
 }
示例#14
0
 /// <summary>
 /// Is the given value not equal to null?
 /// </summary>
 /// <param name="value">Value.</param>
 /// <param name="context">Gets the originator of that issued the state.</param>
 /// <typeparam name="TValue">Value type.</typeparam>
 /// <returns>True if the value is not equal to null; otherwise, false.</returns>
 internal static Assertion IsNotNull <TValue>(TValue?value, StackTraceContext context) where TValue : struct
 {
     return(AreNotEqual(null, value, nameof(IsNotNull), context));
 }
示例#15
0
 /// <summary>
 /// Is the given value equal to null?
 /// </summary>
 /// <param name="value">Value.</param>
 /// <param name="context">Gets the originator of that issued the state.</param>
 /// <typeparam name="TValue">Reference type.</typeparam>
 /// <returns>True if the value is equal to null; otherwise, false.</returns>
 internal static Assertion IsNull <TValue>(TValue value, StackTraceContext context) where TValue : class
 {
     return(AreEqual(null, value, nameof(IsNull), context));
 }