Fixed Issue 77. OrderingComparison is describing mismatches backwards

smgfreeman · smgfreeman · commit dff7af83b9c4 · 2009-04-25T20:45:17.000Z
diff --git a/hamcrest-library/src/main/java/org/hamcrest/number/OrderingComparison.java b/hamcrest-library/src/main/java/org/hamcrest/number/OrderingComparison.java
@@ -1,3 +1,5 @@
+/*  Copyright (c) 2000-2009 hamcrest.org
+ */
 package org.hamcrest.number;
 
 import org.hamcrest.Description;
@@ -6,84 +8,86 @@
 import org.hamcrest.TypeSafeMatcher;
 
 public class OrderingComparison<T extends Comparable<T>> extends TypeSafeMatcher<T> {
-    private final T value;
+    private static final int LESS_THAN = -1;
+    private static final int GREATER_THAN = 1;
+    private static final int EQUAL = 0;
+    private final T expected;
     private final int minCompare, maxCompare;
 
-    private OrderingComparison(T value, int minCompare, int maxCompare) {
-        this.value = value;
+    private OrderingComparison(T expected, int minCompare, int maxCompare) {
+        this.expected = expected;
         this.minCompare = minCompare;
         this.maxCompare = maxCompare;
     }
 
     @Override
-    public boolean matchesSafely(T other) {
-        int compare = Integer.signum(value.compareTo(other));
+    public boolean matchesSafely(T actual) {
+        int compare = Integer.signum(actual.compareTo(expected));
         return minCompare <= compare && compare <= maxCompare;
     }
 
     @Override
-    public void describeMismatchSafely(T item, Description mismatchDescription) {
-      mismatchDescription.appendValue(value) .appendText(" was ")
-                         .appendText(comparison(value.compareTo(item))).appendText(" ").appendValue(item);
+    public void describeMismatchSafely(T actual, Description mismatchDescription) {
+      mismatchDescription.appendValue(expected) .appendText(" was ")
+                         .appendText(comparison(actual.compareTo(expected)))
+                         .appendText(" ").appendValue(actual);
     };
     
     public void describeTo(Description description) {
         description.appendText("a value ").appendText(comparison(minCompare));
         if (minCompare != maxCompare) {
             description.appendText(" or ").appendText(comparison(maxCompare));
         }
-        description.appendText(" ").appendValue(value);
+        description.appendText(" ").appendValue(expected);
     }
 
     private String comparison(int compare) {
-        if (compare > 0) {
-            return "less than";
-        }
-        else if (compare == 0) {
-            return "equal to ";
-        }
-        else {
-            return "greater than";
-        }
+      if (compare == EQUAL) {
+        return "equal to";
+      } else if (compare > EQUAL) {
+        return "greater than";
+      } else {
+        return "less than";
+      }
     }
 
     /**
      * Is value = expected?
      */
     @Factory
     public static <T extends Comparable<T>> Matcher<? super T> comparesEqualTo(T value) {
-        return new OrderingComparison<T>(value, 0, 0);
+        return new OrderingComparison<T>(value, EQUAL, EQUAL);
     }
 
     /**
      * Is value > expected?
      */
     @Factory
     public static <T extends Comparable<T>> Matcher<? super T> greaterThan(T value) {
-        return new OrderingComparison<T>(value, -1, -1);
+        return new OrderingComparison<T>(value, GREATER_THAN, GREATER_THAN);
     }
 
     /**
      * Is value >= expected?
      */
     @Factory
     public static <T extends Comparable<T>> Matcher<? super T> greaterThanOrEqualTo(T value) {
-        return new OrderingComparison<T>(value, -1, 0);
+        return new OrderingComparison<T>(value, EQUAL, GREATER_THAN);
     }
 
     /**
      * Is value < expected?
      */
     @Factory
     public static <T extends Comparable<T>> Matcher<? super T> lessThan(T value) {
-        return new OrderingComparison<T>(value, 1, 1);
+        return new OrderingComparison<T>(value, LESS_THAN, LESS_THAN);
     }
 
     /**
      * Is value <= expected?
      */
     @Factory
     public static <T extends Comparable<T>> Matcher<? super T> lessThanOrEqualTo(T value) {
-        return new OrderingComparison<T>(value, 0, 1);
+        return new OrderingComparison<T>(value, LESS_THAN, EQUAL);
     }
 }
diff --git a/hamcrest-unit-test/src/main/java/org/hamcrest/number/OrderingComparisonTest.java b/hamcrest-unit-test/src/main/java/org/hamcrest/number/OrderingComparisonTest.java
@@ -1,4 +1,4 @@
-/*  Copyright (c) 2000-2006 hamcrest.org
+/*  Copyright (c) 2000-2009 hamcrest.org
  */
 package org.hamcrest.number;
 
@@ -22,6 +22,20 @@ protected Matcher<?> createMatcher() {
         return greaterThan(1);
     }
 
+    public void testDescription() {
+      assertDescription("a value greater than <1>", greaterThan(1));
+      assertDescription("a value equal to or greater than <1>", greaterThanOrEqualTo(1));
+      assertDescription("a value equal to <1>", comparesEqualTo(1));
+      assertDescription("a value less than or equal to <1>", lessThanOrEqualTo(1));
+      assertDescription("a value less than <1>", lessThan(1));
+    }
+
+    public void testMismatchDescriptions() {
+      assertMismatchDescription("<1> was less than <0>", greaterThan(1), 0);
+      assertMismatchDescription("<1> was equal to <1>", greaterThan(1), 1);
+      assertMismatchDescription("<0> was greater than <1>", lessThan(0), 1);
+    }
+    
     public void testComparesObjectsForGreaterThan() {
         assertThat(2, greaterThan(1));
         assertThat(0, not(greaterThan(1)));
@@ -39,8 +53,8 @@ public void testComparesObjectsForEquality() {
     }
 
     public void testAllowsForInclusiveComparisons() {
-        assertThat(1, lessThanOrEqualTo(1));
-        assertThat(1, greaterThanOrEqualTo(1));
+        assertThat("less", 1, lessThanOrEqualTo(1));
+        assertThat("greater", 1, greaterThanOrEqualTo(1));
     }
 
     public void testSupportsDifferentTypesOfComparableObjects() {
