Issue #253: grade school improvements (#271)

* Issue #253: Tried to improve grade school structure. Removed .db() function, added numberOfStudents functions and renamed the sort function to studentsByGradeAlphabetical. Added test to check that grade() gets the students in the order they were inserted. Removed getsStudentsInAGrade() test as what it was testing was already being covered by the tests before it.

* Added tests for protection agains mutation of the list object

* Issue #253: Make the sort test more generic. This to allow a broader range of implementations. Currently users are hindered into return the type HashMap<Integer, List<String>. This test update will check the order of any Map that maps to any Collection value type. This opens the doors for more possible types of solutions.

exercises/grade-school/build.gradle

 }
 
 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

 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;
 
   @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
     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)));
   }
     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)));
   }
 }