DescribedAs matcher can append values to its description

npryce · npryce · commit aadc4d4523b3 · 2006-09-25T06:53:13.000Z
Simplified IsComparableTo implementation, renamed to IsGreaterThan and pulled out factory methods into OrderingComparisons class
diff --git a/src/library/org/hamcrest/core/DescribedAs.java b/src/library/org/hamcrest/core/DescribedAs.java
@@ -2,6 +2,8 @@
  */
 package org.hamcrest.core;
 
+import java.util.regex.Pattern;
+
 import org.hamcrest.Description;
 import org.hamcrest.Matcher;
 import org.hamcrest.Factory;
@@ -10,25 +12,40 @@
  * Provides a custom description to another matcher.
  */
 public class DescribedAs<T> implements Matcher<T> {
-
-    private final String description;
+    private final String descriptionTemplate;
     private final Matcher<T> matcher;
-
-    public DescribedAs(String description, Matcher<T> matcher) {
-        this.description = description;
+    private final Object[] values;
+    
+    private final static Pattern ARG_PATTERN = Pattern.compile("%([0-9]+)"); 
+    
+    public DescribedAs(String descriptionTemplate, Matcher<T> matcher, Object[] values) {
+        this.descriptionTemplate = descriptionTemplate;
         this.matcher = matcher;
+        this.values = values.clone();
     }
-
+    
     public boolean match(T o) {
         return matcher.match(o);
     }
 
     public void describeTo(Description description) {
-        description.appendText(this.description);
+        java.util.regex.Matcher arg = ARG_PATTERN.matcher(descriptionTemplate);
+        
+        int textStart = 0;
+        while (arg.find()) {
+            description.appendText(descriptionTemplate.substring(textStart, arg.start()));
+            int argIndex = Integer.parseInt(arg.group(1));
+            description.appendValue(values[argIndex]);
+            textStart = arg.end();
+        }
+        
+        if (textStart < descriptionTemplate.length()) {
+            description.appendText(descriptionTemplate.substring(textStart));
+        }
     }
-
+    
     @Factory
-    public static <T> Matcher<T> describedAs(String description, Matcher<T> matcher) {
-        return new DescribedAs<T>(description, matcher);
+    public static <T> Matcher<T> describedAs(String description, Matcher<T> matcher, Object... values) {
+        return new DescribedAs<T>(description, matcher, values);
     }
 }
diff --git a/src/library/org/hamcrest/number/IsComparableTo.java b/src/library/org/hamcrest/number/IsComparableTo.java
diff --git a/src/library/org/hamcrest/number/IsGreaterThan.java b/src/library/org/hamcrest/number/IsGreaterThan.java
@@ -0,0 +1,26 @@
+/*  Copyright (c) 2000-2006 hamcrest.org
+ */
+package org.hamcrest.number;
+
+import org.hamcrest.Description;
+import org.hamcrest.Matcher;
+
+/**
+ * Is the value less than or greater than another {@link java.lang.Comparable} value?
+ */
+public class IsGreaterThan<T extends Comparable<T>> implements Matcher<T> {
+    private final Comparable<T> compareTo;
+    
+    public IsGreaterThan(Comparable<T> compareTo) {
+        this.compareTo = compareTo;
+    }
+    
+    public boolean match(T item) {
+        return compareTo.compareTo(item) < 0;
+    }
+    
+    public void describeTo(Description description) {
+        description.appendText("a value greater than ");
+        description.appendValue(compareTo);
+    }
+}
diff --git a/src/library/org/hamcrest/number/OrderingComparisons.java b/src/library/org/hamcrest/number/OrderingComparisons.java
@@ -0,0 +1,37 @@
+package org.hamcrest.number;
+
+import static org.hamcrest.core.IsEqual.eq;
+import static org.hamcrest.core.IsNot.not;
+import static org.hamcrest.core.Or.or;
+import static org.hamcrest.core.DescribedAs.describedAs;
+
+import org.hamcrest.Factory;
+import org.hamcrest.Matcher;
+
+public class OrderingComparisons {
+    @Factory
+    public static <T extends Comparable<T>> Matcher<T> greaterThan(T value) {
+        return new IsGreaterThan<T>(value);
+    }
+    
+    @Factory
+    public static <T extends Comparable<T>> Matcher<T> greaterThanOrEqualTo(T value) {
+        return describedAs("a value greater than or equal to %0", 
+                           or(greaterThan(value), eq(value)),
+                           value);
+    }
+    
+    @Factory
+    public static <T extends Comparable<T>> Matcher<T> lessThan(T value) {
+        return describedAs("a value less than %0", 
+                           not(greaterThanOrEqualTo(value)),
+                           value);
+    }
+
+    @Factory
+    public static <T extends Comparable<T>> Matcher<T> lessThanOrEqualTo(T value) {
+        return describedAs("a value less than or equal to %0",
+                           not(greaterThan(value)),
+                           value);
+    }
+}
diff --git a/src/unit-test/org/hamcrest/core/DescribedAsTest.java b/src/unit-test/org/hamcrest/core/DescribedAsTest.java
@@ -9,7 +9,6 @@
 import org.hamcrest.Matcher;
 
 public class DescribedAsTest extends AbstractMatcherTest {
-
     public void testOverridesDescriptionOfOtherMatcherWithThatPassedToConstructor() {
         Matcher m1 = describedAs("m1 description", alwaysPasses());
         Matcher m2 = describedAs("m2 description", alwaysFails());
@@ -18,12 +17,18 @@ public void testOverridesDescriptionOfOtherMatcherWithThatPassedToConstructor()
         assertDescription("m2 description", m2);
     }
 
+    public void testAppendsValuesToDescription() {
+        Matcher m = describedAs("value 1 = %0, value 2 = %1",
+                                alwaysPasses(), 33, 97);
+        
+        assertDescription("value 1 = <33>, value 2 = <97>", m);
+    }
+    
     public void testDelegatesMatchingToAnotherMatcher() {
         Matcher<Object> m1 = describedAs("irrelevant", alwaysPasses());
         Matcher<Object> m2 = describedAs("irrelevant", alwaysFails());
 
         assertTrue(m1.match(new Object()));
         assertFalse(m2.match("hi"));
     }
-
 }
diff --git a/src/unit-test/org/hamcrest/number/OrderingComparisonsTest.java b/src/unit-test/org/hamcrest/number/OrderingComparisonsTest.java
@@ -5,9 +5,9 @@
 import org.hamcrest.AbstractMatcherTest;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.core.IsNot.not;
-import static org.hamcrest.number.IsComparableTo.*;
+import static org.hamcrest.number.OrderingComparisons.*;
 
-public class IsComparableToTest extends AbstractMatcherTest {
+public class OrderingComparisonsTest extends AbstractMatcherTest {
 
     public void testComparesObjectsForGreaterThan() {
         assertThat(2, greaterThan(1));
