Renamed mapWithKey() -> hasKey(), mapWithValue() -> hasValue(), mapContaining() -> hasEntry()

joeretro · joeretro · commit 70133621a1a4 · 2006-12-16T17:53:59.000Z
diff --git a/src/library/org/hamcrest/collection/IsMapContaining.java b/src/library/org/hamcrest/collection/IsMapContaining.java
@@ -39,32 +39,32 @@ public void describeTo(Description description) {
     }
 
     @Factory
-    public static <K,V> Matcher<Map<K,V>> mapContaining(Matcher<K> keyMatcher, Matcher<V> valueMatcher) {
+    public static <K,V> Matcher<Map<K,V>> hasEntry(Matcher<K> keyMatcher, Matcher<V> valueMatcher) {
         return new IsMapContaining<K,V>(keyMatcher, valueMatcher);
     }
 
     @Factory
-    public static <K,V> Matcher<Map<K,V>> mapContaining(K key, V value) {
-        return mapContaining(equalTo(key), equalTo(value));
+    public static <K,V> Matcher<Map<K,V>> hasEntry(K key, V value) {
+        return hasEntry(equalTo(key), equalTo(value));
     }
 
     @Factory
-    public static <K,V> Matcher<Map<K,V>> mapWithKey(Matcher<K> keyMatcher) {
-        return mapContaining(keyMatcher, IsAnything.<V>anything());
+    public static <K,V> Matcher<Map<K,V>> hasKey(Matcher<K> keyMatcher) {
+        return hasEntry(keyMatcher, IsAnything.<V>anything());
     }
 
     @Factory
-    public static <K,V> Matcher<Map<K,V>> mapWithKey(K key) {
-        return mapWithKey(equalTo(key));
+    public static <K,V> Matcher<Map<K,V>> hasKey(K key) {
+        return hasKey(equalTo(key));
     }
 
     @Factory
-    public static <K,V> Matcher<Map<K,V>> mapWithValue(Matcher<V> valueMatcher) {
-        return mapContaining(IsAnything.<K>anything(), valueMatcher);
+    public static <K,V> Matcher<Map<K,V>> hasValue(Matcher<V> valueMatcher) {
+        return hasEntry(IsAnything.<K>anything(), valueMatcher);
     }
 
     @Factory
-    public static <K,V> Matcher<Map<K,V>> mapWithValue(V value) {
-        return mapWithValue(equalTo(value));
+    public static <K,V> Matcher<Map<K,V>> hasValue(V value) {
+        return hasValue(equalTo(value));
     }
 }
diff --git a/src/unit-test/org/hamcrest/collection/IsMapContainingTest.java b/src/unit-test/org/hamcrest/collection/IsMapContainingTest.java
@@ -2,7 +2,7 @@
 
 import org.hamcrest.AbstractMatcherTest;
 import org.hamcrest.Matcher;
-import static org.hamcrest.collection.IsMapContaining.mapContaining;
+import static org.hamcrest.collection.IsMapContaining.hasEntry;
 import static org.hamcrest.core.IsAnything.anything;
 import static org.hamcrest.core.IsEqual.equalTo;
 
@@ -12,27 +12,27 @@
 public class IsMapContainingTest extends AbstractMatcherTest {
 
     protected Matcher<?> createMatcher() {
-        return mapContaining("irrelevant", "irrelevant");
+        return IsMapContaining.hasEntry("irrelevant", "irrelevant");
     }
 
     public void testMatchesMapContainingMatchingKeyAndValue() {
         Map<String,Integer> map = new HashMap<String,Integer>();
         map.put("a", 1);
         map.put("b", 2);
 
-        assertMatches("matcherA", mapContaining(equalTo("a"), equalTo(1)), map);
-        assertMatches("matcherB", mapContaining(equalTo("b"), equalTo(2)), map);
-        assertDoesNotMatch("matcherC", mapContaining(equalTo("c"), equalTo(3)), map);
+        assertMatches("matcherA", hasEntry(equalTo("a"), equalTo(1)), map);
+        assertMatches("matcherB", hasEntry(equalTo("b"), equalTo(2)), map);
+        assertDoesNotMatch("matcherC", hasEntry(equalTo("c"), equalTo(3)), map);
     }
 
     public void testDoesNotMatchNull() {
         assertDoesNotMatch("should not matches null",
-                mapContaining(anything(), anything()), null);
+                hasEntry(anything(), anything()), null);
     }
 
     public void testHasReadableDescription() {
         assertDescription("map containing [\"a\"-><2>]",
-                mapContaining(equalTo("a"), (equalTo(2))));
+                hasEntry(equalTo("a"), (equalTo(2))));
     }
 
     // Remaining code no longer compiles, thanks to generics. I think that's a good thing, but

Original file line number	Diff line number	Diff line change
`@@ -39,32 +39,32 @@ public void describeTo(Description description) {`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`@Factory`
`42`		`- public static <K,V> Matcher<Map<K,V>> mapContaining(Matcher<K> keyMatcher, Matcher<V> valueMatcher) {`
	`42`	`+ public static <K,V> Matcher<Map<K,V>> hasEntry(Matcher<K> keyMatcher, Matcher<V> valueMatcher) {`
`43`	`43`	`return new IsMapContaining<K,V>(keyMatcher, valueMatcher);`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`@Factory`
`47`		`- public static <K,V> Matcher<Map<K,V>> mapContaining(K key, V value) {`
`48`		`- return mapContaining(equalTo(key), equalTo(value));`
	`47`	`+ public static <K,V> Matcher<Map<K,V>> hasEntry(K key, V value) {`
	`48`	`+ return hasEntry(equalTo(key), equalTo(value));`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`@Factory`
`52`		`- public static <K,V> Matcher<Map<K,V>> mapWithKey(Matcher<K> keyMatcher) {`
`53`		`- return mapContaining(keyMatcher, IsAnything.<V>anything());`
	`52`	`+ public static <K,V> Matcher<Map<K,V>> hasKey(Matcher<K> keyMatcher) {`
	`53`	`+ return hasEntry(keyMatcher, IsAnything.<V>anything());`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`@Factory`
`57`		`- public static <K,V> Matcher<Map<K,V>> mapWithKey(K key) {`
`58`		`- return mapWithKey(equalTo(key));`
	`57`	`+ public static <K,V> Matcher<Map<K,V>> hasKey(K key) {`
	`58`	`+ return hasKey(equalTo(key));`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`@Factory`
`62`		`- public static <K,V> Matcher<Map<K,V>> mapWithValue(Matcher<V> valueMatcher) {`
`63`		`- return mapContaining(IsAnything.<K>anything(), valueMatcher);`
	`62`	`+ public static <K,V> Matcher<Map<K,V>> hasValue(Matcher<V> valueMatcher) {`
	`63`	`+ return hasEntry(IsAnything.<K>anything(), valueMatcher);`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`@Factory`
`67`		`- public static <K,V> Matcher<Map<K,V>> mapWithValue(V value) {`
`68`		`- return mapWithValue(equalTo(value));`
	`67`	`+ public static <K,V> Matcher<Map<K,V>> hasValue(V value) {`
	`68`	`+ return hasValue(equalTo(value));`
`69`	`69`	`}`
`70`	`70`	`}`