private void AssertExpectedIdenticalResult(string input1, string input2, bool expected) { DiffResult result = GetDiffResult(input1, input2); string msg = "Identical: comparing " + input1 + " to " + input2 + ": " + result.Difference; OldAssert.AreEqual(expected, result.Identical, msg); }
/// <summary> /// Asserts that all items contained in collection are of the type specified by expectedType. /// </summary> /// <param name="collection">ICollection of objects to be considered.</param> /// <param name="expectedType">System.Type that all objects in collection must be instances of.</param> /// <param name="message">The message that will be displayed on failure.</param> /// <param name="args">Arguments to be used in formatting the message.</param> public static void AllItemsAreInstancesOfType(ICollection collection, Type expectedType, string message, params object[] args) { bool fail = false; foreach (object o in collection) { if (o.GetType() != expectedType) { fail = true; break; } } if (fail) { if (args != null) { OldAssert.Fail(message, args); } else { OldAssert.Fail(message); } } }
public void EqualResultForSameReader() { TextReader reader = new StringReader("<empty/>"); DiffResult result = PerformDiff(reader, reader); OldAssert.AreEqual(true, result.Equal); }
[Test] public void XpathExistsFalseForUnmatchedExpression() { XPath xpath = new XPath(NONEXISTENT_XPATH); OldAssert.AreEqual(false, xpath.XPathExists(SIMPLE_XML)); }
public static void IsSealed(Type t) { OldAssert.IsNotNull(t); OldAssert.IsTrue(t.IsSealed, "Type {0} is not sealed", t.FullName); }
/// <summary> /// Asserts that all items contained in collection are not equal to null. /// </summary> /// <param name="collection">ICollection of objects to be considered.</param> /// <param name="message">The message that will be displayed on failure.</param> /// <param name="args">Arguments to be used in formatting the message.</param> public static void AllItemsAreNotNull(ICollection collection, string message, params object[] args) { bool fail = false; foreach (object o in collection) { if (o == null) { fail = true; break; } } if (fail) { if (args != null) { OldAssert.Fail(message, args); } else { OldAssert.Fail(message); } } }
/// <summary> /// Ensures that every object contained in collection exists within the collection /// once and only once. /// </summary> /// <param name="collection">ICollection of objects to be considered.</param> /// <param name="message">The message that will be displayed on failure.</param> /// <param name="args">Arguments to be used in formatting the message.</param> public static void AllItemsAreUnique(ICollection collection, string message, params object[] args) { bool fail = false; ArrayList arr = new ArrayList(); foreach (object o in collection) { //do a check to see if it is in the collection already if (arr.Contains(o)) { fail = true; break; } else { arr.Add(o); } } if (fail) { if (args != null) { OldAssert.Fail(message, args); } else { OldAssert.Fail(message); } } }
[Test] public void TextReaderInputTranslatesToXmlReader() { XmlInput input = new XmlInput(new StringReader(INPUT)); string actual = ReadOuterXml(input.CreateXmlReader()); OldAssert.AreEqual(_expected, actual); }
[Test] public void XpathExistsTrueForXpathThatExists() { XPath xpath = new XPath(EXISTENT_XPATH); OldAssert.AreEqual(true, xpath.XPathExists(SIMPLE_XML)); }
/// <summary> /// Asserts that subset is a subset of superset. /// </summary> /// <param name="subset">The ICollection subset to be considered.</param> /// <param name="superset">The ICollection superset to be considered.</param> /// <param name="message">The message that will be displayed on failure.</param> /// <param name="args">Arguments to be used in formatting the message.</param> public static void IsSubsetOf(ICollection subset, ICollection superset, string message, params object[] args) { bool foundAll = true; //All of superset are in subset foreach (object o in subset) { bool found = CheckItemInCollection(superset, o); if (!found) { foundAll = false; break; } } if (!foundAll) { if (args != null) { OldAssert.Fail(message, args); } else { OldAssert.Fail(message); } } }
/// <summary> /// Asserts that the flattened String obtained by executing an Xpath on some XML is a particular value /// </summary> /// <param name="anXPathExpression">An X path expression.</param> /// <param name="inXml">The XML to test.</param> /// <param name="expectedValue">The expected value.</param> public static void XPathEvaluatesTo(string anXPathExpression, XmlInput inXml, string expectedValue) { XPath xpath = new XPath(anXPathExpression); OldAssert.AreEqual(expectedValue, xpath.EvaluateXPath(inXml)); }
[SetUp] public void CreateMinorDifference() { DifferenceType id = DifferenceType.AttributeSequence; OldAssert.AreEqual(false, Differences.IsMajorDifference(id)); minorDifference = new Difference(id); }
[Test] public void XpathEvaluatesToEmptyStringForUnmatchedExpression() { string expectedValue = ""; XPath xpath = new XPath(NONEXISTENT_XPATH); OldAssert.AreEqual(expectedValue, xpath.EvaluateXPath(SIMPLE_XML)); }
/// <summary> /// Asserts that the type has a constructor, with the specified bindind flags, with a signature defined by parameters. /// </summary> public static void HasConstructor(Type type, BindingFlags flags, params Type[] parameters) { OldAssert.IsNotNull(type); OldAssert.IsNotNull(type.GetConstructor(flags, null, parameters, null), "{0} does not have matching constructor", type.FullName ); }
[Test] public void XpathEvaluatesMultiNodeExpression() { string expectedValue = "onetwo"; XPath xpath = new XPath(MULTI_NODE_XPATH); OldAssert.AreEqual(expectedValue, xpath.EvaluateXPath(MORE_COMPLEX_XML)); }
[Test] public void XpathEvaluatesCountExpression() { string expectedValue = "2"; XPath xpath = new XPath(COUNT_XPATH); OldAssert.AreEqual(expectedValue, xpath.EvaluateXPath(MORE_COMPLEX_XML)); }
/// <summary> /// Verifies that the property value <see cref="ICollection.IsSynchronized"/> /// is true. /// </summary> /// <param name="actual"> /// Instance containing the expected value. /// </param> public static void IsSynchronized( ICollection actual ) { OldAssert.IsNotNull(actual); OldAssert.IsTrue(actual.IsSynchronized, "Property IsSynchronized is false"); }
public void SameResultForTwoInvocations() { TextReader reader = new StringReader("<empty/>"); DiffResult result1 = PerformDiff(reader, reader); DiffResult result2 = _xmlDiff.Compare(); OldAssert.AreSame(result1, result2); }
[Test] public void XpathEvaluatesToTextValueForSimpleString() { string expectedValue = "one two"; XPath xpath = new XPath(EXISTENT_XPATH); OldAssert.AreEqual(expectedValue, xpath.EvaluateXPath(SIMPLE_XML)); }
public static Stream GetTestFile(string file) { Stream s = Assembly.GetExecutingAssembly().GetManifestResourceStream( "MbUnit.Tests.Compatibility.Framework.Xml.etc." + file); OldAssert.IsNotNull(s); return(s); }
/// <summary> /// Verifies that the property value <see cref="ICollection.IsSynchronized"/> /// of <paramref name="actual"/> is equal to <paramref name="expected"/>. /// </summary> /// <param name="expected"> /// Expected value. /// </param> /// <param name="actual"> /// Instance containing the tested value. /// </param> public static void AreIsSynchronizedEqual( Boolean expected, ICollection actual ) { OldAssert.IsNotNull(actual); OldAssert.AreEqual(expected, actual.IsSynchronized, "Property IsSynchronized not equal"); }
public static void WriteOnlyProperty(PropertyInfo pi) { OldAssert.IsNotNull(pi); OldAssert.IsFalse(pi.CanRead, "Property {0}.{1} is not read-only", pi.DeclaringType.FullName, pi.Name ); }
private Validator PerformAssertion(Stream input, bool expected) { using (input) { Validator validator = new Validator(new XmlInput(new StreamReader(input))); OldAssert.AreEqual(expected, validator.IsValid, validator.ValidationMessage); return(validator); } }
/// <summary> /// Verifies that the property value <see cref="ICollection.Count"/> /// of <paramref name="actual"/> is equal to <paramref name="expected"/>. /// </summary> /// <param name="expected"> /// Expected value. /// </param> /// <param name="actual"> /// Instance containing the tested value. /// </param> public static void AreCountEqual( Int32 expected, ICollection actual ) { OldAssert.IsNotNull(actual); OldAssert.AreEqual(expected, actual.Count, "Property Count not equal"); }
public void IsNotAssignableFrom() { int[] array10 = new int[10]; int[,] array2 = new int[2, 2]; OldAssert.IsNotAssignableFrom(array2.GetType(), array10); OldAssert.IsNotAssignableFrom(array2.GetType(), array10, "Type Failure Message"); OldAssert.IsNotAssignableFrom(array2.GetType(), array10, "Type Failure Message", null); }
[Test] public void CanPerformTransform() { Xslt xslt = new Xslt(IDENTITY_TRANSFORM); string input = "<qwerty>uiop</qwerty>"; string output = new string(input.ToCharArray()); OldAssert.AreEqual(output, xslt.Transform(input).AsString()); OldAssert.AreEqual(output, xslt.Transform(input).AsString()); }
[Test] public void NotIdenticalButEqualAfterMinorDifferenceFound() { _result.DifferenceFound(_diff, _minorDifference); OldAssert.AreEqual(false, _result.Identical); OldAssert.AreEqual(true, _result.Equal); OldAssert.AreEqual(_diff.OptionalDescription + Environment.NewLine + _minorDifference.ToString(), _result.StringValue); }
/// <summary> /// Asserts whether <paramref name="child"/> is an instance of the /// <paramref name="type"/>. /// </summary> /// <param name="type"> /// <see cref="Type"/> instance. /// </param> /// <param name="child"> /// Child instance. /// </param> public static void IsInstanceOf(Type type, Object child) { OldAssert.IsNotNull(type); OldAssert.IsNotNull(child); OldAssert.IsTrue(type.IsInstanceOfType(child), "{0} is not an instance of {1}", type, child ); }
public static void NotCreatable(Type t) { OldAssert.IsNotNull(t); foreach (ConstructorInfo ci in t.GetConstructors()) { OldAssert.Fail( "Non-private constructor found in class {0} that must not be creatable", t.FullName); } }
/// <summary> /// Asserts whether an instance of the <paramref name="parent"/> /// can be assigned from an instance of <paramref name="child"/>. /// </summary> /// <param name="parent"> /// Parent <see cref="Type"/> instance. /// </param> /// <param name="child"> /// Child <see cref="Type"/> instance. /// </param> public static void IsAssignableFrom(Type parent, Type child) { OldAssert.IsNotNull(parent); OldAssert.IsNotNull(child); OldAssert.IsTrue(parent.IsAssignableFrom(child), "{0} is not assignable from {1}", parent, child ); }