Merge branch 'master' into change

.travis.yml

@@ -3,6 +3,14 @@ language: java
 jdk:
   - oraclejdk8
 
+notifications:
+  webhooks:
+    urls:
+      - https://webhooks.gitter.im/e/5e9ccd41111917b19478
+    on_success: change  # options: [always|never|change] default: always
+    on_failure: always  # options: [always|never|change] default: always
+    on_start: never     # options: [always|never|change] default: always
+
 # http://docs.travis-ci.com/user/migrating-from-legacy
 sudo: false
 cache: bundler

README.md

@@ -1,4 +1,4 @@
-# xJava [![Build Status](https://travis-ci.org/exercism/xjava.svg?branch=master)](https://travis-ci.org/exercism/xjava)
+# xJava [![Build Status](https://travis-ci.org/exercism/xjava.svg?branch=master)](https://travis-ci.org/exercism/xjava) [![Join the chat at https://gitter.im/exercism/xjava](https://badges.gitter.im/exercism/xjava.svg)](https://gitter.im/exercism/xjava?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
 Source for Exercism Exercises in Java.
 

config.json

@@ -58,6 +58,7 @@
     "sublist",
     "rectangles",
     "matrix",
+    "clock",
     "diamond",
     "secret-handshake",
     "flatten-array",
@@ -335,6 +336,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/grade-school/build.gradle

@@ -7,6 +7,7 @@ repositories {
 }
 
 dependencies {
+  testCompile group: 'org.hamcrest', name: 'hamcrest-library', version: '1.3'
   testCompile "junit:junit:4.12"
 }
 test {

exercises/grade-school/src/test/java/SchoolTest.java

@@ -1,14 +1,14 @@
 import org.junit.Ignore;
 import org.junit.Test;
 
-import java.lang.Integer;
-import java.util.*;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
+import java.util.List;
+import java.util.Collection;
 
+import org.hamcrest.Matcher;
+import org.hamcrest.collection.IsIterableContainingInOrder;
 import static org.hamcrest.CoreMatchers.*;
 import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
@@ -62,29 +62,27 @@ public class SchoolTest {
 
   @Ignore
   @Test
-  public void gradeReturnsStudentsInTheOrderTheyWereInserted() {
-    int grade = 4;
-    school.add("Bartimaeus", grade);
-    school.add("Nathaniel", grade);
-    school.add("Faquarl", grade);
-    List<String> studentsInGrade = school.grade(grade);
-    assertThat(studentsInGrade.get(0), is("Bartimaeus"));
-    assertThat(studentsInGrade.get(1), is("Nathaniel"));
-    assertThat(studentsInGrade.get(2), is("Faquarl"));
-  }
-
-  @Ignore
-  @Test
   public void sortsSchool() {
+    school.add("Kyle", 4);
+    school.add("Zed", 4);
+    school.add("Adam", 4);
     school.add("Jennifer", 4);
     school.add("Kareem", 6);
     school.add("Christopher", 4);
-    school.add("Kyle", 3);
-    Map<Integer, List<String>> sortedStudents = new HashMap<Integer, List<String>>();
-    sortedStudents.put(6, Arrays.asList("Kareem"));
-    sortedStudents.put(4, Arrays.asList("Christopher", "Jennifer"));
-    sortedStudents.put(3, Arrays.asList("Kyle"));
-    assertEquals(school.studentsByGradeAlphabetical(), sortedStudents);
+    school.add("Kylie", 3);
+    Map<Integer, Matcher> sortedStudents = new HashMap<Integer, Matcher>();
+    sortedStudents.put(6, IsIterableContainingInOrder
+      .contains("Kareem"));
+    sortedStudents.put(4, IsIterableContainingInOrder
+      .contains("Adam", "Christopher", "Jennifer", "Kyle", "Zed"));
+    sortedStudents.put(3, IsIterableContainingInOrder
+      .contains("Kylie"));
+
+    Map schoolStudents = school.studentsByGradeAlphabetical();
+    for (Map.Entry<?, Matcher> entry : sortedStudents.entrySet()) {
+
+      assertThat((Collection) schoolStudents.get(entry.getKey()), entry.getValue());
+    }
   }
 
   @Ignore
@@ -93,8 +91,14 @@ public class SchoolTest {
     String shouldNotBeAdded = "Should not be added to school";
     int grade = 1;
 
-    List<String> students = school.grade(grade);
-    students.add(shouldNotBeAdded);
+    Collection students = school.grade(grade);
+
+    try {
+      students.add(shouldNotBeAdded);
+    } catch (Exception exception) {
+      // Also valid that the add operation throws an exception
+      // Such as UnsupportedOperationException when an umodifiable collection type is used
+    }
 
     assertThat(school.grade(grade), not(hasItem(shouldNotBeAdded)));
   }
@@ -107,9 +111,16 @@ public class SchoolTest {
     List<String> listWhichShouldNotBeAdded = new ArrayList<>();
     listWhichShouldNotBeAdded.add(studentWhichShouldNotBeAdded);
 
-    Map<Integer, List<String>> sortedStudents = school.studentsByGradeAlphabetical();
-    sortedStudents.put(grade,listWhichShouldNotBeAdded);
+    Map sortedStudents = school.studentsByGradeAlphabetical();
+
+    try {
+      sortedStudents.put(grade, listWhichShouldNotBeAdded);
+    } catch (Exception exception) {
+      // Also valid that the put operation throws an exception
+      // Such as UnsupportedOperationException when an unmodifiableMap is used
+    }
 
-    assertThat(school.studentsByGradeAlphabetical().get(grade), not(hasItem(studentWhichShouldNotBeAdded)));
+    assertThat(school.studentsByGradeAlphabetical().get(grade), 
+      not(hasItem(studentWhichShouldNotBeAdded)));
   }
 }

exercises/settings.gradle

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