Nicer way to support soft assertions (Expect.create junit4 Rule) in JUnit5?

From a purely JUnit5 perspective, am I missing something?

I made this wrapper around the core Expect function:

    public class ThingyThing {
        public static void softly(final SoftAssertions softly) throws Throwable {
            Expect expect = Expect.create();
            expect.apply(new Statement() {
                @Override
                public void evaluate() throws Throwable {
                        softly.apply(expect);
                }
            }, Description.EMPTY)
                    .evaluate();
        }

        public interface SoftAssertions{
            void apply(final Expect expect);
        }
    }

Used like:

        ThingyThing.softly(expector -> {
            expector.that(1).isEqualTo(2);
            expector.that(-1).isGreaterThan(0);
        });

Outputs:

2 expectations failed:
  1. expected: 2
     but was : 1
     	at io.<snip>.ThingTest.lambda$testRemit$0(ThingTest.java:113)
     
  2. expected to be greater than: 0
     but was                    : -1
     	at io.<snip>.ThingTest.lambda$testRemit$0(ThingTest.java:114)

P.s. amazing framework BTW - beautiful. Especially for chained custom objects. Amazing. Wish I’d found it sooner.

[ddaeyeonkim]

My solution Inspired by ThingyThing.

class ExpectExtension : BeforeEachCallback, AfterEachCallback, InvocationInterceptor,
                        ParameterResolver {

    private var _expect: Expect? = null

    val expect: Expect
        get() = _expect!!

    override fun beforeEach(context: ExtensionContext) {
        _expect = Expect.create()
    }

    override fun interceptTestMethod(
        invocation: InvocationInterceptor.Invocation<Void>,
        invocationContext: ReflectiveInvocationContext<Method>,
        extensionContext: ExtensionContext
    ) {
        _expect?.apply(
            object : Statement() {
                override fun evaluate() {
                    invocation.proceed()
                }
            },
            Description.EMPTY,
        )?.evaluate()
    }

    override fun afterEach(context: ExtensionContext) {
        _expect = null
    }

    override fun supportsParameter(
        parameterContext: ParameterContext,
        extensionContext: ExtensionContext
    ): Boolean {
        val paramType = parameterContext.parameter.type
        return paramType is Type && paramType == Expect::class.java
    }

    override fun resolveParameter(
        parameterContext: ParameterContext,
        extensionContext: ExtensionContext
    ): Any {
        return expect
    }
}

A.

@Test
@ExtendWith(ExpectExtension::class)
fun test(expect: Expect) {
    expect.that<Int>(1).isEqualTo(2)
    expect.that<Int>(1).isEqualTo(3)
    expect.that<Int>(1).isEqualTo(4)
}

B.

@JvmField
@RegisterExtension
val extension = ExpectExtension()

@Test
fun test2() {
    extension.expect.that<Int>(1).isEqualTo(2)
    extension.expect.that<Int>(1).isEqualTo(3)
    extension.expect.that<Int>(1).isEqualTo(4)
}

@Test
fun test3(expect: Expect) {
    expect.that<Int>(1).isEqualTo(2)
    expect.that<Int>(1).isEqualTo(3)
    expect.that<Int>(1).isEqualTo(4)
}

I look forward to any form of Expect Extension for JUnit5 being added in the future!

[cpovirk]

As belatedly noted on #894, anything that we label as P3 has no timeline for being reviewed 😦 We hope to eventually schedule some more time for Truth (especially for features that could work well in Kotlin, like this one), but there are no plans yet.

(Another thing we should do: Figure out if this feature request and https://github.com/google/truth/issues/266 represent different requests or if they could be merged.)