Clock: add to track (#260)

* dibs: I will implement exercise Clock

* Implemented clock exercise

config.json

@@ -58,6 +58,7 @@
     "sublist",
     "rectangles",
     "matrix",
+    "clock",
     "diamond",
     "secret-handshake",
     "flatten-array"
@@ -334,6 +335,11 @@
       "topics": []
     },
     {
+      "slug": "clock",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
       "slug": "diamond",
       "difficulty": 1,
       "topics": []

exercises/clock/build.gradle

@@ -0,0 +1,17 @@
+apply plugin: "java"
+apply plugin: "eclipse"
+apply plugin: "idea"
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    testCompile "junit:junit:4.12"
+}
+test {
+    testLogging {
+        exceptionFormat = 'full'
+        events = ["passed", "failed", "skipped"]
+    }
+}

exercises/clock/src/example/java/Clock.java

@@ -0,0 +1,49 @@
+public class Clock {
+    private static final int MINUTES_IN_AN_HOUR = 60;
+    private static final int HOURS_IN_A_DAY = 24;
+
+    private int hours;
+    private int minutes;
+
+    public Clock(int hours, int minutes) {
+        this.hours = hours;
+        this.minutes = minutes;
+        sanitiseTime();
+    }
+
+    public void add(int minutes) {
+        this.minutes += minutes;
+        sanitiseTime();
+    }
+
+    private void sanitiseTime() {
+        while (minutes < 0) {
+            minutes += MINUTES_IN_AN_HOUR;
+            hours--;
+        }
+        while (hours < 0) {
+            hours += HOURS_IN_A_DAY;
+        }
+        int minutesOverflow = minutes / MINUTES_IN_AN_HOUR;
+        minutes = minutes % MINUTES_IN_AN_HOUR;
+        hours = (hours + minutesOverflow) % HOURS_IN_A_DAY;
+    }
+
+    @Override
+    public String toString() {
+        return toTimeString(hours) + ":" + toTimeString(minutes);
+    }
+
+    private String toTimeString(int number) {
+        if (number < 10) return "0" + number;
+        return String.valueOf(number);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (!(obj instanceof Clock)) return false;
+
+        Clock clock = (Clock) obj;
+        return hours == clock.hours && minutes == clock.minutes;
+    }
+}

exercises/clock/src/test/java/ClockAddTest.java

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

exercises/clock/src/test/java/ClockCreationTest.java

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

exercises/clock/src/test/java/ClockEqualTest.java

@@ -0,0 +1,98 @@
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public class ClockEqualTest {
+
+    @Ignore
+    @Test
+    public void clocksWithSameTimeAreEqual() {
+        assertTrue(new Clock(15, 37).equals(new Clock(15, 37)));
+    }
+
+    @Ignore
+    @Test
+    public void clocksAMinuteApartAreNotEqual() {
+        assertFalse(new Clock(15, 36).equals(new Clock(15, 37)));
+    }
+
+    @Ignore
+    @Test
+    public void clocksAnHourApartAreNotEqual() {
+        assertFalse(new Clock(14, 37).equals(new Clock(15, 37)));
+    }
+
+    @Ignore
+    @Test
+    public void clocksWithHourOverflow() {
+        assertTrue(new Clock(10, 37).equals(new Clock(34, 37)));
+    }
+
+    @Ignore
+    @Test
+    public void clocksWithHourOverflowBySeveralDays() {
+        assertTrue(new Clock(3, 11).equals(new Clock(99, 11)));
+    }
+
+    @Ignore
+    @Test
+    public void clocksWithNegateHour() {
+        assertTrue(new Clock(22, 40).equals(new Clock(-2, 40)));
+    }
+
+    @Ignore
+    @Test
+    public void clocksWithNegativeHourThatWraps() {
+        assertTrue(new Clock(17, 3).equals(new Clock(-31, 3)));
+    }
+
+    @Ignore
+    @Test
+    public void clocksWithNegativeHourThatWrapsMultipleTimes() {
+        assertTrue(new Clock(13, 49).equals(new Clock(-83, 49)));
+    }
+
+    @Ignore
+    @Test
+    public void clocksWithMinuteOverflow() {
+        assertTrue(new Clock(0, 1).equals(new Clock(0, 1441)));
+    }
+
+    @Ignore
+    @Test
+    public void clocksWithMinuteOverflowBySeveralDays() {
+        assertTrue(new Clock(2, 2).equals(new Clock(2, 4322)));
+    }
+
+    @Ignore
+    @Test
+    public void clocksWithNegativeMinutes() {
+        assertTrue(new Clock(2, 40).equals(new Clock(3, -20)));
+    }
+
+    @Ignore
+    @Test
+    public void clocksWithNegativeMinutesThatWraps() {
+        assertTrue(new Clock(4, 10).equals(new Clock(5, -1490)));
+    }
+
+    @Ignore
+    @Test
+    public void clocksWithNegativeMinutesThatWrapsMultipleTimes() {
+        assertTrue(new Clock(6, 15).equals(new Clock(6, -4305)));
+    }
+
+    @Ignore
+    @Test
+    public void clocksWithNegativeHoursAndMinutes() {
+        assertTrue(new Clock(7, 32).equals(new Clock(-12, -268)));
+    }
+
+    @Ignore
+    @Test
+    public void clocksWithNegativeHoursAndMinutesThatWrap() {
+        assertTrue(new Clock(18, 7).equals(new Clock(-54, -11513)));
+    }
+}

exercises/settings.gradle

@@ -10,6 +10,7 @@ include 'binary-search'
 include 'binary-search-tree'
 include 'bob'
 include 'bracket-push'
+include 'clock'
 include 'crypto-square'
 include 'custom-set'
 include 'diamond'