3단계 - 자동차 경주

src/main/kotlin/racingCar/Car.kt

@@ -0,0 +1,24 @@
+package racingCar
+
+class Car(
+    private var distance: Int = 0,
+    private val randomNumber: RandomNumber
+) {
+    val readOnlyDistance: Int
+        get() {
+            return distance
+        }
+
+    companion object {
+        const val FORWARD_CONDITIONS: Int = 4
+    }
+
+    fun move() {
+        if (checkForwardCondition())
+            distance++
+    }
+
+    private fun checkForwardCondition(): Boolean {
+        return randomNumber.getRandomNumber() >= FORWARD_CONDITIONS
+    }
+}

src/main/kotlin/racingCar/InputIO.kt

@@ -0,0 +1,31 @@
+package racingCar
+
+import java.lang.NumberFormatException
+
+class InputIO {
+    fun inputNumber(numberType: InputType): Int {
+        inputView(numberType)
+
+        return checkNumber(readlnOrNull()) ?: return inputNumber(numberType)
+    }
+
+    private fun inputView(numberType: InputType) {
+        println(numberType.message)
+    }
+
+    fun checkNumber(inputString: String?): Int? {
+        try {
+            val value = Integer.parseInt(inputString)
+
+            if (value < 0) {
+                println("양수만 입력해 주세요")
+                return null
+            }
+
+            return value
+        } catch (e: NumberFormatException) {
+            println("숫자를 입력해 주세요")
+            return null
+        }
+    }
+}

src/main/kotlin/racingCar/InputType.kt

@@ -0,0 +1,6 @@
+package racingCar
+
+enum class InputType(val message: String) {
+    CAR_COUNT("자동차 대수는 몇 대인가요?"),
+    GAME_COUNT("시도할 횟수는 몇 회인가요?");
+}

src/main/kotlin/racingCar/RacingField.kt

@@ -0,0 +1,31 @@
+package racingCar
+
+class RacingField(
+    private val cars: List<Car>,
+    private val gameCount: Int
+) {
+    constructor(carCount: Int, gameCount: Int) : this(
+        List(if (carCount <= 0) 1 else carCount) { Car(randomNumber = RandomNumberGenerator()) },
+        if (gameCount <= 0) 1 else gameCount
+    )
+
+    fun getGameCount(): Int {
+        return gameCount
+    }
+
+    fun gameStart() {
+        moveCars()
+    }
+
+    private fun moveCars() {
+        cars.forEach { it.move() }
+    }
+
+    fun getCarCount(): Int {
+        return cars.size
+    }
+
+    fun getCarsDistance(): List<Int> {
+        return cars.map { it.readOnlyDistance }
+    }
+}

src/main/kotlin/racingCar/RandomNumberGenerator.kt

@@ -0,0 +1,11 @@
+package racingCar
+
+interface RandomNumber {
+    fun getRandomNumber(): Int
+}
+
+class RandomNumberGenerator : RandomNumber {
+    override fun getRandomNumber(): Int {
+        return (0..9).random()
+    }
+}

src/main/kotlin/racingCar/ResultView.kt

@@ -0,0 +1,23 @@
+package racingCar
+
+class ResultView {
+
+    companion object {
+        const val DISPLAY_STRING = "-"
+    }
+
+    private fun resultMessage() {
+        println("실행 결과")
+    }
+
+    private fun carsDistanceDisplay(distances: List<Int>) {
+        distances.forEach { distance ->
+            println(DISPLAY_STRING.repeat(distance))
+        }
+    }
+
+    fun racingResultDisplay(distances: List<Int>) {
+        resultMessage()
+        carsDistanceDisplay(distances)
+    }
+}

src/main/kotlin/racingCar/main.kt

@@ -0,0 +1,16 @@
+package racingCar
+
+fun main() {
+    val inputIO = InputIO()
+    val carCount = inputIO.inputNumber(InputType.CAR_COUNT)
+    val gameCount = inputIO.inputNumber(InputType.GAME_COUNT)
+
+    val racingField = RacingField(carCount, gameCount)
+
+    val resultView = ResultView()
+
+    repeat(gameCount) {
+        racingField.gameStart()
+        resultView.racingResultDisplay(racingField.getCarsDistance())
+    }
+}

src/test/kotlin/racingCarTest/CarMoveTest.kt

@@ -0,0 +1,21 @@
+package racingCarTest
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+import racingCar.Car
+
+class CarMoveTest {
+    @Test
+    fun `전진 조건이 맞지 않는 경우`() {
+        val car = Car(randomNumber = FixedNumberGenerator(3))
+        car.move()
+        assertThat(car.readOnlyDistance).isEqualTo(0)
+    }
+
+    @Test
+    fun `전진 조건이 맞는 경우`() {
+        val car = Car(randomNumber = FixedNumberGenerator(7))
+        car.move()
+        assertThat(car.readOnlyDistance).isEqualTo(1)
+    }
+}

src/test/kotlin/racingCarTest/CheckNumberTest.kt

@@ -0,0 +1,22 @@
+package racingCarTest
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+import racingCar.InputIO
+
+class CheckNumberTest {
+    @Test
+    fun `입력값이 음수일 경우 null 을 리턴한다`() {
+        val inputIO = InputIO()
+        val negativeValue = inputIO.checkNumber("-1")
+        assertThat(negativeValue).isNull()
+    }
+
+    @Test
+    fun `입력값이 양수일 경우 입력한 값을 Int 로 변환하여 리턴한다`() {
+        val inputIO = InputIO()
+
+        val positiveValue = inputIO.checkNumber("3")
+        assertThat(positiveValue).isEqualTo(3)
+    }
+}

src/test/kotlin/racingCarTest/FixedNumberGenerator.kt

@@ -0,0 +1,11 @@
+package racingCarTest
+
+import racingCar.RandomNumber
+
+class FixedNumberGenerator(
+    private val fixedNumber: Int
+) : RandomNumber {
+    override fun getRandomNumber(): Int {
+        return fixedNumber
+    }
+}

src/test/kotlin/racingCarTest/RacingFieldTest.kt

@@ -0,0 +1,43 @@
+package racingCarTest
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+import racingCar.RacingField
+
+class RacingFieldTest {
+    @Test
+    fun `자동차 수 테스트`() {
+        val racingField = RacingField(3, 0)
+        assertThat(racingField.getCarCount()).isEqualTo(3)
+    }
+
+    @Test
+    fun `자동차 수 음수 테스트`() {
+        val racingField = RacingField(-3, 0)
+        assertThat(racingField.getCarCount()).isEqualTo(1)
+    }
+
+    @Test
+    fun `경기 실행 수 설정 테스트`() {
+        val racingField = RacingField(0, 5)
+        assertThat(racingField.getGameCount()).isEqualTo(5)
+    }
+
+    @Test
+    fun `경기 실행 수 음수 테스트`() {
+        val racingField = RacingField(0, -5)
+        assertThat(racingField.getGameCount()).isEqualTo(1)
+    }
+
+    @Test
+    fun `레이싱 경기 게임 실행 테스트`() {
+        val carCount = 5
+        val gameCount = 100
+        val racingField = RacingField(carCount, gameCount)
+
+        repeat(gameCount) {
+            racingField.gameStart()
+            assertThat(racingField.getCarsDistance().stream().allMatch { it in 0..gameCount })
+        }
+    }
+}