[Nmock-general] nmock/test/NMock/Constraints ConstraintsTest.cs,1.6,1.7 IsArrayEqualTest.cs,1.1,1.2

SourceForge Headquarters 1320 Columbia Street Suite 310 San Diego, CA 92101 +1 (858) 422-6466

Update of /cvsroot/nmock/nmock/test/NMock/Constraints
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv19470/test/NMock/Constraints

Modified Files:
	ConstraintsTest.cs IsArrayEqualTest.cs 
Log Message:
upgraded to nunit 2.2
upgraded to new version of NAnt

Index: ConstraintsTest.cs
===================================================================
RCS file: /cvsroot/nmock/nmock/test/NMock/Constraints/ConstraintsTest.cs,v
retrieving revision 1.6
retrieving revision 1.7
diff -C2 -d -r1.6 -r1.7
*** ConstraintsTest.cs	24 Jul 2003 23:09:05 -0000	1.6
--- ConstraintsTest.cs	22 Oct 2004 11:46:26 -0000	1.7
***************
*** 1,5 ****
! using NUnit.Framework;
  using System.Text.RegularExpressions;
! using System.Collections;
  namespace NMock.Constraints
  {
--- 1,7 ----
! using System;
! using System.IO;
  using System.Text.RegularExpressions;
! using NUnit.Framework;
! 
  namespace NMock.Constraints
  {
***************
*** 15,23 ****
  		{
  			c = new IsNull();
! 			Assertion.Assert(c.Eval(null));
! 			Assertion.Assert(!c.Eval(new object()));
! 			Assertion.Assert(!c.Eval(1));
! 			Assertion.Assert(!c.Eval(true));
! 			Assertion.Assert(!c.Eval(false));
  		}

--- 17,25 ----
  		{
  			c = new IsNull();
! 			Assert.IsTrue(c.Eval(null));
! 			Assert.IsTrue(!c.Eval(new object()));
! 			Assert.IsTrue(!c.Eval(1));
! 			Assert.IsTrue(!c.Eval(true));
! 			Assert.IsTrue(!c.Eval(false));
  		}

***************
*** 26,31 ****
  		{
  			c = new NotNull();
! 			Assertion.Assert(!c.Eval(null));
! 			Assertion.Assert(c.Eval(new object()));
  		}

--- 28,33 ----
  		{
  			c = new NotNull();
! 			Assert.IsTrue(!c.Eval(null));
! 			Assert.IsTrue(c.Eval(new object()));
  		}

***************
*** 36,50 ****
  			object o2 = new object();
  			c = new IsEqual(o1);
! 			Assertion.Assert(c.Eval(o1));
! 			Assertion.Assert(!c.Eval(o2));
! 			Assertion.Assert(!c.Eval(null));

  			int i1 = 1;
  			int i2 = 2;
  			c = new IsEqual(i1);
! 			Assertion.Assert(c.Eval(i1));
! 			Assertion.Assert(c.Eval(1));
! 			Assertion.Assert(!c.Eval(i2));
! 			Assertion.Assert(!c.Eval(2));
  		}

--- 38,52 ----
  			object o2 = new object();
  			c = new IsEqual(o1);
! 			Assert.IsTrue(c.Eval(o1));
! 			Assert.IsTrue(!c.Eval(o2));
! 			Assert.IsTrue(!c.Eval(null));

  			int i1 = 1;
  			int i2 = 2;
  			c = new IsEqual(i1);
! 			Assert.IsTrue(c.Eval(i1));
! 			Assert.IsTrue(c.Eval(1));
! 			Assert.IsTrue(!c.Eval(i2));
! 			Assert.IsTrue(!c.Eval(2));
  		}

***************
*** 56,62 ****

  			c = new IsEqual(new object[] { 1, 2, 3 });
! 			Assertion.Assert("should be equal", c.Eval(o1));
! 			Assertion.Assert("shouldn't be equal", !c.Eval(o2));
! 			Assertion.Assert("it ain't null", !c.Eval(null));
  		}

--- 58,64 ----

  			c = new IsEqual(new object[] { 1, 2, 3 });
! 			Assert.IsTrue(c.Eval(o1), "should be equal");
! 			Assert.IsTrue(!c.Eval(o2), "shouldn't be equal");
! 			Assert.IsTrue(!c.Eval(null), "it ain't null" );
  		}

***************
*** 67,81 ****
  			object o2 = new object();
  			c = new NotEqual(o1);
! 			Assertion.Assert(!c.Eval(o1));
! 			Assertion.Assert(c.Eval(o2));
! 			Assertion.Assert(c.Eval(null));

  			int i1 = 1;
  			int i2 = 2;
  			c = new NotEqual(i1);
! 			Assertion.Assert(!c.Eval(i1));
! 			Assertion.Assert(!c.Eval(1));
! 			Assertion.Assert(c.Eval(i2));
! 			Assertion.Assert(c.Eval(2));
  		}

--- 69,83 ----
  			object o2 = new object();
  			c = new NotEqual(o1);
! 			Assert.IsTrue(!c.Eval(o1));
! 			Assert.IsTrue(c.Eval(o2));
! 			Assert.IsTrue(c.Eval(null));

  			int i1 = 1;
  			int i2 = 2;
  			c = new NotEqual(i1);
! 			Assert.IsTrue(!c.Eval(i1));
! 			Assert.IsTrue(!c.Eval(1));
! 			Assert.IsTrue(c.Eval(i2));
! 			Assert.IsTrue(c.Eval(2));
  		}

***************
*** 84,96 ****
  		{
  			c = new IsAnything();
! 			Assertion.Assert(c.Eval(null));
! 			Assertion.Assert(c.Eval(0));
! 			Assertion.Assert(c.Eval(99));
! 			Assertion.Assert(c.Eval(-2));
! 			Assertion.Assert(c.Eval(true));
! 			Assertion.Assert(c.Eval(false));
! 			Assertion.Assert(c.Eval(""));
! 			Assertion.Assert(c.Eval("hello"));
! 			Assertion.Assert(c.Eval(new object()));
  		}

--- 86,98 ----
  		{
  			c = new IsAnything();
! 			Assert.IsTrue(c.Eval(null));
! 			Assert.IsTrue(c.Eval(0));
! 			Assert.IsTrue(c.Eval(99));
! 			Assert.IsTrue(c.Eval(-2));
! 			Assert.IsTrue(c.Eval(true));
! 			Assert.IsTrue(c.Eval(false));
! 			Assert.IsTrue(c.Eval(""));
! 			Assert.IsTrue(c.Eval("hello"));
! 			Assert.IsTrue(c.Eval(new object()));
  		}

***************
*** 98,105 ****
  		public void IsType()
  		{
! 			c = new IsTypeOf(typeof(System.IO.TextReader));
! 			Assertion.Assert(!c.Eval(null));
! 			Assertion.Assert(c.Eval(new System.IO.StringReader("")));
! 			Assertion.Assert(!c.Eval(new System.IO.StringWriter()));
  		}

--- 100,107 ----
  		public void IsType()
  		{
! 			c = new IsTypeOf(typeof(TextReader));
! 			Assert.IsTrue(!c.Eval(null));
! 			Assert.IsTrue(c.Eval(new StringReader("")));
! 			Assert.IsTrue(!c.Eval(new StringWriter()));
  		}

***************
*** 107,112 ****
  		public void Not()
  		{
! 			Assertion.Assert(new Not(new False()).Eval(null));
! 			Assertion.Assert(!new Not(new True()).Eval(null));
  		}

--- 109,114 ----
  		public void Not()
  		{
! 			Assert.IsTrue(new Not(new False()).Eval(null));
! 			Assert.IsTrue(!new Not(new True()).Eval(null));
  		}

***************
*** 114,121 ****
  		public void And()
  		{
! 			Assertion.Assert( new And(new True() , new True() ).Eval(null));
! 			Assertion.Assert(!new And(new True() , new False()).Eval(null));
! 			Assertion.Assert(!new And(new False(), new True() ).Eval(null));
! 			Assertion.Assert(!new And(new False(), new False()).Eval(null));
  		}

--- 116,123 ----
  		public void And()
  		{
! 			Assert.IsTrue( new And(new True() , new True() ).Eval(null));
! 			Assert.IsTrue(!new And(new True() , new False()).Eval(null));
! 			Assert.IsTrue(!new And(new False(), new True() ).Eval(null));
! 			Assert.IsTrue(!new And(new False(), new False()).Eval(null));
  		}

***************
*** 123,130 ****
  		public void Or()
  		{
! 			Assertion.Assert( new Or(new True() , new True() ).Eval(null));
! 			Assertion.Assert( new Or(new True() , new False()).Eval(null));
! 			Assertion.Assert( new Or(new False(), new True() ).Eval(null));
! 			Assertion.Assert(!new Or(new False(), new False()).Eval(null));
  		}

--- 125,132 ----
  		public void Or()
  		{
! 			Assert.IsTrue( new Or(new True() , new True() ).Eval(null));
! 			Assert.IsTrue( new Or(new True() , new False()).Eval(null));
! 			Assert.IsTrue( new Or(new False(), new True() ).Eval(null));
! 			Assert.IsTrue(!new Or(new False(), new False()).Eval(null));
  		}

***************
*** 133,149 ****
  		{
  			c = new IsIn(2, 3, 5);
! 			Assertion.Assert(!c.Eval(1));
! 			Assertion.Assert(c.Eval(2));
! 			Assertion.Assert(c.Eval(3));
! 			Assertion.Assert(!c.Eval(4));
! 			Assertion.Assert(c.Eval(5));
! 			Assertion.Assert(!c.Eval(6));
! 			Assertion.Assert(!c.Eval(null));

  			int[] array = {1, 2};
  			c = new IsIn(array);
! 			Assertion.Assert(c.Eval(1));
! 			Assertion.Assert(c.Eval(2));
! 			Assertion.Assert(!c.Eval(3));
  		}

--- 135,151 ----
  		{
  			c = new IsIn(2, 3, 5);
! 			Assert.IsTrue(!c.Eval(1));
! 			Assert.IsTrue(c.Eval(2));
! 			Assert.IsTrue(c.Eval(3));
! 			Assert.IsTrue(!c.Eval(4));
! 			Assert.IsTrue(c.Eval(5));
! 			Assert.IsTrue(!c.Eval(6));
! 			Assert.IsTrue(!c.Eval(null));

  			int[] array = {1, 2};
  			c = new IsIn(array);
! 			Assert.IsTrue(c.Eval(1));
! 			Assert.IsTrue(c.Eval(2));
! 			Assert.IsTrue(!c.Eval(3));
  		}

***************
*** 152,164 ****
  		{
  			c = new NotIn(1, 2);
! 			Assertion.Assert(!c.Eval(1));
! 			Assertion.Assert(!c.Eval(2));
! 			Assertion.Assert(c.Eval(3));

  			int[] array = {1, 2};
  			c = new NotIn(array);
! 			Assertion.Assert(!c.Eval(1));
! 			Assertion.Assert(!c.Eval(2));
! 			Assertion.Assert(c.Eval(3));
  		}

--- 154,166 ----
  		{
  			c = new NotIn(1, 2);
! 			Assert.IsTrue(!c.Eval(1));
! 			Assert.IsTrue(!c.Eval(2));
! 			Assert.IsTrue(c.Eval(3));

  			int[] array = {1, 2};
  			c = new NotIn(array);
! 			Assert.IsTrue(!c.Eval(1));
! 			Assert.IsTrue(!c.Eval(2));
! 			Assert.IsTrue(c.Eval(3));
  		}

***************
*** 167,174 ****
  		{
  			c = new IsEqualIgnoreCase("heLLo");
! 			Assertion.Assert(c.Eval("HELLO"));
! 			Assertion.Assert(c.Eval("hello"));
! 			Assertion.Assert(c.Eval("HelLo"));
! 			Assertion.Assert(!c.Eval("abcde"));
  		}

--- 169,176 ----
  		{
  			c = new IsEqualIgnoreCase("heLLo");
! 			Assert.IsTrue(c.Eval("HELLO"));
! 			Assert.IsTrue(c.Eval("hello"));
! 			Assert.IsTrue(c.Eval("HelLo"));
! 			Assert.IsTrue(!c.Eval("abcde"));
  		}

***************
*** 176,182 ****
  		public void StripSpace()
  		{
! 			Assertion.AssertEquals("Hello World", IsEqualIgnoreWhiteSpace.StripSpace("Hello\n  \n World"));
! 			Assertion.AssertEquals("Hello World", IsEqualIgnoreWhiteSpace.StripSpace(" Hello World "));
! 			Assertion.AssertEquals("", IsEqualIgnoreWhiteSpace.StripSpace("  "));
  		}

--- 178,184 ----
  		public void StripSpace()
  		{
! 			Assert.AreEqual("Hello World", IsEqualIgnoreWhiteSpace.StripSpace("Hello\n  \n World"));
! 			Assert.AreEqual("Hello World", IsEqualIgnoreWhiteSpace.StripSpace(" Hello World "));
! 			Assert.AreEqual("", IsEqualIgnoreWhiteSpace.StripSpace("  "));
  		}

***************
*** 185,192 ****
  		{
  			c = new IsEqualIgnoreWhiteSpace("Hello World   how\n are we?");
! 			Assertion.Assert(c.Eval("Hello World how are we?"));
! 			Assertion.Assert(c.Eval("   Hello World   how are \n\n\twe?"));
! 			Assertion.Assert(!c.Eval("HelloWorld how are we?"));
! 			Assertion.Assert(!c.Eval("Hello World how are we"));
  		}

--- 187,194 ----
  		{
  			c = new IsEqualIgnoreWhiteSpace("Hello World   how\n are we?");
! 			Assert.IsTrue(c.Eval("Hello World how are we?"));
! 			Assert.IsTrue(c.Eval("   Hello World   how are \n\n\twe?"));
! 			Assert.IsTrue(!c.Eval("HelloWorld how are we?"));
! 			Assert.IsTrue(!c.Eval("Hello World how are we"));
  		}

***************
*** 195,220 ****
  		{
  			c = new IsMatch(new Regex(@"^th[aeiou]\w* .*$"));
! 			Assertion.Assert(c.Eval("the world"));
! 			Assertion.Assert(!c.Eval("theworld"));
! 			Assertion.Assert(!c.Eval("ThE world"));
! 			Assertion.Assert(!c.Eval(" the world"));
! 			Assertion.Assert(c.Eval("thats nice"));
! 			Assertion.Assert(!c.Eval(new object()));
! 			Assertion.Assert(!c.Eval(null));

  			c = new IsMatch(@"^th[aeiou]\w* .*$");
! 			Assertion.Assert(c.Eval("the world"));
! 			Assertion.Assert(!c.Eval("theworld"));
! 			Assertion.Assert(!c.Eval("ThE world"));

  			c = new IsMatch(@"^th[aeiou]\w* .*$", false);
! 			Assertion.Assert(c.Eval("the world"));
! 			Assertion.Assert(!c.Eval("theworld"));
! 			Assertion.Assert(!c.Eval("ThE world"));

  			c = new IsMatch(@"^th[aeiou]\w* .*$", true);
! 			Assertion.Assert(c.Eval("the world"));
! 			Assertion.Assert(!c.Eval("theworld"));
! 			Assertion.Assert(c.Eval("ThE world"));

  		}
--- 197,222 ----
  		{
  			c = new IsMatch(new Regex(@"^th[aeiou]\w* .*$"));
! 			Assert.IsTrue(c.Eval("the world"));
! 			Assert.IsTrue(!c.Eval("theworld"));
! 			Assert.IsTrue(!c.Eval("ThE world"));
! 			Assert.IsTrue(!c.Eval(" the world"));
! 			Assert.IsTrue(c.Eval("thats nice"));
! 			Assert.IsTrue(!c.Eval(new object()));
! 			Assert.IsTrue(!c.Eval(null));

  			c = new IsMatch(@"^th[aeiou]\w* .*$");
! 			Assert.IsTrue(c.Eval("the world"));
! 			Assert.IsTrue(!c.Eval("theworld"));
! 			Assert.IsTrue(!c.Eval("ThE world"));

  			c = new IsMatch(@"^th[aeiou]\w* .*$", false);
! 			Assert.IsTrue(c.Eval("the world"));
! 			Assert.IsTrue(!c.Eval("theworld"));
! 			Assert.IsTrue(!c.Eval("ThE world"));

  			c = new IsMatch(@"^th[aeiou]\w* .*$", true);
! 			Assert.IsTrue(c.Eval("the world"));
! 			Assert.IsTrue(!c.Eval("theworld"));
! 			Assert.IsTrue(c.Eval("ThE world"));

  		}
***************
*** 225,247 ****
  			c = new IsCloseTo(1.0, 0.5);

! 			Assertion.Assert(c.Eval(1.0));
! 			Assertion.Assert(c.Eval(0.5));
! 			Assertion.Assert(c.Eval(1.5));

! 			Assertion.Assert(c.Eval(1));
! 			Assertion.Assert(c.Eval(0.5f));
! 			Assertion.Assert(c.Eval(new decimal(1.5)));

! 			Assertion.Assert(!c.Eval(0.49));
! 			Assertion.Assert(!c.Eval(1.51));
! 			Assertion.Assert(!c.Eval(-1.0));

! 			Assertion.Assert(c.Eval("1.2"));
! 			Assertion.Assert(!c.Eval("0.2"));
! 			Assertion.Assert(!c.Eval("hello"));

! 			Assertion.Assert(!c.Eval(null));
! 			Assertion.Assert(!c.Eval(0));
! 			Assertion.Assert(!c.Eval(0.0));
  		}

--- 227,249 ----
  			c = new IsCloseTo(1.0, 0.5);

! 			Assert.IsTrue(c.Eval(1.0));
! 			Assert.IsTrue(c.Eval(0.5));
! 			Assert.IsTrue(c.Eval(1.5));

! 			Assert.IsTrue(c.Eval(1));
! 			Assert.IsTrue(c.Eval(0.5f));
! 			Assert.IsTrue(c.Eval(new decimal(1.5)));

! 			Assert.IsTrue(!c.Eval(0.49));
! 			Assert.IsTrue(!c.Eval(1.51));
! 			Assert.IsTrue(!c.Eval(-1.0));

! 			Assert.IsTrue(c.Eval("1.2"));
! 			Assert.IsTrue(!c.Eval("0.2"));
! 			Assert.IsTrue(!c.Eval("hello"));

! 			Assert.IsTrue(!c.Eval(null));
! 			Assert.IsTrue(!c.Eval(0));
! 			Assert.IsTrue(!c.Eval(0.0));
  		}

***************
*** 253,264 ****

  			// test property equals a value
! 			Assertion.Assert(new PropertyIs("MyProp", "hello").Eval(t));
! 			Assertion.Assert(!new PropertyIs("MyProp", "bye").Eval(t));

  			// test property using another constraint
! 			Assertion.Assert(new PropertyIs("MyProp", new IsMatch("ell")).Eval(t));
! 			Assertion.Assert(!new PropertyIs("MyProp", new IsMatch("sfsl")).Eval(t));

! 			Assertion.AssertEquals(
  				"Property MyProp: <x>",
  				new PropertyIs("MyProp", new IsEqual("x")).Message);
--- 255,266 ----

  			// test property equals a value
! 			Assert.IsTrue(new PropertyIs("MyProp", "hello").Eval(t));
! 			Assert.IsTrue(!new PropertyIs("MyProp", "bye").Eval(t));

  			// test property using another constraint
! 			Assert.IsTrue(new PropertyIs("MyProp", new IsMatch("ell")).Eval(t));
! 			Assert.IsTrue(!new PropertyIs("MyProp", new IsMatch("sfsl")).Eval(t));

! 			Assert.AreEqual(
  				"Property MyProp: <x>",
  				new PropertyIs("MyProp", new IsEqual("x")).Message);
***************
*** 268,272 ****
  		public void PropertyIsWithNullValue() 
  		{
! 			Assertion.Assert(!new PropertyIs("Blah", new IsAnything()).Eval(null));
  		}

--- 270,274 ----
  		public void PropertyIsWithNullValue() 
  		{
! 			Assert.IsTrue(!new PropertyIs("Blah", new IsAnything()).Eval(null));
  		}

***************
*** 276,281 ****
  			ThingWithProps t = new ThingWithProps();

! 			Assertion.Assert(new PropertyIs("MyProp.Length", 5).Eval(t));
! 			Assertion.Assert(!new PropertyIs("MyProp.Length", 9).Eval(t));
  		}

--- 278,283 ----
  			ThingWithProps t = new ThingWithProps();

! 			Assert.IsTrue(new PropertyIs("MyProp.Length", 5).Eval(t));
! 			Assert.IsTrue(!new PropertyIs("MyProp.Length", 9).Eval(t));
  		}

***************
*** 293,301 ****
  		{
  			CollectingConstraint c = new CollectingConstraint();
! 			Assertion.Assert(c.Eval("test"));
! 			Assertion.AssertEquals("test", c.Parameter);

! 			Assertion.Assert("eval should always be true", c.Eval(null));
! 			Assertion.AssertNull(c.Parameter);

  		}
--- 295,303 ----
  		{
  			CollectingConstraint c = new CollectingConstraint();
! 			Assert.IsTrue(c.Eval("test"));
! 			Assert.AreEqual("test", c.Parameter);

! 			Assert.IsTrue(c.Eval(null), "eval should always be true");
! 			Assert.IsNull(c.Parameter);

  		}
***************
*** 306,313 ****
  			c = new Constraint(new Constraint.Method(myEval));
  			myFlag = false;
! 			Assertion.Assert(c.Eval(null));
! 			Assertion.Assert(!c.Eval(null));
! 			Assertion.Assert(c.Eval(null));
! 			Assertion.Assert(!c.Eval(null));
  		}

--- 308,315 ----
  			c = new Constraint(new Constraint.Method(myEval));
  			myFlag = false;
! 			Assert.IsTrue(c.Eval(null));
! 			Assert.IsTrue(!c.Eval(null));
! 			Assert.IsTrue(c.Eval(null));
! 			Assert.IsTrue(!c.Eval(null));
  		}

***************
*** 315,334 ****
  		public void Messages()
  		{
! 			Assertion.AssertEquals("null", new IsNull().Message);
! 			Assertion.AssertEquals("", new IsAnything().Message);
! 			Assertion.AssertEquals("IN <hi>, <1>, <bye>", new IsIn("hi", 1, "bye").Message);
! 			Assertion.AssertEquals("<hi>", new IsEqual("hi").Message);
! 			Assertion.AssertEquals("typeof <System.String>", new IsTypeOf(typeof(System.String)).Message);
! 			Assertion.AssertEquals("NOT DUMMY", new Not(new Dummy()).Message);
! 			Assertion.AssertEquals("DUMMY AND DUMMY", new And(new Dummy(), new Dummy()).Message);
! 			Assertion.AssertEquals("DUMMY OR DUMMY", new Or(new Dummy(), new Dummy()).Message);
! 			Assertion.AssertEquals("NOT null", new NotNull().Message);
! 			Assertion.AssertEquals("NOT <hi>", new NotEqual("hi").Message);
! 			Assertion.AssertEquals("NOT IN <hi>, <1>, <bye>", new NotIn("hi", 1, "bye").Message);
! 			Assertion.AssertEquals("<hi>", new IsEqualIgnoreCase("hi").Message);
! 			Assertion.AssertEquals("<hi>", new IsEqualIgnoreWhiteSpace("hi").Message);
! 			Assertion.AssertEquals("<hi>", new IsMatch("hi").Message);
! 			Assertion.AssertEquals("<7>", new IsCloseTo(7.0, 1.1).Message);
! 			Assertion.AssertEquals("Custom Constraint", new Constraint(new Constraint.Method(myEval)).Message);
  		}
  		private bool myFlag;
--- 317,336 ----
  		public void Messages()
  		{
! 			Assert.AreEqual("null", new IsNull().Message);
! 			Assert.AreEqual("", new IsAnything().Message);
! 			Assert.AreEqual("IN <hi>, <1>, <bye>", new IsIn("hi", 1, "bye").Message);
! 			Assert.AreEqual("<hi>", new IsEqual("hi").Message);
! 			Assert.AreEqual("typeof <System.String>", new IsTypeOf(typeof(String)).Message);
! 			Assert.AreEqual("NOT DUMMY", new Not(new Dummy()).Message);
! 			Assert.AreEqual("DUMMY AND DUMMY", new And(new Dummy(), new Dummy()).Message);
! 			Assert.AreEqual("DUMMY OR DUMMY", new Or(new Dummy(), new Dummy()).Message);
! 			Assert.AreEqual("NOT null", new NotNull().Message);
! 			Assert.AreEqual("NOT <hi>", new NotEqual("hi").Message);
! 			Assert.AreEqual("NOT IN <hi>, <1>, <bye>", new NotIn("hi", 1, "bye").Message);
! 			Assert.AreEqual("<hi>", new IsEqualIgnoreCase("hi").Message);
! 			Assert.AreEqual("<hi>", new IsEqualIgnoreWhiteSpace("hi").Message);
! 			Assert.AreEqual("<hi>", new IsMatch("hi").Message);
! 			Assert.AreEqual("<7>", new IsCloseTo(7.0, 1.1).Message);
! 			Assert.AreEqual("Custom Constraint", new Constraint(new Constraint.Method(myEval)).Message);
  		}
  		private bool myFlag;
***************
*** 411,417 ****
              ExtractingConstraint constraint = new ExtractingConstraint("E");           

!             Assertion.AssertEquals("Should be modified value", "A", constraint.ExtractActualValue("ACTUAL"));
!             Assertion.Assert("Should match", constraint.Eval("EQUALS FIRST CHAR"));
!             Assertion.Assert("Should be different", new Not(constraint).Eval("NOT EQUAL"));
          }
          #endregion
--- 413,419 ----
              ExtractingConstraint constraint = new ExtractingConstraint("E");           

!             Assert.AreEqual("A", constraint.ExtractActualValue("ACTUAL"), "Should be modified value");
!             Assert.IsTrue(constraint.Eval("EQUALS FIRST CHAR"), "Should match");
!             Assert.IsTrue(new Not(constraint).Eval("NOT EQUAL"), "Should be different");
          }
          #endregion

Index: IsArrayEqualTest.cs
===================================================================
RCS file: /cvsroot/nmock/nmock/test/NMock/Constraints/IsArrayEqualTest.cs,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** IsArrayEqualTest.cs	11 Jul 2003 08:32:38 -0000	1.1
--- IsArrayEqualTest.cs	22 Oct 2004 11:46:27 -0000	1.2
***************
*** 1,5 ****
  // Contributed by Luke Maxon <lt...@th...>

- using System;
  using System.Collections;
  using NUnit.Framework;
--- 1,4 ----
***************
*** 18,24 ****

  			IsListEqual c = new IsListEqual(o1); 
! 			Assertion.Assert(!c.Eval(o2)); 
! 			Assertion.Assert(!c.Eval(o1)); 
! 			Assertion.Assert(!c.Eval(null)); 
  		} 

--- 17,23 ----

  			IsListEqual c = new IsListEqual(o1); 
! 			Assert.IsTrue(!c.Eval(o2)); 
! 			Assert.IsTrue(!c.Eval(o1)); 
! 			Assert.IsTrue(!c.Eval(null)); 
  		} 

***************
*** 30,36 ****

  			IsListEqual c = new IsListEqual(o1); 
! 			Assertion.Assert(c.Eval(o2)); 
! 			Assertion.Assert(c.Eval(o1)); 
! 			Assertion.Assert(!c.Eval(null)); 
  		} 

--- 29,35 ----

  			IsListEqual c = new IsListEqual(o1); 
! 			Assert.IsTrue(c.Eval(o2)); 
! 			Assert.IsTrue(c.Eval(o1)); 
! 			Assert.IsTrue(!c.Eval(null)); 
  		} 

***************
*** 42,46 ****

  			IsListEqual c = new IsListEqual(o1); 
! 			Assertion.Assert(!c.Eval(o2)); 
  		} 

--- 41,45 ----

  			IsListEqual c = new IsListEqual(o1); 
! 			Assert.IsTrue(!c.Eval(o2)); 
  		} 

***************
*** 52,56 ****

  			IsListEqual c = new IsListEqual(o1); 
! 			Assertion.Assert(c.Eval(o2)); 
  		} 

--- 51,55 ----

  			IsListEqual c = new IsListEqual(o1); 
! 			Assert.IsTrue(c.Eval(o2)); 
  		} 

***************
*** 62,66 ****

  			IsListEqual c = new IsListEqual(o1); 
! 			Assertion.Assert(!c.Eval(o2)); 
  		} 

--- 61,65 ----

  			IsListEqual c = new IsListEqual(o1); 
! 			Assert.IsTrue(!c.Eval(o2)); 
  		} 

***************
*** 72,76 ****

  			IsListEqual c = new IsListEqual(o1); 
! 			Assertion.Assert(c.Eval(o2)); 
  		} 

--- 71,75 ----

  			IsListEqual c = new IsListEqual(o1); 
! 			Assert.IsTrue(c.Eval(o2)); 
  		} 

***************
*** 82,86 ****

  			IsListEqual c = new IsListEqual(o1); 
! 			Assertion.Assert(!c.Eval(o2)); 
  		} 
  	} 
--- 81,85 ----

  			IsListEqual c = new IsListEqual(o1); 
! 			Assert.IsTrue(!c.Eval(o2)); 
  		} 
  	} 
***************
*** 96,102 ****

  			IsListEqual c = new IsListEqual(o1); 
! 			Assertion.Assert(!c.Eval(o2)); 
! 			Assertion.Assert(!c.Eval(o1)); 
! 			Assertion.Assert(!c.Eval(null)); 
  		} 

--- 95,101 ----

  			IsListEqual c = new IsListEqual(o1); 
! 			Assert.IsTrue(!c.Eval(o2)); 
! 			Assert.IsTrue(!c.Eval(o1)); 
! 			Assert.IsTrue(!c.Eval(null)); 
  		} 

***************
*** 108,114 ****

  			IsListEqual c = new IsListEqual(o1); 
! 			Assertion.Assert(c.Eval(o2)); 
! 			Assertion.Assert(c.Eval(o1)); 
! 			Assertion.Assert(!c.Eval(null)); 
  		} 

--- 107,113 ----

  			IsListEqual c = new IsListEqual(o1); 
! 			Assert.IsTrue(c.Eval(o2)); 
! 			Assert.IsTrue(c.Eval(o1)); 
! 			Assert.IsTrue(!c.Eval(null)); 
  		} 

***************
*** 120,124 ****

  			IsListEqual c = new IsListEqual(o1); 
! 			Assertion.Assert(!c.Eval(o2)); 
  		} 

--- 119,123 ----

  			IsListEqual c = new IsListEqual(o1); 
! 			Assert.IsTrue(!c.Eval(o2)); 
  		} 

***************
*** 130,134 ****

  			IsListEqual c = new IsListEqual(o1); 
! 			Assertion.Assert(c.Eval(o2)); 
  		} 

--- 129,133 ----

  			IsListEqual c = new IsListEqual(o1); 
! 			Assert.IsTrue(c.Eval(o2)); 
  		} 

***************
*** 140,144 ****

  			IsListEqual c = new IsListEqual(o1); 
! 			Assertion.Assert(!c.Eval(o2)); 
  		} 

--- 139,143 ----

  			IsListEqual c = new IsListEqual(o1); 
! 			Assert.IsTrue(!c.Eval(o2)); 
  		} 

***************
*** 150,154 ****

  			IsListEqual c = new IsListEqual(o1); 
! 			Assertion.Assert(c.Eval(o2)); 
  		} 

--- 149,153 ----

  			IsListEqual c = new IsListEqual(o1); 
! 			Assert.IsTrue(c.Eval(o2)); 
  		} 

***************
*** 160,166 ****

  			IsListEqual c = new IsListEqual(o1); 
! 			Assertion.Assert(!c.Eval(o2)); 
  		} 
! 	} 
! 	 
  }
\ No newline at end of file
--- 159,164 ----

  			IsListEqual c = new IsListEqual(o1); 
! 			Assert.IsTrue(!c.Eval(o2)); 
  		} 
! 	} 	 
  }
\ No newline at end of file