Home | History | Annotate | Download | only in comparator 
      1 package org.hamcrest.comparator;
      2 
      3 import org.hamcrest.AbstractMatcherTest;
      4 import org.hamcrest.Matcher;
      5 
      6 import java.math.BigDecimal;
      7 import java.util.Comparator;
      8 
      9 import static org.hamcrest.MatcherAssert.assertThat;
     10 import static org.hamcrest.comparator.ComparatorMatcherBuilder.comparedBy;
     11 import static org.hamcrest.core.IsNot.not;
     12 
     13 public class ComparatorMatcherBuilderTest extends AbstractMatcherTest {
     14 
     15     private final ComparatorMatcherBuilder<Integer> integerComparatorMatcherBuilder = ComparatorMatcherBuilder.usingNaturalOrdering();
     16     private final ComparatorMatcherBuilder<Double> doubleComparatorMatcherBuilder = ComparatorMatcherBuilder.usingNaturalOrdering();
     17     private final ComparatorMatcherBuilder<String> stringComparatorMatcherBuilder = ComparatorMatcherBuilder.usingNaturalOrdering();
     18     private final ComparatorMatcherBuilder<BigDecimal> bigDecimalComparatorMatcherBuilder = ComparatorMatcherBuilder.usingNaturalOrdering();
     19     private final Comparator<Integer> backwardsIntegerComparator = new Comparator<Integer>() {
     20         @Override
     21         public int compare(Integer o1, Integer o2) {
     22             return -o1.compareTo(o2);
     23         }
     24 
     25         @Override
     26         public String toString() {
     27             return "backwards integer comparator";
     28         }
     29     };
     30 
     31     @Override
     32     protected Matcher<Integer> createMatcher() {
     33         return integerComparatorMatcherBuilder.greaterThan(1);
     34     }
     35 
     36     public void testDescription() {
     37         assertDescription("a value greater than <1>", integerComparatorMatcherBuilder.greaterThan(1));
     38         assertDescription("a value equal to or greater than <1>", integerComparatorMatcherBuilder.greaterThanOrEqualTo(1));
     39         assertDescription("a value equal to <1>", integerComparatorMatcherBuilder.comparesEqualTo(1));
     40         assertDescription("a value less than or equal to <1>", integerComparatorMatcherBuilder.lessThanOrEqualTo(1));
     41         assertDescription("a value less than <1>", integerComparatorMatcherBuilder.lessThan(1));
     42 
     43         assertDescription("a value greater than <1> when compared by <backwards integer comparator>", comparedBy(backwardsIntegerComparator).greaterThan(1));
     44         assertDescription("a value equal to or greater than <1> when compared by <backwards integer comparator>", comparedBy(backwardsIntegerComparator).greaterThanOrEqualTo(1));
     45         assertDescription("a value equal to <1> when compared by <backwards integer comparator>", comparedBy(backwardsIntegerComparator).comparesEqualTo(1));
     46         assertDescription("a value less than or equal to <1> when compared by <backwards integer comparator>", comparedBy(backwardsIntegerComparator).lessThanOrEqualTo(1));
     47         assertDescription("a value less than <1> when compared by <backwards integer comparator>", comparedBy(backwardsIntegerComparator).lessThan(1));
     48     }
     49 
     50     public void testMismatchDescriptions() {
     51         assertMismatchDescription("<0> was less than <1>", integerComparatorMatcherBuilder.greaterThan(1), 0);
     52         assertMismatchDescription("<1> was equal to <1>", integerComparatorMatcherBuilder.greaterThan(1), 1);
     53         assertMismatchDescription("<1> was greater than <0>", integerComparatorMatcherBuilder.lessThan(0), 1);
     54         assertMismatchDescription("<2> was equal to <2>", integerComparatorMatcherBuilder.lessThan(2), 2);
     55 
     56         assertMismatchDescription("<1> was less than <0> when compared by <backwards integer comparator>", comparedBy(backwardsIntegerComparator).greaterThan(0), 1);
     57         assertMismatchDescription("<1> was equal to <1> when compared by <backwards integer comparator>", comparedBy(backwardsIntegerComparator).greaterThan(1), 1);
     58         assertMismatchDescription("<0> was greater than <1> when compared by <backwards integer comparator>", comparedBy(backwardsIntegerComparator).lessThan(1), 0);
     59         assertMismatchDescription("<2> was equal to <2> when compared by <backwards integer comparator>", comparedBy(backwardsIntegerComparator).lessThan(2), 2);
     60     }
     61 
     62     public void testComparesObjectsForGreaterThan() {
     63         assertThat(2, integerComparatorMatcherBuilder.greaterThan(1));
     64         assertThat(0, not(integerComparatorMatcherBuilder.greaterThan(1)));
     65     }
     66 
     67     public void testComparesObjectsForLessThan() {
     68         assertThat(2, integerComparatorMatcherBuilder.lessThan(3));
     69         assertThat(0, integerComparatorMatcherBuilder.lessThan(1));
     70     }
     71 
     72 
     73     public void testComparesObjectsForEquality() {
     74         assertThat(3, integerComparatorMatcherBuilder.comparesEqualTo(3));
     75         assertThat("aa", stringComparatorMatcherBuilder.comparesEqualTo("aa"));
     76     }
     77 
     78     public void testAllowsForInclusiveComparisons() {
     79         assertThat("less", 1, integerComparatorMatcherBuilder.lessThanOrEqualTo(1));
     80         assertThat("greater", 1, integerComparatorMatcherBuilder.greaterThanOrEqualTo(1));
     81     }
     82 
     83     public void testSupportsDifferentTypesOfComparableObjects() {
     84         assertThat(1.1, doubleComparatorMatcherBuilder.greaterThan(1.0));
     85         assertThat("cc", stringComparatorMatcherBuilder.greaterThan("bb"));
     86     }
     87 
     88     public void testComparesBigDecimalsWithDifferentScalesCorrectlyForIssue20() {
     89         assertThat(new BigDecimal("10.0"), bigDecimalComparatorMatcherBuilder.greaterThanOrEqualTo(new BigDecimal("10")));
     90         assertThat(new BigDecimal(10), bigDecimalComparatorMatcherBuilder.greaterThanOrEqualTo(new BigDecimal("10.0")));
     91         assertThat(new BigDecimal("2"), bigDecimalComparatorMatcherBuilder.comparesEqualTo(new BigDecimal("2.000")));
     92     }
     93 
     94     public void testComparesCustomTypesWhoseCompareToReturnsValuesGreaterThatOne() {
     95         assertThat(new CustomInt(5), ComparatorMatcherBuilder.<CustomInt>usingNaturalOrdering().lessThan(new CustomInt(10)));
     96     }
     97 
     98     public void testComparesByCustomComparator() {
     99         assertThat(5, comparedBy(backwardsIntegerComparator).lessThan(4));
    100     }
    101 
    102     public void testJavadocExamples() {
    103         assertThat(1, ComparatorMatcherBuilder.<Integer>usingNaturalOrdering().comparesEqualTo(1));
    104         assertThat(2, ComparatorMatcherBuilder.<Integer>usingNaturalOrdering().greaterThan(1));
    105         assertThat(1, ComparatorMatcherBuilder.<Integer>usingNaturalOrdering().greaterThanOrEqualTo(1));
    106         assertThat(1, ComparatorMatcherBuilder.<Integer>usingNaturalOrdering().lessThan(2));
    107         assertThat(1, ComparatorMatcherBuilder.<Integer>usingNaturalOrdering().lessThanOrEqualTo(1));
    108         assertThat(5, comparedBy(new Comparator<Integer>() {
    109             @Override
    110             public int compare(Integer o1, Integer o2) {
    111                 return -o1.compareTo(o2);
    112             }
    113         }).lessThan(4));
    114     }
    115 
    116     private static final class CustomInt implements Comparable<CustomInt> {
    117         private final int value;
    118 
    119         public CustomInt(int value) {
    120             this.value = value;
    121         }
    122 
    123         @Override
    124         public int compareTo(CustomInt other) {
    125             return value - other.value;
    126         }
    127     }
    128 }
    129