This one took less time I guess.

Answers.md

@@ -0,0 +1,6 @@
+#Andrew Reed
+## Scoreboard Lab
+
+**Question 1:** With more than one score being entered, it would be necessary to first create the scoreboard, input values of scores, then check that all the scores entered exist in `Scoreboard` as well as checking if they appear in the correct order. There should be 3 tests then, one adding them in accending order, one in decreasing order, and one in a mixed order.
+
+**Question 2:** In order to test the corrections of a full scoreboard, we must create a scoreboard with a certain max size. We then must add scores until the scoreboard is full, and also passed. Then we must check to see that only the highest scores stay. We must also check to see that there aren't more scores in `Scoreboard` than specified as the maximum amount of enteries. There will need to be 4 tests, one for accending order of scores, one for a decending order, one for neither accending or decending, and one for multiple of the same score entries.

src/Scoreboard.java

@@ -5,17 +5,61 @@ public class Scoreboard {
   private int maxCount;
 
   public Scoreboard(int maxScoreCount) {
-    scores = new ArrayList<>(maxScoreCount);
+    scores = new ArrayList<Integer>(maxScoreCount);
     maxCount = maxScoreCount;
   }
 
   public void addScore(int score) {
+    int scoreSize1 = scores.size();
+
+    if (scores.size() == 0)
+    {
+      scores.add(score);
+    }
+
+
+    for (int i = 0; i < scores.size(); i++)
+    {
+      if (score > scores.get(i))
+      {
+        scores.add(i, score);
+        if (scores.size() == maxCount + 1)
+        {
+          scores.remove(maxCount);
+        }
+        return;
+      }
+    }
+
+    int scoreSize2 = scores.size();
+
+    if (scoreSize2 == scoreSize1)
+    {
     scores.add(score);
+    }
+
+    if (scores.size() == maxCount + 1)
+    {
+      scores.remove(maxCount);
+    }
   }
 
   public boolean isHighScore(int score) {
+    boolean isTrue = false;
+
+    if (scores.size() == 0 && score == 0)
+    {
+      isTrue = true;
+    }
 
-    return true;
+    for (int i = 0; i < scores.size(); i++)
+    {
+      if (score == scores.get(i))
+      {
+       isTrue = true;
+      }
+    }
+    return isTrue;
   }
 
   public int getScore(int position) {
@@ -29,5 +73,5 @@ public int getScore(int position) {
 
   public int getNumScores() {
     return scores.size();
-  }
+    }
 }

src/ScoreboardTest.java

@@ -4,7 +4,7 @@ public class ScoreboardTest extends TestCase {
   public void testEmptyScoreboard() {
     Scoreboard sb = new Scoreboard(10);
 
-    assertTrue(sb.isHighScore(10));
+    assertTrue(sb.isHighScore(0));
     assertEquals(0, sb.getScore(0));
     assertEquals(0, sb.getNumScores());
   }
@@ -14,8 +14,212 @@ public void testOneEntry() {
 
     sb.addScore(50);
 
-    assertTrue(sb.isHighScore(10));
+    assertTrue(sb.isHighScore(50));
     assertEquals(50, sb.getScore(0));
     assertEquals(1, sb.getNumScores());
   }
+
+  public void testSecondScoreBeforeFirst()
+  {
+    Scoreboard sb = new Scoreboard(10);
+
+
+    sb.addScore(40);
+    sb.addScore(50);
+
+    assertTrue(sb.isHighScore(40));
+    assertTrue(sb.isHighScore(50));
+    assertEquals(50, sb.getScore(0));
+    assertEquals(40, sb.getScore(1));
+  }
+
+  public void testSecondScoreAfterFrist()
+  {
+    Scoreboard sb = new Scoreboard(10);
+
+    sb.addScore(40);
+    sb.addScore(30);
+
+    assertTrue(sb.isHighScore(40));
+    assertTrue(sb.isHighScore(30));
+    assertEquals(40, sb.getScore(0));
+    assertEquals(30, sb.getScore(1));
+  }
+
+
+  public void testMultipleScoresAccending()
+  {
+    Scoreboard sb = new Scoreboard(10);
+
+    sb.addScore(10);
+    sb.addScore(20);
+    sb.addScore(30);
+    sb.addScore(40);
+    sb.addScore(50);
+
+    assertTrue(sb.isHighScore(10));
+    assertTrue(sb.isHighScore(20));
+    assertTrue(sb.isHighScore(30));
+    assertTrue(sb.isHighScore(40));
+    assertTrue(sb.isHighScore(50));
+
+    assertEquals(50, sb.getScore(0));
+    assertEquals(40, sb.getScore(1));
+    assertEquals(30, sb.getScore(2));
+    assertEquals(20, sb.getScore(3));
+    assertEquals(10, sb.getScore(4));
+  } 
+
+  public void testMultipleScoresDeccending()
+    {
+    Scoreboard sb = new Scoreboard(10);
+
+    sb.addScore(50);
+    sb.addScore(40);
+    sb.addScore(30);
+    sb.addScore(20);
+    sb.addScore(10);
+
+    assertTrue(sb.isHighScore(10));
+    assertTrue(sb.isHighScore(20));
+    assertTrue(sb.isHighScore(30));
+    assertTrue(sb.isHighScore(40));
+    assertTrue(sb.isHighScore(50));
+
+    assertEquals(50, sb.getScore(0));
+    assertEquals(40, sb.getScore(1));
+    assertEquals(30, sb.getScore(2));
+    assertEquals(20, sb.getScore(3));
+    assertEquals(10, sb.getScore(4));
+  } 
+
+  public void testMultipleScoresMixed()
+    {
+    Scoreboard sb = new Scoreboard(10);
+
+    sb.addScore(10);
+    sb.addScore(30);
+    sb.addScore(50);
+    sb.addScore(40);
+    sb.addScore(20);
+
+    assertTrue(sb.isHighScore(10));
+    assertTrue(sb.isHighScore(20));
+    assertTrue(sb.isHighScore(30));
+    assertTrue(sb.isHighScore(40));
+    assertTrue(sb.isHighScore(50));
+
+    assertEquals(50, sb.getScore(0));
+    assertEquals(40, sb.getScore(1));
+    assertEquals(30, sb.getScore(2));
+    assertEquals(20, sb.getScore(3));
+    assertEquals(10, sb.getScore(4));
+  }
+
+  public void testFullDeccending()
+  {
+    Scoreboard sb = new Scoreboard(5);
+
+    sb.addScore(60);
+    sb.addScore(50);
+    sb.addScore(40);
+    sb.addScore(30);
+    sb.addScore(20);
+    sb.addScore(10);
+
+    assertFalse(sb.isHighScore(10));
+    assertTrue(sb.isHighScore(20));
+    assertTrue(sb.isHighScore(30));
+    assertTrue(sb.isHighScore(40));
+    assertTrue(sb.isHighScore(50));
+    assertTrue(sb.isHighScore(60));
+
+    assertEquals(60, sb.getScore(0));
+    assertEquals(50, sb.getScore(1));
+    assertEquals(40, sb.getScore(2));
+    assertEquals(30, sb.getScore(3));
+    assertEquals(20, sb.getScore(4));
+
+    assertEquals(5, sb.getNumScores());
+  } 
+
+  public void testFullAscending()
+  {
+    Scoreboard sb = new Scoreboard(5);
+
+    sb.addScore(10);
+    sb.addScore(20);
+    sb.addScore(30);
+    sb.addScore(40);
+    sb.addScore(50);
+    sb.addScore(60);
+
+    assertFalse(sb.isHighScore(10));
+    assertTrue(sb.isHighScore(20));
+    assertTrue(sb.isHighScore(30));
+    assertTrue(sb.isHighScore(40));
+    assertTrue(sb.isHighScore(50));
+    assertTrue(sb.isHighScore(60));
+
+    assertEquals(60, sb.getScore(0));
+    assertEquals(50, sb.getScore(1));
+    assertEquals(40, sb.getScore(2));
+    assertEquals(30, sb.getScore(3));
+    assertEquals(20, sb.getScore(4));
+
+    assertEquals(5, sb.getNumScores());
+  } 
+
+  public void testFullMixed()
+  {
+    Scoreboard sb = new Scoreboard(5);
+
+    sb.addScore(10);
+    sb.addScore(40);
+    sb.addScore(30);
+    sb.addScore(60);
+    sb.addScore(50);
+    sb.addScore(20);
+
+    assertFalse(sb.isHighScore(10));
+    assertTrue(sb.isHighScore(20));
+    assertTrue(sb.isHighScore(30));
+    assertTrue(sb.isHighScore(40));
+    assertTrue(sb.isHighScore(50));
+    assertTrue(sb.isHighScore(60));
+
+    assertEquals(60, sb.getScore(0));
+    assertEquals(50, sb.getScore(1));
+    assertEquals(40, sb.getScore(2));
+    assertEquals(30, sb.getScore(3));
+    assertEquals(20, sb.getScore(4));
+
+    assertEquals(5, sb.getNumScores());
+  } 
+
+  public void testFullSameVal()
+  {
+    Scoreboard sb = new Scoreboard(5);
+
+    sb.addScore(10);
+    sb.addScore(20);
+    sb.addScore(20);
+    sb.addScore(20);
+    sb.addScore(30);
+    sb.addScore(20);
+    sb.addScore(20);
+
+    assertFalse(sb.isHighScore(10));
+    assertTrue(sb.isHighScore(20));
+    assertTrue(sb.isHighScore(30));
+
+    assertEquals(30, sb.getScore(0));
+    assertEquals(20, sb.getScore(1));
+    assertEquals(20, sb.getScore(2));
+    assertEquals(20, sb.getScore(3));
+    assertEquals(20, sb.getScore(4));
+
+    assertEquals(5, sb.getNumScores());
+  } 
 }
+