Merge pull request #699 from FridaTveit/NucleotideCountRenameClasses

nucleotide-count: rename classes

POLICIES.md

 
 | Track Event | Policies to review |
 |:------------|:-----------------|
-| Exercise added/updated | [Prefer instance methods](#prefer-instance-methods); [Avoid using final](#avoid-using-final); [Adhere to best practices](#adhere-to-best-practices); [Starter implementations](#starter-implementations); [Ignore noninitial tests](#ignore-noninitial-tests); [Multiple file submissions](#multiple-file-submissions) |
+| Exercise added/updated | [Prefer instance methods](#prefer-instance-methods); [Avoid using final](#avoid-using-final); [Adhere to best practices](#adhere-to-best-practices); [Starter implementations](#starter-implementations); [Ignore noninitial tests](#ignore-noninitial-tests); [Multiple file submissions](#multiple-file-submissions); [Name test class after class under test](#name-test-class-after-class-under-test)
 | Track rearranged | [Starter implementations](#starter-implementations); [Multiple file submissions](#multiple-file-submissions) |
 | New issue observed in track | [Good first patches](#good-first-patches) |
 | "Good first patch" issue completed | [Good first patches](#good-first-patches) |
 > The Installing Java instructions should seek to minimize the number of steps and the number of concepts a new-to-the-track practitioner needs to learn to get to coding.
 
 References: [[1](https://github.com/exercism/java/issues/395#issue-215734887)]
+
+### Name test class after class under test
+
+> If you're testing a class called `SomeClassName` then your test class should be called `SomeClassNameTest`. 
+
+> The exception to this is if the tests are split into several test classes where each test class tests different functionality. In that case each class should be named `SomeClassNameFunctionalityTest` where `Functionality` is the name of the functionality to be tested in that class. See the [clock exercise](https://github.com/exercism/java/tree/master/exercises/clock) as an example.
+
+References: [[1](https://github.com/exercism/java/issues/697)]

exercises/nucleotide-count/src/example/java/DNA.java → exercises/nucleotide-count/src/example/java/NucleotideCounter.java

 import java.util.HashMap;
 import java.util.Map;
 
-public final class DNA {
+final class NucleotideCounter {
   private final String sequence;
 
-  public DNA(String sequence) {
+  NucleotideCounter(String sequence) {
     this.sequence = sequence;
   }
 
-  public int count(char base) {
+  int count(char base) {
     if (isCountable(base))
       throw new IllegalArgumentException(base + " is not a nucleotide");
 
     return COUNTABLE_NUCLEOTIDES.indexOf(base) == -1;
   }
 
-  public Map<Character, Integer> nucleotideCounts() {
+  Map<Character, Integer> nucleotideCounts() {
     Map<Character, Integer> counts = emptyCounts();
     for (char c : sequence.toCharArray()) {
       counts.put(c, counts.get(c) + 1);

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

 import static org.hamcrest.Matchers.*;
 import static org.junit.Assert.*;
 
-public class NucleotideTest {
+public class NucleotideCounterTest {
 
     @Rule
     public ExpectedException expectedException = ExpectedException.none();
 
     @Test
     public void testEmptyDnaStringHasNoAdenine() {
-        DNA dna = new DNA("");
-        assertThat(dna.count('A'), is(0));
+        NucleotideCounter nucleotideCounter = new NucleotideCounter("");
+        assertThat(nucleotideCounter.count('A'), is(0));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testEmptyDnaStringHasNoNucleotides() {
-        DNA dna = new DNA("");
-        Map<Character, Integer> counts = dna.nucleotideCounts();
+        NucleotideCounter nucleotideCounter = new NucleotideCounter("");
+        Map<Character, Integer> counts = nucleotideCounter.nucleotideCounts();
         assertThat(counts.size(), is(4));
         assertThat(counts, allOf(
                 hasEntry('A', 0),
     @Ignore("Remove to run test")
     @Test
     public void testRepetitiveCytosineGetsCounted() {
-        DNA dna = new DNA("CCCCC");
-        assertThat(dna.count('C'), is(5));
+        NucleotideCounter nucleotideCounter = new NucleotideCounter("CCCCC");
+        assertThat(nucleotideCounter.count('C'), is(5));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testRepetitiveSequenceWithOnlyGuanine() {
-        DNA dna = new DNA("GGGGGGGG");
-        Map<Character, Integer> counts = dna.nucleotideCounts();
+        NucleotideCounter nucleotideCounter = new NucleotideCounter("GGGGGGGG");
+        Map<Character, Integer> counts = nucleotideCounter.nucleotideCounts();
         assertThat(counts.size(), is(4));
         assertThat(counts, allOf(
                 hasEntry('A', 0),
     @Ignore("Remove to run test")
     @Test
     public void testCountsOnlyThymine() {
-        DNA dna = new DNA("GGGGGTAACCCGG");
-        assertThat(dna.count('T'), is(1));
+        NucleotideCounter nucleotideCounter = new NucleotideCounter("GGGGGTAACCCGG");
+        assertThat(nucleotideCounter.count('T'), is(1));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testCountsANucleotideOnlyOnce() {
-        DNA dna = new DNA("CGATTGGG");
-        dna.count('T');
-        assertThat(dna.count('T'), is(2));
+        NucleotideCounter nucleotideCounter = new NucleotideCounter("CGATTGGG");
+        nucleotideCounter.count('T');
+        assertThat(nucleotideCounter.count('T'), is(2));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testDnaCountsDoNotChangeAfterCountingAdenine() {
-        DNA dna = new DNA("GATTACA");
-        dna.count('A');
-        Map<Character, Integer> counts = dna.nucleotideCounts();
+        NucleotideCounter nucleotideCounter = new NucleotideCounter("GATTACA");
+        nucleotideCounter.count('A');
+        Map<Character, Integer> counts = nucleotideCounter.nucleotideCounts();
         assertThat(counts.size(), is(4));
         assertThat(counts, allOf(
                 hasEntry('A', 3),
     @Test
     public void testValidatesNucleotides() {
         expectedException.expect(IllegalArgumentException.class);
-        DNA dna = new DNA("GACT");
-        dna.count('X');
+        NucleotideCounter nucleotideCounter = new NucleotideCounter("GACT");
+        nucleotideCounter.count('X');
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testCountsAllNucleotides() {
         String s = "AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC";
-        DNA dna = new DNA(s);
-        Map<Character, Integer> counts = dna.nucleotideCounts();
+        NucleotideCounter nucleotideCounter = new NucleotideCounter(s);
+        Map<Character, Integer> counts = nucleotideCounter.nucleotideCounts();
         assertThat(counts.size(), is(4));
         assertThat(counts, allOf(
                 hasEntry('A', 20),