Repository: assertj/assertj

Problem statement:
Assumptions.assumeThat incompatible with TestNG 7.1.1+
See https://github.com/cbeust/testng/issues/2352


Hints:
Thanks for reporting the issue @C-Otto.

We could increase the precedence of `org.testng.SkipException` over `org.junit.AssumptionViolatedException`, but I would first wait for a feedback on the TestNG issue you opened.
cbeust/testng#2358 should fix this issue.

Patch:
diff --git a/src/main/java/org/assertj/core/api/Assumptions.java b/src/main/java/org/assertj/core/api/Assumptions.java
--- a/src/main/java/org/assertj/core/api/Assumptions.java
+++ b/src/main/java/org/assertj/core/api/Assumptions.java
@@ -1293,16 +1293,16 @@ protected static <ASSERTION> Class<? extends ASSERTION> generateAssumptionClass(
   }
 
   private static RuntimeException assumptionNotMet(AssertionError assertionError) throws ReflectiveOperationException {
-    Class<?> assumptionClass = getAssumptionClass("org.junit.AssumptionViolatedException");
+    Class<?> assumptionClass = getAssumptionClass("org.opentest4j.TestAbortedException");
     if (assumptionClass != null) return assumptionNotMet(assumptionClass, assertionError);
 
-    assumptionClass = getAssumptionClass("org.opentest4j.TestAbortedException");
+    assumptionClass = getAssumptionClass("org.testng.SkipException");
     if (assumptionClass != null) return assumptionNotMet(assumptionClass, assertionError);
 
-    assumptionClass = getAssumptionClass("org.testng.SkipException");
+    assumptionClass = getAssumptionClass("org.junit.AssumptionViolatedException");
     if (assumptionClass != null) return assumptionNotMet(assumptionClass, assertionError);
 
-    throw new IllegalStateException("Assumptions require JUnit, opentest4j or TestNG on the classpath");
+    throw new IllegalStateException("Assumptions require opentest4j, TestNG or JUnit on the classpath");
   }
 
   private static Class<?> getAssumptionClass(String className) {


Test patch:
diff --git a/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_Atomics_Test.java b/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_Atomics_Test.java
--- a/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_Atomics_Test.java
+++ b/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_Atomics_Test.java
@@ -13,9 +13,9 @@
 package org.assertj.core.api.assumptions;
 
 import static org.assertj.core.api.Assertions.assertThatCode;
-import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.assertj.core.api.Assumptions.assumeThat;
 import static org.assertj.core.util.Arrays.array;
+import static org.assertj.core.util.AssertionsUtil.expectAssumptionNotMetException;
 
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -31,7 +31,6 @@
 import java.util.concurrent.atomic.AtomicStampedReference;
 import java.util.stream.Stream;
 
-import org.junit.AssumptionViolatedException;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 
@@ -41,154 +40,154 @@ class Assumptions_assumeThat_Atomics_Test {
 
   static Stream<AssumptionRunner<?>> provideAssumptionsRunners() {
     return Stream.of(
-        new AssumptionRunner<AtomicBoolean>(new AtomicBoolean(true)) {
-          @Override
-          public void runFailingAssumption() {
-            assumeThat(actual).isFalse();
-          }
-
-          @Override
-          public void runPassingAssumption() {
-            assumeThat(actual).isTrue();
-          }
-        },
-        new AssumptionRunner<AtomicInteger>(new AtomicInteger(42)) {
-          @Override
-          public void runFailingAssumption() {
-            assumeThat(actual).hasNegativeValue();
-          }
-
-          @Override
-          public void runPassingAssumption() {
-            assumeThat(actual).hasPositiveValue();
-          }
-        },
-        new AssumptionRunner<AtomicIntegerArray>(new AtomicIntegerArray(new int[] { 2, 5, 7 })) {
-          @Override
-          public void runFailingAssumption() {
-            assumeThat(actual).contains(20);
-          }
-
-          @Override
-          public void runPassingAssumption() {
-            assumeThat(actual).contains(7);
-          }
-        },
-        new AssumptionRunner<AtomicIntegerFieldUpdater<VolatileFieldsHolder>>(AtomicIntegerFieldUpdater.newUpdater(VolatileFieldsHolder.class,
-                                                                                                                     "intValue")) {
-          @Override
-          public void runFailingAssumption() {
-            assumeThat(actual).hasValue(10, VOLATILE_FIELDS_HOLDER);
-          }
-
-          @Override
-          public void runPassingAssumption() {
-            assumeThat(actual).hasValue(0, VOLATILE_FIELDS_HOLDER);
-          }
-        },
-        new AssumptionRunner<AtomicLong>(new AtomicLong(42)) {
-          @Override
-          public void runFailingAssumption() {
-            assumeThat(actual).hasNegativeValue();
-          }
-
-          @Override
-          public void runPassingAssumption() {
-            assumeThat(actual).hasPositiveValue();
-          }
-        },
-        new AssumptionRunner<AtomicLongArray>(new AtomicLongArray(new long[] { 2, 5, 7 })) {
-          @Override
-          public void runFailingAssumption() {
-            assumeThat(actual).contains(20);
-          }
-
-          @Override
-          public void runPassingAssumption() {
-            assumeThat(actual).contains(7);
-          }
-        },
-        new AssumptionRunner<AtomicLongFieldUpdater<VolatileFieldsHolder>>(AtomicLongFieldUpdater.newUpdater(VolatileFieldsHolder.class,
-                                                                                                               "longValue")) {
-          @Override
-          public void runFailingAssumption() {
-            assumeThat(actual).hasValue(10L, VOLATILE_FIELDS_HOLDER);
-          }
-
-          @Override
-          public void runPassingAssumption() {
-            assumeThat(actual).hasValue(0L, VOLATILE_FIELDS_HOLDER);
-          }
-        },
-        new AssumptionRunner<AtomicReference<String>>(new AtomicReference<>("test")) {
-          @Override
-          public void runFailingAssumption() {
-            assumeThat(actual).hasValue("other");
-          }
-
-          @Override
-          public void runPassingAssumption() {
-            assumeThat(actual).hasValue("test");
-          }
-        },
-        new AssumptionRunner<AtomicReferenceArray<String>>(new AtomicReferenceArray<>(array("2", "5", "7"))) {
-          @Override
-          public void runFailingAssumption() {
-            assumeThat(actual).contains("20");
-          }
-
-          @Override
-          public void runPassingAssumption() {
-            assumeThat(actual).contains("7");
-          }
-        },
-        new AssumptionRunner<AtomicReferenceFieldUpdater<VolatileFieldsHolder, String>>(AtomicReferenceFieldUpdater.newUpdater(VolatileFieldsHolder.class,
-                                                                                                                                 String.class,
-                                                                                                                                 "stringValue")) {
-          @Override
-          public void runFailingAssumption() {
-            assumeThat(actual).hasValue("other", VOLATILE_FIELDS_HOLDER);
-          }
-
-          @Override
-          public void runPassingAssumption() {
-            assumeThat(actual).hasValue("test", VOLATILE_FIELDS_HOLDER);
-          }
-        },
-        new AssumptionRunner<AtomicMarkableReference<String>>(new AtomicMarkableReference<>("test", true)) {
-          @Override
-          public void runFailingAssumption() {
-            assumeThat(actual).hasReference("other");
-          }
-
-          @Override
-          public void runPassingAssumption() {
-            assumeThat(actual).hasReference("test");
-          }
-        },
-        new AssumptionRunner<AtomicStampedReference<String>>(new AtomicStampedReference<>("test", 1)) {
-          @Override
-          public void runFailingAssumption() {
-            assumeThat(actual).hasStamp(0);
-          }
-
-          @Override
-          public void runPassingAssumption() {
-            assumeThat(actual).hasStamp(1);
-          }
-        });
+                     new AssumptionRunner<AtomicBoolean>(new AtomicBoolean(true)) {
+                       @Override
+                       public void runFailingAssumption() {
+                         assumeThat(actual).isFalse();
+                       }
+
+                       @Override
+                       public void runPassingAssumption() {
+                         assumeThat(actual).isTrue();
+                       }
+                     },
+                     new AssumptionRunner<AtomicInteger>(new AtomicInteger(42)) {
+                       @Override
+                       public void runFailingAssumption() {
+                         assumeThat(actual).hasNegativeValue();
+                       }
+
+                       @Override
+                       public void runPassingAssumption() {
+                         assumeThat(actual).hasPositiveValue();
+                       }
+                     },
+                     new AssumptionRunner<AtomicIntegerArray>(new AtomicIntegerArray(new int[] { 2, 5, 7 })) {
+                       @Override
+                       public void runFailingAssumption() {
+                         assumeThat(actual).contains(20);
+                       }
+
+                       @Override
+                       public void runPassingAssumption() {
+                         assumeThat(actual).contains(7);
+                       }
+                     },
+                     new AssumptionRunner<AtomicIntegerFieldUpdater<VolatileFieldsHolder>>(AtomicIntegerFieldUpdater.newUpdater(VolatileFieldsHolder.class,
+                                                                                                                                "intValue")) {
+                       @Override
+                       public void runFailingAssumption() {
+                         assumeThat(actual).hasValue(10, VOLATILE_FIELDS_HOLDER);
+                       }
+
+                       @Override
+                       public void runPassingAssumption() {
+                         assumeThat(actual).hasValue(0, VOLATILE_FIELDS_HOLDER);
+                       }
+                     },
+                     new AssumptionRunner<AtomicLong>(new AtomicLong(42)) {
+                       @Override
+                       public void runFailingAssumption() {
+                         assumeThat(actual).hasNegativeValue();
+                       }
+
+                       @Override
+                       public void runPassingAssumption() {
+                         assumeThat(actual).hasPositiveValue();
+                       }
+                     },
+                     new AssumptionRunner<AtomicLongArray>(new AtomicLongArray(new long[] { 2, 5, 7 })) {
+                       @Override
+                       public void runFailingAssumption() {
+                         assumeThat(actual).contains(20);
+                       }
+
+                       @Override
+                       public void runPassingAssumption() {
+                         assumeThat(actual).contains(7);
+                       }
+                     },
+                     new AssumptionRunner<AtomicLongFieldUpdater<VolatileFieldsHolder>>(AtomicLongFieldUpdater.newUpdater(VolatileFieldsHolder.class,
+                                                                                                                          "longValue")) {
+                       @Override
+                       public void runFailingAssumption() {
+                         assumeThat(actual).hasValue(10L, VOLATILE_FIELDS_HOLDER);
+                       }
+
+                       @Override
+                       public void runPassingAssumption() {
+                         assumeThat(actual).hasValue(0L, VOLATILE_FIELDS_HOLDER);
+                       }
+                     },
+                     new AssumptionRunner<AtomicReference<String>>(new AtomicReference<>("test")) {
+                       @Override
+                       public void runFailingAssumption() {
+                         assumeThat(actual).hasValue("other");
+                       }
+
+                       @Override
+                       public void runPassingAssumption() {
+                         assumeThat(actual).hasValue("test");
+                       }
+                     },
+                     new AssumptionRunner<AtomicReferenceArray<String>>(new AtomicReferenceArray<>(array("2", "5", "7"))) {
+                       @Override
+                       public void runFailingAssumption() {
+                         assumeThat(actual).contains("20");
+                       }
+
+                       @Override
+                       public void runPassingAssumption() {
+                         assumeThat(actual).contains("7");
+                       }
+                     },
+                     new AssumptionRunner<AtomicReferenceFieldUpdater<VolatileFieldsHolder, String>>(AtomicReferenceFieldUpdater.newUpdater(VolatileFieldsHolder.class,
+                                                                                                                                            String.class,
+                                                                                                                                            "stringValue")) {
+                       @Override
+                       public void runFailingAssumption() {
+                         assumeThat(actual).hasValue("other", VOLATILE_FIELDS_HOLDER);
+                       }
+
+                       @Override
+                       public void runPassingAssumption() {
+                         assumeThat(actual).hasValue("test", VOLATILE_FIELDS_HOLDER);
+                       }
+                     },
+                     new AssumptionRunner<AtomicMarkableReference<String>>(new AtomicMarkableReference<>("test", true)) {
+                       @Override
+                       public void runFailingAssumption() {
+                         assumeThat(actual).hasReference("other");
+                       }
+
+                       @Override
+                       public void runPassingAssumption() {
+                         assumeThat(actual).hasReference("test");
+                       }
+                     },
+                     new AssumptionRunner<AtomicStampedReference<String>>(new AtomicStampedReference<>("test", 1)) {
+                       @Override
+                       public void runFailingAssumption() {
+                         assumeThat(actual).hasStamp(0);
+                       }
+
+                       @Override
+                       public void runPassingAssumption() {
+                         assumeThat(actual).hasStamp(1);
+                       }
+                     });
   }
 
   @ParameterizedTest
   @MethodSource("provideAssumptionsRunners")
   void should_ignore_test_when_assumption_fails(AssumptionRunner<?> assumptionRunner) {
-    assertThatExceptionOfType(AssumptionViolatedException.class).isThrownBy(() -> assumptionRunner.runFailingAssumption());
+    expectAssumptionNotMetException(assumptionRunner::runFailingAssumption);
   }
 
   @ParameterizedTest
   @MethodSource("provideAssumptionsRunners")
   void should_run_test_when_assumption_passes(AssumptionRunner<?> assumptionRunner) {
-    assertThatCode(() -> assumptionRunner.runPassingAssumption()).doesNotThrowAnyException();
+    assertThatCode(assumptionRunner::runPassingAssumption).doesNotThrowAnyException();
   }
 
   @SuppressWarnings("unused")
diff --git a/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_Numbers_Test.java b/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_Numbers_Test.java
--- a/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_Numbers_Test.java
+++ b/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_Numbers_Test.java
@@ -15,14 +15,13 @@
 import static java.math.BigDecimal.ZERO;
 import static java.math.BigInteger.ONE;
 import static org.assertj.core.api.Assertions.assertThatCode;
-import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.assertj.core.api.Assumptions.assumeThat;
+import static org.assertj.core.util.AssertionsUtil.expectAssumptionNotMetException;
 
 import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.util.stream.Stream;
 
-import org.junit.AssumptionViolatedException;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 
@@ -30,238 +29,238 @@ class Assumptions_assumeThat_Numbers_Test {
 
   static Stream<AssumptionRunner<?>> provideAssumptionsRunners() {
     return Stream.of(
-        new AssumptionRunner<Byte>() {
-          @Override
-          public void runFailingAssumption() {
-            assumeThat((byte) 4).isLessThan((byte) 2);
-          }
+                     new AssumptionRunner<Byte>() {
+                       @Override
+                       public void runFailingAssumption() {
+                         assumeThat((byte) 4).isLessThan((byte) 2);
+                       }
 
-          @Override
-          public void runPassingAssumption() {
-            assumeThat((byte) 4).isGreaterThan((byte) 2);
-          }
-        },
-        new AssumptionRunner<Byte>((byte) 4) {
-          @Override
-          public void runFailingAssumption() {
-            assumeThat(actual).isLessThan((byte) 2);
-          }
+                       @Override
+                       public void runPassingAssumption() {
+                         assumeThat((byte) 4).isGreaterThan((byte) 2);
+                       }
+                     },
+                     new AssumptionRunner<Byte>((byte) 4) {
+                       @Override
+                       public void runFailingAssumption() {
+                         assumeThat(actual).isLessThan((byte) 2);
+                       }
 
-          @Override
-          public void runPassingAssumption() {
-            assumeThat(actual).isGreaterThan((byte) 2);
-          }
-        },
-        new AssumptionRunner<byte[]>(new byte[] { 2, 4, 2 }) {
-          @Override
-          public void runFailingAssumption() {
-            assumeThat(actual).containsOnlyOnce(2);
-          }
+                       @Override
+                       public void runPassingAssumption() {
+                         assumeThat(actual).isGreaterThan((byte) 2);
+                       }
+                     },
+                     new AssumptionRunner<byte[]>(new byte[] { 2, 4, 2 }) {
+                       @Override
+                       public void runFailingAssumption() {
+                         assumeThat(actual).containsOnlyOnce(2);
+                       }
 
-          @Override
-          public void runPassingAssumption() {
-            assumeThat(actual).containsOnlyOnce(4);
-          }
-        },
-        new AssumptionRunner<Short>() {
-          @Override
-          public void runFailingAssumption() {
-            assumeThat((short) 4).isLessThan((short) 2);
-          }
+                       @Override
+                       public void runPassingAssumption() {
+                         assumeThat(actual).containsOnlyOnce(4);
+                       }
+                     },
+                     new AssumptionRunner<Short>() {
+                       @Override
+                       public void runFailingAssumption() {
+                         assumeThat((short) 4).isLessThan((short) 2);
+                       }
 
-          @Override
-          public void runPassingAssumption() {
-            assumeThat((short) 4).isGreaterThan((short) 2);
-          }
-        },
-        new AssumptionRunner<Short>((short) 4) {
-          @Override
-          public void runFailingAssumption() {
-            assumeThat(actual).isLessThan((short) 2);
-          }
+                       @Override
+                       public void runPassingAssumption() {
+                         assumeThat((short) 4).isGreaterThan((short) 2);
+                       }
+                     },
+                     new AssumptionRunner<Short>((short) 4) {
+                       @Override
+                       public void runFailingAssumption() {
+                         assumeThat(actual).isLessThan((short) 2);
+                       }
 
-          @Override
-          public void runPassingAssumption() {
-            assumeThat(actual).isGreaterThan((short) 2);
-          }
-        },
-        new AssumptionRunner<short[]>(new short[] { 2, 4, 2 }) {
-          @Override
-          public void runFailingAssumption() {
-            assumeThat(actual).containsOnlyOnce((short) 2);
-          }
+                       @Override
+                       public void runPassingAssumption() {
+                         assumeThat(actual).isGreaterThan((short) 2);
+                       }
+                     },
+                     new AssumptionRunner<short[]>(new short[] { 2, 4, 2 }) {
+                       @Override
+                       public void runFailingAssumption() {
+                         assumeThat(actual).containsOnlyOnce((short) 2);
+                       }
 
-          @Override
-          public void runPassingAssumption() {
-            assumeThat(actual).containsOnlyOnce((short) 4);
-          }
-        },
-        new AssumptionRunner<Integer>() {
-          @Override
-          public void runFailingAssumption() {
-            assumeThat(4).isLessThan(2);
-          }
+                       @Override
+                       public void runPassingAssumption() {
+                         assumeThat(actual).containsOnlyOnce((short) 4);
+                       }
+                     },
+                     new AssumptionRunner<Integer>() {
+                       @Override
+                       public void runFailingAssumption() {
+                         assumeThat(4).isLessThan(2);
+                       }
 
-          @Override
-          public void runPassingAssumption() {
-            assumeThat(4).isGreaterThan(2);
-          }
-        },
-        new AssumptionRunner<Integer>(4) {
-          @Override
-          public void runFailingAssumption() {
-            assumeThat(actual).isLessThan(2);
-          }
+                       @Override
+                       public void runPassingAssumption() {
+                         assumeThat(4).isGreaterThan(2);
+                       }
+                     },
+                     new AssumptionRunner<Integer>(4) {
+                       @Override
+                       public void runFailingAssumption() {
+                         assumeThat(actual).isLessThan(2);
+                       }
 
-          @Override
-          public void runPassingAssumption() {
-            assumeThat(actual).isGreaterThan(2);
-          }
-        },
-        new AssumptionRunner<int[]>(new int[] { 2, 4, 2 }) {
-          @Override
-          public void runFailingAssumption() {
-            assumeThat(actual).containsOnlyOnce(2);
-          }
+                       @Override
+                       public void runPassingAssumption() {
+                         assumeThat(actual).isGreaterThan(2);
+                       }
+                     },
+                     new AssumptionRunner<int[]>(new int[] { 2, 4, 2 }) {
+                       @Override
+                       public void runFailingAssumption() {
+                         assumeThat(actual).containsOnlyOnce(2);
+                       }
 
-          @Override
-          public void runPassingAssumption() {
-            assumeThat(actual).containsOnlyOnce(4);
-          }
-        },
-        new AssumptionRunner<Long>() {
-          @Override
-          public void runFailingAssumption() {
-            assumeThat(4L).isLessThan(2);
-          }
+                       @Override
+                       public void runPassingAssumption() {
+                         assumeThat(actual).containsOnlyOnce(4);
+                       }
+                     },
+                     new AssumptionRunner<Long>() {
+                       @Override
+                       public void runFailingAssumption() {
+                         assumeThat(4L).isLessThan(2);
+                       }
 
-          @Override
-          public void runPassingAssumption() {
-            assumeThat(4L).isGreaterThan(2);
-          }
-        },
-        new AssumptionRunner<Long>(4L) {
-          @Override
-          public void runFailingAssumption() {
-            assumeThat(actual).isLessThan(2);
-          }
+                       @Override
+                       public void runPassingAssumption() {
+                         assumeThat(4L).isGreaterThan(2);
+                       }
+                     },
+                     new AssumptionRunner<Long>(4L) {
+                       @Override
+                       public void runFailingAssumption() {
+                         assumeThat(actual).isLessThan(2);
+                       }
 
-          @Override
-          public void runPassingAssumption() {
-            assumeThat(actual).isGreaterThan(2);
-          }
-        },
-        new AssumptionRunner<long[]>(new long[] { 2, 4, 2 }) {
-          @Override
-          public void runFailingAssumption() {
-            assumeThat(actual).containsOnlyOnce(2);
-          }
+                       @Override
+                       public void runPassingAssumption() {
+                         assumeThat(actual).isGreaterThan(2);
+                       }
+                     },
+                     new AssumptionRunner<long[]>(new long[] { 2, 4, 2 }) {
+                       @Override
+                       public void runFailingAssumption() {
+                         assumeThat(actual).containsOnlyOnce(2);
+                       }
 
-          @Override
-          public void runPassingAssumption() {
-            assumeThat(actual).containsOnlyOnce(4);
-          }
-        },
+                       @Override
+                       public void runPassingAssumption() {
+                         assumeThat(actual).containsOnlyOnce(4);
+                       }
+                     },
 
-        new AssumptionRunner<Float>() {
-          @Override
-          public void runFailingAssumption() {
-            assumeThat(4.0f).isLessThan(2);
-          }
+                     new AssumptionRunner<Float>() {
+                       @Override
+                       public void runFailingAssumption() {
+                         assumeThat(4.0f).isLessThan(2);
+                       }
 
-          @Override
-          public void runPassingAssumption() {
-            assumeThat(4.0f).isGreaterThan((byte) 2);
-          }
-        },
-        new AssumptionRunner<Float>(4.0f) {
-          @Override
-          public void runFailingAssumption() {
-            assumeThat(actual).isLessThan(2);
-          }
+                       @Override
+                       public void runPassingAssumption() {
+                         assumeThat(4.0f).isGreaterThan((byte) 2);
+                       }
+                     },
+                     new AssumptionRunner<Float>(4.0f) {
+                       @Override
+                       public void runFailingAssumption() {
+                         assumeThat(actual).isLessThan(2);
+                       }
 
-          @Override
-          public void runPassingAssumption() {
-            assumeThat(actual).isGreaterThan(2);
-          }
-        },
-        new AssumptionRunner<float[]>(new float[] { 2, 4, 2 }) {
-          @Override
-          public void runFailingAssumption() {
-            assumeThat(actual).hasSize(2);
-          }
+                       @Override
+                       public void runPassingAssumption() {
+                         assumeThat(actual).isGreaterThan(2);
+                       }
+                     },
+                     new AssumptionRunner<float[]>(new float[] { 2, 4, 2 }) {
+                       @Override
+                       public void runFailingAssumption() {
+                         assumeThat(actual).hasSize(2);
+                       }
 
-          @Override
-          public void runPassingAssumption() {
-            assumeThat(actual).hasSize(3);
-          }
-        },
-        new AssumptionRunner<Double>() {
-          @Override
-          public void runFailingAssumption() {
-            assumeThat(4.0).isLessThan(2);
-          }
+                       @Override
+                       public void runPassingAssumption() {
+                         assumeThat(actual).hasSize(3);
+                       }
+                     },
+                     new AssumptionRunner<Double>() {
+                       @Override
+                       public void runFailingAssumption() {
+                         assumeThat(4.0).isLessThan(2);
+                       }
 
-          @Override
-          public void runPassingAssumption() {
-            assumeThat(4.0).isGreaterThan((byte) 2);
-          }
-        },
-        new AssumptionRunner<Double>(4.0) {
-          @Override
-          public void runFailingAssumption() {
-            assumeThat(actual).isLessThan(2);
-          }
+                       @Override
+                       public void runPassingAssumption() {
+                         assumeThat(4.0).isGreaterThan((byte) 2);
+                       }
+                     },
+                     new AssumptionRunner<Double>(4.0) {
+                       @Override
+                       public void runFailingAssumption() {
+                         assumeThat(actual).isLessThan(2);
+                       }
 
-          @Override
-          public void runPassingAssumption() {
-            assumeThat(actual).isGreaterThan(2);
-          }
-        },
-        new AssumptionRunner<double[]>(new double[] { 2, 4, 2 }) {
-          @Override
-          public void runFailingAssumption() {
-            assumeThat(actual).hasSize(2);
-          }
+                       @Override
+                       public void runPassingAssumption() {
+                         assumeThat(actual).isGreaterThan(2);
+                       }
+                     },
+                     new AssumptionRunner<double[]>(new double[] { 2, 4, 2 }) {
+                       @Override
+                       public void runFailingAssumption() {
+                         assumeThat(actual).hasSize(2);
+                       }
 
-          @Override
-          public void runPassingAssumption() {
-            assumeThat(actual).hasSize(3);
-          }
-        },
-        new AssumptionRunner<BigDecimal>(new BigDecimal(4)) {
-          @Override
-          public void runFailingAssumption() {
-            assumeThat(actual).isLessThan(ZERO);
-          }
+                       @Override
+                       public void runPassingAssumption() {
+                         assumeThat(actual).hasSize(3);
+                       }
+                     },
+                     new AssumptionRunner<BigDecimal>(new BigDecimal(4)) {
+                       @Override
+                       public void runFailingAssumption() {
+                         assumeThat(actual).isLessThan(ZERO);
+                       }
 
-          @Override
-          public void runPassingAssumption() {
-            assumeThat(actual).isGreaterThan(ZERO);
-          }
-        },
-        new AssumptionRunner<BigInteger>(BigInteger.valueOf(4)) {
-          @Override
-          public void runFailingAssumption() {
-            assumeThat(actual).isLessThan(ONE);
-          }
+                       @Override
+                       public void runPassingAssumption() {
+                         assumeThat(actual).isGreaterThan(ZERO);
+                       }
+                     },
+                     new AssumptionRunner<BigInteger>(BigInteger.valueOf(4)) {
+                       @Override
+                       public void runFailingAssumption() {
+                         assumeThat(actual).isLessThan(ONE);
+                       }
 
-          @Override
-          public void runPassingAssumption() {
-            assumeThat(actual).isGreaterThan(ONE);
-          }
-        });
+                       @Override
+                       public void runPassingAssumption() {
+                         assumeThat(actual).isGreaterThan(ONE);
+                       }
+                     });
   }
 
   @ParameterizedTest
   @MethodSource("provideAssumptionsRunners")
   void should_ignore_test_when_assumption_fails(AssumptionRunner<?> assumptionRunner) {
-    assertThatExceptionOfType(AssumptionViolatedException.class).isThrownBy(() -> assumptionRunner.runFailingAssumption());
+    expectAssumptionNotMetException(assumptionRunner::runFailingAssumption);
   }
 
   @ParameterizedTest
   @MethodSource("provideAssumptionsRunners")
   void should_run_test_when_assumption_passes(AssumptionRunner<?> assumptionRunner) {
-    assertThatCode(() -> assumptionRunner.runPassingAssumption()).doesNotThrowAnyException();
+    assertThatCode(assumptionRunner::runPassingAssumption).doesNotThrowAnyException();
   }
 }
diff --git a/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_Object_Test.java b/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_Object_Test.java
--- a/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_Object_Test.java
+++ b/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_Object_Test.java
@@ -14,10 +14,9 @@
 
 import static java.util.Arrays.asList;
 import static org.assertj.core.api.Assertions.assertThatCode;
-import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.assertj.core.api.Assumptions.assumeThat;
+import static org.assertj.core.util.AssertionsUtil.expectAssumptionNotMetException;
 
-import org.junit.AssumptionViolatedException;
 import org.junit.jupiter.api.Test;
 
 class Assumptions_assumeThat_Object_Test {
@@ -42,23 +41,23 @@ void should_run_test_when_assumption_for_internally_created_list_passes() {
 
   @Test
   void should_ignore_test_when_assumption_fails() {
-    assertThatExceptionOfType(AssumptionViolatedException.class).isThrownBy(() -> assumeThat(STRING_OBJECT).isNotNull()
-                                                                                                           .isEqualTo("other"));
+    expectAssumptionNotMetException(() -> assumeThat(STRING_OBJECT).isNotNull()
+                                                                   .isEqualTo("other"));
   }
 
   @Test
   void should_ignore_test_when_assumption_for_internally_created_string_assertion_fails() {
-    assertThatExceptionOfType(AssumptionViolatedException.class).isThrownBy(() -> assumeThat(STRING_OBJECT).isNotNull()
-                                                                                                           .asString()
-                                                                                                           .isEqualTo("other"));
+    expectAssumptionNotMetException(() -> assumeThat(STRING_OBJECT).isNotNull()
+                                                                   .asString()
+                                                                   .isEqualTo("other"));
   }
 
   @Test
   void should_ignore_test_when_assumption_for_internally_created_list_assertion_fails() {
     Object listObject = asList(1, 2, 3);
-    assertThatExceptionOfType(AssumptionViolatedException.class).isThrownBy(() -> assumeThat(listObject).isNotNull()
-                                                                                                        .asList()
-                                                                                                        .contains(4,
-                                                                                                                  5));
+    expectAssumptionNotMetException(() -> assumeThat(listObject).isNotNull()
+                                                                .asList()
+                                                                .contains(4,
+                                                                          5));
   }
 }
diff --git a/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_Test.java b/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_Test.java
--- a/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_Test.java
+++ b/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_Test.java
@@ -14,12 +14,11 @@
 
 import static java.util.Arrays.asList;
 import static org.assertj.core.api.Assertions.assertThatCode;
-import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.assertj.core.api.Assumptions.assumeThat;
 import static org.assertj.core.presentation.UnicodeRepresentation.UNICODE_REPRESENTATION;
+import static org.assertj.core.util.AssertionsUtil.expectAssumptionNotMetException;
 
 import org.assertj.core.util.CaseInsensitiveStringComparator;
-import org.junit.AssumptionViolatedException;
 import org.junit.jupiter.api.Test;
 
 class Assumptions_assumeThat_Test {
@@ -27,7 +26,7 @@ class Assumptions_assumeThat_Test {
   @Test
   void should_ignore_test_when_one_of_the_assumption_fails() {
     assumeThat("foo").isNotEmpty();
-    assertThatExceptionOfType(AssumptionViolatedException.class).isThrownBy(() -> assumeThat("bar").isEmpty());
+    expectAssumptionNotMetException(() -> assumeThat("bar").isEmpty());
   }
 
   @Test
diff --git a/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_involving_iterable_navigation_Test.java b/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_involving_iterable_navigation_Test.java
--- a/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_involving_iterable_navigation_Test.java
+++ b/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_involving_iterable_navigation_Test.java
@@ -16,7 +16,7 @@
 import static org.assertj.core.api.Assertions.assertThatCode;
 import static org.assertj.core.api.Assumptions.assumeThat;
 import static org.assertj.core.api.InstanceOfAssertFactories.type;
-import static org.assertj.core.util.AssertionsUtil.expectAssumptionViolatedException;
+import static org.assertj.core.util.AssertionsUtil.expectAssumptionNotMetException;
 import static org.assertj.core.util.Lists.list;
 import static org.assertj.core.util.Lists.newArrayList;
 import static org.assertj.core.util.Sets.newLinkedHashSet;
@@ -75,65 +75,65 @@ void should_run_test_when_assumption_after_navigating_to_elements_passes() {
 
   @Test
   void should_ignore_test_when_assumption_on_size_fails() {
-    expectAssumptionViolatedException(() -> assumeThat(jedis).size()
-                                                             .as("check size")
-                                                             .isGreaterThan(3));
+    expectAssumptionNotMetException(() -> assumeThat(jedis).size()
+                                                           .as("check size")
+                                                           .isGreaterThan(3));
   }
 
   @Test
   void should_ignore_test_when_assumption_after_navigating_to_first_fails() {
-    expectAssumptionViolatedException(() -> assumeThat(jedis).first()
-                                                             .as("check first element")
-                                                             .isEqualTo(luke));
+    expectAssumptionNotMetException(() -> assumeThat(jedis).first()
+                                                           .as("check first element")
+                                                           .isEqualTo(luke));
   }
 
   @Test
   void should_ignore_test_when_assumption_after_navigating_to_first_with_InstanceOfAssertFactory_fails() {
-    expectAssumptionViolatedException(() -> assumeThat(jedis).first(as(type(Jedi.class)))
-                                                             .as("check first element")
-                                                             .isEqualTo(luke));
+    expectAssumptionNotMetException(() -> assumeThat(jedis).first(as(type(Jedi.class)))
+                                                           .as("check first element")
+                                                           .isEqualTo(luke));
   }
 
   @Test
   void should_ignore_test_when_assumption_after_navigating_to_last_fails() {
-    expectAssumptionViolatedException(() -> assumeThat(jedis).last()
-                                                             .as("check last element")
-                                                             .isEqualTo(yoda));
+    expectAssumptionNotMetException(() -> assumeThat(jedis).last()
+                                                           .as("check last element")
+                                                           .isEqualTo(yoda));
   }
 
   @Test
   void should_ignore_test_when_assumption_after_navigating_to_last_with_InstanceOfAssertFactory_fails() {
-    expectAssumptionViolatedException(() -> assumeThat(jedis).last(as(type(Jedi.class)))
-                                                             .as("check last element")
-                                                             .isEqualTo(yoda));
+    expectAssumptionNotMetException(() -> assumeThat(jedis).last(as(type(Jedi.class)))
+                                                           .as("check last element")
+                                                           .isEqualTo(yoda));
   }
 
   @Test
   void should_ignore_test_when_assumption_after_navigating_to_element_fails() {
-    expectAssumptionViolatedException(() -> assumeThat(jedis).element(1)
-                                                             .as("check element at index 1")
-                                                             .isEqualTo(yoda));
+    expectAssumptionNotMetException(() -> assumeThat(jedis).element(1)
+                                                           .as("check element at index 1")
+                                                           .isEqualTo(yoda));
   }
 
   @Test
   void should_ignore_test_when_assumption_after_navigating_to_element_with_InstanceOfAssertFactory_fails() {
-    expectAssumptionViolatedException(() -> assumeThat(jedis).element(1, as(type(Jedi.class)))
-                                                             .as("check element at index 1")
-                                                             .isEqualTo(yoda));
+    expectAssumptionNotMetException(() -> assumeThat(jedis).element(1, as(type(Jedi.class)))
+                                                           .as("check element at index 1")
+                                                           .isEqualTo(yoda));
   }
 
   @Test
   void should_ignore_test_when_assumption_after_navigating_to_singleElement_fails() {
-    expectAssumptionViolatedException(() -> assumeThat(list(yoda)).singleElement()
-                                                                  .as("check single element")
-                                                                  .isEqualTo(luke));
+    expectAssumptionNotMetException(() -> assumeThat(list(yoda)).singleElement()
+                                                                .as("check single element")
+                                                                .isEqualTo(luke));
   }
 
   @Test
   void should_ignore_test_when_assumption_after_navigating_to_singleElement_with_InstanceOfAssertFactory_fails() {
-    expectAssumptionViolatedException(() -> assumeThat(list(yoda)).singleElement(as(type(Jedi.class)))
-                                                                  .as("check single element")
-                                                                  .isEqualTo(luke));
+    expectAssumptionNotMetException(() -> assumeThat(list(yoda)).singleElement(as(type(Jedi.class)))
+                                                                .as("check single element")
+                                                                .isEqualTo(luke));
   }
 
 }
diff --git a/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_with_Stream_Test.java b/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_with_Stream_Test.java
--- a/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_with_Stream_Test.java
+++ b/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_with_Stream_Test.java
@@ -12,14 +12,13 @@
  */
 package org.assertj.core.api.assumptions;
 
-import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.assertj.core.api.Assumptions.assumeThat;
+import static org.assertj.core.util.AssertionsUtil.expectAssumptionNotMetException;
 import static org.assertj.core.util.Lists.newArrayList;
 
 import java.util.List;
 import java.util.stream.Stream;
 
-import org.junit.AssumptionViolatedException;
 import org.junit.jupiter.api.Test;
 
 class Assumptions_assumeThat_with_Stream_Test {
@@ -27,14 +26,14 @@ class Assumptions_assumeThat_with_Stream_Test {
   @Test
   void stream_test() {
     Stream<String> stream = Stream.of("test");
-    assertThatExceptionOfType(AssumptionViolatedException.class).isThrownBy(() -> assumeThat(stream).containsAnyOf("other",
-                                                                                                                   "foo"));
+    expectAssumptionNotMetException(() -> assumeThat(stream).containsAnyOf("other",
+                                                                           "foo"));
   }
 
   @Test
   void list_test() {
     List<String> list = newArrayList("test");
-    assertThatExceptionOfType(AssumptionViolatedException.class).isThrownBy(() -> assumeThat(list).contains("other",
-                                                                                                            "foo"));
+    expectAssumptionNotMetException(() -> assumeThat(list).contains("other",
+                                                                    "foo"));
   }
 }
diff --git a/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_with_asInstanceOf_Test.java b/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_with_asInstanceOf_Test.java
--- a/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_with_asInstanceOf_Test.java
+++ b/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_with_asInstanceOf_Test.java
@@ -13,12 +13,11 @@
 package org.assertj.core.api.assumptions;
 
 import static org.assertj.core.api.Assertions.assertThatCode;
-import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.assertj.core.api.Assumptions.assumeThat;
 import static org.assertj.core.api.InstanceOfAssertFactories.INTEGER;
 import static org.assertj.core.api.InstanceOfAssertFactories.STRING;
+import static org.assertj.core.util.AssertionsUtil.expectAssumptionNotMetException;
 
-import org.junit.AssumptionViolatedException;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
@@ -38,7 +37,7 @@ void should_run_test_when_assumption_with_as_instance_of_passes() {
 
   @Test
   void should_ignore_test_when_assumption_with_as_instance_of_fails() {
-    assertThatExceptionOfType(AssumptionViolatedException.class).isThrownBy(() -> assumeThat(value).asInstanceOf(INTEGER)
-                                                                                                   .isZero());
+    expectAssumptionNotMetException(() -> assumeThat(value).asInstanceOf(INTEGER)
+                                                           .isZero());
   }
 }
diff --git a/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_with_extracting_Test.java b/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_with_extracting_Test.java
--- a/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_with_extracting_Test.java
+++ b/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_with_extracting_Test.java
@@ -14,10 +14,10 @@
 
 import static com.google.common.collect.Sets.newHashSet;
 import static org.assertj.core.api.Assertions.assertThatCode;
-import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.assertj.core.api.Assertions.entry;
 import static org.assertj.core.api.Assumptions.assumeThat;
 import static org.assertj.core.test.Maps.mapOf;
+import static org.assertj.core.util.AssertionsUtil.expectAssumptionNotMetException;
 import static org.assertj.core.util.Lists.newArrayList;
 
 import java.util.Map;
@@ -25,7 +25,6 @@
 
 import org.assertj.core.test.CartoonCharacter;
 import org.assertj.core.test.Jedi;
-import org.junit.AssumptionViolatedException;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
@@ -90,7 +89,7 @@ void should_allow_assumptions_with_flatExtracting() {
 
   @Test
   void should_ignore_test_when_assumption_using_extracting_fails() {
-    assertThatExceptionOfType(AssumptionViolatedException.class).isThrownBy(() -> assumeThat(jedis).extracting("name")
-                                                                                                   .contains("Vader"));
+    expectAssumptionNotMetException(() -> assumeThat(jedis).extracting("name")
+                                                           .contains("Vader"));
   }
 }
diff --git a/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_with_filteredOn_Test.java b/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_with_filteredOn_Test.java
--- a/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_with_filteredOn_Test.java
+++ b/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_with_filteredOn_Test.java
@@ -14,13 +14,12 @@
 
 import static com.google.common.collect.Sets.newHashSet;
 import static org.assertj.core.api.Assertions.assertThatCode;
-import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.assertj.core.api.Assumptions.assumeThat;
+import static org.assertj.core.util.AssertionsUtil.expectAssumptionNotMetException;
 
 import java.util.Set;
 
 import org.assertj.core.test.Jedi;
-import org.junit.AssumptionViolatedException;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
@@ -44,6 +43,7 @@ void should_run_test_when_assumption_with_filtered_elements_passes() {
 
   @Test
   void should_ignore_test_when_assumption_with_filtered_elements_fails() {
-    assertThatExceptionOfType(AssumptionViolatedException.class).isThrownBy(() -> assumeThat(jedis).filteredOn("name", "Luke").contains(yoda));
+    expectAssumptionNotMetException(() -> assumeThat(jedis).filteredOn("name", "Luke")
+                                                           .contains(yoda));
   }
 }
diff --git a/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_with_succeedsWithin_Test.java b/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_with_succeedsWithin_Test.java
--- a/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_with_succeedsWithin_Test.java
+++ b/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_with_succeedsWithin_Test.java
@@ -18,7 +18,7 @@
 import static org.assertj.core.api.Assertions.assertThatCode;
 import static org.assertj.core.api.Assumptions.assumeThat;
 import static org.assertj.core.api.InstanceOfAssertFactories.STRING;
-import static org.assertj.core.util.AssertionsUtil.expectAssumptionViolatedException;
+import static org.assertj.core.util.AssertionsUtil.expectAssumptionNotMetException;
 
 import java.time.Duration;
 import java.util.concurrent.CompletableFuture;
@@ -50,8 +50,8 @@ void should_ignore_test_when_assumption_after_succeedsWithin_fails() {
     String value = "ook!";
     CompletableFuture<String> future = completedFuture(value);
     // WHEN
-    expectAssumptionViolatedException(() -> assumeThat(future).succeedsWithin(1, MILLISECONDS)
-                                                              .isEqualTo("eeek!"));
+    expectAssumptionNotMetException(() -> assumeThat(future).succeedsWithin(1, MILLISECONDS)
+                                                            .isEqualTo("eeek!"));
   }
 
   @Test
@@ -72,8 +72,8 @@ void should_ignore_test_when_assumption_after_succeedsWithin_asString_fails() {
     String value = "ook!";
     CompletableFuture<String> future = completedFuture(value);
     // WHEN
-    expectAssumptionViolatedException(() -> assumeThat(future).succeedsWithin(1, MILLISECONDS, as(STRING))
-                                                              .startsWith("eek"));
+    expectAssumptionNotMetException(() -> assumeThat(future).succeedsWithin(1, MILLISECONDS, as(STRING))
+                                                            .startsWith("eek"));
   }
 
   @Test
@@ -94,8 +94,8 @@ void should_ignore_test_when_assumption_after_succeedsWithin_with_Duration_fails
     String value = "ook!";
     CompletableFuture<String> future = completedFuture(value);
     // WHEN
-    expectAssumptionViolatedException(() -> assumeThat(future).succeedsWithin(ONE_MILLIS)
-                                                              .isEqualTo("eeek!"));
+    expectAssumptionNotMetException(() -> assumeThat(future).succeedsWithin(ONE_MILLIS)
+                                                            .isEqualTo("eeek!"));
   }
 
   @Test
@@ -116,7 +116,7 @@ void should_ignore_test_when_assumption_after_succeedsWithin_with_Duration_asStr
     String value = "ook!";
     CompletableFuture<String> future = completedFuture(value);
     // WHEN
-    expectAssumptionViolatedException(() -> assumeThat(future).succeedsWithin(ONE_MILLIS, as(STRING))
-                                                              .startsWith("eek"));
+    expectAssumptionNotMetException(() -> assumeThat(future).succeedsWithin(ONE_MILLIS, as(STRING))
+                                                            .startsWith("eek"));
   }
 }
diff --git a/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_with_various_java_8_types_Test.java b/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_with_various_java_8_types_Test.java
--- a/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_with_various_java_8_types_Test.java
+++ b/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_with_various_java_8_types_Test.java
@@ -17,6 +17,7 @@
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.assertj.core.api.Assumptions.assumeThat;
 import static org.assertj.core.api.Assumptions.assumeThatCode;
+import static org.assertj.core.util.AssertionsUtil.expectAssumptionNotMetException;
 
 import java.time.Duration;
 import java.time.Instant;
@@ -41,9 +42,9 @@
 import java.util.stream.Stream;
 
 import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
-import org.junit.AssumptionViolatedException;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
+import org.opentest4j.TestAbortedException;
 
 class Assumptions_assumeThat_with_various_java_8_types_Test {
 
@@ -296,7 +297,7 @@ public void runPassingAssumption() {
   @ParameterizedTest
   @MethodSource("provideAssumptionsRunners")
   void should_ignore_test_when_assumption_fails(AssumptionRunner<?> assumptionRunner) {
-    assertThatExceptionOfType(AssumptionViolatedException.class).isThrownBy(assumptionRunner::runFailingAssumption);
+    expectAssumptionNotMetException(assumptionRunner::runFailingAssumption);
   }
 
   @ParameterizedTest
diff --git a/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_with_various_types_Test.java b/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_with_various_types_Test.java
--- a/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_with_various_types_Test.java
+++ b/src/test/java/org/assertj/core/api/assumptions/Assumptions_assumeThat_with_various_types_Test.java
@@ -16,12 +16,12 @@
 import static java.util.Arrays.asList;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatCode;
-import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.assertj.core.api.Assertions.assertThatObject;
 import static org.assertj.core.api.Assumptions.assumeThat;
 import static org.assertj.core.api.Assumptions.assumeThatObject;
 import static org.assertj.core.api.Assumptions.assumeThatThrownBy;
 import static org.assertj.core.util.Arrays.array;
+import static org.assertj.core.util.AssertionsUtil.expectAssumptionNotMetException;
 import static org.assertj.core.util.Lists.list;
 import static org.assertj.core.util.Maps.newHashMap;
 import static org.mockito.Mockito.mock;
@@ -45,7 +45,6 @@
 import org.assertj.core.api.Condition;
 import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
 import org.assertj.core.api.test.ComparableExample;
-import org.junit.AssumptionViolatedException;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 
@@ -221,7 +220,7 @@ public void runPassingAssumption() {
         },
         new AssumptionRunner<ThrowingCallable>(new ThrowingCallable() {
           @Override
-          public void call() throws Throwable {
+          public void call() {
             throw new IllegalArgumentException();
           }
         }) {
@@ -368,7 +367,7 @@ public void runPassingAssumption() {
               new Condition<>(list -> list.getFirst().equals("abc"), "First element is 'abc'")));
           }
         },
-        new AssumptionRunner<Spliterator>(Stream.of(1, 2).spliterator()) {
+        new AssumptionRunner<Spliterator<Integer>>(Stream.of(1, 2).spliterator()) {
           @Override
           public void runFailingAssumption() {
             assumeThat(actual).hasCharacteristics(Spliterator.DISTINCT);
@@ -393,12 +392,12 @@ private static URL createUrl() {
   @ParameterizedTest
   @MethodSource("provideAssumptionsRunners")
   void should_ignore_test_when_assumption_fails(AssumptionRunner<?> assumptionRunner) {
-    assertThatExceptionOfType(AssumptionViolatedException.class).isThrownBy(() -> assumptionRunner.runFailingAssumption());
+    expectAssumptionNotMetException(assumptionRunner::runFailingAssumption);
   }
 
   @ParameterizedTest
   @MethodSource("provideAssumptionsRunners")
   void should_run_test_when_assumption_passes(AssumptionRunner<?> assumptionRunner) {
-    assertThatCode(() -> assumptionRunner.runPassingAssumption()).doesNotThrowAnyException();
+    assertThatCode(assumptionRunner::runPassingAssumption).doesNotThrowAnyException();
   }
 }
diff --git a/src/test/java/org/assertj/core/api/assumptions/BDDAssumptionsTest.java b/src/test/java/org/assertj/core/api/assumptions/BDDAssumptionsTest.java
--- a/src/test/java/org/assertj/core/api/assumptions/BDDAssumptionsTest.java
+++ b/src/test/java/org/assertj/core/api/assumptions/BDDAssumptionsTest.java
@@ -16,7 +16,7 @@
 import static org.assertj.core.api.BDDAssumptions.given;
 import static org.assertj.core.api.BDDAssumptions.givenCode;
 import static org.assertj.core.api.BDDAssumptions.givenObject;
-import static org.assertj.core.util.AssertionsUtil.expectAssumptionViolatedException;
+import static org.assertj.core.util.AssertionsUtil.expectAssumptionNotMetException;
 import static org.mockito.BDDMockito.willReturn;
 import static org.mockito.Mockito.mock;
 
@@ -92,7 +92,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isFalse());
+      expectAssumptionNotMetException(() -> given(actual).isFalse());
     }
   }
 
@@ -107,7 +107,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isFalse());
+      expectAssumptionNotMetException(() -> given(actual).isFalse());
     }
   }
 
@@ -122,7 +122,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).contains(false));
+      expectAssumptionNotMetException(() -> given(actual).contains(false));
     }
   }
 
@@ -137,7 +137,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isZero());
+      expectAssumptionNotMetException(() -> given(actual).isZero());
     }
   }
 
@@ -152,7 +152,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isZero());
+      expectAssumptionNotMetException(() -> given(actual).isZero());
     }
   }
 
@@ -167,7 +167,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).contains((byte) 0));
+      expectAssumptionNotMetException(() -> given(actual).contains((byte) 0));
     }
   }
 
@@ -182,7 +182,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isZero());
+      expectAssumptionNotMetException(() -> given(actual).isZero());
     }
   }
 
@@ -197,7 +197,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isZero());
+      expectAssumptionNotMetException(() -> given(actual).isZero());
     }
   }
 
@@ -212,7 +212,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).contains((short) 0));
+      expectAssumptionNotMetException(() -> given(actual).contains((short) 0));
     }
   }
 
@@ -227,7 +227,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isZero());
+      expectAssumptionNotMetException(() -> given(actual).isZero());
     }
   }
 
@@ -242,7 +242,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isZero());
+      expectAssumptionNotMetException(() -> given(actual).isZero());
     }
   }
 
@@ -257,7 +257,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).contains(0));
+      expectAssumptionNotMetException(() -> given(actual).contains(0));
     }
   }
 
@@ -272,7 +272,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isZero());
+      expectAssumptionNotMetException(() -> given(actual).isZero());
     }
   }
 
@@ -287,7 +287,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isZero());
+      expectAssumptionNotMetException(() -> given(actual).isZero());
     }
   }
 
@@ -302,7 +302,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isZero());
+      expectAssumptionNotMetException(() -> given(actual).isZero());
     }
   }
 
@@ -317,7 +317,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).contains(0L));
+      expectAssumptionNotMetException(() -> given(actual).contains(0L));
     }
   }
 
@@ -332,7 +332,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isZero());
+      expectAssumptionNotMetException(() -> given(actual).isZero());
     }
   }
 
@@ -347,7 +347,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isZero());
+      expectAssumptionNotMetException(() -> given(actual).isZero());
     }
   }
 
@@ -362,7 +362,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).contains(0.0f));
+      expectAssumptionNotMetException(() -> given(actual).contains(0.0f));
     }
   }
 
@@ -377,7 +377,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isZero());
+      expectAssumptionNotMetException(() -> given(actual).isZero());
     }
   }
 
@@ -392,7 +392,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isZero());
+      expectAssumptionNotMetException(() -> given(actual).isZero());
     }
   }
 
@@ -407,7 +407,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).contains(0.0f));
+      expectAssumptionNotMetException(() -> given(actual).contains(0.0f));
     }
   }
 
@@ -422,7 +422,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isZero());
+      expectAssumptionNotMetException(() -> given(actual).isZero());
     }
   }
 
@@ -437,7 +437,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isLowerCase());
+      expectAssumptionNotMetException(() -> given(actual).isLowerCase());
     }
   }
 
@@ -452,7 +452,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isLowerCase());
+      expectAssumptionNotMetException(() -> given(actual).isLowerCase());
     }
   }
 
@@ -467,7 +467,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).contains('C'));
+      expectAssumptionNotMetException(() -> given(actual).contains('C'));
     }
   }
 
@@ -482,7 +482,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isNullOrEmpty());
+      expectAssumptionNotMetException(() -> given(actual).isNullOrEmpty());
     }
   }
 
@@ -497,7 +497,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isNullOrEmpty());
+      expectAssumptionNotMetException(() -> given(actual).isNullOrEmpty());
     }
   }
 
@@ -512,7 +512,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isNullOrEmpty());
+      expectAssumptionNotMetException(() -> given(actual).isNullOrEmpty());
     }
   }
 
@@ -527,7 +527,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isNullOrEmpty());
+      expectAssumptionNotMetException(() -> given(actual).isNullOrEmpty());
     }
   }
 
@@ -542,7 +542,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isInterface());
+      expectAssumptionNotMetException(() -> given(actual).isInterface());
     }
   }
 
@@ -568,7 +568,7 @@ void should_run_test_when_assumption_passes() {
 
       @Test
       void should_ignore_test_when_assumption_fails() {
-        expectAssumptionViolatedException(() -> given(actual).hasAllNullFieldsOrProperties());
+        expectAssumptionNotMetException(() -> given(actual).hasAllNullFieldsOrProperties());
       }
     }
 
@@ -583,7 +583,7 @@ void should_run_test_when_assumption_passes() {
 
       @Test
       void should_ignore_test_when_assumption_fails() {
-        expectAssumptionViolatedException(() -> given(actual).isNullOrEmpty());
+        expectAssumptionNotMetException(() -> given(actual).isNullOrEmpty());
       }
     }
 
@@ -598,7 +598,7 @@ void should_run_test_when_assumption_passes() {
 
       @Test
       void should_ignore_test_when_assumption_fails() {
-        expectAssumptionViolatedException(() -> givenObject(actual).hasAllNullFieldsOrProperties());
+        expectAssumptionNotMetException(() -> givenObject(actual).hasAllNullFieldsOrProperties());
       }
     }
   }
@@ -621,7 +621,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isNotEqualByComparingTo(new Yoda()));
+      expectAssumptionNotMetException(() -> given(actual).isNotEqualByComparingTo(new Yoda()));
     }
   }
 
@@ -636,7 +636,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).hasMessage(""));
+      expectAssumptionNotMetException(() -> given(actual).hasMessage(""));
     }
   }
 
@@ -651,7 +651,7 @@ void should_run_test_when_assumption_passes() {
 
       @Test
       void should_ignore_test_when_assumption_fails() {
-        expectAssumptionViolatedException(() -> givenCode(() -> { /* some code */ }).hasMessage("Yoda time"));
+        expectAssumptionNotMetException(() -> givenCode(() -> { /* some code */ }).hasMessage("Yoda time"));
       }
     }
 
@@ -666,7 +666,7 @@ void should_run_test_when_assumption_passes() {
 
       @Test
       void should_ignore_test_when_assumption_fails() {
-        expectAssumptionViolatedException(() -> givenCode(() -> {
+        expectAssumptionNotMetException(() -> givenCode(() -> {
           throw new Exception("Yoda time");
         }).doesNotThrowAnyException());
       }
@@ -684,7 +684,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).containsOnly(2));
+      expectAssumptionNotMetException(() -> given(actual).containsOnly(2));
     }
   }
 
@@ -699,7 +699,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isExhausted());
+      expectAssumptionNotMetException(() -> given(actual).isExhausted());
     }
   }
 
@@ -714,7 +714,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).containsOnly(2));
+      expectAssumptionNotMetException(() -> given(actual).containsOnly(2));
     }
   }
 
@@ -729,7 +729,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).containsEntry(2, 1));
+      expectAssumptionNotMetException(() -> given(actual).containsEntry(2, 1));
     }
   }
 
@@ -744,7 +744,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).accepts(-2, -1));
+      expectAssumptionNotMetException(() -> given(actual).accepts(-2, -1));
     }
   }
 
@@ -759,7 +759,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).accepts(-2, -1));
+      expectAssumptionNotMetException(() -> given(actual).accepts(-2, -1));
     }
   }
 
@@ -774,7 +774,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).accepts(-2, -1));
+      expectAssumptionNotMetException(() -> given(actual).accepts(-2, -1));
     }
   }
 
@@ -789,7 +789,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).accepts(-2.0, -1.0));
+      expectAssumptionNotMetException(() -> given(actual).accepts(-2.0, -1.0));
     }
   }
 
@@ -804,7 +804,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isNotEmpty());
+      expectAssumptionNotMetException(() -> given(actual).isNotEmpty());
     }
   }
 
@@ -819,7 +819,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isNotEmpty());
+      expectAssumptionNotMetException(() -> given(actual).isNotEmpty());
     }
   }
 
@@ -834,7 +834,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isNotEmpty());
+      expectAssumptionNotMetException(() -> given(actual).isNotEmpty());
     }
   }
 
@@ -849,7 +849,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isNotEmpty());
+      expectAssumptionNotMetException(() -> given(actual).isNotEmpty());
     }
   }
 
@@ -864,7 +864,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).containsOnly(2));
+      expectAssumptionNotMetException(() -> given(actual).containsOnly(2));
     }
   }
 
@@ -879,7 +879,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).containsOnly(2));
+      expectAssumptionNotMetException(() -> given(actual).containsOnly(2));
     }
   }
 
@@ -894,7 +894,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).containsOnly(2L));
+      expectAssumptionNotMetException(() -> given(actual).containsOnly(2L));
     }
   }
 
@@ -909,7 +909,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).containsOnly(2.0));
+      expectAssumptionNotMetException(() -> given(actual).containsOnly(2.0));
     }
   }
 
@@ -924,7 +924,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).hasCharacteristics(Spliterator.DISTINCT));
+      expectAssumptionNotMetException(() -> given(actual).hasCharacteristics(Spliterator.DISTINCT));
     }
   }
 
@@ -944,7 +944,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isNotCancelled());
+      expectAssumptionNotMetException(() -> given(actual).isNotCancelled());
     }
   }
 
@@ -959,7 +959,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isNotDone());
+      expectAssumptionNotMetException(() -> given(actual).isNotDone());
     }
   }
 
@@ -974,7 +974,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isNotDone());
+      expectAssumptionNotMetException(() -> given(actual).isNotDone());
     }
   }
 
@@ -989,7 +989,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isFalse());
+      expectAssumptionNotMetException(() -> given(actual).isFalse());
     }
   }
 
@@ -1004,7 +1004,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).hasNegativeValue());
+      expectAssumptionNotMetException(() -> given(actual).hasNegativeValue());
     }
   }
 
@@ -1019,7 +1019,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isNotEmpty());
+      expectAssumptionNotMetException(() -> given(actual).isNotEmpty());
     }
   }
 
@@ -1045,7 +1045,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).hasValue(2, value));
+      expectAssumptionNotMetException(() -> given(actual).hasValue(2, value));
     }
   }
 
@@ -1060,7 +1060,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).hasNegativeValue());
+      expectAssumptionNotMetException(() -> given(actual).hasNegativeValue());
     }
   }
 
@@ -1075,7 +1075,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isNotEmpty());
+      expectAssumptionNotMetException(() -> given(actual).isNotEmpty());
     }
   }
 
@@ -1101,7 +1101,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).hasValue(2L, value));
+      expectAssumptionNotMetException(() -> given(actual).hasValue(2L, value));
     }
   }
 
@@ -1116,7 +1116,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).doesNotHaveValue("Yoda"));
+      expectAssumptionNotMetException(() -> given(actual).doesNotHaveValue("Yoda"));
     }
   }
 
@@ -1131,7 +1131,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isNotEmpty());
+      expectAssumptionNotMetException(() -> given(actual).isNotEmpty());
     }
   }
 
@@ -1159,7 +1159,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).hasValue("", value));
+      expectAssumptionNotMetException(() -> given(actual).hasValue("", value));
     }
   }
 
@@ -1174,7 +1174,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isNotMarked());
+      expectAssumptionNotMetException(() -> given(actual).isNotMarked());
     }
   }
 
@@ -1189,7 +1189,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).hasStamp(0));
+      expectAssumptionNotMetException(() -> given(actual).hasStamp(0));
     }
   }
 
@@ -1204,7 +1204,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isAfter("2016-12-03T10:15:30Z"));
+      expectAssumptionNotMetException(() -> given(actual).isAfter("2016-12-03T10:15:30Z"));
     }
   }
 
@@ -1219,7 +1219,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isAfter(LocalDate.now()));
+      expectAssumptionNotMetException(() -> given(actual).isAfter(LocalDate.now()));
     }
   }
 
@@ -1234,7 +1234,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isAfter(LocalTime.now()));
+      expectAssumptionNotMetException(() -> given(actual).isAfter(LocalTime.now()));
     }
   }
 
@@ -1249,7 +1249,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isAfter(OffsetTime.now()));
+      expectAssumptionNotMetException(() -> given(actual).isAfter(OffsetTime.now()));
     }
   }
 
@@ -1264,7 +1264,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isAfter(LocalDateTime.now()));
+      expectAssumptionNotMetException(() -> given(actual).isAfter(LocalDateTime.now()));
     }
   }
 
@@ -1279,7 +1279,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isAfter(Instant.now()));
+      expectAssumptionNotMetException(() -> given(actual).isAfter(Instant.now()));
     }
   }
 
@@ -1294,7 +1294,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isAfter(OffsetDateTime.now()));
+      expectAssumptionNotMetException(() -> given(actual).isAfter(OffsetDateTime.now()));
     }
   }
 
@@ -1309,7 +1309,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isAfter(ZonedDateTime.now()));
+      expectAssumptionNotMetException(() -> given(actual).isAfter(ZonedDateTime.now()));
     }
   }
 
@@ -1324,7 +1324,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).hasContent("B"));
+      expectAssumptionNotMetException(() -> given(actual).hasContent("B"));
     }
   }
 
@@ -1339,7 +1339,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isAbsolute());
+      expectAssumptionNotMetException(() -> given(actual).isAbsolute());
     }
   }
 
@@ -1354,7 +1354,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(actual).isAbsolute());
+      expectAssumptionNotMetException(() -> given(actual).isAbsolute());
     }
   }
 
@@ -1367,7 +1367,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(new URI("http://assertj.org")).hasPort(80));
+      expectAssumptionNotMetException(() -> given(new URI("http://assertj.org")).hasPort(80));
     }
   }
 
@@ -1380,7 +1380,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(new URL("http://assertj.org")).hasPort(80));
+      expectAssumptionNotMetException(() -> given(new URL("http://assertj.org")).hasPort(80));
     }
   }
 
@@ -1393,7 +1393,7 @@ void should_run_test_when_assumption_passes() {
 
     @Test
     void should_ignore_test_when_assumption_fails() {
-      expectAssumptionViolatedException(() -> given(Duration.ofHours(1)).isNotNull().isNegative());
+      expectAssumptionNotMetException(() -> given(Duration.ofHours(1)).isNotNull().isNegative());
     }
   }
 }
diff --git a/src/test/java/org/assertj/core/api/assumptions/BaseAssumptionsRunnerTest.java b/src/test/java/org/assertj/core/api/assumptions/BaseAssumptionsRunnerTest.java
--- a/src/test/java/org/assertj/core/api/assumptions/BaseAssumptionsRunnerTest.java
+++ b/src/test/java/org/assertj/core/api/assumptions/BaseAssumptionsRunnerTest.java
@@ -13,7 +13,7 @@
 package org.assertj.core.api.assumptions;
 
 import static org.assertj.core.api.Assertions.assertThatCode;
-import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+import static org.assertj.core.util.AssertionsUtil.expectAssumptionNotMetException;
 
 import java.util.Collection;
 import java.util.function.Function;
@@ -23,7 +23,6 @@
 import org.assertj.core.data.TolkienCharacter;
 import org.assertj.core.data.TolkienCharacter.Race;
 import org.assertj.core.test.CartoonCharacter;
-import org.junit.AssumptionViolatedException;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 
@@ -81,7 +80,7 @@ private static void setupData() {
   @ParameterizedTest
   @MethodSource("provideAssumptionsRunners")
   void should_ignore_test_when_assumption_fails(AssumptionRunner<?> assumptionRunner) {
-    assertThatExceptionOfType(AssumptionViolatedException.class).isThrownBy(assumptionRunner::runFailingAssumption);
+    expectAssumptionNotMetException(assumptionRunner::runFailingAssumption);
   }
 
   @ParameterizedTest
diff --git a/src/test/java/org/assertj/core/api/bytearray/ByteArrayAssert_asHexString_Test.java b/src/test/java/org/assertj/core/api/bytearray/ByteArrayAssert_asHexString_Test.java
--- a/src/test/java/org/assertj/core/api/bytearray/ByteArrayAssert_asHexString_Test.java
+++ b/src/test/java/org/assertj/core/api/bytearray/ByteArrayAssert_asHexString_Test.java
@@ -16,7 +16,7 @@
 import static org.assertj.core.api.Assertions.assertThatCode;
 import static org.assertj.core.api.Assumptions.assumeThat;
 import static org.assertj.core.util.AssertionsUtil.expectAssertionError;
-import static org.assertj.core.util.AssertionsUtil.expectAssumptionViolatedException;
+import static org.assertj.core.util.AssertionsUtil.expectAssumptionNotMetException;
 import static org.assertj.core.util.FailureMessages.actualIsNull;
 
 import org.assertj.core.api.SoftAssertions;
@@ -101,7 +101,7 @@ void should_fail_with_soft_assertions_capturing_all_errors() {
 
   @Test
   void should_ignore_test_when_assumption_for_internally_created_hex_string_assertion_fails() {
-    expectAssumptionViolatedException(() -> assumeThat(BYTES).asHexString().isEqualTo("other"));
+    expectAssumptionNotMetException(() -> assumeThat(BYTES).asHexString().isEqualTo("other"));
   }
 
   @Test
diff --git a/src/test/java/org/assertj/core/api/bytearray/ByteArrayAssert_asString_Test.java b/src/test/java/org/assertj/core/api/bytearray/ByteArrayAssert_asString_Test.java
--- a/src/test/java/org/assertj/core/api/bytearray/ByteArrayAssert_asString_Test.java
+++ b/src/test/java/org/assertj/core/api/bytearray/ByteArrayAssert_asString_Test.java
@@ -16,7 +16,7 @@
 import static org.assertj.core.api.Assertions.assertThatCode;
 import static org.assertj.core.api.Assumptions.assumeThat;
 import static org.assertj.core.util.AssertionsUtil.expectAssertionError;
-import static org.assertj.core.util.AssertionsUtil.expectAssumptionViolatedException;
+import static org.assertj.core.util.AssertionsUtil.expectAssumptionNotMetException;
 import static org.assertj.core.util.FailureMessages.actualIsNull;
 
 import org.assertj.core.api.SoftAssertions;
@@ -101,7 +101,7 @@ void should_ignore_test_when_assumption_for_internally_created_hex_string_assert
     // GIVEN
     String foo = "foo";
     // WHEN/THEN
-    expectAssumptionViolatedException(() -> assumeThat(foo.getBytes()).asString().isEqualTo("bar"));
+    expectAssumptionNotMetException(() -> assumeThat(foo.getBytes()).asString().isEqualTo("bar"));
   }
 
   @Test
diff --git a/src/test/java/org/assertj/core/api/bytearray/ByteArrayAssert_asString_with_charset_Test.java b/src/test/java/org/assertj/core/api/bytearray/ByteArrayAssert_asString_with_charset_Test.java
--- a/src/test/java/org/assertj/core/api/bytearray/ByteArrayAssert_asString_with_charset_Test.java
+++ b/src/test/java/org/assertj/core/api/bytearray/ByteArrayAssert_asString_with_charset_Test.java
@@ -16,7 +16,7 @@
 import static org.assertj.core.api.Assertions.assertThatCode;
 import static org.assertj.core.api.Assumptions.assumeThat;
 import static org.assertj.core.util.AssertionsUtil.expectAssertionError;
-import static org.assertj.core.util.AssertionsUtil.expectAssumptionViolatedException;
+import static org.assertj.core.util.AssertionsUtil.expectAssumptionNotMetException;
 import static org.assertj.core.util.FailureMessages.actualIsNull;
 
 import java.nio.charset.Charset;
@@ -110,7 +110,7 @@ void should_ignore_test_when_assumption_for_internally_created_hex_string_assert
     String real = "Gerçek";
     byte[] bytes = real.getBytes(TURKISH_CHARSET);
     // WHEN/THEN
-    expectAssumptionViolatedException(() -> assumeThat(bytes).asString(TURKISH_CHARSET).isEqualTo("bar"));
+    expectAssumptionNotMetException(() -> assumeThat(bytes).asString(TURKISH_CHARSET).isEqualTo("bar"));
   }
 
   @Test
diff --git a/src/test/java/org/assertj/core/api/recursive/comparison/RecursiveComparisonAssert_assumptions_Test.java b/src/test/java/org/assertj/core/api/recursive/comparison/RecursiveComparisonAssert_assumptions_Test.java
--- a/src/test/java/org/assertj/core/api/recursive/comparison/RecursiveComparisonAssert_assumptions_Test.java
+++ b/src/test/java/org/assertj/core/api/recursive/comparison/RecursiveComparisonAssert_assumptions_Test.java
@@ -13,13 +13,12 @@
 package org.assertj.core.api.recursive.comparison;
 
 import static org.assertj.core.api.Assertions.assertThatCode;
-import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.assertj.core.api.Assumptions.assumeThat;
 import static org.assertj.core.presentation.UnicodeRepresentation.UNICODE_REPRESENTATION;
+import static org.assertj.core.util.AssertionsUtil.expectAssumptionNotMetException;
 
 import org.assertj.core.api.RecursiveComparisonAssert_isEqualTo_BaseTest;
 import org.assertj.core.internal.objects.data.Person;
-import org.junit.AssumptionViolatedException;
 import org.junit.jupiter.api.Test;
 
 class RecursiveComparisonAssert_assumptions_Test extends RecursiveComparisonAssert_isEqualTo_BaseTest {
@@ -35,8 +34,8 @@ void should_ignore_test_when_one_of_the_assumption_fails() {
     unexpected.home.address.number = 2;
     // THEN
     assumeThat(actual).usingRecursiveComparison().isEqualTo(expected);
-    assertThatExceptionOfType(AssumptionViolatedException.class).isThrownBy(() -> assumeThat(actual).usingRecursiveComparison()
-                                                                                                    .isEqualTo(unexpected));
+    expectAssumptionNotMetException(() -> assumeThat(actual).usingRecursiveComparison()
+                                                            .isEqualTo(unexpected));
   }
 
   @Test
diff --git a/src/test/java/org/assertj/core/util/AssertionsUtil.java b/src/test/java/org/assertj/core/util/AssertionsUtil.java
--- a/src/test/java/org/assertj/core/util/AssertionsUtil.java
+++ b/src/test/java/org/assertj/core/util/AssertionsUtil.java
@@ -24,7 +24,7 @@
 
 import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
 import org.assertj.core.api.ThrowableAssertAlternative;
-import org.junit.AssumptionViolatedException;
+import org.opentest4j.TestAbortedException;
 
 public class AssertionsUtil {
 
@@ -40,8 +40,8 @@ public static ThrowableAssertAlternative<AssertionError> assertThatAssertionErro
     return assertThatExceptionOfType(AssertionError.class).isThrownBy(shouldRaiseAssertionError);
   }
 
-  public static void expectAssumptionViolatedException(ThrowingCallable shouldRaiseError) {
-    assertThatThrownBy(shouldRaiseError).isInstanceOf(AssumptionViolatedException.class);
+  public static void expectAssumptionNotMetException(ThrowingCallable shouldRaiseError) {
+    assertThatThrownBy(shouldRaiseError).isInstanceOf(TestAbortedException.class);
   }
 
   public static Charset getDifferentCharsetFrom(Charset charset) {