Refasterrules

Composite Recipes

Recipes that include further recipes, often including the individual recipes below.

• AssertJBigIntegerRules Refaster recipes
• AssertJBooleanRules Refaster recipes
• AssertJByteRules Refaster recipes
• AssertJCharSequenceRules Refaster recipes
• AssertJDoubleRules Refaster recipes
• AssertJFloatRules Refaster recipes
• AssertJIntegerRules Refaster recipes
• AssertJLongRules Refaster recipes
• AssertJNumberRules Refaster recipes
• AssertJPrimitiveRules Refaster recipes
• AssertJShortRules Refaster recipes
• AssertJStringRules Refaster recipes
• Assorted Refaster rules that do not (yet) belong in one of the other classes with more topical Refaster rules
• Refaster rules related to AssertJ assertions over BigDecimals
• Refaster rules related to AssertJ assertions over expressions that may throw a Throwable subtype
• Refaster rules related to AssertJ expressions and statements
• Refaster rules related to Mockito expressions and statements
• Refaster rules related to Reactor expressions and statements
• Refaster rules related to code dealing with regular expressions
• Refaster rules related to com.google.errorprone.bugpatterns.BugChecker classes
• Refaster rules related to expressions dealing with (in)equalities
• Refaster rules related to expressions dealing with (possibly) null values
• Refaster rules related to expressions dealing with BigDecimals
• Refaster rules related to expressions dealing with DoubleStreams
• Refaster rules related to expressions dealing with InputStreams
• Refaster rules related to expressions dealing with IntStreams
• Refaster rules related to expressions dealing with LongStreams
• Refaster rules related to expressions dealing with Micrometer
• Refaster rules related to expressions dealing with Strings
• Refaster rules related to expressions dealing with SuggestedFixes
• Refaster rules related to expressions dealing with files
• Refaster rules related to expressions dealing with org.springframework.web.reactive.function.client.WebClient and related types
• Refaster rules related to expressions dealing with primitives
• Refaster rules related to expressions dealing with time
• Refaster rules that replace TestNG assertions with equivalent AssertJ assertions
• Refaster rules to replace JUnit assertions with AssertJ equivalents

Recipes

• Apply DoubleStream#filter(DoublePredicate) before DoubleStream#sorted() to reduce the number of elements to sort
• Apply IntStream#filter(IntPredicate) before IntStream#sorted() to reduce the number of elements to sort
• Apply LongStream#filter(LongPredicate) before LongStream#sorted() to reduce the number of elements to sort
• Avoid calling BugCheckerRefactoringTestHelper#setFixChooser(FixChooser) or BugCheckerRefactoringTestHelper#setImportOrder(String) with their respective default values
• Avoid contrived ways of expressing the "greater than or equal to" relationship
• Avoid contrived ways of expressing the "greater than" relationship
• Avoid contrived ways of expressing the "less than or equal to" relationship
• Avoid contrived ways of expressing the "less than" relationship
• Avoid double negations; this is not Javascript
• Avoid redundant conversions from Path to File
• Don't negate an equality test or use the ternary operator to compare two booleans; directly test for inequality instead
• Don't negate an inequality test or use the ternary operator to compare two booleans; directly test for equality instead
• Don't unnecessarily call Streams#concat(DoubleStream...)
• Don't unnecessarily call Streams#concat(IntStream...)
• Don't unnecessarily call Streams#concat(LongStream...)
• Don't unnecessarily convert to and from milliseconds. (This way nanosecond precision is retained.) < p >Warning: this rewrite rule increases precision!
• Don't unnecessarily convert to and from milliseconds. (This way nanosecond precision is retained.) < p >Warning: this rewrite rule increases precision!
• Don't unnecessarily repeat boolean expressions
• Don't unnecessarily use the two-argument String#substring(int, int)
• Don't use the ternary operator to create an optionally-absent string
• In order to test whether a stream has any element, simply try to find one
• In order to test whether a stream has any element, simply try to find one
• In order to test whether a stream has any element, simply try to find one
• In order to test whether a stream has any element, simply try to find one
• In order to test whether a stream has any element, simply try to find one
• In order to test whether a stream has any element, simply try to find one
• Prefer BigDecimal#valueOf(double) over the associated constructor
• Prefer Boolean#hashCode(boolean) over the Guava alternative
• Prefer BugCheckerRefactoringTestHelper.ExpectOutput#expectUnchanged() over repeating the input
• Prefer Byte#hashCode(byte) over the Guava alternative
• Prefer Character#BYTES over the Guava alternative
• Prefer Character#hashCode(char) over the Guava alternative
• Prefer ChronoLocalDate#isBefore(ChronoLocalDate) over explicit comparison, as it yields more readable code
• Prefer ChronoLocalDate#isBefore(ChronoLocalDate) over explicit comparison, as it yields more readable code
• Prefer ChronoLocalDateTime#isBefore(ChronoLocalDateTime) over explicit comparison, as it yields more readable code
• Prefer ChronoLocalDateTime#isBefore(ChronoLocalDateTime) over explicit comparison, as it yields more readable code
• Prefer ChronoZonedDateTime#isBefore(ChronoZonedDateTime) over explicit comparison, as it yields more readable code
• Prefer ChronoZonedDateTime#isBefore(ChronoZonedDateTime) over explicit comparison, as it yields more readable code
• Prefer Clock#instant() over Instant#now(Clock), as it is more concise and more "OOP-py"
• Prefer Collectors#joining() over Collectors#joining(CharSequence) with an empty delimiter string
• Prefer Double#BYTES over the Guava alternative
• Prefer Double#hashCode(double) over the Guava alternative
• Prefer Double#isFinite(double) over the Guava alternative
• Prefer DoubleStream#anyMatch(DoublePredicate) over more contrived alternatives
• Prefer DoubleStream#concat(DoubleStream, DoubleStream) over the Guava alternative
• Prefer DoubleStream#noneMatch(DoublePredicate) over more contrived alternatives
• Prefer Duration#isZero() over more contrived alternatives
• Prefer Duration#ofDays(long) over alternative representations
• Prefer Duration#ofHours(long) over alternative representations
• Prefer Duration#ofMillis(long) over alternative representations
• Prefer Duration#ofMinutes(long) over alternative representations
• Prefer Duration#ofNanos(long) over alternative representations
• Prefer Duration#ofSeconds(long) over alternative representations
• Prefer Files#createTempFile(Path, String, String, FileAttribute[]) over alternatives that create files with more liberal permissions
• Prefer Files#createTempFile(String, String, FileAttribute[]) over alternatives that create files with more liberal permissions
• Prefer Files#readString(Path) over more verbose alternatives
• Prefer Files#readString(Path, Charset) over more contrived alternatives
• Prefer Float#BYTES over the Guava alternative
• Prefer Float#hashCode(float) over the Guava alternative
• Prefer Float#isFinite(float) over the Guava alternative
• Prefer Instant#EPOCH over alternative representations
• Prefer Instant#atOffset(ZoneOffset) over more verbose alternatives
• Prefer Instant#atZone(ZoneId) over more verbose alternatives
• Prefer Instant#isBefore(Instant) over explicit comparison, as it yields more readable code
• Prefer Instant#isBefore(Instant) over explicit comparison, as it yields more readable code
• Prefer IntStream#anyMatch(IntPredicate) over more contrived alternatives
• Prefer IntStream#concat(IntStream, IntStream) over the Guava alternative
• Prefer IntStream#noneMatch(IntPredicate) over more contrived alternatives
• Prefer IntStream#range(int, int) over the more contrived alternative
• Prefer Integer#BYTES over the Guava alternative
• Prefer Integer#hashCode(int) over the Guava alternative
• Prefer JDK's Integer#compareUnsigned(int, int) over third-party alternatives
• Prefer JDK's Integer#divideUnsigned(int, int) over third-party alternatives
• Prefer JDK's Integer#parseUnsignedInt(String) over third-party or more verbose alternatives
• Prefer JDK's Integer#parseUnsignedInt(String, int) over third-party alternatives
• Prefer JDK's Integer#remainderUnsigned(int, int) over third-party alternatives
• Prefer JDK's Integer#toUnsignedString(int) over third-party or more verbose alternatives
• Prefer JDK's Integer#toUnsignedString(int,int) over third-party or more verbose alternatives
• Prefer JDK's Long#compareUnsigned(long, long) over third-party alternatives
• Prefer JDK's Long#divideUnsigned(long, long) over third-party alternatives
• Prefer JDK's Long#parseUnsignedLong(String) over third-party or more verbose alternatives
• Prefer JDK's Long#parseUnsignedLong(String, int) over third-party alternatives
• Prefer JDK's Long#remainderUnsigned(long, long) over third-party alternatives
• Prefer JDK's Long#toUnsignedString(long) over third-party or more verbose alternatives
• Prefer JDK's Long#toUnsignedString(long,int) over third-party or more verbose alternatives
• Prefer LocalDate#atStartOfDay() over more contrived alternatives
• Prefer LocalDate#minusDays(long) over more contrived alternatives
• Prefer LocalDate#minusMonths(long) over more contrived alternatives
• Prefer LocalDate#minusWeeks(long) over more contrived alternatives
• Prefer LocalDate#minusYears(long) over more contrived alternatives
• Prefer LocalDate#ofInstant(Instant, ZoneId) over more indirect alternatives
• Prefer LocalDate#plusDays(long) over more contrived alternatives
• Prefer LocalDate#plusMonths(long) over more contrived alternatives
• Prefer LocalDate#plusWeeks(long) over more contrived alternatives
• Prefer LocalDate#plusYears(long) over more contrived alternatives
• Prefer LocalDateTime#minusDays(long) over more contrived alternatives
• Prefer LocalDateTime#minusHours(long) over more contrived alternatives
• Prefer LocalDateTime#minusMinutes(long) over more contrived alternatives
• Prefer LocalDateTime#minusMonths(long) over more contrived alternatives
• Prefer LocalDateTime#minusNanos(long) over more contrived alternatives
• Prefer LocalDateTime#minusSeconds(long) over more contrived alternatives
• Prefer LocalDateTime#minusWeeks(long) over more contrived alternatives
• Prefer LocalDateTime#minusYears(long) over more contrived alternatives
• Prefer LocalDateTime#ofInstant(Instant, ZoneId) over more indirect alternatives
• Prefer LocalDateTime#plusDays(long) over more contrived alternatives
• Prefer LocalDateTime#plusHours(long) over more contrived alternatives
• Prefer LocalDateTime#plusMinutes(long) over more contrived alternatives
• Prefer LocalDateTime#plusMonths(long) over more contrived alternatives
• Prefer LocalDateTime#plusNanos(long) over more contrived alternatives
• Prefer LocalDateTime#plusSeconds(long) over more contrived alternatives
• Prefer LocalDateTime#plusWeeks(long) over more contrived alternatives
• Prefer LocalDateTime#plusYears(long) over more contrived alternatives
• Prefer LocalTime#minusHours(long) over more contrived alternatives
• Prefer LocalTime#minusMinutes(long) over more contrived alternatives
• Prefer LocalTime#minusNanos(long) over more contrived alternatives
• Prefer LocalTime#minusSeconds(long) over more contrived alternatives
• Prefer LocalTime#ofInstant(Instant, ZoneId) over more indirect alternatives
• Prefer LocalTime#plusHours(long) over more contrived alternatives
• Prefer LocalTime#plusMinutes(long) over more contrived alternatives
• Prefer LocalTime#plusNanos(long) over more contrived alternatives
• Prefer LocalTime#plusSeconds(long) over more contrived alternatives
• Prefer Long#BYTES over the Guava alternative
• Prefer Long#hashCode(long) over the Guava alternative
• Prefer LongStream#anyMatch(LongPredicate) over more contrived alternatives
• Prefer LongStream#concat(LongStream, LongStream) over the Guava alternative
• Prefer LongStream#noneMatch(LongPredicate) over more contrived alternatives
• Prefer LongStream#range(long, long) over the more contrived alternative
• Prefer Math#toIntExact(long) over the Guava alternative
• Prefer Mockito#never()} over explicitly specifying that the associated invocation must happen precisely zero times
• Prefer Name#contentEquals(CharSequence) over more verbose alternatives
• Prefer Objects#checkIndex(int, int) over the Guava alternative
• Prefer OffsetDateTime#isBefore(OffsetDateTime) over explicit comparison, as it yields more readable code
• Prefer OffsetDateTime#isBefore(OffsetDateTime) over explicit comparison, as it yields more readable code
• Prefer OffsetDateTime#minusDays(long) over more contrived alternatives
• Prefer OffsetDateTime#minusHours(long) over more contrived alternatives
• Prefer OffsetDateTime#minusMinutes(long) over more contrived alternatives
• Prefer OffsetDateTime#minusMonths(long) over more contrived alternatives
• Prefer OffsetDateTime#minusNanos(long) over more contrived alternatives
• Prefer OffsetDateTime#minusSeconds(long) over more contrived alternatives
• Prefer OffsetDateTime#minusWeeks(long) over more contrived alternatives
• Prefer OffsetDateTime#minusYears(long) over more contrived alternatives
• Prefer OffsetDateTime#ofInstant(Instant, ZoneId) over more indirect alternatives
• Prefer OffsetDateTime#plusDays(long) over more contrived alternatives
• Prefer OffsetDateTime#plusHours(long) over more contrived alternatives
• Prefer OffsetDateTime#plusMinutes(long) over more contrived alternatives
• Prefer OffsetDateTime#plusMonths(long) over more contrived alternatives
• Prefer OffsetDateTime#plusNanos(long) over more contrived alternatives
• Prefer OffsetDateTime#plusSeconds(long) over more contrived alternatives
• Prefer OffsetDateTime#plusWeeks(long) over more contrived alternatives
• Prefer OffsetDateTime#plusYears(long) over more contrived alternatives
• Prefer OffsetTime#minusHours(long) over more contrived alternatives
• Prefer OffsetTime#minusMinutes(long) over more contrived alternatives
• Prefer OffsetTime#minusNanos(long) over more contrived alternatives
• Prefer OffsetTime#minusSeconds(long) over more contrived alternatives
• Prefer OffsetTime#ofInstant(Instant, ZoneId) over more indirect alternatives
• Prefer OffsetTime#plusHours(long) over more contrived alternatives
• Prefer OffsetTime#plusMinutes(long) over more contrived alternatives
• Prefer OffsetTime#plusNanos(long) over more contrived alternatives
• Prefer OffsetTime#plusSeconds(long) over more contrived alternatives
• Prefer Pattern#asPredicate() over non-JDK alternatives
• Prefer Pattern#asPredicate() over non-JDK alternatives
• Prefer Short#BYTES over the Guava alternative
• Prefer Short#hashCode(short) over the Guava alternative
• Prefer Splitter#splitToStream(CharSequence) over less efficient alternatives
• Prefer StepVerifier.LastStep#verifyComplete() over more verbose alternatives
• Prefer StepVerifier.LastStep#verifyError() over more verbose alternatives
• Prefer StepVerifier.LastStep#verifyErrorMatches(Predicate) over more verbose alternatives
• Prefer StepVerifier.LastStep#verifyErrorMessage(String) over more verbose alternatives
• Prefer StepVerifier.LastStep#verifyErrorSatisfies(Consumer) over more verbose alternatives
• Prefer StepVerifier.LastStep#verifyTimeout(Duration) over more verbose alternatives
• Prefer String#indexOf(String, int) over less efficient alternatives
• Prefer String#indexOf(int, int) over less efficient alternatives
• Prefer String#isEmpty() over alternatives that consult the string's length
• Prefer String#join(CharSequence, Iterable) and variants over the Guava alternative
• Prefer String#lastIndexOf(String, int) over less efficient alternatives
• Prefer String#lastIndexOf(String, int) over less efficient alternatives
• Prefer String#lastIndexOf(int, int) over less efficient alternatives
• Prefer String#lastIndexOf(int, int) over less efficient alternatives
• Prefer String#startsWith(String, int) over less efficient alternatives
• Prefer Strings#isNullOrEmpty(String) over the more verbose alternative
• Prefer SuggestedFix#delete(Tree) over more contrived alternatives
• Prefer SuggestedFix#postfixWith(Tree, String)} over more contrived alternatives
• Prefer SuggestedFix#prefixWith(Tree, String) over more contrived alternatives
• Prefer SuggestedFix#replace(Tree, String)} over more contrived alternatives
• Prefer SuggestedFix#replace(Tree, String, int, int)} over more contrived alternatives
• Prefer SuggestedFix#replace(int, int, String)} over more contrived alternatives
• Prefer SuggestedFix#swap(Tree, Tree) over more contrived alternatives
• Prefer Utf8#encodedLength(CharSequence) over less efficient alternatives
• Prefer WebClient#get() over WebClient#method(HttpMethod) with HttpMethod#GET
• Prefer WebClient#head() over WebClient#method(HttpMethod) with HttpMethod#HEAD
• Prefer WebClient#options() over WebClient#method(HttpMethod) with HttpMethod#OPTIONS
• Prefer WebClient#patch() over WebClient#method(HttpMethod) with HttpMethod#PATCH
• Prefer WebClient#post() over WebClient#method(HttpMethod) with HttpMethod#POST
• Prefer WebClient#put() over WebClient#method(HttpMethod) with HttpMethod#PUT
• Prefer ZonedDateTime#minusDays(long) over more contrived alternatives
• Prefer ZonedDateTime#minusHours(long) over more contrived alternatives
• Prefer ZonedDateTime#minusMinutes(long) over more contrived alternatives
• Prefer ZonedDateTime#minusMonths(long) over more contrived alternatives
• Prefer ZonedDateTime#minusNanos(long) over more contrived alternatives
• Prefer ZonedDateTime#minusSeconds(long) over more contrived alternatives
• Prefer ZonedDateTime#minusWeeks(long) over more contrived alternatives
• Prefer ZonedDateTime#minusYears(long) over more contrived alternatives
• Prefer ZonedDateTime#plusDays(long) over more contrived alternatives
• Prefer ZonedDateTime#plusHours(long) over more contrived alternatives
• Prefer ZonedDateTime#plusMinutes(long) over more contrived alternatives
• Prefer ZonedDateTime#plusMonths(long) over more contrived alternatives
• Prefer ZonedDateTime#plusNanos(long) over more contrived alternatives
• Prefer ZonedDateTime#plusSeconds(long) over more contrived alternatives
• Prefer ZonedDateTime#plusWeeks(long) over more contrived alternatives
• Prefer ZonedDateTime#plusYears(long) over more contrived alternatives
• Prefer a BigDecimal#signum() comparison to -1 over more contrived or less clear alternatives
• Prefer a BigDecimal#signum() comparison to 1 over more contrived or less clear alternatives
• Prefer an Integer#signum(int) comparison to -1 over less clear alternatives
• Prefer an Integer#signum(int) comparison to 1 over less clear alternatives
• Prefer an Long#signum(long) comparison to -1 over less clear alternatives
• Prefer an Long#signum(long) comparison to 1 over less clear alternatives
• Prefer direct invocation of String#String(char[]) over the indirection introduced by alternatives
• Prefer direct invocation of String#String(char[], int, int) over the indirection introduced by alternatives
• Prefer direct invocation of String#valueOf(Object) over the indirection introduced by Objects#toString(Object)
• Prefer the != operator (with null as the second operand) over Objects#nonNull(Object)
• Prefer the == operator (with null as the second operand) over Objects#isNull(Object)
• Prefer the LocalTime#MIN over alternative representations
• Prefer the more idiomatic Path#of(URI) over Paths#get(URI)
• Prefer using BigDecimal#signum() over more contrived alternatives
• Prefer using Tags over other immutable collections
• Prefer using Tags over other immutable collections
• Prefer using Tags over other immutable collections
• Prefer using Tags over other immutable collections
• Prefer using Tags over other immutable collections
• Prefer using the Constants API over more verbose alternatives
• Prefer using the constant BigDecimal#ONE when possible
• Prefer using the constant BigDecimal#TEN when possible
• Prefer using the constant BigDecimal#ZERO when possible
• Refaster rules related to expressions dealing with RxJava2Adapter
• Refaster rules related to expressions dealing with Streams
• Refaster template AssertJBigDecimalRules.AbstractBigDecimalAssertIsEqualByComparingTo
• Refaster template AssertJBigDecimalRules.AbstractBigDecimalAssertIsNotEqualByComparingTo
• Refaster template AssertJBigIntegerRules.AbstractBigIntegerAssertIsEqualTo
• Refaster template AssertJBigIntegerRules.AbstractBigIntegerAssertIsNotEqualTo
• Refaster template AssertJBigIntegerRules.AbstractBigIntegerAssertIsNotZero
• Refaster template AssertJBigIntegerRules.AbstractBigIntegerAssertIsOne
• Refaster template AssertJBigIntegerRules.AbstractBigIntegerAssertIsZero
• Refaster template AssertJBooleanRules.AbstractBooleanAssertIsEqualTo
• Refaster template AssertJBooleanRules.AbstractBooleanAssertIsFalse
• Refaster template AssertJBooleanRules.AbstractBooleanAssertIsNotEqualTo
• Refaster template AssertJBooleanRules.AbstractBooleanAssertIsTrue
• Refaster template AssertJBooleanRules.AssertThatBooleanIsFalse
• Refaster template AssertJBooleanRules.AssertThatBooleanIsTrue
• Refaster template AssertJByteRules.AbstractByteAssertIsEqualTo
• Refaster template AssertJByteRules.AbstractByteAssertIsNotEqualTo
• Refaster template AssertJByteRules.AbstractByteAssertIsNotZero
• Refaster template AssertJByteRules.AbstractByteAssertIsOne
• Refaster template AssertJByteRules.AbstractByteAssertIsZero
• Refaster template AssertJCharSequenceRules.AssertThatCharSequenceHasSize
• Refaster template AssertJCharSequenceRules.AssertThatCharSequenceIsEmpty
• Refaster template AssertJCharSequenceRules.AssertThatCharSequenceIsNotEmpty
• Refaster template AssertJDoubleRules.AbstractDoubleAssertIsCloseToWithOffset
• Refaster template AssertJDoubleRules.AbstractDoubleAssertIsEqualTo
• Refaster template AssertJDoubleRules.AbstractDoubleAssertIsNotEqualTo
• Refaster template AssertJDoubleRules.AbstractDoubleAssertIsNotZero
• Refaster template AssertJDoubleRules.AbstractDoubleAssertIsOne
• Refaster template AssertJDoubleRules.AbstractDoubleAssertIsZero
• Refaster template AssertJFloatRules.AbstractFloatAssertIsCloseToWithOffset
• Refaster template AssertJFloatRules.AbstractFloatAssertIsEqualTo
• Refaster template AssertJFloatRules.AbstractFloatAssertIsNotEqualTo
• Refaster template AssertJFloatRules.AbstractFloatAssertIsNotZero
• Refaster template AssertJFloatRules.AbstractFloatAssertIsOne
• Refaster template AssertJFloatRules.AbstractFloatAssertIsZero
• Refaster template AssertJIntegerRules.AbstractIntegerAssertIsEqualTo
• Refaster template AssertJIntegerRules.AbstractIntegerAssertIsNotEqualTo
• Refaster template AssertJIntegerRules.AbstractIntegerAssertIsNotZero
• Refaster template AssertJIntegerRules.AbstractIntegerAssertIsOne
• Refaster template AssertJIntegerRules.AbstractIntegerAssertIsZero
• Refaster template AssertJLongRules.AbstractLongAssertIsEqualTo
• Refaster template AssertJLongRules.AbstractLongAssertIsNotEqualTo
• Refaster template AssertJLongRules.AbstractLongAssertIsNotZero
• Refaster template AssertJLongRules.AbstractLongAssertIsOne
• Refaster template AssertJLongRules.AbstractLongAssertIsZero
• Refaster template AssertJNumberRules.NumberAssertIsNegative
• Refaster template AssertJNumberRules.NumberAssertIsNotNegative
• Refaster template AssertJNumberRules.NumberAssertIsNotPositive
• Refaster template AssertJNumberRules.NumberAssertIsPositive
• Refaster template AssertJPrimitiveRules.AssertThatIsEqualTo
• Refaster template AssertJPrimitiveRules.AssertThatIsGreaterThan
• Refaster template AssertJPrimitiveRules.AssertThatIsGreaterThanOrEqualTo
• Refaster template AssertJPrimitiveRules.AssertThatIsLessThan
• Refaster template AssertJPrimitiveRules.AssertThatIsLessThanOrEqualTo
• Refaster template AssertJPrimitiveRules.AssertThatIsNotEqualTo
• Refaster template AssertJRules.AssertThatOptionalDouble
• Refaster template AssertJRules.AssertThatOptionalInt
• Refaster template AssertJRules.AssertThatOptionalLong
• Refaster template AssertJShortRules.AbstractShortAssertIsEqualTo
• Refaster template AssertJShortRules.AbstractShortAssertIsNotEqualTo
• Refaster template AssertJShortRules.AbstractShortAssertIsNotZero
• Refaster template AssertJShortRules.AbstractShortAssertIsOne
• Refaster template AssertJShortRules.AbstractShortAssertIsZero
• Refaster template AssertJStringRules.AbstractStringAssertStringIsEmpty
• Refaster template AssertJStringRules.AbstractStringAssertStringIsNotEmpty
• Refaster template AssertJStringRules.AssertThatDoesNotMatch
• Refaster template AssertJStringRules.AssertThatMatches
• Refaster template AssertJStringRules.AssertThatPathContent
• Refaster template AssertJStringRules.AssertThatPathContentUtf8
• Refaster template AssertJStringRules.AssertThatStringIsEmpty
• Refaster template AssertJStringRules.AssertThatStringIsNotEmpty
• Refaster template AssertJThrowingCallableRules.AssertThatThrownBy
• Refaster template AssertJThrowingCallableRules.AssertThatThrownByHasMessage
• Refaster template AssertJThrowingCallableRules.AssertThatThrownByHasMessageContaining
• Refaster template AssertJThrowingCallableRules.AssertThatThrownByHasMessageNotContaining
• Refaster template AssertJThrowingCallableRules.AssertThatThrownByHasMessageStartingWith
• Refaster template AssertJThrowingCallableRules.AssertThatThrownByIOException
• Refaster template AssertJThrowingCallableRules.AssertThatThrownByIOExceptionHasMessage
• Refaster template AssertJThrowingCallableRules.AssertThatThrownByIOExceptionHasMessageContaining
• Refaster template AssertJThrowingCallableRules.AssertThatThrownByIOExceptionHasMessageNotContaining
• Refaster template AssertJThrowingCallableRules.AssertThatThrownByIOExceptionHasMessageStartingWith
• Refaster template AssertJThrowingCallableRules.AssertThatThrownByIllegalArgumentException
• Refaster template AssertJThrowingCallableRules.AssertThatThrownByIllegalArgumentExceptionHasMessage
• Refaster template AssertJThrowingCallableRules.AssertThatThrownByIllegalArgumentExceptionHasMessageContaining
• Refaster template AssertJThrowingCallableRules.AssertThatThrownByIllegalArgumentExceptionHasMessageStartingWith
• Refaster template AssertJThrowingCallableRules.AssertThatThrownByIllegalStateException
• Refaster template AssertJThrowingCallableRules.AssertThatThrownByIllegalStateExceptionHasMessage
• Refaster template AssertJThrowingCallableRules.AssertThatThrownByIllegalStateExceptionHasMessageContaining
• Refaster template AssertJThrowingCallableRules.AssertThatThrownByIllegalStateExceptionHasMessageNotContaining
• Refaster template AssertJThrowingCallableRules.AssertThatThrownByIllegalStateExceptionHasMessageStartingWith
• Refaster template AssertJThrowingCallableRules.AssertThatThrownByNullPointerException
• Refaster template AssertJThrowingCallableRules.AssertThatThrownByNullPointerExceptionHasMessage
• Refaster template AssertJThrowingCallableRules.AssertThatThrownByNullPointerExceptionHasMessageContaining
• Refaster template AssertJThrowingCallableRules.AssertThatThrownByNullPointerExceptionHasMessageNotContaining
• Refaster template AssertJThrowingCallableRules.AssertThatThrownByNullPointerExceptionHasMessageStartingWith
• Refaster template DoubleStreamRules.DoubleStreamAllMatch
• Refaster template DoubleStreamRules.DoubleStreamMin
• Refaster template DoubleStreamRules.DoubleStreamTakeWhile
• Refaster template InputStreamRules.InputStreamReadAllBytes
• Refaster template InputStreamRules.InputStreamReadNBytes
• Refaster template InputStreamRules.InputStreamSkipNBytes
• Refaster template InputStreamRules.InputStreamTransferTo
• Refaster template IntStreamRules.IntStreamAllMatch
• Refaster template IntStreamRules.IntStreamMin
• Refaster template IntStreamRules.IntStreamTakeWhile
• Refaster template JUnitToAssertJRules.AssertThatCodeDoesNotThrowAnyException
• Refaster template JUnitToAssertJRules.AssertThatCodeWithFailMessageStringDoesNotThrowAnyException
• Refaster template JUnitToAssertJRules.AssertThatCodeWithFailMessageSupplierDoesNotThrowAnyException
• Refaster template JUnitToAssertJRules.AssertThatIsFalse
• Refaster template JUnitToAssertJRules.AssertThatIsNotNull
• Refaster template JUnitToAssertJRules.AssertThatIsNotSameAs
• Refaster template JUnitToAssertJRules.AssertThatIsNull
• Refaster template JUnitToAssertJRules.AssertThatIsSameAs
• Refaster template JUnitToAssertJRules.AssertThatIsTrue
• Refaster template JUnitToAssertJRules.AssertThatWithFailMessageStringIsFalse
• Refaster template JUnitToAssertJRules.AssertThatWithFailMessageStringIsNotNull
• Refaster template JUnitToAssertJRules.AssertThatWithFailMessageStringIsNotSameAs
• Refaster template JUnitToAssertJRules.AssertThatWithFailMessageStringIsNull
• Refaster template JUnitToAssertJRules.AssertThatWithFailMessageStringIsSameAs
• Refaster template JUnitToAssertJRules.AssertThatWithFailMessageStringIsTrue
• Refaster template JUnitToAssertJRules.AssertThatWithFailMessageSupplierIsFalse
• Refaster template JUnitToAssertJRules.AssertThatWithFailMessageSupplierIsNotNull
• Refaster template JUnitToAssertJRules.AssertThatWithFailMessageSupplierIsNotSameAs
• Refaster template JUnitToAssertJRules.AssertThatWithFailMessageSupplierIsNull
• Refaster template JUnitToAssertJRules.AssertThatWithFailMessageSupplierIsSameAs
• Refaster template JUnitToAssertJRules.AssertThatWithFailMessageSupplierIsTrue
• Refaster template LongStreamRules.LongStreamAllMatch
• Refaster template LongStreamRules.LongStreamMin
• Refaster template LongStreamRules.LongStreamTakeWhile
• Refaster template MockitoRules.InvocationOnMockGetArguments
• Refaster template StringRules.FilterEmptyString
• Refaster template TestNGToAssertJRules.AssertEqual
• Refaster template TestNGToAssertJRules.AssertEqualArrayIterationOrder
• Refaster template TestNGToAssertJRules.AssertEqualArrayIterationOrderWithMessage
• Refaster template TestNGToAssertJRules.AssertEqualArraysIrrespectiveOfOrder
• Refaster template TestNGToAssertJRules.AssertEqualArraysIrrespectiveOfOrderWithMessage
• Refaster template TestNGToAssertJRules.AssertEqualDoublesWithDelta
• Refaster template TestNGToAssertJRules.AssertEqualDoublesWithDeltaWithMessage
• Refaster template TestNGToAssertJRules.AssertEqualFloatsWithDelta
• Refaster template TestNGToAssertJRules.AssertEqualFloatsWithDeltaWithMessage
• Refaster template TestNGToAssertJRules.AssertEqualWithMessage
• Refaster template TestNGToAssertJRules.AssertFalse
• Refaster template TestNGToAssertJRules.AssertFalseWithMessage
• Refaster template TestNGToAssertJRules.AssertNotNull
• Refaster template TestNGToAssertJRules.AssertNotNullWithMessage
• Refaster template TestNGToAssertJRules.AssertNotSame
• Refaster template TestNGToAssertJRules.AssertNotSameWithMessage
• Refaster template TestNGToAssertJRules.AssertNull
• Refaster template TestNGToAssertJRules.AssertNullWithMessage
• Refaster template TestNGToAssertJRules.AssertSame
• Refaster template TestNGToAssertJRules.AssertSameWithMessage
• Refaster template TestNGToAssertJRules.AssertThrows
• Refaster template TestNGToAssertJRules.AssertTrue
• Refaster template TestNGToAssertJRules.AssertTrueWithMessage
• Refaster template TestNGToAssertJRules.AssertUnequal
• Refaster template TestNGToAssertJRules.AssertUnequalDoublesWithDelta
• Refaster template TestNGToAssertJRules.AssertUnequalDoublesWithDeltaWithMessage
• Refaster template TestNGToAssertJRules.AssertUnequalFloatsWithDelta
• Refaster template TestNGToAssertJRules.AssertUnequalFloatsWithDeltaWithMessage
• Refaster template TestNGToAssertJRules.AssertUnequalWithMessage
• Refaster template TestNGToAssertJRules.Fail
• Refaster template TestNGToAssertJRules.FailWithMessage
• Refaster template TestNGToAssertJRules.FailWithMessageAndThrowable
• Refaster template TimeRules.ZeroDuration
• Refaster template TimeRules.ZeroPeriod
• Use Clock#systemUTC() when possible
• Use ZoneOffset#UTC when possible
• Use the fluent API style when using RxJava2Adapter#completableToMono