Skip to main content

8.51.0 release (2025-04-25)

Total recipe count: 3707

info

This changelog only shows what recipes have been added, removed, or changed. OpenRewrite may do releases that do not include these types of changes. To see these changes, please go to the releases page.

New Recipes​

Limitations:

  • If two methods in a class are effectively the same getter then one's name will be corrected and the others name will be left as it is.
  • If the correct name for a method is already taken by another method then the name will not be corrected.
  • Method name swaps or circular renaming within a class cannot be performed because the names block each other. E.g. int getFoo() { return ba; } int getBa() { return foo; } stays as it is.
static final class AssertThatIsEqualByComparingTo<T extends Comparable<? super T>> {
    
    @BeforeTemplate
    AbstractIntegerAssert<?> before(T actual, T expected) {
        return assertThat(actual.compareTo(expected)).isEqualTo(0);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    AbstractComparableAssert<?, ?> after(T actual, T expected) {
        return assertThat(actual).isEqualByComparingTo(expected);
    }
}

.

static final class AssertThatIsGreaterThanOrEqualTo<T extends Comparable<? super T>> {
    
    @BeforeTemplate
    AbstractIntegerAssert<?> before(T actual, T expected) {
        return assertThat(actual.compareTo(expected)).isNotNegative();
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    AbstractComparableAssert<?, ?> after(T actual, T expected) {
        return assertThat(actual).isGreaterThanOrEqualTo(expected);
    }
}

.

static final class AssertThatIsGreaterThan<T extends Comparable<? super T>> {
    
    @BeforeTemplate
    AbstractIntegerAssert<?> before(T actual, T expected) {
        return assertThat(actual.compareTo(expected)).isPositive();
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    AbstractComparableAssert<?, ?> after(T actual, T expected) {
        return assertThat(actual).isGreaterThan(expected);
    }
}

.

static final class AssertThatIsLessThanOrEqualTo<T extends Comparable<? super T>> {
    
    @BeforeTemplate
    AbstractIntegerAssert<?> before(T actual, T expected) {
        return assertThat(actual.compareTo(expected)).isNotPositive();
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    AbstractComparableAssert<?, ?> after(T actual, T expected) {
        return assertThat(actual).isLessThanOrEqualTo(expected);
    }
}

.

static final class AssertThatIsLessThan<T extends Comparable<? super T>> {
    
    @BeforeTemplate
    AbstractIntegerAssert<?> before(T actual, T expected) {
        return assertThat(actual.compareTo(expected)).isNegative();
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    AbstractComparableAssert<?, ?> after(T actual, T expected) {
        return assertThat(actual).isLessThan(expected);
    }
}

.

static final class AssertThatIsNotEqualByComparingTo<T extends Comparable<? super T>> {
    
    @BeforeTemplate
    AbstractIntegerAssert<?> before(T actual, T expected) {
        return assertThat(actual.compareTo(expected)).isNotEqualTo(0);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    AbstractComparableAssert<?, ?> after(T actual, T expected) {
        return assertThat(actual).isNotEqualByComparingTo(expected);
    }
}

.

static final class EnumerableAssertHasSameSizeAs<S, E> {
    
    @BeforeTemplate
    EnumerableAssert<?, S> before(EnumerableAssert<?, S> enumAssert, Iterable<E> iterable) {
        return enumAssert.hasSize(Iterables.size(iterable));
    }
    
    @BeforeTemplate
    EnumerableAssert<?, S> before(EnumerableAssert<?, S> enumAssert, Collection<E> iterable) {
        return enumAssert.hasSize(iterable.size());
    }
    
    @BeforeTemplate
    EnumerableAssert<?, S> before(EnumerableAssert<?, S> enumAssert, E[] iterable) {
        return enumAssert.hasSize(iterable.length);
    }
    
    @BeforeTemplate
    EnumerableAssert<?, S> before(EnumerableAssert<?, S> enumAssert, CharSequence iterable) {
        return enumAssert.hasSize(iterable.length());
    }
    
    @AfterTemplate
    EnumerableAssert<?, S> after(EnumerableAssert<?, S> enumAssert, Iterable<E> iterable) {
        return enumAssert.hasSameSizeAs(iterable);
    }
}

.

static final class EnumerableAssertHasSizeBetween<E> {
    
    @BeforeTemplate
    AbstractIterableAssert<?, ?, E, ?> before(AbstractIterableAssert<?, ?, E, ?> enumAssert, int lower, int upper) {
        return enumAssert.size().isBetween(lower, upper).returnToIterable();
    }
    
    @BeforeTemplate
    AbstractIterableSizeAssert<?, ?, E, ?> before2(AbstractIterableAssert<?, ?, E, ?> enumAssert, int lower, int upper) {
        return enumAssert.size().isBetween(lower, upper);
    }
    
    @AfterTemplate
    EnumerableAssert<?, E> after(EnumerableAssert<?, E> enumAssert, int lower, int upper) {
        return enumAssert.hasSizeBetween(lower, upper);
    }
}

.

static final class EnumerableAssertHasSizeGreaterThanOrEqualTo<E> {
    
    @BeforeTemplate
    AbstractIterableAssert<?, ?, E, ?> before(AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
        return enumAssert.size().isGreaterThanOrEqualTo(size).returnToIterable();
    }
    
    @BeforeTemplate
    AbstractIterableSizeAssert<?, ?, E, ?> before2(AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
        return enumAssert.size().isGreaterThanOrEqualTo(size);
    }
    
    @AfterTemplate
    EnumerableAssert<?, E> after(EnumerableAssert<?, E> enumAssert, int size) {
        return enumAssert.hasSizeGreaterThanOrEqualTo(size);
    }
}

.

static final class EnumerableAssertHasSizeGreaterThan<E> {
    
    @BeforeTemplate
    AbstractIterableAssert<?, ?, E, ?> before(AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
        return enumAssert.size().isGreaterThan(size).returnToIterable();
    }
    
    @BeforeTemplate
    AbstractIterableSizeAssert<?, ?, E, ?> before2(AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
        return enumAssert.size().isGreaterThan(size);
    }
    
    @AfterTemplate
    EnumerableAssert<?, E> after(EnumerableAssert<?, E> enumAssert, int size) {
        return enumAssert.hasSizeGreaterThan(size);
    }
}

.

static final class EnumerableAssertHasSizeLessThanOrEqualTo<E> {
    
    @BeforeTemplate
    AbstractIterableAssert<?, ?, E, ?> before(AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
        return enumAssert.size().isLessThanOrEqualTo(size).returnToIterable();
    }
    
    @BeforeTemplate
    AbstractIterableSizeAssert<?, ?, E, ?> before2(AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
        return enumAssert.size().isLessThanOrEqualTo(size);
    }
    
    @AfterTemplate
    EnumerableAssert<?, E> after(EnumerableAssert<?, E> enumAssert, int size) {
        return enumAssert.hasSizeLessThanOrEqualTo(size);
    }
}

.

static final class EnumerableAssertHasSizeLessThan<E> {
    
    @BeforeTemplate
    AbstractIterableAssert<?, ?, E, ?> before(AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
        return enumAssert.size().isLessThan(size).returnToIterable();
    }
    
    @BeforeTemplate
    AbstractIterableSizeAssert<?, ?, E, ?> before2(AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
        return enumAssert.size().isLessThan(size);
    }
    
    @AfterTemplate
    EnumerableAssert<?, E> after(EnumerableAssert<?, E> enumAssert, int size) {
        return enumAssert.hasSizeLessThan(size);
    }
}

.

static final class EnumerableAssertHasSize<E> {
    
    @BeforeTemplate
    AbstractIterableAssert<?, ?, E, ?> before(AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
        return enumAssert.size().isEqualTo(size).returnToIterable();
    }
    
    @BeforeTemplate
    AbstractIterableSizeAssert<?, ?, E, ?> before2(AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
        return enumAssert.size().isEqualTo(size);
    }
    
    @AfterTemplate
    EnumerableAssert<?, E> after(EnumerableAssert<?, E> enumAssert, int size) {
        return enumAssert.hasSize(size);
    }
}

.

static final class EnumerableAssertIsEmpty<E> {
    
    @BeforeTemplate
    void before(EnumerableAssert<?, E> enumAssert) {
        Refaster.anyOf(enumAssert.hasSize(0), enumAssert.hasSizeLessThanOrEqualTo(0), enumAssert.hasSizeLessThan(1));
    }
    
    @BeforeTemplate
    void before(AbstractIterableAssert<?, ?, E, ?> enumAssert) {
        enumAssert.size().isNotPositive();
    }
    
    @AfterTemplate
    void after(EnumerableAssert<?, E> enumAssert) {
        enumAssert.isEmpty();
    }
}

.

static final class EnumerableAssertIsNotEmpty<E> {
    
    @BeforeTemplate
    EnumerableAssert<?, E> before(EnumerableAssert<?, E> enumAssert) {
        return Refaster.anyOf(enumAssert.hasSizeGreaterThan(0), enumAssert.hasSizeGreaterThanOrEqualTo(1));
    }
    
    @BeforeTemplate
    AbstractIterableAssert<?, ?, E, ?> before(AbstractIterableAssert<?, ?, E, ?> enumAssert) {
        return Refaster.anyOf(enumAssert.size().isNotEqualTo(0).returnToIterable(), enumAssert.size().isPositive().returnToIterable());
    }
    
    @BeforeTemplate
    AbstractIntegerAssert<?> before2(AbstractIterableAssert<?, ?, E, ?> enumAssert) {
        return Refaster.anyOf(enumAssert.size().isNotEqualTo(0), enumAssert.size().isPositive());
    }
    
    @AfterTemplate
    EnumerableAssert<?, E> after(EnumerableAssert<?, E> enumAssert) {
        return enumAssert.isNotEmpty();
    }
}

.

static final class AssertThatIterableHasOneElementEqualTo<S, E extends S> {
    
    @BeforeTemplate
    ObjectAssert<S> before(Iterable<S> iterable, E element) {
        return assertThat(Iterables.getOnlyElement(iterable)).isEqualTo(element);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    IterableAssert<S> after(Iterable<S> iterable, E element) {
        return assertThat(iterable).containsExactly(element);
    }
}

.

static final class AssertThatIterableIsEmpty<E> {
    
    @BeforeTemplate
    void before(Iterable<E> iterable) {
        assertThat(iterable.iterator()).isExhausted();
    }
    
    @BeforeTemplate
    void before(Collection<E> iterable) {
        assertThat(iterable.isEmpty()).isTrue();
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(Collection<E> iterable) {
        assertThat(iterable).isEmpty();
    }
}

.

static final class AssertThatIterableIsNotEmpty<E> {
    
    @BeforeTemplate
    AbstractAssert<?, ?> before(Iterable<E> iterable) {
        return assertThat(iterable.iterator()).hasNext();
    }
    
    @BeforeTemplate
    AbstractAssert<?, ?> before(Collection<E> iterable) {
        return assertThat(iterable.isEmpty()).isFalse();
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    IterableAssert<E> after(Iterable<E> iterable) {
        return assertThat(iterable).isNotEmpty();
    }
}

.

static final class AssertThatIterableSize<E> {
    
    @BeforeTemplate
    AbstractIntegerAssert<?> before(Iterable<E> iterable) {
        return assertThat(Iterables.size(iterable));
    }
    
    @BeforeTemplate
    AbstractIntegerAssert<?> before(Collection<E> iterable) {
        return assertThat(iterable.size());
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    AbstractIntegerAssert<?> after(Iterable<E> iterable) {
        return assertThat(iterable).size();
    }
}

.

static final class AssertThatHasNext<T> {
    
    @BeforeTemplate
    AbstractBooleanAssert<?> before(Iterator<T> iterator) {
        return assertThat(iterator.hasNext()).isTrue();
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    IteratorAssert<T> after(Iterator<T> iterator) {
        return assertThat(iterator).hasNext();
    }
}

.

static final class AssertThatIsExhausted<T> {
    
    @BeforeTemplate
    AbstractBooleanAssert<?> before(Iterator<T> iterator) {
        return assertThat(iterator.hasNext()).isFalse();
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    IteratorAssert<T> after(Iterator<T> iterator) {
        return assertThat(iterator).isExhausted();
    }
}

.

static final class AbstractMapAssertContainsExactlyEntriesOf<K, V> {
    
    @BeforeTemplate
    AbstractMapAssert<?, ?, K, V> before(AbstractMapAssert<?, ?, K, V> mapAssert, K key, V value) {
        return mapAssert.containsExactlyInAnyOrderEntriesOf(ImmutableMap.of(key, value));
    }
    
    @AfterTemplate
    AbstractMapAssert<?, ?, K, V> after(AbstractMapAssert<?, ?, K, V> mapAssert, K key, V value) {
        return mapAssert.containsExactlyEntriesOf(ImmutableMap.of(key, value));
    }
}

.

static final class AbstractMapAssertContainsExactlyInAnyOrderEntriesOf<K, V> {
    
    @BeforeTemplate
    AbstractMapAssert<?, ?, K, V> before(AbstractMapAssert<?, ?, K, V> mapAssert, Map<? extends K, ? extends V> map) {
        return mapAssert.isEqualTo(map);
    }
    
    @AfterTemplate
    AbstractMapAssert<?, ?, K, V> after(AbstractMapAssert<?, ?, K, V> mapAssert, Map<? extends K, ? extends V> map) {
        return mapAssert.containsExactlyInAnyOrderEntriesOf(map);
    }
}

.

static final class AbstractMapAssertHasSameSizeAs<K, V> {
    
    @BeforeTemplate
    AbstractMapAssert<?, ?, K, V> before(AbstractMapAssert<?, ?, K, V> mapAssert, Map<?, ?> map) {
        return mapAssert.hasSize(map.size());
    }
    
    @AfterTemplate
    AbstractMapAssert<?, ?, K, V> after(AbstractMapAssert<?, ?, K, V> mapAssert, Map<?, ?> map) {
        return mapAssert.hasSameSizeAs(map);
    }
}

.

static final class AssertThatMapContainsKey<K, V> {
    
    @BeforeTemplate
    AbstractBooleanAssert<?> before(Map<K, V> map, K key) {
        return assertThat(map.containsKey(key)).isTrue();
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    MapAssert<K, V> after(Map<K, V> map, K key) {
        return assertThat(map).containsKey(key);
    }
}

.

static final class AssertThatMapContainsOnlyKeys<K, V> {
    
    @BeforeTemplate
    AbstractCollectionAssert<?, Collection<? extends K>, K, ?> before(Map<K, V> map, Iterable<? extends K> keys) {
        return assertThat(map.keySet()).hasSameElementsAs(keys);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    MapAssert<K, V> after(Map<K, V> map, Iterable<? extends K> keys) {
        return assertThat(map).containsOnlyKeys(keys);
    }
}

.

static final class AssertThatMapContainsValue<K, V> {
    
    @BeforeTemplate
    AbstractBooleanAssert<?> before(Map<K, V> map, V value) {
        return assertThat(map.containsValue(value)).isTrue();
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    MapAssert<K, V> after(Map<K, V> map, V value) {
        return assertThat(map).containsValue(value);
    }
}

.

static final class AssertThatMapDoesNotContainKey<K, V> {
    
    @BeforeTemplate
    AbstractBooleanAssert<?> before(Map<K, V> map, K key) {
        return assertThat(map.containsKey(key)).isFalse();
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    MapAssert<K, V> after(Map<K, V> map, K key) {
        return assertThat(map).doesNotContainKey(key);
    }
}

.

static final class AssertThatMapDoesNotContainValue<K, V> {
    
    @BeforeTemplate
    AbstractBooleanAssert<?> before(Map<K, V> map, V value) {
        return assertThat(map.containsValue(value)).isFalse();
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    MapAssert<K, V> after(Map<K, V> map, V value) {
        return assertThat(map).doesNotContainValue(value);
    }
}

.

static final class AssertThatMapIsEmpty<K, V> {
    
    @BeforeTemplate
    void before(Map<K, V> map) {
        Refaster.anyOf(assertThat(map).hasSize(0), assertThat(map.isEmpty()).isTrue(), assertThat(map.size()).isEqualTo(0L), assertThat(map.size()).isNotPositive());
    }
    
    @BeforeTemplate
    void before2(Map<K, V> map) {
        assertThat(Refaster.anyOf(map.keySet(), map.values(), map.entrySet())).isEmpty();
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(Map<K, V> map) {
        assertThat(map).isEmpty();
    }
}

.

static final class AssertThatHasToString<T> {
    
    @BeforeTemplate
    AbstractStringAssert<?> before(T object, String str) {
        return assertThat(object.toString()).isEqualTo(str);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    ObjectAssert<T> after(T object, String str) {
        return assertThat(object).hasToString(str);
    }
}

.

static final class AssertThatIsIsEqualTo<S, T> {
    
    @BeforeTemplate
    AbstractBooleanAssert<?> before(S object1, T object2) {
        return assertThat(object1.equals(object2)).isTrue();
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    ObjectAssert<S> after(S object1, T object2) {
        return assertThat(object1).isEqualTo(object2);
    }
}

.

static final class AssertThatIsIsNotEqualTo<S, T> {
    
    @BeforeTemplate
    AbstractBooleanAssert<?> before(S object1, T object2) {
        return assertThat(object1.equals(object2)).isFalse();
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    ObjectAssert<S> after(S object1, T object2) {
        return assertThat(object1).isNotEqualTo(object2);
    }
}

.

static final class AbstractOptionalAssertContainsSame<T> {
    
    @BeforeTemplate
    AbstractAssert<?, ?> before(AbstractOptionalAssert<?, T> optionalAssert, T value) {
        return Refaster.anyOf(optionalAssert.get().isSameAs(value), optionalAssert.isPresent().isSameAs(value));
    }
    
    @AfterTemplate
    AbstractOptionalAssert<?, T> after(AbstractOptionalAssert<?, T> optionalAssert, T value) {
        return optionalAssert.containsSame(value);
    }
}

.

static final class AbstractOptionalAssertHasValue<T> {
    
    @BeforeTemplate
    AbstractAssert<?, ?> before(AbstractOptionalAssert<?, T> optionalAssert, T value) {
        return Refaster.anyOf(optionalAssert.get().isEqualTo(value), optionalAssert.isEqualTo(Optional.of(value)), optionalAssert.contains(value), optionalAssert.isPresent().hasValue(value));
    }
    
    @AfterTemplate
    AbstractOptionalAssert<?, T> after(AbstractOptionalAssert<?, T> optionalAssert, T value) {
        return optionalAssert.hasValue(value);
    }
}

.

static final class AbstractOptionalAssertIsEmpty<T> {
    
    @BeforeTemplate
    AbstractAssert<?, ?> before(AbstractOptionalAssert<?, T> optionalAssert) {
        return Refaster.anyOf(optionalAssert.isNotPresent(), optionalAssert.isEqualTo(Optional.empty()));
    }
    
    @AfterTemplate
    AbstractOptionalAssert<?, T> after(AbstractOptionalAssert<?, T> optionalAssert) {
        return optionalAssert.isEmpty();
    }
}

.

static final class AbstractOptionalAssertIsPresent<T> {
    
    @BeforeTemplate
    AbstractAssert<?, ?> before(AbstractOptionalAssert<?, T> optionalAssert) {
        return Refaster.anyOf(optionalAssert.isNotEmpty(), optionalAssert.isNotEqualTo(Optional.empty()));
    }
    
    @AfterTemplate
    AbstractOptionalAssert<?, T> after(AbstractOptionalAssert<?, T> optionalAssert) {
        return optionalAssert.isPresent();
    }
}

.

static final class AssertThatOptionalHasValueMatching<T> {
    
    @BeforeTemplate
    AbstractOptionalAssert<?, T> before(Optional<T> optional, Predicate<? super T> predicate) {
        return assertThat(optional.filter(predicate)).isPresent();
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    AbstractObjectAssert<?, T> after(Optional<T> optional, Predicate<? super T> predicate) {
        return assertThat(optional).get().matches(predicate);
    }
}

.

static final class AssertThatOptionalIsEmpty<T> {
    
    @BeforeTemplate
    AbstractAssert<?, ?> before(Optional<T> optional) {
        return Refaster.anyOf(assertThat(optional.isEmpty()).isTrue(), assertThat(optional.isPresent()).isFalse());
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    OptionalAssert<T> after(Optional<T> optional) {
        return assertThat(optional).isEmpty();
    }
}

.

static final class AssertThatOptionalIsPresent<T> {
    
    @BeforeTemplate
    AbstractAssert<?, ?> before(Optional<T> optional) {
        return Refaster.anyOf(assertThat(optional.isPresent()).isTrue(), assertThat(optional.isEmpty()).isFalse());
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    OptionalAssert<T> after(Optional<T> optional) {
        return assertThat(optional).isPresent();
    }
}

.

static final class AssertThatOptional<T> {
    
    @BeforeTemplate
    ObjectAssert<T> before(Optional<T> optional) {
        return assertThat(optional.orElseThrow());
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    AbstractObjectAssert<?, T> after(Optional<T> optional) {
        return assertThat(optional).get();
    }
}

.

static final class AssertThatListsAreEqual<S, T extends S> {
    
    @BeforeTemplate
    ListAssert<S> before(List<S> list1, Iterable<T> list2) {
        return assertThat(list1).isEqualTo(list2);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    ListAssert<S> after(List<S> list1, Iterable<T> list2) {
        return assertThat(list1).containsExactlyElementsOf(list2);
    }
}

.

static final class AssertThatMapContainsEntry<K, V> {
    
    @BeforeTemplate
    ObjectAssert<?> before(Map<K, V> map, K key, V value) {
        return assertThat(map.get(key)).isEqualTo(value);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    MapAssert<K, V> after(Map<K, V> map, K key, V value) {
        return assertThat(map).containsEntry(key, value);
    }
}

.

static final class AssertThatMultisetsAreEqual<S, T extends S> {
    
    @BeforeTemplate
    AbstractCollectionAssert<?, ?, S, ?> before(Multiset<S> multiset1, Iterable<T> multiset2) {
        return assertThat(multiset1).isEqualTo(multiset2);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    AbstractCollectionAssert<?, ?, S, ?> after(Multiset<S> multiset1, Iterable<T> multiset2) {
        return assertThat(multiset1).containsExactlyInAnyOrderElementsOf(multiset2);
    }
}

.

static final class AssertThatPredicateAccepts<T> {
    
    @BeforeTemplate
    void before(Predicate<T> predicate, T object) {
        assertThat(predicate.test(object)).isTrue();
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(Predicate<T> predicate, T object) {
        assertThat(predicate).accepts(object);
    }
}

.

static final class AssertThatPredicateRejects<T> {
    
    @BeforeTemplate
    void before(Predicate<T> predicate, T object) {
        assertThat(predicate.test(object)).isFalse();
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(Predicate<T> predicate, T object) {
        assertThat(predicate).rejects(object);
    }
}

.

static final class AssertThatSetContainsExactlyOneElement<S, T extends S> {
    
    @BeforeTemplate
    ObjectEnumerableAssert<?, S> before(Set<S> set, T element) {
        return assertThat(set).containsOnly(element);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    ObjectEnumerableAssert<?, S> after(Set<S> set, T element) {
        return assertThat(set).containsExactly(element);
    }
}

.

static final class AssertThatSetsAreEqual<S, T extends S> {
    
    @BeforeTemplate
    AbstractCollectionAssert<?, ?, S, ?> before(Set<S> set1, Iterable<T> set2) {
        return Refaster.anyOf(assertThat(set1).isEqualTo(set2), assertThat(set1).containsExactlyInAnyOrderElementsOf(set2));
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    AbstractCollectionAssert<?, ?, S, ?> after(Set<S> set1, Iterable<T> set2) {
        return assertThat(set1).hasSameElementsAs(set2);
    }
}

.

static final class AssertThatStreamContainsAll<S, T extends S, U extends T> {
    
    @BeforeTemplate
    IterableAssert<T> before(Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends Iterable<T>> collector) {
        return assertThat(stream.collect(collector)).containsAll(iterable);
    }
    
    @BeforeTemplate
    ListAssert<T> before2(Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends List<T>> collector) {
        return assertThat(stream.collect(collector)).containsAll(iterable);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    ListAssert<S> after(Stream<S> stream, Iterable<U> iterable) {
        return assertThat(stream).containsAll(iterable);
    }
}

.

static final class AssertThatStreamContainsAnyElementsOf<S, T extends S, U extends T> {
    
    @BeforeTemplate
    IterableAssert<T> before(Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends Iterable<T>> collector) {
        return assertThat(stream.collect(collector)).containsAnyElementsOf(iterable);
    }
    
    @BeforeTemplate
    ListAssert<T> before2(Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends List<T>> collector) {
        return assertThat(stream.collect(collector)).containsAnyElementsOf(iterable);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    ListAssert<S> after(Stream<S> stream, Iterable<U> iterable) {
        return assertThat(stream).containsAnyElementsOf(iterable);
    }
}

.

static final class AssertThatStreamContainsAnyOf<S, T extends S, U extends T> {
    
    @BeforeTemplate
    IterableAssert<T> before(Stream<S> stream, U[] array, Collector<S, ?, ? extends Iterable<T>> collector) {
        return assertThat(stream.collect(collector)).containsAnyOf(array);
    }
    
    @BeforeTemplate
    ListAssert<T> before2(Stream<S> stream, U[] array, Collector<S, ?, ? extends List<T>> collector) {
        return assertThat(stream.collect(collector)).containsAnyOf(array);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    ListAssert<S> after(Stream<S> stream, U[] array) {
        return assertThat(stream).containsAnyOf(array);
    }
}

.

static final class AssertThatStreamContainsExactlyElementsOf<S, T extends S, U extends T> {
    
    @BeforeTemplate
    ListAssert<T> before(Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends List<T>> collector) {
        return assertThat(stream.collect(collector)).containsExactlyElementsOf(iterable);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    ListAssert<S> after(Stream<S> stream, Iterable<U> iterable) {
        return assertThat(stream).containsExactlyElementsOf(iterable);
    }
}

.

static final class AssertThatStreamContainsExactlyInAnyOrderElementsOf<S, T extends S, U extends T> {
    
    @BeforeTemplate
    ListAssert<T> before(Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends List<T>> collector) {
        return assertThat(stream.collect(collector)).containsExactlyInAnyOrderElementsOf(iterable);
    }
    
    @BeforeTemplate
    AbstractCollectionAssert<?, ?, T, ?> before2(Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends Multiset<T>> collector) {
        return assertThat(stream.collect(collector)).containsExactlyInAnyOrderElementsOf(iterable);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    ListAssert<S> after(Stream<S> stream, Iterable<U> iterable) {
        return assertThat(stream).containsExactlyInAnyOrderElementsOf(iterable);
    }
}

.

static final class AssertThatStreamContainsExactlyInAnyOrder<S, T extends S, U extends T> {
    
    @BeforeTemplate
    ListAssert<T> before(Stream<S> stream, U[] array, Collector<S, ?, ? extends List<T>> collector) {
        return assertThat(stream.collect(collector)).containsExactlyInAnyOrder(array);
    }
    
    @BeforeTemplate
    AbstractCollectionAssert<?, ?, T, ?> before2(Stream<S> stream, U[] array, Collector<S, ?, ? extends Multiset<T>> collector) {
        return assertThat(stream.collect(collector)).containsExactlyInAnyOrder(array);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    ListAssert<S> after(Stream<S> stream, U[] array) {
        return assertThat(stream).containsExactlyInAnyOrder(array);
    }
}

.

static final class AssertThatStreamContainsExactly<S, T extends S, U extends T> {
    
    @BeforeTemplate
    ListAssert<T> before(Stream<S> stream, U[] array, Collector<S, ?, ? extends List<T>> collector) {
        return assertThat(stream.collect(collector)).containsExactly(array);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    ListAssert<S> after(Stream<S> stream, U[] array) {
        return assertThat(stream).containsExactly(array);
    }
}

.

static final class AssertThatStreamContainsOnly<S, T extends S, U extends T> {
    
    @BeforeTemplate
    IterableAssert<T> before(Stream<S> stream, U[] array, Collector<S, ?, ? extends Iterable<T>> collector) {
        return assertThat(stream.collect(collector)).containsOnly(array);
    }
    
    @BeforeTemplate
    ListAssert<T> before2(Stream<S> stream, U[] array, Collector<S, ?, ? extends List<T>> collector) {
        return assertThat(stream.collect(collector)).containsOnly(array);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    ListAssert<S> after(Stream<S> stream, U[] array) {
        return assertThat(stream).containsOnly(array);
    }
}

.

static final class AssertThatStreamContains<S, T extends S, U extends T> {
    
    @BeforeTemplate
    IterableAssert<T> before(Stream<S> stream, U[] array, Collector<S, ?, ? extends Iterable<T>> collector) {
        return assertThat(stream.collect(collector)).contains(array);
    }
    
    @BeforeTemplate
    ListAssert<T> before2(Stream<S> stream, U[] array, Collector<S, ?, ? extends List<T>> collector) {
        return assertThat(stream.collect(collector)).contains(array);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    ListAssert<S> after(Stream<S> stream, U[] array) {
        return assertThat(stream).contains(array);
    }
}

.

static final class AssertThatStreamContainsSequence<S, T extends S, U extends T> {
    
    @BeforeTemplate
    ListAssert<T> before(Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends List<T>> collector) {
        return assertThat(stream.collect(collector)).containsSequence(iterable);
    }
    
    @BeforeTemplate
    ListAssert<T> before(Stream<S> stream, U[] iterable, Collector<S, ?, ? extends List<T>> collector) {
        return assertThat(stream.collect(collector)).containsSequence(iterable);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    ListAssert<S> after(Stream<S> stream, Iterable<U> iterable) {
        return assertThat(stream).containsSequence(iterable);
    }
}

.

static final class AssertThatStreamContainsSubsequence<S, T extends S, U extends T> {
    
    @BeforeTemplate
    ListAssert<T> before(Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends List<T>> collector) {
        return assertThat(stream.collect(collector)).containsSubsequence(iterable);
    }
    
    @BeforeTemplate
    ListAssert<T> before(Stream<S> stream, U[] iterable, Collector<S, ?, ? extends List<T>> collector) {
        return assertThat(stream.collect(collector)).containsSubsequence(iterable);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    ListAssert<S> after(Stream<S> stream, Iterable<U> iterable) {
        return assertThat(stream).containsSubsequence(iterable);
    }
}

.

static final class AssertThatStreamDoesNotContainAnyElementsOf<S, T extends S, U extends T> {
    
    @BeforeTemplate
    IterableAssert<T> before(Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends Iterable<T>> collector) {
        return assertThat(stream.collect(collector)).doesNotContainAnyElementsOf(iterable);
    }
    
    @BeforeTemplate
    ListAssert<T> before2(Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends List<T>> collector) {
        return assertThat(stream.collect(collector)).doesNotContainAnyElementsOf(iterable);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    ListAssert<S> after(Stream<S> stream, Iterable<U> iterable) {
        return assertThat(stream).doesNotContainAnyElementsOf(iterable);
    }
}

.

static final class AssertThatStreamDoesNotContain<S, T extends S, U extends T> {
    
    @BeforeTemplate
    IterableAssert<T> before(Stream<S> stream, U[] array, Collector<S, ?, ? extends Iterable<T>> collector) {
        return assertThat(stream.collect(collector)).doesNotContain(array);
    }
    
    @BeforeTemplate
    ListAssert<T> before2(Stream<S> stream, U[] array, Collector<S, ?, ? extends List<T>> collector) {
        return assertThat(stream.collect(collector)).doesNotContain(array);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    ListAssert<S> after(Stream<S> stream, U[] array) {
        return assertThat(stream).doesNotContain(array);
    }
}

.

static final class AssertThatStreamDoesNotContainSequence<S, T extends S, U extends T> {
    
    @BeforeTemplate
    ListAssert<T> before(Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends List<T>> collector) {
        return assertThat(stream.collect(collector)).doesNotContainSequence(iterable);
    }
    
    @BeforeTemplate
    ListAssert<T> before(Stream<S> stream, U[] iterable, Collector<S, ?, ? extends List<T>> collector) {
        return assertThat(stream.collect(collector)).doesNotContainSequence(iterable);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    ListAssert<S> after(Stream<S> stream, Iterable<U> iterable) {
        return assertThat(stream).doesNotContainSequence(iterable);
    }
}

.

static final class AssertThatStreamHasSameElementsAs<S, T extends S, U extends T> {
    
    @BeforeTemplate
    IterableAssert<T> before(Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends Iterable<T>> collector) {
        return assertThat(stream.collect(collector)).hasSameElementsAs(iterable);
    }
    
    @BeforeTemplate
    ListAssert<T> before2(Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends List<T>> collector) {
        return assertThat(stream.collect(collector)).hasSameElementsAs(iterable);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    ListAssert<S> after(Stream<S> stream, Iterable<U> iterable) {
        return assertThat(stream).hasSameElementsAs(iterable);
    }
}

.

static final class AssertThatStreamHasSize<T> {
    
    @BeforeTemplate
    void before(Stream<T> stream, int size) {
        assertThat(stream.count()).isEqualTo(size);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(Stream<T> stream, int size) {
        assertThat(stream).hasSize(size);
    }
}

.

static final class AssertThatStreamIsEmpty<S, T extends S> {
    
    @BeforeTemplate
    void before(Stream<S> stream, Collector<S, ?, ? extends Iterable<T>> collector) {
        assertThat(stream.collect(collector)).isEmpty();
    }
    
    @BeforeTemplate
    void before2(Stream<S> stream, Collector<S, ?, ? extends List<T>> collector) {
        assertThat(stream.collect(collector)).isEmpty();
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(Stream<S> stream) {
        assertThat(stream).isEmpty();
    }
}

.

static final class AssertThatStreamIsNotEmpty<S, T extends S> {
    
    @BeforeTemplate
    void before(Stream<S> stream, Collector<S, ?, ? extends Iterable<T>> collector) {
        assertThat(stream.collect(collector)).isNotEmpty();
    }
    
    @BeforeTemplate
    void before2(Stream<S> stream, Collector<S, ?, ? extends List<T>> collector) {
        assertThat(stream.collect(collector)).isNotEmpty();
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(Stream<S> stream) {
        assertThat(stream).isNotEmpty();
    }
}

.

static final class AssertThatStreamIsSubsetOf<S, T extends S, U extends T> {
    
    @BeforeTemplate
    IterableAssert<T> before(Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends Iterable<T>> collector) {
        return assertThat(stream.collect(collector)).isSubsetOf(iterable);
    }
    
    @BeforeTemplate
    IterableAssert<T> before(Stream<S> stream, U[] iterable, Collector<S, ?, ? extends Iterable<T>> collector) {
        return assertThat(stream.collect(collector)).isSubsetOf(iterable);
    }
    
    @BeforeTemplate
    ListAssert<T> before2(Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends List<T>> collector) {
        return assertThat(stream.collect(collector)).isSubsetOf(iterable);
    }
    
    @BeforeTemplate
    ListAssert<T> before2(Stream<S> stream, U[] iterable, Collector<S, ?, ? extends List<T>> collector) {
        return assertThat(stream.collect(collector)).isSubsetOf(iterable);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    ListAssert<S> after(Stream<S> stream, U[] iterable) {
        return assertThat(stream).isSubsetOf(iterable);
    }
}

.

static final class ObjectEnumerableContainsOneElement<S, T extends S> {
    
    @BeforeTemplate
    @SuppressWarnings(value = "unchecked")
    ObjectEnumerableAssert<?, S> before(ObjectEnumerableAssert<?, S> iterAssert, T element) {
        return Refaster.anyOf(iterAssert.containsAnyOf(element), iterAssert.containsSequence(element), iterAssert.containsSubsequence(element));
    }
    
    @AfterTemplate
    @SuppressWarnings(value = "unchecked")
    ObjectEnumerableAssert<?, S> after(ObjectEnumerableAssert<?, S> iterAssert, T element) {
        return iterAssert.contains(element);
    }
}

.

static final class ObjectEnumerableDoesNotContainOneElement<S, T extends S> {
    
    @BeforeTemplate
    @SuppressWarnings(value = "unchecked")
    ObjectEnumerableAssert<?, S> before(ObjectEnumerableAssert<?, S> iterAssert, T element) {
        return iterAssert.doesNotContainSequence(element);
    }
    
    @AfterTemplate
    @SuppressWarnings(value = "unchecked")
    ObjectEnumerableAssert<?, S> after(ObjectEnumerableAssert<?, S> iterAssert, T element) {
        return iterAssert.doesNotContain(element);
    }
}

.

static final class AssertThatThrownByAsInstanceOfThrowable<T extends Throwable> {
    
    @BeforeTemplate
    ThrowableAssertAlternative<T> before(ThrowingCallable throwingCallable, Class<T> exceptionType) {
        return assertThatExceptionOfType(exceptionType).isThrownBy(throwingCallable);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    AbstractThrowableAssert<?, T> after(ThrowingCallable throwingCallable, Class<T> exceptionType) {
        return assertThatThrownBy(throwingCallable).asInstanceOf(throwable(exceptionType));
    }
}

.

static final class AssertThatThrownByIsInstanceOf<T extends Throwable> {
    
    @BeforeTemplate
    void before(ThrowingCallable throwingCallable, Class<T> exceptionType) {
        Refaster.anyOf(assertThatThrownBy(throwingCallable).asInstanceOf(throwable(exceptionType)), assertThatThrownBy(throwingCallable).asInstanceOf(type(exceptionType)));
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(ThrowingCallable throwingCallable, Class<T> exceptionType) {
        assertThatThrownBy(throwingCallable).isInstanceOf(exceptionType);
    }
}

.

static final class CollectionAddAllToCollectionBlock<T, S extends T> {
    
    @BeforeTemplate
    void before(Collection<T> addTo, Collection<S> elementsToAdd) {
        elementsToAdd.forEach(addTo::add);
    }
    
    @BeforeTemplate
    void before2(Collection<T> addTo, Collection<S> elementsToAdd) {
        for (T element : elementsToAdd) {
            addTo.add(element);
        }
    }
    
    @BeforeTemplate
    void before3(Collection<T> addTo, Collection<S> elementsToAdd) {
        for (S element : elementsToAdd) {
            addTo.add(element);
        }
    }
    
    @AfterTemplate
    void after(Collection<T> addTo, Collection<S> elementsToAdd) {
        addTo.addAll(elementsToAdd);
    }
}

.

static final class CollectionRemoveAllFromCollectionBlock<T, S extends T> {
    
    @BeforeTemplate
    void before(Collection<T> removeFrom, Collection<S> elementsToRemove) {
        elementsToRemove.forEach(removeFrom::remove);
    }
    
    @BeforeTemplate
    void before2(Collection<T> removeFrom, Collection<S> elementsToRemove) {
        for (T element : elementsToRemove) {
            removeFrom.remove(element);
        }
    }
    
    @BeforeTemplate
    void before3(Collection<T> removeFrom, Collection<S> elementsToRemove) {
        for (S element : elementsToRemove) {
            removeFrom.remove(element);
        }
    }
    
    @AfterTemplate
    void after(Collection<T> removeFrom, Collection<S> elementsToRemove) {
        removeFrom.removeAll(elementsToRemove);
    }
}

.

static final class AssertThatIsInstanceOf<T> {
    
    @BeforeTemplate
    void before(Object actual, Class<T> clazz) {
        assertInstanceOf(clazz, actual);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(Object actual, Class<T> clazz) {
        assertThat(actual).isInstanceOf(clazz);
    }
}

.

static final class AssertThatThrownByIsExactlyInstanceOf<T extends Throwable> {
    
    @BeforeTemplate
    void before(Executable throwingCallable, Class<T> clazz) {
        assertThrowsExactly(clazz, throwingCallable);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(ThrowingCallable throwingCallable, Class<T> clazz) {
        assertThatThrownBy(throwingCallable).isExactlyInstanceOf(clazz);
    }
}

.

static final class AssertThatThrownByIsInstanceOf<T extends Throwable> {
    
    @BeforeTemplate
    void before(Executable throwingCallable, Class<T> clazz) {
        assertThrows(clazz, throwingCallable);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(ThrowingCallable throwingCallable, Class<T> clazz) {
        assertThatThrownBy(throwingCallable).isInstanceOf(clazz);
    }
}

.

static final class AssertThatThrownByWithFailMessageStringIsExactlyInstanceOf<T extends Throwable> {
    
    @BeforeTemplate
    void before(Executable throwingCallable, String message, Class<T> clazz) {
        assertThrowsExactly(clazz, throwingCallable, message);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(ThrowingCallable throwingCallable, String message, Class<T> clazz) {
        assertThatThrownBy(throwingCallable).withFailMessage(message).isExactlyInstanceOf(clazz);
    }
}

.

static final class AssertThatThrownByWithFailMessageStringIsInstanceOf<T extends Throwable> {
    
    @BeforeTemplate
    void before(Executable throwingCallable, String message, Class<T> clazz) {
        assertThrows(clazz, throwingCallable, message);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(ThrowingCallable throwingCallable, String message, Class<T> clazz) {
        assertThatThrownBy(throwingCallable).withFailMessage(message).isInstanceOf(clazz);
    }
}

.

static final class AssertThatThrownByWithFailMessageSupplierIsExactlyInstanceOf<T extends Throwable> {
    
    @BeforeTemplate
    void before(Executable throwingCallable, Supplier<String> supplier, Class<T> clazz) {
        assertThrowsExactly(clazz, throwingCallable, supplier);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(ThrowingCallable throwingCallable, Supplier<String> supplier, Class<T> clazz) {
        assertThatThrownBy(throwingCallable).withFailMessage(supplier).isExactlyInstanceOf(clazz);
    }
}

.

static final class AssertThatThrownByWithFailMessageSupplierIsInstanceOf<T extends Throwable> {
    
    @BeforeTemplate
    void before(Executable throwingCallable, Supplier<String> supplier, Class<T> clazz) {
        assertThrows(clazz, throwingCallable, supplier);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(ThrowingCallable throwingCallable, Supplier<String> supplier, Class<T> clazz) {
        assertThatThrownBy(throwingCallable).withFailMessage(supplier).isInstanceOf(clazz);
    }
}

.

static final class AssertThatWithFailMessageStringIsInstanceOf<T> {
    
    @BeforeTemplate
    void before(Object actual, String message, Class<T> clazz) {
        assertInstanceOf(clazz, actual, message);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(Object actual, String message, Class<T> clazz) {
        assertThat(actual).withFailMessage(message).isInstanceOf(clazz);
    }
}

.

static final class AssertThatWithFailMessageSupplierIsInstanceOf<T> {
    
    @BeforeTemplate
    void before(Object actual, Supplier<String> supplier, Class<T> clazz) {
        assertInstanceOf(clazz, actual, supplier);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(Object actual, Supplier<String> supplier, Class<T> clazz) {
        assertThat(actual).withFailMessage(supplier).isInstanceOf(clazz);
    }
}

.

static final class Fail<T> {
    
    @BeforeTemplate
    T before() {
        return Assertions.fail();
    }
    
    @AfterTemplate
    @DoNotCall
    T after() {
        return fail();
    }
}

.

static final class FailWithMessageAndThrowable<T> {
    
    @BeforeTemplate
    T before(String message, Throwable throwable) {
        return Assertions.fail(message, throwable);
    }
    
    @AfterTemplate
    T after(String message, Throwable throwable) {
        return fail(message, throwable);
    }
}

.

static final class FailWithMessage<T> {
    
    @BeforeTemplate
    T before(String message) {
        return Assertions.fail(message);
    }
    
    @AfterTemplate
    T after(String message) {
        return fail(message);
    }
}

.

static final class FailWithThrowable<T> {
    
    @BeforeTemplate
    T before(Throwable throwable) {
        return Assertions.fail(throwable);
    }
    
    @AfterTemplate
    @DoNotCall
    T after(Throwable throwable) {
        return fail(throwable);
    }
}

.

static final class MapGetOrNull<K, V, T> {
    
    @BeforeTemplate
    @Nullable
    V before(Map<K, V> map, T key) {
        return map.getOrDefault(key, null);
    }
    
    @AfterTemplate
    @Nullable
    V after(Map<K, V> map, T key) {
        return map.get(key);
    }
}

.

static final class OptionalOfNullable<T> {
    
    @BeforeTemplate
    @SuppressWarnings(value = "TernaryOperatorOptionalNegativeFiltering")
    Optional<T> before(@Nullable
    T object) {
        return object == null ? Optional.empty() : Optional.of(object);
    }
    
    @AfterTemplate
    Optional<T> after(T object) {
        return Optional.ofNullable(object);
    }
}

.

static final class OrOrElseThrow<T> {
    
    @BeforeTemplate
    @SuppressWarnings(value = "NullAway")
    T before(Optional<T> o1, Optional<T> o2) {
        return o1.orElseGet(()->o2.orElseThrow());
    }
    
    @AfterTemplate
    @SuppressWarnings(value = "NullAway")
    T after(Optional<T> o1, Optional<T> o2) {
        return o1.or(()->o2).orElseThrow();
    }
}

.

static final class StreamCount<T> {
    
    @BeforeTemplate
    @SuppressWarnings(value = "java:S4266")
    long before(Stream<T> stream) {
        return stream.collect(counting());
    }
    
    @AfterTemplate
    long after(Stream<T> stream) {
        return stream.count();
    }
}

.

static final class StreamFilterCollect<T, R> {
    
    @BeforeTemplate
    R before(Stream<T> stream, Predicate<? super T> predicate, Collector<? super T, ?, R> collector) {
        return stream.collect(filtering(predicate, collector));
    }
    
    @AfterTemplate
    R after(Stream<T> stream, Predicate<? super T> predicate, Collector<? super T, ?, R> collector) {
        return stream.filter(predicate).collect(collector);
    }
}

.

static final class StreamFlatMapCollect<T, U, R> {
    
    @BeforeTemplate
    R before(Stream<T> stream, Function<? super T, ? extends Stream<? extends U>> mapper, Collector<? super U, ?, R> collector) {
        return stream.collect(flatMapping(mapper, collector));
    }
    
    @AfterTemplate
    R after(Stream<T> stream, Function<? super T, ? extends Stream<? extends U>> mapper, Collector<? super U, ?, R> collector) {
        return stream.flatMap(mapper).collect(collector);
    }
}

.

static final class StreamMapCollect<T, U, R> {
    
    @BeforeTemplate
    @SuppressWarnings(value = "java:S4266")
    R before(Stream<T> stream, Function<? super T, ? extends U> mapper, Collector<? super U, ?, R> collector) {
        return stream.collect(mapping(mapper, collector));
    }
    
    @AfterTemplate
    R after(Stream<T> stream, Function<? super T, ? extends U> mapper, Collector<? super U, ?, R> collector) {
        return stream.map(mapper).collect(collector);
    }
}

.

static final class StreamMapToDoubleSummaryStatistics<T> {
    
    @BeforeTemplate
    DoubleSummaryStatistics before(Stream<T> stream, ToDoubleFunction<T> mapper) {
        return stream.collect(summarizingDouble(mapper));
    }
    
    @AfterTemplate
    DoubleSummaryStatistics after(Stream<T> stream, ToDoubleFunction<T> mapper) {
        return stream.mapToDouble(mapper).summaryStatistics();
    }
}

.

static final class StreamMapToIntSummaryStatistics<T> {
    
    @BeforeTemplate
    IntSummaryStatistics before(Stream<T> stream, ToIntFunction<T> mapper) {
        return stream.collect(summarizingInt(mapper));
    }
    
    @AfterTemplate
    IntSummaryStatistics after(Stream<T> stream, ToIntFunction<T> mapper) {
        return stream.mapToInt(mapper).summaryStatistics();
    }
}

.

static final class StreamMapToLongSummaryStatistics<T> {
    
    @BeforeTemplate
    LongSummaryStatistics before(Stream<T> stream, ToLongFunction<T> mapper) {
        return stream.collect(summarizingLong(mapper));
    }
    
    @AfterTemplate
    LongSummaryStatistics after(Stream<T> stream, ToLongFunction<T> mapper) {
        return stream.mapToLong(mapper).summaryStatistics();
    }
}

.

static final class StreamMaxNaturalOrder<T extends Comparable<? super T>> {
    
    @BeforeTemplate
    Optional<T> before(Stream<T> stream) {
        return Refaster.anyOf(stream.min(reverseOrder()), Streams.findLast(stream.sorted()));
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    Optional<T> after(Stream<T> stream) {
        return stream.max(naturalOrder());
    }
}

.

static final class StreamMax<T> {
    
    @BeforeTemplate
    @SuppressWarnings(value = "java:S4266")
    Optional<T> before(Stream<T> stream, Comparator<? super T> comparator) {
        return Refaster.anyOf(stream.min(comparator.reversed()), Streams.findLast(stream.sorted(comparator)), stream.collect(maxBy(comparator)));
    }
    
    @AfterTemplate
    Optional<T> after(Stream<T> stream, Comparator<? super T> comparator) {
        return stream.max(comparator);
    }
}

.

static final class StreamMinNaturalOrder<T extends Comparable<? super T>> {
    
    @BeforeTemplate
    Optional<T> before(Stream<T> stream) {
        return Refaster.anyOf(stream.max(reverseOrder()), stream.sorted().findFirst());
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    Optional<T> after(Stream<T> stream) {
        return stream.min(naturalOrder());
    }
}

.

static final class StreamMin<T> {
    
    @BeforeTemplate
    @SuppressWarnings(value = "java:S4266")
    Optional<T> before(Stream<T> stream, Comparator<? super T> comparator) {
        return Refaster.anyOf(stream.max(comparator.reversed()), stream.sorted(comparator).findFirst(), stream.collect(minBy(comparator)));
    }
    
    @AfterTemplate
    Optional<T> after(Stream<T> stream, Comparator<? super T> comparator) {
        return stream.min(comparator);
    }
}

.

static final class StreamReduce<T> {
    
    @BeforeTemplate
    @SuppressWarnings(value = "java:S4266")
    Optional<T> before(Stream<T> stream, BinaryOperator<T> accumulator) {
        return stream.collect(reducing(accumulator));
    }
    
    @AfterTemplate
    Optional<T> after(Stream<T> stream, BinaryOperator<T> accumulator) {
        return stream.reduce(accumulator);
    }
}

.

static final class StreamReduceWithIdentity<T> {
    
    @BeforeTemplate
    @SuppressWarnings(value = "java:S4266")
    T before(Stream<T> stream, T identity, BinaryOperator<T> accumulator) {
        return stream.collect(reducing(identity, accumulator));
    }
    
    @AfterTemplate
    T after(Stream<T> stream, T identity, BinaryOperator<T> accumulator) {
        return stream.reduce(identity, accumulator);
    }
}

.

static final class StreamTakeWhile<T> {
    
    @BeforeTemplate
    Stream<T> before(Stream<T> stream, Predicate<? super T> predicate) {
        return stream.takeWhile(predicate).filter(predicate);
    }
    
    @AfterTemplate
    Stream<T> after(Stream<T> stream, Predicate<? super T> predicate) {
        return stream.takeWhile(predicate);
    }
}

.

static final class AssertEqualIterableIterationOrder<S, T extends S> {
    
    @BeforeTemplate
    void before(Iterable<S> actual, Iterable<T> expected) {
        assertEquals(actual, expected);
    }
    
    @BeforeTemplate
    void before(Collection<S> actual, Collection<T> expected) {
        assertEquals(actual, expected);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(Iterable<S> actual, Iterable<T> expected) {
        assertThat(actual).containsExactlyElementsOf(expected);
    }
}

.

static final class AssertEqualIterableIterationOrderWithMessage<S, T extends S> {
    
    @BeforeTemplate
    void before(Iterable<S> actual, String message, Iterable<T> expected) {
        assertEquals(actual, expected, message);
    }
    
    @BeforeTemplate
    void before(Collection<S> actual, String message, Collection<T> expected) {
        assertEquals(actual, expected, message);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(Iterable<S> actual, String message, Iterable<T> expected) {
        assertThat(actual).withFailMessage(message).containsExactlyElementsOf(expected);
    }
}

.

static final class AssertEqualIteratorIterationOrder<S, T extends S> {
    
    @BeforeTemplate
    void before(Iterator<S> actual, Iterator<T> expected) {
        assertEquals(actual, expected);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(Iterator<S> actual, Iterator<T> expected) {
        assertThat(actual).toIterable().containsExactlyElementsOf(ImmutableList.copyOf(expected));
    }
}

.

static final class AssertEqualIteratorIterationOrderWithMessage<S, T extends S> {
    
    @BeforeTemplate
    void before(Iterator<S> actual, String message, Iterator<T> expected) {
        assertEquals(actual, expected, message);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(Iterator<S> actual, String message, Iterator<T> expected) {
        assertThat(actual).toIterable().withFailMessage(message).containsExactlyElementsOf(ImmutableList.copyOf(expected));
    }
}

.

static final class AssertEqualSets<S, T extends S> {
    
    @BeforeTemplate
    void before(Set<S> actual, Set<T> expected) {
        assertEquals(actual, expected);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(Set<S> actual, Set<T> expected) {
        assertThat(actual).hasSameElementsAs(expected);
    }
}

.

static final class AssertEqualSetsWithMessage<S, T extends S> {
    
    @BeforeTemplate
    void before(Set<S> actual, String message, Set<T> expected) {
        assertEquals(actual, expected, message);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(Set<S> actual, String message, Set<T> expected) {
        assertThat(actual).withFailMessage(message).hasSameElementsAs(expected);
    }
}

.

static final class AssertThrowsWithType<T extends Throwable> {
    
    @BeforeTemplate
    void before(ThrowingRunnable runnable, Class<T> clazz) {
        assertThrows(clazz, runnable);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(ThrowingCallable runnable, Class<T> clazz) {
        assertThatThrownBy(runnable).isInstanceOf(clazz);
    }
}

.

Removed Recipes​

  • org.openrewrite.recipes.JavaRecipeBestPractices: Best practices for Java recipe development.
  • org.openrewrite.recipes.RecipeNullabilityBestPractices: Use JSpecify nullable annotations; drop Nonnull annotations; use NullMarked on package-info.java instead.
  • org.openrewrite.recipes.RecipeTestingBestPractices: Best practices for testing recipes.

Changed Recipes​

  • org.openrewrite.kubernetes.services.FindServiceExternalIPs was changed:
    • Old Options:
      • externalIPs: { type: Set, required: true }
      • fileMatcher: { type: String, required: false }
      • findMissing: { type: boolean, required: false }
    • New Options:
      • externalIPs: { type: Set, required: true }
      • fileMatcher: { type: String, required: false }
      • findMissing: { type: Boolean, required: false }