[Kotlin] The last case in when for seal object is never show coverage without already test

[thuypt]

I wrote a when condition for seal object and implement test for all cases, but Jacoco doesn't show coverage for the last case.

ex:
Code

        when (index) {
            is Index.First -> instayWifi.clear()
            is Index.Second -> instayWifi.setUpInStayWifiCredential()
        }

Test

       whenSampleCoverrage.apply(Index.Second)
        verify(instayWifi).setUpInStayWifiCredential()

        whenSampleCoverrage.apply(Index.First)
        verify(instayWifi).clear()

In the coverrage result, it doesn't show coverage for last case

JaCoCo version: 0.8.1
Operating system: MacOS
Tool integration: AndroidStudio/Gradle/Java/Kotlin

Expected behaviour

The last case in when should show coverage after call testing.

Actual behaviour

The last case in when never show coverage after call testing.

[marchof]

@thuypt My guess is that you're missing the case that there is no match at all.

[thuypt]

@marchof I had same think with you at the first time, and I run debug for testing then, it already jump to the last case. You can see in my test

 whenSampleCoverrage.apply(Index.Second)

FYI: when works fine with normal object, just broken with seal class (Kotlin has this type class, Java don't, this may be the cause of the problem)

[marchof]

@thuypt I'm talking about the fall through case, something like:

whenSampleCoverrage.apply(Index.Third)

This is probably the missed branch.

[thuypt]

@marchof Just only two objects define in Index,

sealed class Index {
    object First : Index()
    object Second : Index()
}

btw, I think even we have Index.Third, JaCoCo should mark the line testing with Index.Second are coverage.

[marchof]

@thuypt JaCoCo does not know about the semantics of the statement. It only sees a missed branch -- and reports it. The same holds true for Java switches on enums.

We have this issue on our filtering wish list but for now we don't have a solution as we don't have other classes at hand during analysis (e.g. to check whether there are more members in the enum).

[Godin]

For the completeness of picture:

JaCoCo performs analysis of bytecode, not source code. Kotlin compiler for function example in SealedExample.kt

sealed class Index {
    object First : Index()
    object Second : Index()
}

fun example(index: Index): Int = when(index) {
  is Index.First -> 1
  is Index.Second -> 2  // line 8
}

generates following bytecode (javap -v -p SealedExample.class)

  public static final int example(Index);
    descriptor: (LIndex;)I
    flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL
    Code:
      stack=2, locals=2, args_size=1
         0: aload_0
         1: ldc           #9                  // String index
         3: invokestatic  #15                 // Method kotlin/jvm/internal/Intrinsics.checkParameterIsNotNull:(Ljava/lang/Object;Ljava/lang/String;)V
         6: aload_0
         7: astore_1
         8: aload_1
         9: instanceof    #17                 // class Index$First
        12: ifeq          19
        15: iconst_1
        16: goto          38
        19: aload_1
        20: instanceof    #19                 // class Index$Second
        23: ifeq          30
        26: iconst_2
        27: goto          38
        30: new           #21                 // class kotlin/NoWhenBranchMatchedException
        33: dup
        34: invokespecial #25                 // Method kotlin/NoWhenBranchMatchedException."<init>":()V
        37: athrow
        38: ireturn
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      39     0 index   LIndex;
      LineNumberTable:
        line 6: 6
        line 7: 8
        line 8: 19
        line 6: 38
        line 9: 38

and there is clearly two branches (23: ifeq 30) in bytecode associated with line 8.

While from a Kotlin language semantics point of view for when expression on sealed class

the else clause is not required

and compilation of

fun example(index: Index): Int = when(index) {
  is Index.First -> 1
  is Index.Second -> 2  // line 8
  else -> 3  // line 9
}

results in a warning

SealedExample.kt: (9, 3): 'when' is exhaustive so 'else' is redundant here

and while from user point of view might seem that in first case NoWhenBranchMatchedException is impossible and in second case else is unreachable, practically this is pretty well possible and reachable:

example(org.mockito.Mockito(Index::class.java))

This even can happen without mock, if you somehow messed up with build/packaging of classes and at runtime got additional class that inherits Index that initially wasn't presented in when expression.

This is indeed looks quite similar to the case of Java's swtich statment with cases for all values of enum.

Maybe even more similar to Java switch on string that javac compiles into multiple switch and if bytecode instructions - see https://stackoverflow.com/questions/42642840/why-is-jacoco-not-covering-my-string-switch-statements/42680333#42680333

@marchof maybe we even don't need information about classes in this case compared to swtitch on enum and maybe we can do similarly to switch on string. However I'm fine to not reopen this ticket right now, because currently personally I don't have capacity to dig deeper - just added a note to our filtering wish list so that maybe reopen this ticket later.

[Godin]

And BTW coverage engine developed by JetBrains and embedded in IntelliJ IDEA 2017.3.4 has two modes - "sampling" and "tracing". AFAIK first one is default, fast and doesn't record information about branches, second one is slow however records information about branches. This coverage engine in a "tracing" mode also believes that line 8 is partially covered 😉

[Godin]

While seems that when expression on enum classes requires more than currently filters can do - ignore branch of lookupswitch and tableswitch, I have prototype of filter for when expression on sealed classes, so reopen this ticket.