Comment assertions with script.

Author: codecop

java-junit/src/test/java/org/codecop/Session1_GreeterTest.java

@@ -14,19 +14,19 @@ public class Session1_GreeterTest {
     @Test
     public void shouldReturnHelloName() {
         Greeter greeter = new Greeter();
-        assertEquals("Hello Peter", greeter.greet("Peter"));
+        // TODO Check that "Hello Peter", greeter.greet("Peter").
     }
 
     @Test
     public void shouldReturnHelloForNull() {
         Greeter greeter = new Greeter();
-        assertEquals("Hello", greeter.greet(null));
+        // TODO Check that "Hello", greeter.greet(null).
     }
 
     @Test
     public void shouldIgnoreWhitespace() {
         Greeter greeter = new Greeter();
-        assertEquals("Hello Peter", greeter.greet(" Peter "));
+        // TODO Check that "Hello Peter", greeter.greet(" Peter ").
     }
 
 }

java-junit/src/test/java/org/codecop/Session2a_WordCounterTest.java

@@ -21,49 +21,49 @@ public class Session2a_WordCounterTest {
     @Test
     public void shouldCountNumberOfWords() {
         WordCounter counter = new WordCounter("Keep the bar green to keep the code clean.");
-        assertEquals(9, counter.numberOfWords());
+        // TODO Check that 9, counter.numberOfWords().
     }
 
     @Test
     public void shouldVerifyContainmentOfWord() {
         WordCounter counter = new WordCounter("green bar green hat");
-        assertTrue(counter.containsWord("bar"));
+        // TODO Check that counter.containsWord("bar").
     }
 
     @Test
     public void shouldVerifyNonContainmentOfWord() {
         WordCounter counter = new WordCounter("green hat");
-        assertFalse(counter.containsWord("red"));
+        // TODO Check that counter.containsWord("red") is false.
     }
 
     @Test
     public void shouldReturnNullForUnknownWordCount() {
         WordCounter counter = new WordCounter("green bar green hat");
-        assertNull(counter.countOf("else"));
+        // TODO Check that counter.countOf("else") is null.
     }
 
     @Test
     public void shouldReturnNotNullWordCountForExistingWord() {
         WordCounter counter = new WordCounter("green bar green hat");
-        assertNotNull(counter.countOf("green"));
+        // TODO Check that counter.countOf("green") is not null.
     }
 
     @Test
     public void shouldCountGreenTwice() {
         WordCounter counter = new WordCounter("green bar green hat");
-        assertEquals(Integer.valueOf(2), counter.countOf("green"));
+        // TODO Check that 2, counter.countOf("green").
     }
 
     @Test
     public void shouldFindUniqueWords() {
         WordCounter counter = new WordCounter("green bar green hat");
-        assertArrayEquals(new String[] { "bar", "green", "hat" }, counter.uniqueWords());
+        // TODO Check that new String[] { "bar", "green", "hat" }, counter.uniqueWords().
     }
 
     @Test
     public void shouldReturnRatioOfWords() {
         WordCounter counter = new WordCounter("green bar green");
-        assertEquals(0.33, counter.ratioOf("bar"), 0.01);
+        // TODO Check that 0.33, counter.ratioOf("bar").
         // Note that floating point numbers need an accuracy delta, e.g. 0.01.
     }
 

java-junit/src/test/java/org/codecop/Session2c_WordCounterTest.java

@@ -25,33 +25,33 @@ public class Session2c_WordCounterTest {
     @Test
     public void shouldCountNumberOfWords() {
         WordCounter counter = new WordCounter("Keep the bar green to keep the code clean.");
-        assertEquals(9, counter.numberOfWords()); // keep
+        assertEquals(9, counter.numberOfWords()); 
         // Hamcrest improves readability:
-        assertThat(counter.numberOfWords(), equalTo(9));
+        // TODO Check that counter.numberOfWords(), equalTo 9.
     }
 
     @Test
     public void shouldContainUniqueWord() {
         WordCounter counter = new WordCounter("green bar green hat");
-        assertTrue(Arrays.asList(counter.uniqueWords()).contains("bar")); // keep
+        assertTrue(Arrays.asList(counter.uniqueWords()).contains("bar")); 
         // Hamcrest improves readability:
-        assertThat(counter.uniqueWords(), hasItemInArray("bar"));
+        // TODO Check that counter.uniqueWords(), hasItemInArray "bar".
     }
 
     @Test
     public void shouldNotContainUniqueWord() {
         WordCounter counter = new WordCounter("green bar green hat");
-        assertFalse(Arrays.asList(counter.uniqueWords()).contains("foo")); // keep
+        assertFalse(Arrays.asList(counter.uniqueWords()).contains("foo")); 
         // Hamcrest improves readability:
-        assertThat(counter.uniqueWords(), not(hasItemInArray("foo")));
+        // TODO Check that counter.uniqueWords(), not hasItemInArray "foo".
     }
 
     @Test
     public void shouldFindNumberOfUniqueWords() {
         WordCounter counter = new WordCounter("green bar green hat");
-        assertEquals(3, counter.uniqueWords().length); // keep
+        assertEquals(3, counter.uniqueWords().length); 
         // Hamcrest improves readability:
-        assertThat(counter.uniqueWords(), arrayWithSize(3));
+        // TODO Check that counter.uniqueWords(), arrayWithSize 3.
     }
 
 }

java-junit/src/test/java/org/codecop/Session2d_WordCounterTest.java

@@ -23,32 +23,32 @@ public class Session2d_WordCounterTest {
     @Test
     public void shouldCountNumberOfWords() {
         WordCounter counter = new WordCounter("Keep the bar green to keep the code clean.");
-        assertEquals(9, counter.numberOfWords()); // keep
+        assertEquals(9, counter.numberOfWords()); 
         // AssertJ is fluent:
-        assertThat(counter.numberOfWords()).isEqualTo(9);
+        // TODO Check that counter.numberOfWords() isEqualTo 9.
     }
 
     @Test
     public void shouldContainUniqueWord() {
         WordCounter counter = new WordCounter("green bar green hat");
-        assertTrue(Arrays.asList(counter.uniqueWords()).contains("bar")); // keep
+        assertTrue(Arrays.asList(counter.uniqueWords()).contains("bar")); 
         // AssertJ is fluent:
-        assertThat(counter.uniqueWords()).contains("bar");
+        // TODO Check that counter.uniqueWords() contains "bar".
     }
 
     @Test
     public void shouldNotContainUniqueWord() {
         WordCounter counter = new WordCounter("green bar green hat");
-        assertFalse(Arrays.asList(counter.uniqueWords()).contains("foo")); // keep
+        assertFalse(Arrays.asList(counter.uniqueWords()).contains("foo")); 
         // AssertJ is fluent:
-        assertThat(counter.uniqueWords()).doesNotContain("foo");
+        // TODO Check that counter.uniqueWords() doesNotContain "foo".
     }
 
     @Test
     public void shouldFindNumberOfUniqueWords() {
         WordCounter counter = new WordCounter("green bar green hat");
-        assertEquals(3, counter.uniqueWords().length); // keep
+        assertEquals(3, counter.uniqueWords().length); 
         // AssertJ is fluent:
-        assertThat(counter.uniqueWords()).hasSize(3);
+        // TODO Check that counter.uniqueWords() hasSize 3.
     }
 }

java-junit/src/test/java/org/codecop/Session3_WordCounterFileTest.java

@@ -22,7 +22,7 @@ public void shouldReturnCountOfWords() throws IOException {
         StringToFile.write("Keep the bar green to keep the code clean.", file);
 
         WordCounter counter = new WordCounter(file);
-        assertEquals(9, counter.numberOfWords()); // keep
+        assertEquals(9, counter.numberOfWords()); 
 
         file.delete();
     }
@@ -34,27 +34,27 @@ public void shouldReturnCountOfWords() throws IOException {
 
     private final File testFile = new File("FileWordCounterTest.tmp");
 
-    @Before // This method should be called before each test.
+    // TODO This method should be called before each test.
     public void createFreshTestFileForEachTest() throws IOException {
         StringToFile.write("Keep the bar green to keep the code clean.", testFile);
     }
 
-    @After // This method should be called after each test.
+    // TODO This method should be called after each test.
     public void deleteTestFile() {
-        assertTrue(testFile.delete()); // keep
+        assertTrue(testFile.delete()); 
     }
 
     // TODO add the proper assertions to complete the tests.
 
     @Test
     public void shouldReturnCountOfWordsBetter() throws IOException {
         WordCounter counter = new WordCounter(testFile);
-        assertEquals(9, counter.numberOfWords());
+        // TODO Check that 9, counter.numberOfWords().
     }
 
     @Test
     public void shouldVerifyContainmentOfWord() throws IOException {
         WordCounter counter = new WordCounter(testFile);
-        assertTrue(counter.containsWord("bar"));
+        // TODO Check that counter.containsWord("bar").
     }
 }

java-junit/src/test/java/org/codecop/Session4_WordCounterFailureTest.java

@@ -16,12 +16,12 @@ public class Session4_WordCounterFailureTest {
 
     // TODO Add the needed code/annotations to test for an expected exception.
 
-    @Test(expected = IOException.class)
+    // TODO Mark this test to expect IOException.class.
     public void shouldThrowIOExceptionOnMissingFile() throws IOException {
         new WordCounter(new File("IamSureThisDoesNotExist.txt"));
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    // TODO Mark this test to expect IllegalArgumentException.class.
     public void shouldThrowIllegalArgumentExceptionForUnknownWord() {
         WordCounter counter = new WordCounter("green bar green");
         counter.ratioOf("missingWord");
@@ -31,10 +31,10 @@ public void shouldThrowIllegalArgumentExceptionForUnknownWord() {
     // but we will do that tomorrow. For today let's ignore it.
 
     @Test
-    @Ignore("work in progress, will continue tomorrow")
+    // TODO Mark this test as ignored with "work in progress, will continue tomorrow".
     public void shouldCountUniqueWordsCaseInsensitive() {
         WordCounter counter = new WordCounter("green bar Green hat");
-        assertArrayEquals(new String[] { "bar", "green", "hat" }, counter.uniqueWords()); // keep
+        assertArrayEquals(new String[] { "bar", "green", "hat" }, counter.uniqueWords()); 
     }
 
 }

java-junit/src/test/java/org/codecop/Session4b_WordCounterFailureTest.java

@@ -20,12 +20,12 @@ public class Session4b_WordCounterFailureTest {
     @Test
     public void shouldThrowIllegalArgumentExceptionWithMessageOnUnknownWord() {
         WordCounter counter = new WordCounter("green bar green");
-        verifyException(counter, IllegalArgumentException.class).ratioOf("missingWord");
+        // TODO Verify IllegalArgumentException.class is thrown from counter.ratioOf("missingWord");
 
         // Hamcrest improves readability:
-        catchException(counter).ratioOf("missingWord"); // keep
-        assertThat(caughtException(), IsInstanceOf.instanceOf(IllegalArgumentException.class));
-        assertEquals("missingWord not in sentence", caughtException().getMessage());
+        catchException(counter).ratioOf("missingWord"); 
+        // TODO Check that caughtException(), IsInstanceOf.instanceOf IllegalArgumentException.class.
+        // TODO Check that "missingWord not in sentence", caughtException().getMessage().
     }
 
 }

java-junit/src/test/java/org/codecop/Session5_WordCounterRatioTest.java

@@ -14,7 +14,7 @@
  * Session 5: WordCounterRatioTest - parameterised/table driven tests. <br />
  * @see "https://github.com/junit-team/junit/wiki/Parameterized-tests"
  */
-@RunWith(Parameterized.class) // Mark this test as parameterised
+// TODO Mark this test as parameterised
 public class Session5_WordCounterRatioTest {
 
     // TODO Add the needed annotations to run this test with all examples.
@@ -27,7 +27,7 @@ public class Session5_WordCounterRatioTest {
             new Object[] { "green bar green", "bar", 0.33 } //
             );
 
-    @Parameters(name = "ratio of '{1}' in words '{0}' should be {2}") // This method returns the parameters
+    // TODO This method returns the parameters
     public static List<Object[]> getTestCases() {
         return TEST_CASES;
     }
@@ -45,7 +45,7 @@ public Session5_WordCounterRatioTest(String sentence, String word, double expect
     @Test
     public void shouldReturnRatioOfGivenWord() {
         WordCounter counter = new WordCounter(sentence);
-        assertEquals(expectedRatio, counter.ratioOf(word), 0.01); // keep
+        assertEquals(expectedRatio, counter.ratioOf(word), 0.01); 
     }
 
 }

java-junit/src/test/java/org/codecop/Session5b_WordCounterRatioTest.java

@@ -11,26 +11,24 @@
  * Session 5b: WordCounterRatioTest - parameterised/table driven tests with JUnitParams. <br />
  * @see "https://github.com/Pragmatists/junitparams"
  */
-@RunWith(JUnitParamsRunner.class) // Mark this test as parameterised with JUnitParams
+// TODO Mark this test as parameterised with JUnitParams
 public class Session5b_WordCounterRatioTest {
 
     // TODO Add the needed annotations to run this test with all examples.
 
-    @Test // keep
+    @Test 
     // We want to test more cases for the ratio. Here is a table of test cases.
-    @Parameters( // drop
-    // use /*
+    /*
     { //
         "green, green, 1.0", //
         "green bar green, green, 0.66", //
         "green bar green bar, green, 0.5", //
         "green bar green, bar, 0.33" //
     }
-    // use */
-    ) // drop
+    */
     public void shouldReturnRatioOfGivenWord(String sentence, String word, double expectedRatio) {
         WordCounter counter = new WordCounter(sentence);
-        assertEquals(expectedRatio, counter.ratioOf(word), 0.01); // keep
+        assertEquals(expectedRatio, counter.ratioOf(word), 0.01); 
     }
 
 }