Home » JVM Languages » Kotlin » Testing Kotlin with Spock Part 2 – Enum with instance method

About Dominik Przybysz

Dominik Przybysz
Dominik is a software developer in TouK, committer in Apache Aries and contributor in some open source projects. He writes code using generally the JVM languages, occasionally also makes some scripts in python or shell. Dominik loves testing (especially written in Spock) and any automation in the software development process. He takes care of the clean code (his or someone's else) through frequent code review

Testing Kotlin with Spock Part 2 – Enum with instance method

The enum class with instance method in Kotlin is quite similar to its Java version, but they are look a bit different in the bytecode. Let’s see the difference by writing some tests using
Spock.

What do we want to test?

Let’s see the code that we want to test:

enum class EnumWithInstanceMethod {
    PLUS {
        override fun sign(): String = "+"
    },
    MINUS {
        override fun sign(): String = "-"
    };

    abstract fun sign(): String
}

Obviously, it can be written in a better way (e. g. using enum instance variable), but this example shows the case we want to test in the simplest way.

How to test it with Spock?

The simplest test (that does not work)

First, we can write the test like we would do it with a Java enum:

def "should use enum method like in java"() {
    expect:
        EnumWithInstanceMethod.MINUS.sign() == '-'
}

The test fails:

Condition failed with Exception:

EnumWithInstanceMethod.MINUS.sign() == '-'
                             |
                             groovy.lang.MissingMethodException: No signature of method: static com.github.alien11689.testingkotlinwithspock.EnumWithInstanceMethod$MINUS.sign() is applicable for argument types: () values: []
                             Possible solutions: sign(), sign(), is(java.lang.Object), find(), with(groovy.lang.Closure), find(groovy.lang.Closure)


    at com.github.alien11689.testingkotlinwithspock.EnumWithInstanceMethodTest.should use enum method like in java(EnumWithInstanceMethodTest.groovy:11)
Caused by: groovy.lang.MissingMethodException: No signature of method: static com.github.alien11689.testingkotlinwithspock.EnumWithInstanceMethod$MINUS.sign() is applicable for argument types: () values: []
Possible solutions: sign(), sign(), is(java.lang.Object), find(), with(groovy.lang.Closure), find(groovy.lang.Closure)
    ... 1 more

Interesting… Why is Groovy telling us that we are trying to call a static method? Maybe we are not using the enum instance but something else?. Let’s create a test where we pass the enum instance to method:

static String consume(EnumWithInstanceMethod e) {
    return e.sign()
}

def "should pass enum as parameter"() {
    expect:
        consume(EnumWithInstanceMethod.MINUS) == '-'
}

Error message:

Condition failed with Exception:

consume(EnumWithInstanceMethod.MINUS) == '-'
|
groovy.lang.MissingMethodException: No signature of method: static com.github.alien11689.testingkotlinwithspock.EnumWithInstanceMethodTest.consume() is applicable for argument types: (java.lang.Class) values: [class com.github.alien11689.testingkotlinwithspock.EnumWithInstanceMethod$MINUS]
Possible solutions: consume(com.github.alien11689.testingkotlinwithspock.EnumWithInstanceMethod)


    at com.github.alien11689.testingkotlinwithspock.EnumWithInstanceMethodTest.should pass enum as parameter(EnumWithInstanceMethodTest.groovy:29)
Caused by: groovy.lang.MissingMethodException: No signature of method: static com.github.alien11689.testingkotlinwithspock.EnumWithInstanceMethodTest.consume() is applicable for argument types: (java.lang.Class) values: [class com.github.alien11689.testingkotlinwithspock.EnumWithInstanceMethod$MINUS]
Possible solutions: consume(com.github.alien11689.testingkotlinwithspock.EnumWithInstanceMethod)
    ... 1 more

Now we see that we passed the class
com.github.alien11689.testingkotlinwithspock.EnumWithInstanceMethod$MINUS, not the enum instance.

But it works in Java…

Analogous code in JUnit works perfectly and the test passes:

@Test
public void shouldReturnSign() {
    assertEquals("-", EnumWithInstanceMethod.MINUS.sign());
}

Java can access Kotlin’s instance method without problems, so maybe something is wrong with Groovy…

But the Java enum with instance method, e. g.

public enum EnumWithInstanceMethodInJava {
    PLUS {
        public String sign() {
            return "+";
        }
    },
    MINUS {
        public String sign() {
            return "-";
        }
    };

    public abstract String sign();
}

works correctly in the Spock test:

def "should use enum method"() {
    expect:
        EnumWithInstanceMethodInJava.MINUS.sign() == '-'
}

What’s the difference?

We can spot the difference just by looking at the compiled classes:

$ tree build/classes/main/
build/classes/main/
└── com
    └── github
        └── alien11689
            └── testingkotlinwithspock
                ├── AdultValidator.class
                ├── EnumWithInstanceMethod.class
                ├── EnumWithInstanceMethodInJava$1.class
                ├── EnumWithInstanceMethodInJava$2.class
                ├── EnumWithInstanceMethodInJava.class
                ├── EnumWithInstanceMethod$MINUS.class
                ├── EnumWithInstanceMethod$PLUS.class
                ├── Error.class
                ├── Ok.class
                ├── ValidationStatus.class
                └── Validator.class

Java generates anonymous classes (
EnumWithInstanceMethodInJava$1 and
EnumWithInstanceMethodInJava$2) for the enum instances, but Kotlin names those classes after the enum instances names (
EnumWithInstanceMethod$MINUS and
EnumWithInstanceMethod$PLUS).

How does it tie into the problem with Groovy? Groovy does not need the
.class when accessing class in code, so when we try to access
EnumWithInstanceMethod.MINUS, Groovy converts it to
EnumWithInstanceMethod.MINUS.class, not the instance of the enum. The same problem does not occur in Java code since there is no
EnumWithInstanceMethodInJava$MINUS class.

Solution

Knowing the difference, we can solve the problem of accessing Kotlin’s enum instance in our Groovy code.

The first solution is accessing the enum instance with
valueOf method:

def "should use enum method working"() {
    expect:
        EnumWithInstanceMethod.valueOf('MINUS').sign() == '-'
}

The second way is to tell Groovy explicitly that we want to access the static field which is the instance of enum:

def "should use enum method"() {
    expect:
        EnumWithInstanceMethod.@MINUS.sign() == '-'
}

You can choose either solution depending on style of your code and your preferences.

Show me the code

Code is available here.

Published on Java Code Geeks with permission by Dominik Przybysz, partner at our JCG program. See the original article here: Testing Kotlin with Spock Part 2 – Enum with instance method

Opinions expressed by Java Code Geeks contributors are their own.

(0 rating, 0 votes)
You need to be a registered member to rate this.
Start the discussion Views Tweet it!
Do you want to know how to develop your skillset to become a Java Rockstar?
Subscribe to our newsletter to start Rocking right now!
To get you started we give you our best selling eBooks for FREE!
1. JPA Mini Book
2. JVM Troubleshooting Guide
3. JUnit Tutorial for Unit Testing
4. Java Annotations Tutorial
5. Java Interview Questions
6. Spring Interview Questions
7. Android UI Design
and many more ....
I agree to the Terms and Privacy Policy

Leave a Reply

avatar

This site uses Akismet to reduce spam. Learn how your comment data is processed.

  Subscribe  
Notify of