[ejuf-cvs] ejuf/src/java/tests/ejuf/assertions EqualityAssertionsImplTest.java,1.2,1.3

[<fb...@us...>]

Update of /cvsroot/ejuf/ejuf/src/java/tests/ejuf/assertions
In directory sc8-pr-cvs1:/tmp/cvs-serv5814/tests/ejuf/assertions

Modified Files:
	EqualityAssertionsImplTest.java 
Log Message:
Corrected a bug where float and double comparison would fail if the expected value was larger than the actual value.  This was due to a failure to use Math.abs() while comparing values.

Index: EqualityAssertionsImplTest.java
===================================================================
RCS file: /cvsroot/ejuf/ejuf/src/java/tests/ejuf/assertions/EqualityAssertionsImplTest.java,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** EqualityAssertionsImplTest.java	15 Nov 2002 17:34:49 -0000	1.2
--- EqualityAssertionsImplTest.java	23 Dec 2002 23:36:27 -0000	1.3
***************
*** 11,15 ****
  
      public void setUp() throws Exception {
!         ((AssertionServices)a).addAssertionListener(this);
  
          expectedAssertionCount.setExpected(2);
--- 11,15 ----
  
      public void setUp() throws Exception {
!         a.addAssertionListener(this);
  
          expectedAssertionCount.setExpected(2);
***************
*** 192,195 ****
--- 192,291 ----
              assertEquals(new Float(1.1f), possibleSuccess.getActualValue());
              assertEquals("with message", possibleSuccess.getAssertionMessage());
+         }
+     }
+ 
+     public void testInt_ExpectedLargerThanActual() {
+         expectedAssertionCount.setExpected(1);
+ 
+         try {
+             a.assertEquals("should fail", 1, 0);
+             fail("test should have failed");
+         } catch (ComparisonError possibleSuccess) {
+             assertEquals(new Integer(1), possibleSuccess.getExpectedValue());
+             assertEquals(new Integer(0), possibleSuccess.getActualValue());
+         }
+     }
+ 
+     public void testInt_ActualLargerThanExpected() {
+         expectedAssertionCount.setExpected(1);
+ 
+         try {
+             a.assertEquals("should fail", 0, 1);
+             fail("test should have failed");
+         } catch (ComparisonError possibleSuccess) {
+             assertEquals(new Integer(0), possibleSuccess.getExpectedValue());
+             assertEquals(new Integer(1), possibleSuccess.getActualValue());
+         }
+     }
+ 
+     public void testLong_ExpectedLargerThanActual() {
+         expectedAssertionCount.setExpected(1);
+ 
+         try {
+             a.assertEquals("should fail", 1l, 0l);
+             fail("test should have failed");
+         } catch (ComparisonError possibleSuccess) {
+             assertEquals(new Long(1l), possibleSuccess.getExpectedValue());
+             assertEquals(new Long(0l), possibleSuccess.getActualValue());
+         }
+     }
+ 
+     public void testLong_ActualLargerThanExpected() {
+         expectedAssertionCount.setExpected(1);
+ 
+         try {
+             a.assertEquals("should fail", 0l, 1l);
+             fail("test should have failed");
+         } catch (ComparisonError possibleSuccess) {
+             assertEquals(new Long(0l), possibleSuccess.getExpectedValue());
+             assertEquals(new Long(1l), possibleSuccess.getActualValue());
+         }
+     }
+ 
+     public void testFloat_ExpectedLargerThanActual() {
+         expectedAssertionCount.setExpected(1);
+ 
+         try {
+             a.assertEquals("should fail", 1.0f, 0.0f, 0.0f);
+             fail("test should have failed");
+         } catch (ComparisonError possibleSuccess) {
+             assertEquals(new Float(1.0f), possibleSuccess.getExpectedValue());
+             assertEquals(new Float(0.0f), possibleSuccess.getActualValue());
+         }
+     }
+ 
+     public void testFloat_ActualLargerThanExpected() {
+         expectedAssertionCount.setExpected(1);
+ 
+         try {
+             a.assertEquals("should fail", 0.0f, 1.0f, 0.0f);
+             fail("test should have failed");
+         } catch (ComparisonError possibleSuccess) {
+             assertEquals(new Float(0.0f), possibleSuccess.getExpectedValue());
+             assertEquals(new Float(1.0f), possibleSuccess.getActualValue());
+         }
+     }
+ 
+     public void testDouble_ExpectedLargerThanActual() {
+         expectedAssertionCount.setExpected(1);
+ 
+         try {
+             a.assertEquals("should fail", 1.0d, 0.0d, 0.0d);
+             fail("test should have failed");
+         } catch (ComparisonError possibleSuccess) {
+             assertEquals(new Double(1.0d), possibleSuccess.getExpectedValue());
+             assertEquals(new Double(0.0d), possibleSuccess.getActualValue());
+         }
+     }
+ 
+     public void testDouble_ActualLargerThanExpected() {
+         expectedAssertionCount.setExpected(1);
+ 
+         try {
+             a.assertEquals("should fail", 0.0d, 1.0d, 0.0d);
+             fail("test should have failed");
+         } catch (ComparisonError possibleSuccess) {
+             assertEquals(new Double(0.0d), possibleSuccess.getExpectedValue());
+             assertEquals(new Double(1.0d), possibleSuccess.getActualValue());
          }
      }