can't test my commonMain with jvm packages.

# multiplatform

[calidion]

can't test my commonMain with jvm packages.

[Michael Paus]

What exactly are you trying to test? You cannot have any JVM packages inside commonMain if you have configured any non-JVM target like iOS for example.

[calidion]

Yes. but I need to test with it before export it be used as a common base.

[calidion]

should only limit the commonMain source code not the commonTest code.

[Michael Paus]

For commonTest code the same rules apply.

[calidion]

That may not be right. if the test code is limited then the test can not be made.

[calidion]

your code can't be tested them.

[Moussa]

@calidion
If I understood you correctly.
Let's assume you have 3 targets
• JVM
• Android
• iOS
That would mean that your commonMain won't be able to have a dependency on jvm only libs and the same goes for commonTest.

If you want to write some test cases that are only available for the jvm target. You can write them in jvmTest and if you want to have access to specific libs that are only available on jvm you can import these libs in gradle for jvmTest source set. This way, in your jvmTest, you would have access to all code written in commonMain and libs that are only available in jvm.

Hope that answer your questions!

[calidion]

My test code is prepared for commonMain, why should I write tests in jvmTest instead of androidTest? commonMain defines the intefaces for jvm, android, iso to be used. Without a real implementation, common code can't be tested. And it should not be placed in jvm, android, ios.

[Moussa]

My test code is prepared for commonMain, why should I write tests in jvmTest

Because you want to use jvm dependencies to test your code as per this

can't test my commonMain with jvm packages.

Am I misunderstanding your question?!

[calidion]

yes. jvm is optional , but the tests are essential to make my code fully tested.

[Moussa]

Can we rephrase the question, I'm honestly not getting it

[calidion]

And I want all my tests accompanied with coverage report.

[calidion]

1. commonMain code is for all platform

[calidion]

2. interfaces for all platform to be implemented.

[calidion]

3. commonMain has invocation to these interfaces.

[calidion]

4. tests need to be done to test the interfaces are properly set.

[calidion]

5. you need one of the implementation from jvm, android, ios.

[calidion]

6. jvm may be the simplest option for implementation.

[Moussa]

Let's tackle it one part at a time.

• If you are looking for coverage report in KMP, you can use kotlinx-kover https://github.com/Kotlin/kotlinx-kover and if you want to get JaCoCo reports like we would do in jvm or android you can check this configuration from kotlinx-kover documentation https://kotlin.github.io/kotlinx-kover/gradle-plugin/#using-jacoco
• commonMain is where you can write Kotlin code that will be shared among all targets that you have already added in your Gradle file. If you wrote a class in it, it will automatically be available for all targets. But, if you need different implementation per platform (something like an interface and that interface implementation is implemented differently for each target) then you can use expect/actual feature of the KMP https://kotlinlang.org/docs/multiplatform-expect-actual.html

[Moussa]

Did I understood your question correctly?

[Moussa]

If not, please give me more details so I can better help you

[calidion]

How can I test interfaces inside the commonMain if it is not implemented? and how do I get the coverage report before jvm/android/ios code is written?

[calidion]

I think the process of written a source code is :
1. write some code
2. write some test
3. publish it as an api

[calidion]

so the process of writing commonMain code precedes the writing of androidMain code normally

[calidion]

Normally I must fully test the commonMain before I start to write androidMain or JvmMain code.

[Moussa]

Interfaces define a contract, a set of methods that a class must implement. You can't test an interface as just an interface test.

example, this code are all in commonMain

interface Animal {
    fun speak(): String
}

class Cat : Animal {
    override fun speak(): String {
        return "Newo Newo"
    }
}

class Dog : Animal {
    override fun speak(): String {
        return "Hao Hao"
    }
}

You won't be able to test the Animal interface. But you will be able to test the classes that are implement it, in this case, it would be Cat and Dog which will use the interface which will be added to the coverage report as being used.

The other option, which is using expect/actual, example

// commanMain
interface Animal {
    fun speak(): String
}

expect class Cat : Animal // This means that I your need to implement it in all supported targets (in this example, JVM, iOS)

// jvmMain
actual class Cat : Animal {
    override fun speak(): String {
        return "Newo Newo From JVM"
    }
}

// iosMain
actual class Cat : Animal {
    override fun speak(): String {
        return "Newo Newo From iOS"
    }
}

Then you can add your tests in commonTest like this

expect class CatTests {
    @Test
    fun `test speak method`()
}

Then you go and implement the custom tests of the CatTests per platform like we did with implementation of the Cat class
In jvmMain

actual class CatTests {
    @Test
    fun `test speak method`() {
        assertEquals("Newo Newo From JVM", Cat().speak())
    }
}

In iosMain

actual class CatTests {
    @Test
    fun `test speak method`() {
        assertEquals("Newo Newo From iOS", Cat().speak())
    }
}

[calidion]

can this code be tested? they are all in commonMain.

interface In {
  fun api()
}

fun useInterface(i: In) {
   i.api()
}

[Moussa]

Yes, with a 100% coverage report as well.

class Tests {
    private val inImpl: In = object : In {
        override fun api() {
            // implement the logic you want here for testing purposes 
        }

    }
    
    @Test 
    fun `test useInterface method`() {
        useInterface(inImpl)
    } 
}

[calidion]

Ok. It means that I don't have to implement interface to test?

[Moussa]

As per the example you shared with me, yes. This how you would implement tests for it.

[calidion]

OK. i Will try it later.

[Moussa]

Great. Let me know how it goes

[calidion]

@Moussa But the problem is that only the implementation is jvm, android or ios. can test the logic.

[calidion]

Problems cannot be solved this way.

[calidion]

You can't make you code fully tested with out a real implementation.

[calidion]

so the commonTest code at lease should be enabled to use jvm code.

[Moussa]

If your implementation of your interface is in iosMain, jvmMain, or androidMain then you implement your tests in two ways.
The first way is to implement unit tests for each of them in their correct folder. Let's take your shared code as an example
In commanMain

interface In {
  fun api()
}

fun useInterface(i: In) {
   i.api()
}

in jvmMain

class Moussa : In {
    override fun api() {
        // Implement your logic here
    }
}

Then you have to write test cases in jvmTests to test that specific logic and have coverage report for the part implemented in jvmMain

OR, you can use expect/actual
You would have in commonTest

expect class InTests {
    @Test
    fun `test api method per platform`()
}

Then you would go and implement that class and it's method in the test module of each platform. This way, make your code testable from common and allow access to your different implementation per platform and allow for the test coverage for all of them
In jvmTest you would have

actual class InTests {
    @Test
    actual fun `test api method per platform`() {
        // Implement your unit test here
    }
}