Revert matchers back to 4.10 to compile against Hamcrest 1.1

JUnit 4.12 is supposed to be built against Hamcrest 1.3 or above
but external/hamcrest is still at 1.1. This reverts affected
files back to their 4.10 version so that they will compile
against Hamcrest 1.1 for now.

Bug: 33613916
Test: make checkbuild
Change-Id: Ie3c15047aa5a942ed0987c31c345725bef4db3d4

9 files changed, 193 insertions, 155 deletions

diff --git a/src/main/java/org/junit/internal/matchers/CombinableMatcher.java b/src/main/java/org/junit/internal/matchers/CombinableMatcher.java
new file mode 100644
index 0000000..e9e6947
--- /dev/null
+++ b/src/main/java/org/junit/internal/matchers/CombinableMatcher.java
@@ -0,0 +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;
+
+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));
+	}
+}
\ No newline at end of file
diff --git a/src/main/java/org/junit/internal/matchers/Each.java b/src/main/java/org/junit/internal/matchers/Each.java
new file mode 100644
index 0000000..527db3b
--- /dev/null
+++ b/src/main/java/org/junit/internal/matchers/Each.java
@@ -0,0 +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;
+
+public class Each {
+	public static <T> Matcher<Iterable<T>> each(final Matcher<T> 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);
+			}
+		};
+	}
+}
diff --git a/src/main/java/org/junit/internal/matchers/IsCollectionContaining.java b/src/main/java/org/junit/internal/matchers/IsCollectionContaining.java
new file mode 100644
index 0000000..4436a83
--- /dev/null
+++ b/src/main/java/org/junit/internal/matchers/IsCollectionContaining.java
@@ -0,0 +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
+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);
+    }
+
+}
diff --git a/src/main/java/org/junit/internal/matchers/StacktracePrintingMatcher.java b/src/main/java/org/junit/internal/matchers/StacktracePrintingMatcher.java
deleted file mode 100644
index 5d45ba3..0000000
--- a/src/main/java/org/junit/internal/matchers/StacktracePrintingMatcher.java
+++ /dev/null
@@ -1,56 +0,0 @@
-package org.junit.internal.matchers;
-
-import java.io.PrintWriter;
-import java.io.StringWriter;
-
-import org.hamcrest.Description;
-import org.hamcrest.Factory;
-import org.hamcrest.Matcher;
-
-/**
- * A matcher that delegates to throwableMatcher and in addition appends the
- * stacktrace of the actual Throwable in case of a mismatch.
- */
-public class StacktracePrintingMatcher<T extends Throwable> extends
-        org.hamcrest.TypeSafeMatcher<T> {
-
-    private final Matcher<T> throwableMatcher;
-
-    public StacktracePrintingMatcher(Matcher<T> throwableMatcher) {
-        this.throwableMatcher = throwableMatcher;
-    }
-
-    public void describeTo(Description description) {
-        throwableMatcher.describeTo(description);
-    }
-
-    @Override
-    protected boolean matchesSafely(T item) {
-        return throwableMatcher.matches(item);
-    }
-
-    @Override
-    protected void describeMismatchSafely(T item, Description description) {
-        throwableMatcher.describeMismatch(item, description);
-        description.appendText("\nStacktrace was: ");
-        description.appendText(readStacktrace(item));
-    }
-
-    private String readStacktrace(Throwable throwable) {
-        StringWriter stringWriter = new StringWriter();
-        throwable.printStackTrace(new PrintWriter(stringWriter));
-        return stringWriter.toString();
-    }
-
-    @Factory
-    public static <T extends Throwable> Matcher<T> isThrowable(
-            Matcher<T> throwableMatcher) {
-        return new StacktracePrintingMatcher<T>(throwableMatcher);
-    }
-
-    @Factory
-    public static <T extends Exception> Matcher<T> isException(
-            Matcher<T> exceptionMatcher) {
-        return new StacktracePrintingMatcher<T>(exceptionMatcher);
-    }
-}
diff --git a/src/main/java/org/junit/internal/matchers/StringContains.java b/src/main/java/org/junit/internal/matchers/StringContains.java
new file mode 100644
index 0000000..e5f5334
--- /dev/null
+++ b/src/main/java/org/junit/internal/matchers/StringContains.java
@@ -0,0 +1,31 @@
+/*  Copyright (c) 2000-2006 hamcrest.org
+ */
+package org.junit.internal.matchers;
+
+import org.hamcrest.Factory;
+import org.hamcrest.Matcher;
+
+/**
+ * Tests if the argument is a string that contains a substring.
+ */
+public class StringContains extends SubstringMatcher {
+    public StringContains(String substring) {
+        super(substring);
+    }
+
+    @Override
+	protected boolean evalSubstringOf(String s) {
+        return s.indexOf(substring) >= 0;
+    }
+
+    @Override
+	protected String relationship() {
+        return "containing";
+    }
+
+    @Factory
+    public static Matcher<String> containsString(String substring) {
+        return new StringContains(substring);
+    }
+
+}
\ No newline at end of file
diff --git a/src/main/java/org/junit/internal/matchers/SubstringMatcher.java b/src/main/java/org/junit/internal/matchers/SubstringMatcher.java
new file mode 100644
index 0000000..1c65240
--- /dev/null
+++ b/src/main/java/org/junit/internal/matchers/SubstringMatcher.java
@@ -0,0 +1,28 @@
+package org.junit.internal.matchers;
+
+import org.hamcrest.Description;
+
+public abstract class SubstringMatcher extends TypeSafeMatcher<String> {
+
+    protected final String substring;
+
+    protected SubstringMatcher(final String substring) {
+        this.substring = substring;
+    }
+
+    @Override
+	public boolean matchesSafely(String item) {
+        return evalSubstringOf(item);
+    }
+
+    public void describeTo(Description description) {
+        description.appendText("a string ")
+                .appendText(relationship())
+                .appendText(" ")
+                .appendValue(substring);
+    }
+
+    protected abstract boolean evalSubstringOf(String string);
+
+    protected abstract String relationship();
+}
\ No newline at end of file
diff --git a/src/main/java/org/junit/internal/matchers/ThrowableCauseMatcher.java b/src/main/java/org/junit/internal/matchers/ThrowableCauseMatcher.java
deleted file mode 100644
index 22ce8bd..0000000
--- a/src/main/java/org/junit/internal/matchers/ThrowableCauseMatcher.java
+++ /dev/null
@@ -1,50 +0,0 @@
-package org.junit.internal.matchers;
-
-import org.hamcrest.Description;
-import org.hamcrest.Factory;
-import org.hamcrest.Matcher;
-import org.hamcrest.TypeSafeMatcher;
-
-/**
- * A matcher that applies a delegate matcher to the cause of the current Throwable, returning the result of that
- * match.
- *
- * @param <T> the type of the throwable being matched
- */
-public class ThrowableCauseMatcher<T extends Throwable> extends
-        TypeSafeMatcher<T> {
-
-    private final Matcher<? extends Throwable> causeMatcher;
-
-    public ThrowableCauseMatcher(Matcher<? extends Throwable> causeMatcher) {
-        this.causeMatcher = causeMatcher;
-    }
-
-    public void describeTo(Description description) {
-        description.appendText("exception with cause ");
-        description.appendDescriptionOf(causeMatcher);
-    }
-
-    @Override
-    protected boolean matchesSafely(T item) {
-        return causeMatcher.matches(item.getCause());
-    }
-
-    @Override
-    protected void describeMismatchSafely(T item, Description description) {
-        description.appendText("cause ");
-        causeMatcher.describeMismatch(item.getCause(), description);
-    }
-
-    /**
-     * Returns a matcher that verifies that the outer exception has a cause for which the supplied matcher
-     * evaluates to true.
-     *
-     * @param matcher to apply to the cause of the outer exception
-     * @param <T> type of the outer exception
-     */
-    @Factory
-    public static <T extends Throwable> Matcher<T> hasCause(final Matcher<? extends Throwable> matcher) {
-        return new ThrowableCauseMatcher<T>(matcher);
-    }
-}
\ No newline at end of file
diff --git a/src/main/java/org/junit/internal/matchers/ThrowableMessageMatcher.java b/src/main/java/org/junit/internal/matchers/ThrowableMessageMatcher.java
deleted file mode 100644
index 74386a8..0000000
--- a/src/main/java/org/junit/internal/matchers/ThrowableMessageMatcher.java
+++ /dev/null
@@ -1,37 +0,0 @@
-package org.junit.internal.matchers;
-
-import org.hamcrest.Description;
-import org.hamcrest.Factory;
-import org.hamcrest.Matcher;
-import org.hamcrest.TypeSafeMatcher;
-
-public class ThrowableMessageMatcher<T extends Throwable> extends
-        TypeSafeMatcher<T> {
-
-    private final Matcher<String> matcher;
-
-    public ThrowableMessageMatcher(Matcher<String> matcher) {
-        this.matcher = matcher;
-    }
-
-    public void describeTo(Description description) {
-        description.appendText("exception with message ");
-        description.appendDescriptionOf(matcher);
-    }
-
-    @Override
-    protected boolean matchesSafely(T item) {
-        return matcher.matches(item.getMessage());
-    }
-
-    @Override
-    protected void describeMismatchSafely(T item, Description description) {
-        description.appendText("message ");
-        matcher.describeMismatch(item.getMessage(), description);
-    }
-
-    @Factory
-    public static <T extends Throwable> Matcher<T> hasMessage(final Matcher<String> matcher) {
-        return new ThrowableMessageMatcher<T>(matcher);
-    }
-}
\ No newline at end of file
diff --git a/src/main/java/org/junit/internal/matchers/TypeSafeMatcher.java b/src/main/java/org/junit/internal/matchers/TypeSafeMatcher.java
index 4e2cc12..794a174 100644
--- a/src/main/java/org/junit/internal/matchers/TypeSafeMatcher.java
+++ b/src/main/java/org/junit/internal/matchers/TypeSafeMatcher.java
@@ -3,16 +3,13 @@ package org.junit.internal.matchers;
 import java.lang.reflect.Method;
 
 import org.hamcrest.BaseMatcher;
-import org.junit.internal.MethodSorter;
 
 /**
  * Convenient base class for Matchers that require a non-null value of a specific type.
  * This simply implements the null check, checks the type and then casts.
  *
  * @author Joe Walnes
- * @deprecated Please use {@link org.hamcrest.TypeSafeMatcher}.
  */
-@Deprecated
 public abstract class TypeSafeMatcher<T> extends BaseMatcher<T> {
 
     private Class<?> expectedType;
@@ -26,27 +23,27 @@ public abstract class TypeSafeMatcher<T> extends BaseMatcher<T> {
     protected TypeSafeMatcher() {
         expectedType = findExpectedType(getClass());
     }
-
+    
     private static Class<?> findExpectedType(Class<?> fromClass) {
         for (Class<?> c = fromClass; c != Object.class; c = c.getSuperclass()) {
-            for (Method method : MethodSorter.getDeclaredMethods(c)) {
+            for (Method method : c.getDeclaredMethods()) {
                 if (isMatchesSafelyMethod(method)) {
                     return method.getParameterTypes()[0];
                 }
             }
         }
-
+        
         throw new Error("Cannot determine correct type for matchesSafely() method.");
     }
-
+    
     private static boolean isMatchesSafelyMethod(Method method) {
-        return method.getName().equals("matchesSafely")
-                && method.getParameterTypes().length == 1
-                && !method.isSynthetic();
+        return method.getName().equals("matchesSafely") 
+            && method.getParameterTypes().length == 1
+            && !method.isSynthetic(); 
     }
-
+    
     protected TypeSafeMatcher(Class<T> expectedType) {
-        this.expectedType = expectedType;
+    	this.expectedType = expectedType;
     }
 
     /**