KotlinでTDDを活用した拡張関数のテスト方法を徹底解説

import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Test

class ExampleTest {
    @Test
    fun `sample test`() {
        val result = add(2, 3)
        assertEquals(5, result)
    }

    private fun add(a: Int, b: Int) = a + b
}

fun String.isPalindrome(): Boolean {
    val reversed = this.reversed()
    return this == reversed
}

fun List<Int>.averageValue(): Double {
    return if (this.isEmpty()) 0.0 else this.sum().toDouble() / this.size
}

val numbers = listOf(1, 2, 3, 4, 5)
println(numbers.averageValue()) // 出力: 3.0

fun String.isPalindrome(): Boolean {
    val cleaned = this.replace("\\s+".toRegex(), "").lowercase()
    return cleaned == cleaned.reversed()
}

class ExtensionFunctionTest {
    @Test
    fun `isPalindrome returns true for palindrome strings`() {
        assertTrue("A man a plan a canal Panama".isPalindrome())
    }

    @Test
    fun `isPalindrome returns false for non-palindrome strings`() {
        assertFalse("Hello, world!".isPalindrome())
    }
}

fun String.isPalindrome(): Boolean {
    // 未実装状態の関数
    TODO("Implement this function")
}

class ExtensionFunctionTest {
    @Test
    fun `isPalindrome returns true for palindrome strings`() {
        assertTrue("madam".isPalindrome())
    }

    @Test
    fun `isPalindrome returns false for non-palindrome strings`() {
        assertFalse("hello".isPalindrome())
    }
}

fun String.isPalindrome(): Boolean {
    return this == this.reversed()
}

fun String.isPalindrome(): Boolean {
    val cleaned = this.replace("\\s+".toRegex(), "").lowercase()
    return cleaned == cleaned.reversed()
}

fun List<Int>.median(): Double {
    TODO("Implement this function")
}

class ListExtensionTest {
    @Test
    fun `median returns the middle value for odd-sized lists`() {
        assertEquals(3.0, listOf(1, 3, 5).median())
    }

    @Test
    fun `median returns the average of two middle values for even-sized lists`() {
        assertEquals(2.5, listOf(1, 2, 3, 4).median())
    }

    @Test
    fun `median returns 0 for an empty list`() {
        assertEquals(0.0, emptyList<Int>().median())
    }
}

fun List<Int>.median(): Double {
    if (this.isEmpty()) return 0.0
    val sorted = this.sorted()
    val middle = size / 2
    return if (size % 2 == 0) {
        (sorted[middle - 1] + sorted[middle]) / 2.0
    } else {
        sorted[middle].toDouble()
    }
}

fun List<Int>.median(): Double = when {
    isEmpty() -> 0.0
    size % 2 == 0 -> sorted().let { (it[size / 2 - 1] + it[size / 2]) / 2.0 }
    else -> sorted()[size / 2].toDouble()
}

import org.junit.jupiter.api.Test
import org.junit.jupiter.api.Assertions.assertEquals

class JUnitTestExample {
    @Test
    fun `addition test`() {
        val sum = 2 + 3
        assertEquals(5, sum)
    }
}

import io.kotest.core.spec.style.StringSpec
import io.kotest.matchers.shouldBe

class KotestExample : StringSpec({
    "addition test" {
        val sum = 2 + 3
        sum shouldBe 5
    }
})

import io.mockk.every
import io.mockk.mockk
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.Assertions.assertEquals

class MockKExample {
    @Test
    fun `mock example`() {
        val mockCalculator = mockk<Calculator>()
        every { mockCalculator.add(2, 3) } returns 5
        assertEquals(5, mockCalculator.add(2, 3))
    }
}

class Calculator {
    fun add(a: Int, b: Int): Int = a + b
}

dependencies {
    testImplementation("org.junit.jupiter:junit-jupiter:5.8.2")
    testImplementation("io.kotest:kotest-runner-junit5:5.0.3")
    testImplementation("io.mockk:mockk:1.12.4")
}

import io.kotest.core.spec.style.StringSpec
import io.kotest.data.Row2
import io.kotest.data.forAll
import io.kotest.data.row
import io.kotest.matchers.shouldBe

class ParameterizedTest : StringSpec({
    "multiplication test" {
        forAll(
            row(2, 3, 6),
            row(4, 5, 20),
            row(6, 7, 42)
        ) { a, b, result ->
            (a * b) shouldBe result
        }
    }
})

fun String.reverseWords(): String {
    return this.split(" ")
        .map { it.reversed() }
        .joinToString(" ")
}

val input = "Kotlin is fun"
println(input.reverseWords()) // 出力: "niltoK si nuf"

import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Test

class ReverseWordsTest {

    @Test
    fun `reverseWords should reverse words in a normal sentence`() {
        val input = "Kotlin is fun"
        val expected = "niltoK si nuf"
        assertEquals(expected, input.reverseWords())
    }

    @Test
    fun `reverseWords should handle an empty string`() {
        val input = ""
        val expected = ""
        assertEquals(expected, input.reverseWords())
    }

    @Test
    fun `reverseWords should handle spaces only`() {
        val input = "   "
        val expected = "   "
        assertEquals(expected, input.reverseWords())
    }

    @Test
    fun `reverseWords should reverse words with special characters`() {
        val input = "123 !@# Kotlin"
        val expected = "321 #@! niltoK"
        assertEquals(expected, input.reverseWords())
    }
}

All tests passed successfully.

fun String.reverseWords(): String = this.split(Regex("\\s+"))
    .joinToString(" ") { it.reversed() }

fun List<String>.uniqueSorted(): List<String> {
    // ここに処理を実装する
    TODO("Implement this function")
}

import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Test

class UniqueSortedTest {

    @Test
    fun `uniqueSorted should handle a list with no duplicates`() {
        val input = listOf("apple", "banana", "cherry")
        val expected = listOf("apple", "banana", "cherry")
        assertEquals(expected, input.uniqueSorted())
    }

    @Test
    fun `uniqueSorted should remove duplicates`() {
        val input = listOf("apple", "banana", "apple", "cherry")
        val expected = listOf("apple", "banana", "cherry")
        assertEquals(expected, input.uniqueSorted())
    }

    @Test
    fun `uniqueSorted should handle an empty list`() {
        val input = emptyList<String>()
        val expected = emptyList<String>()
        assertEquals(expected, input.uniqueSorted())
    }

    @Test
    fun `uniqueSorted should handle mixed case strings`() {
        val input = listOf("Apple", "banana", "apple", "Cherry")
        val expected = listOf("Apple", "Cherry", "apple", "banana")
        assertEquals(expected, input.uniqueSorted())
    }
}

fun List<String>.uniqueSorted(): List<String> {
    return this.toSet().sorted()
}

All tests passed successfully.

@Test
fun `reverseWords should handle strings with multiple spaces`() {
    val input = "  Kotlin   is   fun  "
    val expected = "  niltoK   si   nuf  "
    assertEquals(expected, input.reverseWords())
}