Kotlin - Completed Clock

kotlin/clock/README.md

@@ -0,0 +1,16 @@
+# Clock
+
+Implement a clock that handles times without dates.
+
+You should be able to add and subtract minutes to it.
+
+Two clocks that represent the same time should be equal to each other.
+
+
+
+## Source
+
+Pairing session with Erin Drummond [https://twitter.com/ebdrummond](https://twitter.com/ebdrummond)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

kotlin/clock/build.gradle

@@ -0,0 +1,28 @@
+buildscript {
+  ext.kotlin_version = '1.1.1'
+  repositories {
+    mavenCentral()
+  }
+  dependencies {
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+  }
+}
+
+apply plugin: 'kotlin'
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+  testCompile 'junit:junit:4.12'
+  testCompile "org.jetbrains.kotlin:kotlin-test-junit:$kotlin_version"
+}
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

kotlin/clock/src/main/kotlin/Clock.kt

@@ -12,22 +12,34 @@ data class Clock(var hours: Int, var minutes: Int) {
     }
 
     private fun addMinutes(x: Int): Unit {
-        if (x > 59){
+        if ((x + this.minutes) >= 60) {
-
+            addHours((x + this.minutes).div(60))
+            this.minutes = (x + this.minutes).rem(60)
+        } else {
+            this.minutes += x
         }
+
+        while (this.minutes < 0){
+            this.minutes += 60
+            this.hours -= 1
+        }
+
+        this.hours = if (this.hours.rem(24) < 0) { 24 + this.hours.rem(24) } else this.hours.rem(24)
     }
 
     private fun addHours(x: Int): Unit {
-
+        if (x + this.hours > 23){
+            this.hours = (x+this.hours).rem(24)
+        } else {
+            this.hours += x
+        }
     }
 
     fun add(i: Int) {
         this.addMinutes(i)
-        this.addHours(i.div(60))
-
     }
 
     override fun toString(): String {
         return "${if (hours > 9){ "$hours"} else {"0$hours"}}:${if (minutes > 9){ "$minutes"} else {"0$minutes"}}"
     }
-}
+}

kotlin/clock/src/test/kotlin/ClockAddTest.kt

@@ -0,0 +1,138 @@
+import org.junit.Ignore
+import org.junit.Test
+import kotlin.test.assertEquals
+
+/*
+ * version: 1.0.1
+ */
+class ClockAddTest {
+
+    @Ignore
+    @Test
+    fun addMinutes() {
+        val clock = Clock(10, 0)
+        clock.add(3)
+        assertEquals("10:03", clock.toString())
+    }
+
+    @Ignore
+    @Test
+    fun addNoMinutes() {
+        val clock = Clock(6, 41)
+        clock.add(0)
+        assertEquals("06:41", clock.toString())
+    }
+
+    @Ignore
+    @Test
+    fun addToNextHour() {
+        val clock = Clock(0, 45)
+        clock.add(40)
+        assertEquals("01:25", clock.toString())
+    }
+
+    @Ignore
+    @Test
+    fun addMoreThanOneHour() {
+        val clock = Clock(10, 0)
+        clock.add(61)
+        assertEquals("11:01", clock.toString())
+    }
+
+    @Ignore
+    @Test
+    fun addMoreThanTwoHoursWithCarry() {
+        val clock = Clock(0, 45)
+        clock.add(160)
+        assertEquals("03:25", clock.toString())
+    }
+
+    @Ignore
+    @Test
+    fun addAcrossMidnight() {
+        val clock = Clock(23, 59)
+        clock.add(2)
+        assertEquals("00:01", clock.toString())
+    }
+
+    @Ignore
+    @Test
+    fun addMoreThanOneDay() {
+        val clock = Clock(5, 32)
+        clock.add(1500)
+        assertEquals("06:32", clock.toString())
+    }
+
+    @Ignore
+    @Test
+    fun addMoreThanTwoDays() {
+        val clock = Clock(1, 1)
+        clock.add(3500)
+        assertEquals("11:21", clock.toString())
+    }
+
+    @Ignore
+    @Test
+    fun subtractMinutes() {
+        val clock = Clock(10, 3)
+        clock.add(-3)
+        assertEquals("10:00", clock.toString())
+    }
+
+    @Ignore
+    @Test
+    fun subtractToPreviousHour() {
+        val clock = Clock(10, 3)
+        clock.add(-30)
+        assertEquals("09:33", clock.toString())
+    }
+
+    @Ignore
+    @Test
+    fun subtractMoreThanAnHour() {
+        val clock = Clock(10, 3)
+        clock.add(-70)
+        assertEquals("08:53", clock.toString())
+    }
+
+    @Ignore
+    @Test
+    fun subtractAcrossMidnight() {
+        val clock = Clock(0, 3)
+        clock.add(-4)
+        assertEquals("23:59", clock.toString())
+    }
+
+    @Ignore
+    @Test
+    fun subtractMoreThanTwoHours() {
+        val clock = Clock(0, 0)
+        clock.add(-160)
+        assertEquals("21:20", clock.toString())
+    }
+
+    @Ignore
+    @Test
+    fun subtractMoreThanTwoHoursWithBorrow() {
+        val clock = Clock(6, 15)
+        clock.add(-160)
+        assertEquals("03:35", clock.toString())
+    }
+
+    @Ignore
+    @Test
+    fun subtractMoreThanOneDay() {
+        val clock = Clock(5, 32)
+        clock.add(-1500)
+        assertEquals("04:32", clock.toString())
+    }
+
+    @Ignore
+    @Test
+    fun subtractMoreThanTwoDays() {
+        val clock = Clock(2, 20)
+        clock.add(-3000)
+        assertEquals("00:20", clock.toString())
+    }
+
+}

kotlin/clock/src/test/kotlin/ClockCreationTest.kt

@@ -0,0 +1,123 @@
+import org.junit.Ignore
+import org.junit.Test
+import kotlin.test.assertEquals
+
+/*
+ * version: 1.0.1
+ */
+class ClockCreationTest {
+
+    @Test
+    fun canPrintTimeOnTheHour() {
+        assertEquals("08:00", Clock(8, 0).toString())
+    }
+
+    @Ignore
+    @Test
+    fun canPrintTimeWithMinutes() {
+        assertEquals("11:09", Clock(11, 9).toString())
+    }
+
+    @Ignore
+    @Test
+    fun midnightPrintsAsZero() {
+        assertEquals("00:00", Clock(24, 0).toString())
+    }
+
+    @Ignore
+    @Test
+    fun hourRollsOver() {
+        assertEquals("01:00", Clock(25, 0).toString())
+    }
+
+    @Ignore
+    @Test
+    fun hourRollsOverContinuously() {
+        assertEquals("04:00", Clock(100, 0).toString())
+    }
+
+    @Ignore
+    @Test
+    fun sixtyMinutesIsNextHour() {
+        assertEquals("02:00", Clock(1, 60).toString())
+    }
+
+    @Ignore
+    @Test
+    fun minutesRollOver() {
+        assertEquals("02:40", Clock(0, 160).toString())
+    }
+
+    @Ignore
+    @Test
+    fun minutesRollOverContinuously() {
+        assertEquals("04:43", Clock(0, 1723).toString())
+    }
+
+    @Ignore
+    @Test
+    fun hourAndMinutesRollOver() {
+        assertEquals("03:40", Clock(25, 160).toString())
+    }
+
+    @Ignore
+    @Test
+    fun hourAndMinutesRollOverContinuously() {
+        assertEquals("11:01", Clock(201, 3001).toString())
+    }
+
+    @Ignore
+    @Test
+    fun hourAndMinutesRollOverToExactlyMidnight() {
+        assertEquals("00:00", Clock(72, 8640).toString())
+    }
+
+    @Ignore
+    @Test
+    fun negativeHour() {
+        assertEquals("23:15", Clock(-1, 15).toString())
+    }
+
+    @Ignore
+    @Test
+    fun negativeHourRollsOver() {
+        assertEquals("23:00", Clock(-25, 0).toString())
+    }
+
+    @Ignore
+    @Test
+    fun negativeHourRollsOverContinuously() {
+        assertEquals("05:00", Clock(-91, 0).toString())
+    }
+
+    @Ignore
+    @Test
+    fun negativeMinutes() {
+        assertEquals("00:20", Clock(1, -40).toString())
+    }
+
+    @Ignore
+    @Test
+    fun negativeMinutesRollOver() {
+        assertEquals("22:20", Clock(1, -160).toString())
+    }
+
+    @Ignore
+    @Test
+    fun negativeMinutesRollOverContinuously() {
+        assertEquals("16:40", Clock(1, -4820).toString())
+    }
+
+    @Ignore
+    @Test
+    fun negativeHourAndMinutesBothRollOver() {
+        assertEquals("20:20", Clock(-25, -160).toString())
+    }
+
+    @Ignore
+    @Test
+    fun negativeHourAndMinutesBothRollOverContinuously() {
+        assertEquals("22:10", Clock(-121, -5810).toString())
+    }
+
+}

kotlin/clock/src/test/kotlin/ClockEqualTest.kt

@@ -0,0 +1,101 @@
+import org.junit.Ignore
+import org.junit.Test
+import kotlin.test.assertNotEquals
+import kotlin.test.assertEquals
+
+/*
+ * version: 1.0.1
+ */
+class ClockEqualTest {
+
+    @Ignore
+    @Test
+    fun clocksWithSameTimeAreEqual() {
+        assertEquals(Clock(15, 37), Clock(15, 37))
+    }
+
+    @Ignore
+    @Test
+    fun clocksAMinuteApartAreNotEqual() {
+        assertNotEquals(Clock(15, 36), Clock(15, 37))
+    }
+
+    @Ignore
+    @Test
+    fun clocksAnHourApartAreNotEqual() {
+        assertNotEquals(Clock(14, 37), Clock(15, 37))
+    }
+
+    @Ignore
+    @Test
+    fun clocksWithHourOverflow() {
+        assertEquals(Clock(10, 37), Clock(34, 37))
+    }
+
+    @Ignore
+    @Test
+    fun clocksWithHourOverflowBySeveralDays() {
+        assertEquals(Clock(3, 11), Clock(99, 11))
+    }
+
+    @Ignore
+    @Test
+    fun clocksWithNegateHour() {
+        assertEquals(Clock(22, 40), Clock(-2, 40))
+    }
+
+    @Ignore
+    @Test
+    fun clocksWithNegativeHourThatWraps() {
+        assertEquals(Clock(17, 3), Clock(-31, 3))
+    }
+
+    @Ignore
+    @Test
+    fun clocksWithNegativeHourThatWrapsMultipleTimes() {
+        assertEquals(Clock(13, 49), Clock(-83, 49))
+    }
+
+    @Ignore
+    @Test
+    fun clocksWithMinuteOverflow() {
+        assertEquals(Clock(0, 1), Clock(0, 1441))
+    }
+
+    @Ignore
+    @Test
+    fun clocksWithMinuteOverflowBySeveralDays() {
+        assertEquals(Clock(2, 2), Clock(2, 4322))
+    }
+
+    @Ignore
+    @Test
+    fun clocksWithNegativeMinutes() {
+        assertEquals(Clock(2, 40), Clock(3, -20))
+    }
+
+    @Ignore
+    @Test
+    fun clocksWithNegativeMinutesThatWraps() {
+        assertEquals(Clock(4, 10), Clock(5, -1490))
+    }
+
+    @Ignore
+    @Test
+    fun clocksWithNegativeMinutesThatWrapsMultipleTimes() {
+        assertEquals(Clock(6, 15), Clock(6, -4305))
+    }
+
+    @Ignore
+    @Test
+    fun clocksWithNegativeHoursAndMinutes() {
+        assertEquals(Clock(7, 32), Clock(-12, -268))
+    }
+
+    @Ignore
+    @Test
+    fun clocksWithNegativeHoursAndMinutesThatWrap() {
+        assertEquals(Clock(18, 7), Clock(-54, -11513))
+    }
+
+}