Rollback to hamcrest 1.1

.classpath

@@ -3,6 +3,6 @@
 	<classpathentry kind="src" path="src/main/java"/>
 	<classpathentry kind="src" path="src/test/java"/>
 	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/>
-	<classpathentry kind="lib" path="lib/hamcrest-core-1.2.jar"/>
+	<classpathentry exported="true" kind="lib" path="lib/hamcrest-core-1.1.jar"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>

src/main/java/org/junit/Assume.java

@@ -4,9 +4,9 @@
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.CoreMatchers.notNullValue;
 import static org.hamcrest.CoreMatchers.nullValue;
-import static org.hamcrest.CoreMatchers.everyItem;
 import org.hamcrest.Matcher;
 import org.junit.internal.AssumptionViolatedException;
+import org.junit.internal.matchers.Each;
 
 /**
  * A set of methods useful for stating assumptions about the conditions in which a test is meaningful.
@@ -44,7 +44,7 @@ public static void assumeTrue(boolean b) {
 	 * @param objects
 	 */
 		public static void assumeNotNull(Object... objects) {
-		assumeThat(asList(objects), everyItem(notNullValue()));
+		assumeThat(asList(objects), Each.each(notNullValue()));
 	}
 
 	    /**

src/main/java/org/junit/experimental/results/ResultMatchers.java

@@ -3,7 +3,7 @@
 import org.hamcrest.BaseMatcher;
 import org.hamcrest.Description;
 import org.hamcrest.Matcher;
-import org.hamcrest.TypeSafeMatcher;
+import org.junit.internal.matchers.TypeSafeMatcher;
 
 /**
  * Matchers on a PrintableResult, to enable JUnit self-tests.

src/main/java/org/junit/internal/matchers/CombinableMatcher.java

@@ -1,14 +1,34 @@
 package org.junit.internal.matchers;
 
+import static org.hamcrest.CoreMatchers.allOf;
+import static org.hamcrest.CoreMatchers.anyOf;
+import org.hamcrest.BaseMatcher;
+import org.hamcrest.Description;
 import org.hamcrest.Matcher;
 
-/**
- * @deprectated Use org.hamcrest.core.CombinableMatcher directly
- */
-@Deprecated
-public class CombinableMatcher<T> extends org.hamcrest.core.CombinableMatcher<T> {
-	// should only be using static factories
-	private CombinableMatcher(Matcher<? super T> matcher) {
-		super(matcher);
+public class CombinableMatcher<T> extends BaseMatcher<T> {
+
+	private final Matcher<? extends T> fMatcher;
+
+	public CombinableMatcher(Matcher<? extends T> matcher) {
+		fMatcher= matcher;
+	}
+
+	public boolean matches(Object item) {
+		return fMatcher.matches(item);
+	}
+
+	public void describeTo(Description description) {
+		description.appendDescriptionOf(fMatcher);
+	}
+
+	@SuppressWarnings("unchecked")
+	public CombinableMatcher<T> and(Matcher<? extends T> matcher) {
+		return new CombinableMatcher<T>(allOf(matcher, fMatcher));
+	}
+
+	@SuppressWarnings("unchecked")
+	public CombinableMatcher<T> or(Matcher<? extends T> matcher) {
+		return new CombinableMatcher<T>(anyOf(matcher, fMatcher));
 	}
 }

src/main/java/org/junit/internal/matchers/Each.java

@@ -1,15 +1,24 @@
 package org.junit.internal.matchers;
 
+import static org.hamcrest.CoreMatchers.not;
+import static org.junit.internal.matchers.IsCollectionContaining.hasItem;
+import org.hamcrest.BaseMatcher;
+import org.hamcrest.Description;
 import org.hamcrest.Matcher;
-import org.hamcrest.core.Every;
 
-
-/**
- * @deprecated use org.hamcrest.core.Every
- */
-@Deprecated
 public class Each {
 	public static <T> Matcher<Iterable<T>> each(final Matcher<T> individual) {
-		return Every.everyItem(individual);
+		final Matcher<Iterable<T>> allItemsAre = not(hasItem(not(individual)));
+
+		return new BaseMatcher<Iterable<T>>() {
+			public boolean matches(Object item) {
+				return allItemsAre.matches(item);
+			}
+
+			public void describeTo(Description description) {
+				description.appendText("each ");
+				individual.describeTo(description);
+			}
+		};
 	}
 }

src/main/java/org/junit/internal/matchers/IsCollectionContaining.java

@@ -1,15 +1,67 @@
 package org.junit.internal.matchers;
 
+import static org.hamcrest.core.AllOf.allOf;
+import static org.hamcrest.core.IsEqual.equalTo;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+import org.hamcrest.Description;
+import org.hamcrest.Factory;
 import org.hamcrest.Matcher;
 
 // Copied (hopefully temporarily) from hamcrest-library
-/**
- * @deprecated use org.hamcrest.core.IsCollectionContaining directly
- */
-@Deprecated 
-public class IsCollectionContaining<T> extends org.hamcrest.core.IsCollectionContaining<T> {
-	// Client code should just use static factories, so this should be OK
-	private IsCollectionContaining(Matcher<? super T> elementMatcher) {
-		super(elementMatcher);
-	}
+public class IsCollectionContaining<T> extends TypeSafeMatcher<Iterable<T>> {
+    private final Matcher<? extends T> elementMatcher;
+
+    public IsCollectionContaining(Matcher<? extends T> elementMatcher) {
+        this.elementMatcher = elementMatcher;
+    }
+
+    @Override
+	public boolean matchesSafely(Iterable<T> collection) {
+        for (T item : collection) {
+            if (elementMatcher.matches(item)){
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public void describeTo(Description description) {
+        description
+        	.appendText("a collection containing ")
+        	.appendDescriptionOf(elementMatcher);
+    }
+
+    @Factory
+    public static <T> Matcher<Iterable<T>> hasItem(Matcher<? extends T> elementMatcher) {
+        return new IsCollectionContaining<T>(elementMatcher);
+    }
+
+    @Factory
+    public static <T> Matcher<Iterable<T>> hasItem(T element) {
+        return hasItem(equalTo(element));
+    }
+
+    @Factory
+    public static <T> Matcher<Iterable<T>> hasItems(Matcher<? extends T>... elementMatchers) {
+        Collection<Matcher<? extends Iterable<T>>> all
+                = new ArrayList<Matcher<? extends Iterable<T>>>(elementMatchers.length);
+        for (Matcher<? extends T> elementMatcher : elementMatchers) {
+            all.add(hasItem(elementMatcher));
+        }
+        return allOf(all);
+    }
+
+    @Factory
+    public static <T> Matcher<Iterable<T>> hasItems(T... elements) {
+        Collection<Matcher<? extends Iterable<T>>> all
+                = new ArrayList<Matcher<? extends Iterable<T>>>(elements.length);
+        for (T element : elements) {
+            all.add(hasItem(element));
+        }
+        return allOf(all);
+    }
+
 }

src/main/java/org/junit/internal/matchers/StringContains.java

@@ -2,14 +2,12 @@
  */
 package org.junit.internal.matchers;
 
-import org.hamcrest.CoreMatchers;
 import org.hamcrest.Factory;
 import org.hamcrest.Matcher;
 
 /**
- * @deprectated Use org.hamcrest.core.StringContains directly
+ * Tests if the argument is a string that contains a substring.
  */
-@Deprecated
 public class StringContains extends SubstringMatcher {
     public StringContains(String substring) {
         super(substring);
@@ -27,7 +25,7 @@ protected String relationship() {
 
     @Factory
     public static Matcher<String> containsString(String substring) {
-        return CoreMatchers.containsString(substring);
+        return new StringContains(substring);
     }
 
 }

src/main/java/org/junit/internal/matchers/SubstringMatcher.java

@@ -2,10 +2,6 @@
 
 import org.hamcrest.Description;
 
-/**
- * @deprectated Use org.hamcrest.core.SubstringMatcher directly
- */
-@Deprecated
 public abstract class SubstringMatcher extends TypeSafeMatcher<String> {
 
     protected final String substring;

src/main/java/org/junit/internal/matchers/TypeSafeMatcher.java

@@ -10,10 +10,6 @@
  *
  * @author Joe Walnes
  */
-/**
- * @deprectated Use org.hamcrest.TypeSafeMatcher
- */
-@Deprecated
 public abstract class TypeSafeMatcher<T> extends BaseMatcher<T> {
 
     private Class<?> expectedType;

src/main/java/org/junit/matchers/JUnitMatchers.java

@@ -1,14 +1,10 @@
 package org.junit.matchers;
 
-import static org.hamcrest.CoreMatchers.anyOf;
-import static org.hamcrest.CoreMatchers.equalTo;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import org.hamcrest.CoreMatchers;
 import org.hamcrest.Matcher;
-import org.hamcrest.core.CombinableMatcher;
+import org.junit.internal.matchers.CombinableMatcher;
+import org.junit.internal.matchers.Each;
+import org.junit.internal.matchers.IsCollectionContaining;
+import org.junit.internal.matchers.StringContains;
 
 /**
  * Convenience import class: these are useful matchers for use with the assertThat method, but they are
@@ -18,63 +14,51 @@ public class JUnitMatchers {
 	/**
 	 * @param element
 	 * @return A matcher matching any collection containing element
-	 * @deprecated Use org.hamcrest.CoreMatchers.hasItem
 	 */
-	@Deprecated
-	public static <T> Matcher<Iterable<? super T>> hasItem(T element) {
-		return CoreMatchers.<T>hasItem(element);
+	public static <T> org.hamcrest.Matcher<java.lang.Iterable<T>> hasItem(T element) {
+		return IsCollectionContaining.hasItem(element);
 	}
 
 	/**
 	 * @param elementMatcher
 	 * @return A matcher matching any collection containing an element matching elementMatcher
-	 * @deprecated Use org.hamcrest.CoreMatchers.hasItem
 	 */
-	@Deprecated
-    public static <T> Matcher<Iterable<? super T>> hasItem(Matcher<? super T> elementMatcher) {
-		return CoreMatchers.<T>hasItem(elementMatcher);
+	public static <T> org.hamcrest.Matcher<java.lang.Iterable<T>> hasItem(org.hamcrest.Matcher<? extends T> elementMatcher) {
+		return IsCollectionContaining.hasItem(elementMatcher);
 	}
 
 	/**
 	 * @param elements
 	 * @return A matcher matching any collection containing every element in elements
-	 * @deprecated Use org.hamcrest.CoreMatchers.hasItems
 	 */
-	@Deprecated
 	public static <T> org.hamcrest.Matcher<java.lang.Iterable<T>> hasItems(T... elements) {
-		return CoreMatchers.hasItems(elements);
+		return IsCollectionContaining.hasItems(elements);
 	}
 
 	/**
 	 * @param elementMatchers
 	 * @return A matcher matching any collection containing at least one element that matches 
 	 *         each matcher in elementMatcher (this may be one element matching all matchers,
 	 *         or different elements matching each matcher)
-	 * @deprecated Use org.hamcrest.CoreMatchers.hasItems
 	 */
-	@Deprecated
-	public static <T> Matcher<Iterable<T>> hasItems(Matcher<? super T>... elementMatchers) {
-		return CoreMatchers.hasItems(elementMatchers);
+	public static <T> org.hamcrest.Matcher<java.lang.Iterable<T>> hasItems(org.hamcrest.Matcher<? extends T>... elementMatchers) {
+		return IsCollectionContaining.hasItems(elementMatchers);
 	}
 
 	/**
 	 * @param elementMatcher
 	 * @return A matcher matching any collection in which every element matches elementMatcher
-	 * @deprecated use CoreMatchers.everyItem directly
 	 */
-	@Deprecated
-	public static <T> Matcher<Iterable<T>> each(final Matcher<T> elementMatcher) {
-		return CoreMatchers.everyItem(elementMatcher);
+	public static <T> Matcher<Iterable<T>> everyItem(final Matcher<T> elementMatcher) {
+		return Each.each(elementMatcher);
 	}
 
 	/**
 	 * @param substring
 	 * @return a matcher matching any string that contains substring
-	 * @deprecated Use org.hamcrest.CoreMatchers.containsString
 	 */
-	@Deprecated
 	public static org.hamcrest.Matcher<java.lang.String> containsString(java.lang.String substring) {
-		return CoreMatchers.containsString(substring);
+		return StringContains.containsString(substring);
 	}
 
 	/**
@@ -84,57 +68,16 @@ public static org.hamcrest.Matcher<java.lang.String> containsString(java.lang.St
 	 * </pre>
 	 */
 	public static <T> CombinableMatcher<T> both(Matcher<T> matcher) {
-		return CoreMatchers.both(matcher);
+		return new CombinableMatcher<T>(matcher);
 	}
 
 	/**
 	 * This is useful for fluently combining matchers where either may pass, for example:
 	 * <pre>
-	 *   assertThat(string, either(containsString("a")).or(containsString("b")));
+	 *   assertThat(string, both(containsString("a")).and(containsString("b")));
 	 * </pre>
-	 * 
-	 * If you want to say either(is(3)).or(is(4)), and are prevented,
-	 * please see isOneOf(...) below.
 	 */
 	public static <T> CombinableMatcher<T> either(Matcher<T> matcher) {
-		return CoreMatchers.either(matcher);
-	}
-
-	/**
-	 * This is sugar for the situation where you want to specify
-	 * a finite list of concrete objects that can match.
-	 * For example:
-	 * <pre>
-	 *   assertThat(string, isOneOf("a", "b", "c"));
-	 *   // is equivalent to
-	 *   assertThat(string, anyOf(is("a"), is("b"), is("c")))
-	 * </pre>
-	 */
-	public static <T> Matcher<T> isOneOf(T... objects) {
-		List<Matcher<? super T>> matchers = new ArrayList<Matcher<? super T>>();
-		for (T each : objects) {
-			matchers.add(equalTo(each));
-		}
-		return anyOf(matchers);
-	}
-
-	/**
-	 * Loosens type parameter, in order to use a Matcher 
-	 * in a place where Java doesn't want to type-check:
-	 *
-	 * Goofy example:
-	 * <pre>
-	 *   assertThat(3, matches(containsString("a")));
-	 * </pre>
-	 * 
-	 * Real example:
-	 * <pre>
-	 *   assertThat(3, either(matches(is(String.class))).or(
-	 *		                  matches(is(Integer.class))));
-	 * </pre>
-	 */
-	@SuppressWarnings("unchecked")
-	public static <T> Matcher<T> matches(Matcher<?> matcher) {
-		return (Matcher<T>)matcher;
-	}
+		return new CombinableMatcher<T>(matcher);
+	}	
 }