Change: add alias to new matchers in org.hamcrest.Matchers

Author: ggalmazor

hamcrest/src/main/java/org/hamcrest/Matchers.java

@@ -3,6 +3,9 @@
 import org.hamcrest.collection.ArrayMatching;
 import org.hamcrest.core.IsIterableContaining;
 import org.hamcrest.core.StringRegularExpression;
+import org.hamcrest.exception.ThrowsException;
+import org.hamcrest.exception.ThrowsExceptionEqualTo;
+import org.hamcrest.exception.ThrowsExceptionWithMessage;
 import org.hamcrest.optional.OptionalEmpty;
 import org.hamcrest.optional.OptionalWithValue;
 import org.hamcrest.text.IsEqualCompressingWhiteSpace;
@@ -2228,4 +2231,86 @@ public static <T> Matcher<Optional<T>> optionalWithValue(T value) {
   public static <T> Matcher<Optional<T>> optionalWithValue(Matcher<? super T> matcher) {
     return OptionalWithValue.optionalWithValue(matcher);
   }
+
+  /**
+   * Matcher for {@link Throwable} that expects that the Runnable throws an exception
+   *
+   * @param <T> type of the Runnable
+   * @return The matcher.
+   */
+  public static <T extends Runnable> ThrowsException<T> throwsException() {
+    return ThrowsException.throwsException();
+  }
+
+  /**
+   * Matcher for {@link Throwable} that expects that the Runnable throws an exception equal to the provided <code>throwable</code>
+   *
+   * @param <T>       type of the Runnable
+   * @param <U>       type of the Throwable
+   * @param throwable the Throwable instance against which examined exceptions are compared
+   * @return The matcher.
+   */
+  public static <T extends Runnable, U extends Throwable> ThrowsException<T> throwsException(U throwable) {
+    return ThrowsException.throwsException(throwable);
+  }
+
+  /**
+   * Matcher for {@link Throwable} that expects that the Runnable throws an exception of the provided <code>throwableClass</code> class
+   *
+   * @param <U>            type of the Runnable
+   * @param <T>            type of the Throwable
+   * @param throwableClass the Throwable class against which examined exceptions are compared
+   * @return The matcher.
+   */
+  public static <T extends Runnable, U extends Throwable> ThrowsException<T> throwsException(Class<U> throwableClass) {
+    return ThrowsException.throwsException(throwableClass);
+  }
+
+  /**
+   * Matcher for {@link Throwable} that expects that the Runnable throws an exception with a message equal to the provided <code>message</code> class
+   *
+   * @param <T>     type of the Runnable
+   * @param message the String against which examined exception messages are compared
+   * @return The matcher.
+   */
+  public static <T extends Runnable> ThrowsException<T> throwsException(String message) {
+    return ThrowsException.throwsException(message);
+  }
+
+  /**
+   * Matcher for {@link Throwable} that expects that the Runnable throws an exception matching provided <code>matcher</code>
+   *
+   * @param <T>     type of the Runnable
+   * @param matcher matcher to validate the exception
+   * @return The matcher.
+   */
+  public static <T extends Runnable> ThrowsException<T> throwsException(Matcher<? super Throwable> matcher) {
+    return ThrowsException.throwsException(matcher);
+  }
+
+  /**
+   * Matcher for {@link Throwable} that expects that the Runnable throws an exception of the provided <code>throwableClass</code> class and has a message equal to the provided <code>message</code>
+   *
+   * @param <T>            type of the Runnable
+   * @param <U>            type of the Throwable
+   * @param throwableClass the Throwable class against which examined exceptions are compared
+   * @param message        the String against which examined exception messages are compared
+   * @return The matcher.
+   */
+  public static <T extends Runnable, U extends Throwable> ThrowsException<T> throwsException(Class<U> throwableClass, String message) {
+    return ThrowsException.throwsException(throwableClass, message);
+  }
+
+  /**
+   * Matcher for {@link Throwable} that expects that the Runnable throws an exception of the provided <code>throwableClass</code> class and matches the provided <code>matcher</code>
+   *
+   * @param <U>            type of the Runnable
+   * @param <T>            type of the Throwable
+   * @param throwableClass the Throwable class against which examined exceptions are compared
+   * @param matcher        matcher to validate the exception
+   * @return The matcher.
+   */
+  public static <T extends Runnable, U extends Throwable> ThrowsException<T> throwsException(Class<U> throwableClass, Matcher<? super Throwable> matcher) {
+    return ThrowsException.throwsException(throwableClass, matcher);
+  }
 }

hamcrest/src/main/java/org/hamcrest/exception/ThrowsException.java

@@ -24,7 +24,7 @@ public class ThrowsException<T extends Runnable> extends TypeSafeMatcher<T> {
      *
      * @param elementMatcher matches the expected element
      */
-    ThrowsException(Matcher<? super Throwable> elementMatcher) {
+    public ThrowsException(Matcher<? super Throwable> elementMatcher) {
         this.exceptionMatcher = elementMatcher;
     }
 

hamcrest/src/main/java/org/hamcrest/exception/ThrowsExceptionEqualTo.java

@@ -16,7 +16,7 @@ public class ThrowsExceptionEqualTo<T extends Throwable> extends TypeSafeDiagnos
      *
      * @param expectedException the expected exception.
      */
-    ThrowsExceptionEqualTo(T expectedException) {
+    public ThrowsExceptionEqualTo(T expectedException) {
         this.expectedException = expectedException;
     }
 

hamcrest/src/main/java/org/hamcrest/exception/ThrowsExceptionWithMessage.java

@@ -19,7 +19,7 @@ public class ThrowsExceptionWithMessage<T extends Throwable> extends TypeSafeDia
      *
      * @param messageMatcher matches the exception message
      */
-    ThrowsExceptionWithMessage(Matcher<? super String> messageMatcher) {
+    public ThrowsExceptionWithMessage(Matcher<? super String> messageMatcher) {
         this.messageMatcher = messageMatcher;
     }