Remove Hamcrest compile dependency

Use hamcrest-junit 2.0.0.0 instead

Fixes junit-team#1145

Author: marcphilipp

.classpath

@@ -5,6 +5,8 @@
 	<classpathentry kind="src" path="src/test/resources"/>
 	<classpathentry kind="src" path="src/main/resources"/>
 	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7"/>
-	<classpathentry exported="true" kind="lib" path="lib/hamcrest-core-1.3.jar" sourcepath="lib/hamcrest-core-1.3-sources.jar"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
+	<classpathentry kind="lib" path="lib/java-hamcrest-2.0.0.0.jar" sourcepath="lib/java-hamcrest-2.0.0.0-sources.jar"/>
+	<classpathentry kind="lib" path="lib/hamcrest-junit-2.0.0.0.jar" sourcepath="lib/hamcrest-junit-2.0.0.0-sources.jar"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>

lib/hamcrest-core-1.3-sources.jar

@@ -110,8 +110,21 @@
     <dependencies>
         <dependency>
             <groupId>org.hamcrest</groupId>
-            <artifactId>hamcrest-core</artifactId>
-            <version>1.3</version>
+            <artifactId>java-hamcrest</artifactId>
+            <version>2.0.0.0</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.hamcrest</groupId>
+            <artifactId>hamcrest-junit</artifactId>
+            <version>2.0.0.0</version>
+            <scope>test</scope>
+            <exclusions>
+				<exclusion>
+					<groupId>junit</groupId>
+					<artifactId>junit</artifactId>
+				</exclusion>
+            </exclusions>
         </dependency>
     </dependencies>
 
@@ -303,10 +316,6 @@
                     <minmemory>32m</minmemory>
                     <maxmemory>128m</maxmemory>
                     <failOnError>true</failOnError>
-                    <includeDependencySources>true</includeDependencySources>
-                    <dependencySourceIncludes>
-                        <dependencySourceInclude>org.hamcrest:hamcrest-core:*</dependencySourceInclude>
-                    </dependencySourceIncludes>
                 </configuration>
             </plugin>
             <plugin>
@@ -355,10 +364,6 @@
             <plugin>
                 <artifactId>maven-project-info-reports-plugin</artifactId>
                 <version>2.7</version>
-                <configuration>
-                    <dependencyLocationsEnabled>false</dependencyLocationsEnabled>
-                    <!-- waiting for MPIR-267 -->
-                </configuration>
                 <reportSets>
                     <reportSet>
                         <reports>
@@ -407,10 +412,6 @@
                     <minmemory>32m</minmemory>
                     <maxmemory>128m</maxmemory>
                     <failOnError>true</failOnError>
-                    <includeDependencySources>true</includeDependencySources>
-                    <dependencySourceIncludes>
-                        <dependencySourceInclude>org.hamcrest:hamcrest-core:*</dependencySourceInclude>
-                    </dependencySourceIncludes>
                 </configuration>
                 <reportSets>
                     <reportSet>

lib/hamcrest-core-1.3.jar

@@ -1,7 +1,5 @@
 package org.junit;
 
-import org.hamcrest.Matcher;
-import org.hamcrest.MatcherAssert;
 import org.junit.internal.ArrayComparisonFailure;
 import org.junit.internal.ExactComparisonCriteria;
 import org.junit.internal.InexactComparisonCriteria;
@@ -893,66 +891,4 @@ public static void assertEquals(Object[] expecteds, Object[] actuals) {
         assertArrayEquals(expecteds, actuals);
     }
 
-    /**
-     * Asserts that <code>actual</code> satisfies the condition specified by
-     * <code>matcher</code>. If not, an {@link AssertionError} is thrown with
-     * information about the matcher and failing value. Example:
-     *
-     * <pre>
-     *   assertThat(0, is(1)); // fails:
-     *     // failure message:
-     *     // expected: is &lt;1&gt;
-     *     // got value: &lt;0&gt;
-     *   assertThat(0, is(not(1))) // passes
-     * </pre>
-     *
-     * <code>org.hamcrest.Matcher</code> does not currently document the meaning
-     * of its type parameter <code>T</code>.  This method assumes that a matcher
-     * typed as <code>Matcher&lt;T&gt;</code> can be meaningfully applied only
-     * to values that could be assigned to a variable of type <code>T</code>.
-     *
-     * @param <T> the static type accepted by the matcher (this can flag obvious
-     * compile-time problems such as {@code assertThat(1, is("a"))}
-     * @param actual the computed value being compared
-     * @param matcher an expression, built of {@link Matcher}s, specifying allowed
-     * values
-     * @see org.hamcrest.CoreMatchers
-     * @see org.hamcrest.MatcherAssert
-     */
-    public static <T> void assertThat(T actual, Matcher<? super T> matcher) {
-        assertThat("", actual, matcher);
-    }
-
-    /**
-     * Asserts that <code>actual</code> satisfies the condition specified by
-     * <code>matcher</code>. If not, an {@link AssertionError} is thrown with
-     * the reason and information about the matcher and failing value. Example:
-     *
-     * <pre>
-     *   assertThat(&quot;Help! Integers don't work&quot;, 0, is(1)); // fails:
-     *     // failure message:
-     *     // Help! Integers don't work
-     *     // expected: is &lt;1&gt;
-     *     // got value: &lt;0&gt;
-     *   assertThat(&quot;Zero is one&quot;, 0, is(not(1))) // passes
-     * </pre>
-     *
-     * <code>org.hamcrest.Matcher</code> does not currently document the meaning
-     * of its type parameter <code>T</code>.  This method assumes that a matcher
-     * typed as <code>Matcher&lt;T&gt;</code> can be meaningfully applied only
-     * to values that could be assigned to a variable of type <code>T</code>.
-     *
-     * @param reason additional information about the error
-     * @param <T> the static type accepted by the matcher (this can flag obvious
-     * compile-time problems such as {@code assertThat(1, is("a"))}
-     * @param actual the computed value being compared
-     * @param matcher an expression, built of {@link Matcher}s, specifying allowed
-     * values
-     * @see org.hamcrest.CoreMatchers
-     * @see org.hamcrest.MatcherAssert
-     */
-    public static <T> void assertThat(String reason, T actual,
-            Matcher<? super T> matcher) {
-        MatcherAssert.assertThat(reason, actual, matcher);
-    }
 }

lib/hamcrest-junit-2.0.0.0-sources.jar

@@ -1,13 +1,5 @@
 package org.junit;
 
-import static java.util.Arrays.asList;
-import static org.hamcrest.CoreMatchers.everyItem;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.CoreMatchers.notNullValue;
-import static org.hamcrest.CoreMatchers.nullValue;
-
-import org.hamcrest.Matcher;
-
 /**
  * A set of methods useful for stating assumptions about the conditions in which a test is meaningful.
  * A failed assumption does not mean the code is broken, but that the test provides no useful information. Assume
@@ -38,7 +30,7 @@ public class Assume {
      * If called with an expression evaluating to {@code false}, the test will halt and be ignored.
      */
     public static void assumeTrue(boolean b) {
-        assumeThat(b, is(true));
+        assumeTrue(null, b);
     }
 
     /**
@@ -70,53 +62,37 @@ public static void assumeFalse(String message, boolean b) {
      * If called with one or more null elements in <code>objects</code>, the test will halt and be ignored.
      */
     public static void assumeNotNull(Object... objects) {
-        assumeThat(asList(objects), everyItem(notNullValue()));
+        for (int i = 0; i < objects.length; i++) {
+            assumeNotNull("objects[" + i + "] is not null", objects[i]);
+        }
     }
 
     /**
-     * Call to assume that <code>actual</code> satisfies the condition specified by <code>matcher</code>.
-     * If not, the test halts and is ignored.
-     * Example:
-     * <pre>:
-     *   assumeThat(1, is(1)); // passes
-     *   foo(); // will execute
-     *   assumeThat(0, is(1)); // assumption failure! test halts
-     *   int x = 1 / 0; // will never execute
-     * </pre>
-     *
-     * @param <T> the static type accepted by the matcher (this can flag obvious compile-time problems such as {@code assumeThat(1, is("a"))}
-     * @param actual the computed value being compared
-     * @param matcher an expression, built of {@link Matcher}s, specifying allowed values
-     * @see org.hamcrest.CoreMatchers
-     * @see org.junit.matchers.JUnitMatchers
+     * If called with null, the test will halt and be ignored.
      */
-    public static <T> void assumeThat(T actual, Matcher<T> matcher) {
-        if (!matcher.matches(actual)) {
-            throw new AssumptionViolatedException(actual, matcher);
-        }
+    public static void assumeNotNull(Object object) {
+        assumeNotNull("object is not null", object);
     }
 
     /**
-     * Call to assume that <code>actual</code> satisfies the condition specified by <code>matcher</code>.
-     * If not, the test halts and is ignored.
-     * Example:
-     * <pre>:
-     *   assumeThat("alwaysPasses", 1, is(1)); // passes
-     *   foo(); // will execute
-     *   assumeThat("alwaysFails", 0, is(1)); // assumption failure! test halts
-     *   int x = 1 / 0; // will never execute
-     * </pre>
-     *
-     * @param <T> the static type accepted by the matcher (this can flag obvious compile-time problems such as {@code assumeThat(1, is("a"))}
-     * @param actual the computed value being compared
-     * @param matcher an expression, built of {@link Matcher}s, specifying allowed values
-     * @see org.hamcrest.CoreMatchers
-     * @see org.junit.matchers.JUnitMatchers
+     * If called with null, the test will halt and be ignored.
      */
-    public static <T> void assumeThat(String message, T actual, Matcher<T> matcher) {
-        if (!matcher.matches(actual)) {
-            throw new AssumptionViolatedException(message, actual, matcher);
-        }
+    public static void assumeNotNull(String message, Object object) {
+        assumeFalse(message, object == null);
+    }
+
+    /**
+     * If called with null, the test will halt and be ignored.
+     */
+    public static void assumeNull(Object object) {
+        assumeNull("object is null", object);
+    }
+
+    /**
+     * If called with null, the test will halt and be ignored.
+     */
+    public static void assumeNull(String message, Object object) {
+        assumeTrue(message, object == null);
     }
 
     /**
@@ -139,7 +115,7 @@ public static <T> void assumeThat(String message, T actual, Matcher<T> matcher)
      * @param e if non-null, the offending exception
      */
     public static void assumeNoException(Throwable e) {
-        assumeThat(e, nullValue());
+        assumeNoException("no exception", e);
     }
 
     /**
@@ -153,6 +129,6 @@ public static void assumeNoException(Throwable e) {
      * @see #assumeNoException(Throwable)
      */
     public static void assumeNoException(String message, Throwable e) {
-        assumeThat(message, e, nullValue());
+        if (e != null) throw new AssumptionViolatedException(message, e);
     }
 }

lib/hamcrest-junit-2.0.0.0.jar

@@ -1,7 +1,5 @@
 package org.junit;
 
-import org.hamcrest.Matcher;
-
 /**
  * An exception class used to implement <i>assumptions</i> (state in which a given test
  * is meaningful and should or should not be executed). A test for which an assumption
@@ -10,37 +8,24 @@
  * @see org.junit.Assume
  * @since 4.12
  */
-@SuppressWarnings("deprecation")
 public class AssumptionViolatedException extends org.junit.internal.AssumptionViolatedException {
-    private static final long serialVersionUID = 1L;
 
-    /**
-     * An assumption exception with the given <i>actual</i> value and a <i>matcher</i> describing 
-     * the expectation that failed.
-     */
-    public <T> AssumptionViolatedException(T actual, Matcher<T> matcher) {
-        super(actual, matcher);
-    }
-
-    /**
-     * An assumption exception with a message with the given <i>actual</i> value and a
-     * <i>matcher</i> describing the expectation that failed.
-     */
-    public <T> AssumptionViolatedException(String message, T expected, Matcher<T> matcher) {
-        super(message, expected, matcher);
-    }
+    private static final long serialVersionUID = 2L;
 
     /**
      * An assumption exception with the given message only.
      */
+    @SuppressWarnings("deprecation")
     public AssumptionViolatedException(String message) {
         super(message);
     }
 
     /**
      * An assumption exception with the given message and a cause.
      */
-    public AssumptionViolatedException(String assumption, Throwable t) {
-        super(assumption, t);
+    @SuppressWarnings("deprecation")
+    public AssumptionViolatedException(String message, Throwable e) {
+        super(message, e);
     }
+
 }