From 620cafefff925b77d6dadff5843bd8fc300351d6 Mon Sep 17 00:00:00 2001 From: Anthony Date: Sat, 12 Aug 2017 14:42:31 -0400 Subject: [PATCH] Kotlin - Completed Clock --- kotlin/clock/README.md | 16 ++ kotlin/clock/build.gradle | 28 ++++ kotlin/clock/src/main/kotlin/Clock.kt | 24 ++- kotlin/clock/src/test/kotlin/ClockAddTest.kt | 138 ++++++++++++++++++ .../src/test/kotlin/ClockCreationTest.kt | 123 ++++++++++++++++ .../clock/src/test/kotlin/ClockEqualTest.kt | 101 +++++++++++++ 6 files changed, 424 insertions(+), 6 deletions(-) create mode 100644 kotlin/clock/README.md create mode 100644 kotlin/clock/build.gradle create mode 100644 kotlin/clock/src/test/kotlin/ClockAddTest.kt create mode 100644 kotlin/clock/src/test/kotlin/ClockCreationTest.kt create mode 100644 kotlin/clock/src/test/kotlin/ClockEqualTest.kt diff --git a/kotlin/clock/README.md b/kotlin/clock/README.md new file mode 100644 index 0000000..29877b3 --- /dev/null +++ b/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. diff --git a/kotlin/clock/build.gradle b/kotlin/clock/build.gradle new file mode 100644 index 0000000..16c36c0 --- /dev/null +++ b/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"] + } +} diff --git a/kotlin/clock/src/main/kotlin/Clock.kt b/kotlin/clock/src/main/kotlin/Clock.kt index 6e2faa8..92c1561 100644 --- a/kotlin/clock/src/main/kotlin/Clock.kt +++ b/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"}}" } -} \ No newline at end of file +} diff --git a/kotlin/clock/src/test/kotlin/ClockAddTest.kt b/kotlin/clock/src/test/kotlin/ClockAddTest.kt new file mode 100644 index 0000000..fd3a3e2 --- /dev/null +++ b/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()) + } + +} \ No newline at end of file diff --git a/kotlin/clock/src/test/kotlin/ClockCreationTest.kt b/kotlin/clock/src/test/kotlin/ClockCreationTest.kt new file mode 100644 index 0000000..e9c2200 --- /dev/null +++ b/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()) + } + +} \ No newline at end of file diff --git a/kotlin/clock/src/test/kotlin/ClockEqualTest.kt b/kotlin/clock/src/test/kotlin/ClockEqualTest.kt new file mode 100644 index 0000000..87ac35b --- /dev/null +++ b/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)) + } + +} \ No newline at end of file