Nucleotide count tests and version #1142 (#1248)

* version 1.3.0 added to nucleotide-count

* tests added

* removed duplicate

* added exception throwing statement

* refactored to fit the canonical data

* Tests made more thorough

* Updated to throw Illegal ArguementException

* Remove unnecessary Tests

* Remove @Ignore

* Braces added

* Shifted checking to constructor

exercises/nucleotide-count/.meta/src/reference/java/NucleotideCounter.java

 
   NucleotideCounter(String sequence) {
     this.sequence = sequence;
+    for (char c : sequence.toCharArray()) {
+      if (isCountable(c)) {
+        throw new IllegalArgumentException(c + " is not a nucleotide");
+      }
+    }
   }
 
   int count(char base) {
-    if (isCountable(base))
+    if (isCountable(base)) {
       throw new IllegalArgumentException(base + " is not a nucleotide");
+    }
 
     try {
       return nucleotideCounts().get(base);

exercises/nucleotide-count/.meta/version

+1.3.0

exercises/nucleotide-count/src/test/java/NucleotideCounterTest.java

     public ExpectedException expectedException = ExpectedException.none();
 
     @Test
-    public void testEmptyDnaStringHasNoAdenine() {
-        NucleotideCounter nucleotideCounter = new NucleotideCounter("");
-        assertThat(nucleotideCounter.count('A'), is(0));
-    }
-
-    @Ignore("Remove to run test")
-    @Test
     public void testEmptyDnaStringHasNoNucleotides() {
         NucleotideCounter nucleotideCounter = new NucleotideCounter("");
         Map<Character, Integer> counts = nucleotideCounter.nucleotideCounts();
-        assertThat(counts.size(), is(4));
         assertThat(counts, allOf(
                 hasEntry('A', 0),
                 hasEntry('C', 0),
 
     @Ignore("Remove to run test")
     @Test
-    public void testRepetitiveCytosineGetsCounted() {
-        NucleotideCounter nucleotideCounter = new NucleotideCounter("CCCCC");
-        assertThat(nucleotideCounter.count('C'), is(5));
-    }
-
-    @Ignore("Remove to run test")
-    @Test
-    public void testRepetitiveSequenceWithOnlyGuanine() {
-        NucleotideCounter nucleotideCounter = new NucleotideCounter("GGGGGGGG");
+    public void testDnaStringHasOneNucleotide() {
+        NucleotideCounter nucleotideCounter = new NucleotideCounter("G");
         Map<Character, Integer> counts = nucleotideCounter.nucleotideCounts();
-        assertThat(counts.size(), is(4));
         assertThat(counts, allOf(
                 hasEntry('A', 0),
                 hasEntry('C', 0),
-                hasEntry('G', 8),
+                hasEntry('G', 1),
                 hasEntry('T', 0)
         ));
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testCountsOnlyThymine() {
-        NucleotideCounter nucleotideCounter = new NucleotideCounter("GGGGGTAACCCGG");
-        assertThat(nucleotideCounter.count('T'), is(1));
-    }
-
-    @Ignore("Remove to run test")
-    @Test
-    public void testCountsANucleotideOnlyOnce() {
-        NucleotideCounter nucleotideCounter = new NucleotideCounter("CGATTGGG");
-        nucleotideCounter.count('T');
-        assertThat(nucleotideCounter.count('T'), is(2));
-    }
-
-    @Ignore("Remove to run test")
-    @Test
-    public void testDnaCountsDoNotChangeAfterCountingAdenine() {
-        NucleotideCounter nucleotideCounter = new NucleotideCounter("GATTACA");
-        nucleotideCounter.count('A');
+    public void testRepetitiveSequenceWithOnlyGuanine() {
+        NucleotideCounter nucleotideCounter = new NucleotideCounter("GGGGGGG");
         Map<Character, Integer> counts = nucleotideCounter.nucleotideCounts();
-        assertThat(counts.size(), is(4));
         assertThat(counts, allOf(
-                hasEntry('A', 3),
-                hasEntry('C', 1),
-                hasEntry('G', 1),
-                hasEntry('T', 2)
+                hasEntry('A', 0),
+                hasEntry('C', 0),
+                hasEntry('G', 7),
+                hasEntry('T', 0)
         ));
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testValidatesNucleotides() {
-        expectedException.expect(IllegalArgumentException.class);
-        NucleotideCounter nucleotideCounter = new NucleotideCounter("GACT");
-        nucleotideCounter.count('X');
-    }
-
-    @Ignore("Remove to run test")
-    @Test
-    public void testCountsAllNucleotides() {
-        String s = "AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC";
-        NucleotideCounter nucleotideCounter = new NucleotideCounter(s);
+    public void testDnaStringHasMultipleNucleotide() {
+        NucleotideCounter nucleotideCounter
+            = new NucleotideCounter("AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC");
         Map<Character, Integer> counts = nucleotideCounter.nucleotideCounts();
-        assertThat(counts.size(), is(4));
         assertThat(counts, allOf(
                 hasEntry('A', 20),
                 hasEntry('C', 12),
                 hasEntry('T', 21)
         ));
     }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testDnaStringHasInvalidNucleotides() {
+        expectedException.expect(IllegalArgumentException.class);
+        NucleotideCounter nucleotideCounter = new NucleotideCounter("AGXXACT");
+    }
 }