Kotlinで拡張関数を活用したテスト駆動開発（TDD）の実践ガイド

fun String.capitalizeWords(): String {
    return this.split(" ").joinToString(" ") { it.capitalize() }
}

val text = "hello world"
println(text.capitalizeWords())  // 出力: "Hello World"

// 拡張関数のテスト例
fun String.reverseWords(): String = this.split(" ").reversed().joinToString(" ")

class StringExtensionsTest {
    @Test
    fun `reverseWords should reverse the order of words in a string`() {
        val input = "hello world Kotlin"
        val result = input.reverseWords()
        assertEquals("Kotlin world hello", result)
    }
}

class StringExtensionsTest {
    @Test
    fun `capitalizeWords should capitalize the first letter of each word`() {
        val input = "kotlin is fun"
        val result = input.capitalizeWords()
        assertEquals("Kotlin Is Fun", result) // この時点ではテストは失敗
    }
}

fun String.capitalizeWords(): String {
    return this.split(" ").joinToString(" ") { it.capitalize() }
}

fun String.capitalizeWords(): String = split(" ").joinToString(" ") { it.capitalize() }

@Test
fun `capitalizeWords should handle empty strings`() {
    val input = ""
    val result = input.capitalizeWords()
    assertEquals("", result)
}

@Test
fun `capitalizeWords should handle strings with multiple spaces`() {
    val input = "  kotlin    is  fun  "
    val result = input.capitalizeWords()
    assertEquals("Kotlin Is Fun", result)
}

@Test
fun `capitalizeWords should capitalize the first letter of each word`() {
    val input = "kotlin is fun"
    val result = input.capitalizeWords()
    assertEquals("Kotlin Is Fun", result)
}

@Test
fun `capitalizeWords should handle empty strings`() {
    val input = ""
    val result = input.capitalizeWords()
    assertEquals("", result)
}

@Test
fun `capitalizeWords should handle single-word strings`() {
    val input = "kotlin"
    val result = input.capitalizeWords()
    assertEquals("Kotlin", result)
}

@Test
fun `capitalizeWords should handle strings with numbers and symbols`() {
    val input = "123 kotlin @fun"
    val result = input.capitalizeWords()
    assertEquals("123 Kotlin @Fun", result)
}

fun String?.safeCapitalizeWords(): String {
    return this?.split(" ")?.joinToString(" ") { it.capitalize() } ?: ""
}

@Test
fun `safeCapitalizeWords should handle null inputs`() {
    val input: String? = null
    val result = input.safeCapitalizeWords()
    assertEquals("", result)
}

@Test
fun `capitalizeWords should handle long strings efficiently`() {
    val input = "kotlin ".repeat(1000).trim()
    val result = input.capitalizeWords()
    assertTrue(result.startsWith("Kotlin Kotlin Kotlin"))
}

@Test
fun `capitalizeWords should be idempotent`() {
    val input = "kotlin is fun"
    val result1 = input.capitalizeWords()
    val result2 = result1.capitalizeWords()
    assertEquals(result1, result2)
}

class StringExtensionsTest {
    @Test
    fun `reverseWords should reverse the order of words in a string`() {
        val input = "Kotlin is fun"
        val result = input.reverseWords()
        assertEquals("fun is Kotlin", result)
    }
}

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

@Test
fun `reverseWords should handle empty strings`() {
    val input = ""
    val result = input.reverseWords()
    assertEquals("", result)
}

@Test
fun `reverseWords should handle single-word strings`() {
    val input = "Kotlin"
    val result = input.reverseWords()
    assertEquals("Kotlin", result)
}

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

val paragraph = "Kotlin is versatile. It is great for mobile development."
val reversedParagraph = paragraph.reverseWords()
println(reversedParagraph)
// 出力: "development. mobile for great is It versatile. is Kotlin"

object StringExtensions {
    fun String.reverseWords(): String = this.split(" ").reversed().joinToString(" ")
}

fun List<Int>.averageOrNull(): Double? {
    return if (this.isEmpty()) null else this.average()
}

class ListExtensionsTest {
    @ParameterizedTest
    @CsvSource(
        "1,2,3,4,5,3.0",
        "10,20,30,40,50,30.0",
        ",null"
    )
    fun `averageOrNull should calculate the average correctly`(input: String, expected: Double?) {
        val list = input.split(",").mapNotNull { it.toIntOrNull() }
        val result = list.averageOrNull()
        assertEquals(expected, result)
    }
}

fun HttpResponse?.isSuccessful(): Boolean {
    return this?.status == 200
}

class HttpResponseExtensionsTest {
    @Test
    fun `isSuccessful should return true for status 200`() {
        val response = mockk<HttpResponse> {
            every { status } returns 200
        }
        assertTrue(response.isSuccessful())
    }
}

fun StringBuilder.appendTag(tag: String, content: String) {
    append("<$tag>$content</$tag>")
}

@Test
fun `appendTag should create valid HTML tags`() {
    val builder = StringBuilder()
    builder.appendTag("h1", "Hello, Kotlin!")
    assertEquals("<h1>Hello, Kotlin!</h1>", builder.toString())
}

fun <T> List<T>.filterIf(predicate: (T) -> Boolean, condition: Boolean): List<T> {
    return if (condition) this.filter(predicate) else this
}

@Test
fun `filterIf should conditionally filter a list`() {
    val numbers = listOf(1, 2, 3, 4, 5)
    val result = numbers.filterIf({ it % 2 == 0 }, true)
    assertEquals(listOf(2, 4), result)
}

fun String?.orEmptyTrimmed(): String = this?.trim() ?: ""

@Test
fun `orEmptyTrimmed should return trimmed or default value`() {
    assertEquals("Kotlin", " Kotlin ".orEmptyTrimmed())
    assertEquals("", null.orEmptyTrimmed())
}

package com.example.extensions

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

fun String.isValidEmail(): Boolean {
    return this.matches(Regex("^[A-Za-z0-9+_.-]+@[A-Za-z0-9.-]+$"))
}

@Test
fun `isValidEmail should validate email addresses correctly`() {
    assertTrue("test@example.com".isValidEmail())
    assertFalse("invalid-email".isValidEmail())
}

fun String.toMockUser(): User {
    return User(name = this, email = "$this@example.com")
}

@Test
fun `toMockUser should create a mock user`() {
    val mockUser = "John".toMockUser()
    assertEquals("John", mockUser.name)
    assertEquals("John@example.com", mockUser.email)
}

fun Double.applyTax(taxRate: Double): Double {
    return this + (this * taxRate)
}

@Test
fun `applyTax should calculate tax correctly`() {
    val price = 100.0
    val result = price.applyTax(0.1)
    assertEquals(110.0, result, 0.01)
}

fun ApiResponse.toDomainModel(): DomainModel {
    return DomainModel(id = this.id, name = this.name, isActive = this.status == "active")
}

@Test
fun `toDomainModel should map ApiResponse to DomainModel`() {
    val response = ApiResponse(id = 1, name = "Kotlin", status = "active")
    val model = response.toDomainModel()
    assertEquals(1, model.id)
    assertEquals("Kotlin", model.name)
    assertTrue(model.isActive)
}

tasks.test {
    useJUnitPlatform()
    testLogging {
        events("passed", "skipped", "failed")
    }
}