is(Class) and is(Object) both are Matcher<Object>, which makes Java sense

david.saff · david.saff · commit 613cd127fe3f · 2009-05-28T19:53:32.000Z
diff --git a/hamcrest-core/src/main/java/org/hamcrest/core/Is.java b/hamcrest-core/src/main/java/org/hamcrest/core/Is.java
@@ -55,7 +55,7 @@ public static <T> Matcher<T> is(Matcher<T> matcher) {
      *          vs.  assertThat(cheese, is(smelly))
      */
     @Factory
-    public static <T> Matcher<? super T> is(T value) {
+    public static Matcher<Object> is(Object value) {
         return is(equalTo(value));
     }
 
@@ -66,7 +66,7 @@ public static <T> Matcher<? super T> is(T value) {
      *          vs.  assertThat(cheese, is(Cheddar.class))
      */
     @Factory
-    public static <T> Matcher<? super T> is(Class<T> type) {
+    public static Matcher<Object> is(Class<?> type) {
         return is(instanceOf(type));
     }
 }
diff --git a/hamcrest-core/src/main/java/org/hamcrest/core/IsEqual.java b/hamcrest-core/src/main/java/org/hamcrest/core/IsEqual.java
@@ -14,10 +14,10 @@
  * Is the value equal to another value, as tested by the
  * {@link java.lang.Object#equals} invokedMethod?
  */
-public class IsEqual<T> extends BaseMatcher<T> {
+public class IsEqual extends BaseMatcher<Object> {
     private final Object object;
 
-    public IsEqual(T equalArg) {
+    public IsEqual(Object equalArg) {
         object = equalArg;
     }
 
@@ -64,7 +64,7 @@ private static boolean isArray(Object o) {
      * {@link java.lang.Object#equals} invokedMethod?
      */
     @Factory
-    public static <T> Matcher<? super T> equalTo(T operand) {
-        return new IsEqual<T>(operand);
+    public static Matcher<Object> equalTo(Object operand) {
+        return new IsEqual(operand);
     }
 }
diff --git a/hamcrest-library/src/main/java/org/hamcrest/beans/SamePropertyValuesAs.java b/hamcrest-library/src/main/java/org/hamcrest/beans/SamePropertyValuesAs.java
@@ -94,7 +94,7 @@ public static class PropertyMatcher extends DiagnosingMatcher<Object> {
     public PropertyMatcher(PropertyDescriptor descriptor, Object expectedObject) {
       this.propertyName = descriptor.getDisplayName();
       this.readMethod = descriptor.getReadMethod();
-      this.matcher = new IsEqual<Object>(readProperty(readMethod, expectedObject));
+      this.matcher = new IsEqual(readProperty(readMethod, expectedObject));
     }
     @Override
     public boolean matches(Object actual, Description mismatchDescription) {
diff --git a/hamcrest-unit-test/src/main/java/org/hamcrest/FeatureMatcherTest.java b/hamcrest-unit-test/src/main/java/org/hamcrest/FeatureMatcherTest.java
@@ -31,7 +31,7 @@ public void testDoesNotThrowClassCastException() {
   }
 
   
-  public static class Match extends IsEqual<String> {
+  public static class Match extends IsEqual {
     public Match(String equalArg) { super(equalArg); }
     @Override public void describeMismatch(Object item, Description description) {
       description.appendText("mismatch-description");
diff --git a/hamcrest-unit-test/src/main/java/org/hamcrest/collection/IsCollectionContainingTest.java b/hamcrest-unit-test/src/main/java/org/hamcrest/collection/IsCollectionContainingTest.java
@@ -51,7 +51,7 @@ public void testCanMatchItemWhenCollectionHoldsSuperclass() // Issue 24
     {
       final Set<Number> s = new HashSet<Number>();
       s.add(Integer.valueOf(2));
-      assertThat(s, new IsCollectionContaining<Number>(new IsEqual<Object>(Integer.valueOf(2))));
+      assertThat(s, new IsCollectionContaining<Number>(new IsEqual(Integer.valueOf(2))));
       assertThat(s, IsCollectionContaining.hasItem(Integer.valueOf(2)));
     }
 
diff --git a/hamcrest-unit-test/src/main/java/org/hamcrest/core/AllOfTest.java b/hamcrest-unit-test/src/main/java/org/hamcrest/core/AllOfTest.java
@@ -16,7 +16,6 @@ protected Matcher<?> createMatcher() {
         return allOf(equalTo("irrelevant"));
     }
     
-    @SuppressWarnings("unchecked")
     public void testEvaluatesToTheTheLogicalConjunctionOfTwoOtherMatchers() {
         assertThat("good", allOf(equalTo("good"), equalTo("good")));
 
@@ -25,30 +24,26 @@ public void testEvaluatesToTheTheLogicalConjunctionOfTwoOtherMatchers() {
         assertThat("good", not(allOf(equalTo("bad"), equalTo("bad"))));
     }
 
-    @SuppressWarnings("unchecked")
     public void testEvaluatesToTheTheLogicalConjunctionOfManyOtherMatchers() {
         assertThat("good", allOf(equalTo("good"), equalTo("good"), equalTo("good"), equalTo("good"), equalTo("good")));
         assertThat("good", not(allOf(equalTo("good"), equalTo("good"), equalTo("bad"), equalTo("good"), equalTo("good"))));
     }
     
-    @SuppressWarnings("unchecked")
     public void testSupportsMixedTypes() {
-        final Matcher<SampleSubClass> all = allOf(
+        final Matcher<Object> all = allOf(
                 equalTo(new SampleBaseClass("bad")),
                 equalTo(new SampleBaseClass("good")),
                 equalTo(new SampleSubClass("ugly")));
-        final Matcher<SampleSubClass> negated = not(all);
+        final Matcher<Object> negated = not(all);
         
         assertThat(new SampleSubClass("good"), negated);
     }
     
-    @SuppressWarnings("unchecked")
     public void testHasAReadableDescription() {
         assertDescription("(\"good\" and \"bad\" and \"ugly\")",
                 allOf(equalTo("good"), equalTo("bad"), equalTo("ugly")));
     }
 
-    @SuppressWarnings("unchecked")
     public void testMismatchDescriptionDescribesFirstFailingMatch() {
     	assertMismatchDescription("\"good\" was \"bad\"", allOf(equalTo("bad"), equalTo("good")), "bad");
 	}
diff --git a/hamcrest-unit-test/src/main/java/org/hamcrest/core/AnyOfTest.java b/hamcrest-unit-test/src/main/java/org/hamcrest/core/AnyOfTest.java
@@ -16,7 +16,6 @@ protected Matcher<?> createMatcher() {
         return anyOf(equalTo("irrelevant"));
     }
 
-    @SuppressWarnings("unchecked")
     public void testEvaluatesToTheTheLogicalDisjunctionOfTwoOtherMatchers() {
         assertThat("good", anyOf(equalTo("bad"), equalTo("good")));
         assertThat("good", anyOf(equalTo("good"), equalTo("good")));
@@ -25,15 +24,13 @@ public void testEvaluatesToTheTheLogicalDisjunctionOfTwoOtherMatchers() {
         assertThat("good", not(anyOf(equalTo("bad"), equalTo("bad"))));
     }
 
-    @SuppressWarnings("unchecked")
     public void testEvaluatesToTheTheLogicalDisjunctionOfManyOtherMatchers() {
         assertThat("good", anyOf(equalTo("bad"), equalTo("good"), equalTo("bad"), equalTo("bad"), equalTo("bad")));
         assertThat("good", not(anyOf(equalTo("bad"), equalTo("bad"), equalTo("bad"), equalTo("bad"), equalTo("bad"))));
     }
 
-    @SuppressWarnings("unchecked")
     public void testSupportsMixedTypes() {
-        final Matcher<SampleSubClass> combined = anyOf(
+        final Matcher<Object> combined = anyOf(
                 equalTo(new SampleBaseClass("bad")),
                 equalTo(new SampleBaseClass("good")),
                 equalTo(new SampleSubClass("ugly"))
@@ -42,7 +39,6 @@ public void testSupportsMixedTypes() {
         assertThat(new SampleSubClass("good"), combined);
     }    
     
-    @SuppressWarnings("unchecked")
     public void testHasAReadableDescription() {
         assertDescription("(\"good\" or \"bad\" or \"ugly\")",
                 anyOf(equalTo("good"), equalTo("bad"), equalTo("ugly")));
diff --git a/hamcrest-unit-test/src/main/java/org/hamcrest/core/CombinableTest.java b/hamcrest-unit-test/src/main/java/org/hamcrest/core/CombinableTest.java
@@ -1,5 +1,6 @@
 package org.hamcrest.core;
 
+import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.equalTo;
@@ -22,11 +23,16 @@ public void bothAcceptsAndRejects() {
   }
   
   @Test
-  public void bothAcceptsAndRejectsInline() {
+  public void bothCompilesWithEqualTo() {
     assertThat(2, CombinableMatcher.both(not(equalTo(3))).and(not(equalTo(4))));
     assertThat(3, not(CombinableMatcher.both(not(equalTo(3))).and(not(equalTo(4)))));
   }
 
+  @Test
+  public void bothCompilesWithIs() {
+	assertThat(3, CombinableMatcher.both(is(3)).and(is(Integer.class)));
+  }
+	
   @Test
   public void acceptsAndRejectsThreeAnds() {
     final CombinableMatcher<? super Integer> tripleAnd = NOT_3_AND_NOT_4.and(equalTo(2));

Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,7 @@ public static <T> Matcher<T> is(Matcher<T> matcher) {`
`55`	`55`	`* vs. assertThat(cheese, is(smelly))`
`56`	`56`	`*/`
`57`	`57`	`@Factory`
`58`		`- public static <T> Matcher<? super T> is(T value) {`
	`58`	`+ public static Matcher<Object> is(Object value) {`
`59`	`59`	`return is(equalTo(value));`
`60`	`60`	`}`
`61`	`61`
`@@ -66,7 +66,7 @@ public static <T> Matcher<? super T> is(T value) {`
`66`	`66`	`* vs. assertThat(cheese, is(Cheddar.class))`
`67`	`67`	`*/`
`68`	`68`	`@Factory`
`69`		`- public static <T> Matcher<? super T> is(Class<T> type) {`
	`69`	`+ public static Matcher<Object> is(Class<?> type) {`
`70`	`70`	`return is(instanceOf(type));`
`71`	`71`	`}`
`72`	`72`	`}`
Original file line number	Diff line number	Diff line change
`@@ -94,7 +94,7 @@ public static class PropertyMatcher extends DiagnosingMatcher<Object> {`
`94`	`94`	`public PropertyMatcher(PropertyDescriptor descriptor, Object expectedObject) {`
`95`	`95`	`this.propertyName = descriptor.getDisplayName();`
`96`	`96`	`this.readMethod = descriptor.getReadMethod();`
`97`		`- this.matcher = new IsEqual<Object>(readProperty(readMethod, expectedObject));`
	`97`	`+ this.matcher = new IsEqual(readProperty(readMethod, expectedObject));`
`98`	`98`	`}`
`99`	`99`	`@Override`
`100`	`100`	`public boolean matches(Object actual, Description mismatchDescription) {`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ public void testDoesNotThrowClassCastException() {`
`31`	`31`	`}`
`32`	`32`
`33`	`33`
`34`		`- public static class Match extends IsEqual<String> {`
	`34`	`+ public static class Match extends IsEqual {`
`35`	`35`	`public Match(String equalArg) { super(equalArg); }`
`36`	`36`	`@Override public void describeMismatch(Object item, Description description) {`
`37`	`37`	`description.appendText("mismatch-description");`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ public void testCanMatchItemWhenCollectionHoldsSuperclass() // Issue 24`
`51`	`51`	`{`
`52`	`52`	`final Set<Number> s = new HashSet<Number>();`
`53`	`53`	`s.add(Integer.valueOf(2));`
`54`		`- assertThat(s, new IsCollectionContaining<Number>(new IsEqual<Object>(Integer.valueOf(2))));`
	`54`	`+ assertThat(s, new IsCollectionContaining<Number>(new IsEqual(Integer.valueOf(2))));`
`55`	`55`	`assertThat(s, IsCollectionContaining.hasItem(Integer.valueOf(2)));`
`56`	`56`	`}`
`57`	`57`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,6 @@ protected Matcher<?> createMatcher() {`
`16`	`16`	`return allOf(equalTo("irrelevant"));`
`17`	`17`	`}`
`18`	`18`
`19`		`- @SuppressWarnings("unchecked")`
`20`	`19`	`public void testEvaluatesToTheTheLogicalConjunctionOfTwoOtherMatchers() {`
`21`	`20`	`assertThat("good", allOf(equalTo("good"), equalTo("good")));`
`22`	`21`
`@@ -25,30 +24,26 @@ public void testEvaluatesToTheTheLogicalConjunctionOfTwoOtherMatchers() {`
`25`	`24`	`assertThat("good", not(allOf(equalTo("bad"), equalTo("bad"))));`
`26`	`25`	`}`
`27`	`26`
`28`		`- @SuppressWarnings("unchecked")`
`29`	`27`	`public void testEvaluatesToTheTheLogicalConjunctionOfManyOtherMatchers() {`
`30`	`28`	`assertThat("good", allOf(equalTo("good"), equalTo("good"), equalTo("good"), equalTo("good"), equalTo("good")));`
`31`	`29`	`assertThat("good", not(allOf(equalTo("good"), equalTo("good"), equalTo("bad"), equalTo("good"), equalTo("good"))));`
`32`	`30`	`}`
`33`	`31`
`34`		`- @SuppressWarnings("unchecked")`
`35`	`32`	`public void testSupportsMixedTypes() {`
`36`		`- final Matcher<SampleSubClass> all = allOf(`
	`33`	`+ final Matcher<Object> all = allOf(`
`37`	`34`	`equalTo(new SampleBaseClass("bad")),`
`38`	`35`	`equalTo(new SampleBaseClass("good")),`
`39`	`36`	`equalTo(new SampleSubClass("ugly")));`
`40`		`- final Matcher<SampleSubClass> negated = not(all);`
	`37`	`+ final Matcher<Object> negated = not(all);`
`41`	`38`
`42`	`39`	`assertThat(new SampleSubClass("good"), negated);`
`43`	`40`	`}`
`44`	`41`
`45`		`- @SuppressWarnings("unchecked")`
`46`	`42`	`public void testHasAReadableDescription() {`
`47`	`43`	`assertDescription("(\"good\" and \"bad\" and \"ugly\")",`
`48`	`44`	`allOf(equalTo("good"), equalTo("bad"), equalTo("ugly")));`
`49`	`45`	`}`
`50`	`46`
`51`		`- @SuppressWarnings("unchecked")`
`52`	`47`	`public void testMismatchDescriptionDescribesFirstFailingMatch() {`
`53`	`48`	`assertMismatchDescription("\"good\" was \"bad\"", allOf(equalTo("bad"), equalTo("good")), "bad");`
`54`	`49`	`}`