ElectionManagerTester.java

//////////////// FILE HEADER (INCLUDE IN EVERY FILE) //////////////////////////
//
// Title:    ElectionManager
// Course:   CS 300 Fall 2024
//
// Author:   Matthew Suri
// Email:    mssuri@wisc.edu
// Lecturer: Blerina Gkotse
//
//////////////////// PAIR PROGRAMMERS COMPLETE THIS SECTION ///////////////////
// 
// Partner Name:    (name of your pair programming partner)
// Partner Email:   (email address of your programming partner)
// Partner Lecturer's Name: (name of your partner's lecturer)
// 
// VERIFY THE FOLLOWING BY PLACING AN X NEXT TO EACH TRUE STATEMENT:
//   ___ Write-up states that pair programming is allowed for this assignment.
//   ___ We have both read and understand the course Pair Programming Policy.
//   ___ We have registered our team prior to the team registration deadline.
//
//////////////////////// ASSISTANCE/HELP CITATIONS ////////////////////////////
//
// Persons:         N/A
// Online Sources:  https://docs.oracle.com/en/java/ 
//
///////////////////////////////////////////////////////////////////////////////

import java.util.Arrays;

/**
 * This is a class that tests the methods in ElectionManager
 */
public class ElectionManagerTester {
  
  // CONTAINS TESTS:

    /**
   * Tests the ElectionManager.containsCandidate method to ensure it correctly handles
   * an empty candidate list and returns false when no candidates are present.
   * 
   * This test method sets up an empty candidate list and verifies that the containsCandidate 
   * method returns false when attempting to find a candidate in the empty list. It also 
   * ensures that the candidate list is not modified during the process.
   * 
   * @return true if the method behaves as expected (returns false and does not modify 
   *         the array), otherwise false.
   */
  public static boolean testContainsEmpty() {
    // (1a) Set up the test variables
    String[][] candidateList = {null, null, null, null, null, null};
    String[][] candidateCopy = Arrays.copyOf(candidateList, candidateList.length);
    int size = 0;
    String targetName = "Wooper";
    String targetParty = "Water";
    boolean expected = false;
    
    // (1b) call the method we are testing
    boolean actual = ElectionManager.containsCandidate(candidateList, size, targetName, targetParty);
    
    // (2) verify that the expected method return value and the actual return value match
    if (expected != actual) return false;

    // (3) since THIS method should not modify the array, check it against a copy we made
    if (!Arrays.deepEquals(candidateList, candidateCopy)) return false;

    // (4) if we have not yet returned false, we can now return true as all tests have passed!
    return true;
  }
  
    /**
   * Tests the ElectionManager.containsCandidate method to ensure it correctly returns false 
   * when the candidate is not present in the provided candidate list.
   * 
   * This test method sets up a candidate list with valid entries and verifies that the 
   * containsCandidate method does not mistakenly find a candidate that isn't in the list.
   * The method also ensures that the candidate list is not modified during the process.
   * 
   * @return true if the method behaves as expected (returns false and does not modify 
   *         the array), otherwise false.
   */
  public static boolean testDoesNotContain() {
    
    // (1a) set up the test variables
    String[][] candidateList = {
      {"Slowpoke", "Water", "3"},
      {"Squirtle", "Water", "127"},
      {"Wooper", "Water", "300"},
      null, null, null};
    String[][] candidateCopy = Arrays.copyOf(candidateList, candidateList.length);
    int size = 3;
    String targetName = "Goldeen";
    String targetParty = "Water";
    boolean expected = false;

    // (1b) call the method we are testing
    boolean actual = ElectionManager.containsCandidate(candidateList, size, targetName, targetParty);
    
    // (2) verify that the expected method return value and the actual return value match
    if (expected != actual) return false;

    // (3) since THIS method should not modify the array, check it against a copy we made
    if (!Arrays.deepEquals(candidateList, candidateCopy)) return false;

    // (4) if we have not yet returned false, we can now return true as all tests have passed!
    return true;
  }
  
  /**
   * PROVIDED TESTER METHOD: example test method for verifying whether a candidate has
   * already been added to the race.
   * 
   * NOTE: This method ONLY tests scenarios where the candidate IS PRESENT in the list;
   * situations where the candidate is not present or the list is empty should be
   * tested in the other contains tester methods.
   * 
   * @return false if any of the scenarios we test have results other than what we expect;
   * true ONLY if all of our expectations are met by the method we are testing
   */
  public static boolean testDoesContain() { 
    
    // (1a) set up the test variables
    String[][] candidateList = {
        {"Slowpoke", "Water", "3"},
        {"Squirtle", "Water", "127"},
        {"Wooper", "Water", "300"},
        null, null, null};
    String[][] candidateCopy = Arrays.copyOf(candidateList, candidateList.length);
    int size = 3;
    String targetName = "Wooper";
    String targetParty = "Water";
    boolean expected = true;
    
    // (1b) call the method we are testing
    boolean actual = ElectionManager.containsCandidate(candidateList, size, targetName, targetParty);
    
    // (2) verify that the expected method return value and the actual return value match
    if (expected != actual) return false;
    
    // (3) since THIS method should not modify the array, check it against a copy we made
    if (!Arrays.deepEquals(candidateList, candidateCopy)) return false;
    
    // (4) if we have not yet returned false, we can now return true as all tests have passed!
    return true;
    
  }

  // ADD CANDIDATE TESTS:
  
    /**
   * Tests the ElectionManager.addCandidate method to ensure that it correctly adds a new candidate 
   * to an empty candidate list.
   * 
   * This test method sets up an empty candidate list and verifies that the addCandidate method 
   * properly adds a new candidate to the list, updates the list size, and ensures the new candidate 
   * is placed in the correct position. It also checks that the candidate list is updated correctly 
   * to reflect the added candidate.
   * 
   * @return true if the method behaves as expected (adds the candidate, updates the size, and 
   *         modifies the array correctly), otherwise false.
   */
  public static boolean testAddToEmpty() {
    
    // (1a) set up the test variables
    String[][] candidateList = {null, null, null, null, null, null};
    String newName = "Goldeen";
    String newParty = "Water";
    int newVotes = 5;
    String[][] expectedList = {{"Goldeen", "Water", "5"}, null, null, null, null, null};
    int size = 0;
    int expected = 1;

    // (1b) call the method we are testing
    int actual = ElectionManager.addCandidate(candidateList, size, newName, newParty, newVotes);

    // (2) verify that the expected method return value and the actual return value match
    if (expected != actual) return false;

    // (3) since THIS method should not modify the array, check it against a copy we made
    if (!Arrays.deepEquals(candidateList, expectedList)) return false;

    // (4) if we have not yet returned false, we can now return true as all tests have passed!
    return true;
  }
  
  /**
   * PROVIDED TESTER METHOD: example test method for verifying whether a new candidate has
   * been added correctly to the race.
   * 
   * @return false if any of the scenarios we test have results other than what we expect;
   * true ONLY if all of our expectations are met by the method we are testing
   */
  public static boolean testAddToNonEmpty() {
    
    // (1a) set up the test variables
    String[][] candidateList = {
        {"Slowpoke", "Water", "3"},
        {"Squirtle", "Water", "127"},
        {"Wooper", "Water", "300"},
        null, null, null};
    String newName = "Goldeen";
    String newParty = "Water";
    int newVotes = 5;
    String[][] expectedList = {
        {"Goldeen", "Water", "5"}, // alphabetically first, new candidate will be added here
        {"Slowpoke", "Water", "3"},
        {"Squirtle", "Water", "127"},
        {"Wooper", "Water", "300"},
        null, null};  // now only TWO null values in this length-6 array!
    int size = 3;
    int expected = 4;
    
    // (1b) call the method we are testing
    int actual = ElectionManager.addCandidate(candidateList, size, newName, newParty, newVotes);

    // (2) verify that the expected method return value and the actual return value match
    if (expected != actual) return false;

    // (3) this method modifies the input array; verify that it was modified correctly
    if (!Arrays.deepEquals(candidateList, expectedList)) return false;

    // (4) if we have not yet returned false, we can now return true as all tests have passed!
    return true;
  }
  
    /**
   * Tests the ElectionManager.addCandidate method to ensure that it handles invalid inputs, 
   * specifically negative vote counts, without modifying the candidate list.
   * 
   * This test method sets up a valid candidate list and attempts to add a new candidate with 
   * a negative vote count. The test verifies that the addCandidate method correctly rejects 
   * the candidate, does not modify the candidate list, and returns the appropriate list size.
   * 
   * @return true if the method behaves as expected (rejects the invalid candidate, does not modify 
   *         the array, and returns the correct list size), otherwise false.
   */
  public static boolean testAddCandidateErrors() {
     
    // (1a) set up the test variables
    String[][] candidateList = {
      {"Slowpoke", "Water", "3"},
      {"Squirtle", "Water", "127"},
      {"Wooper", "Water", "300"},
      null, null, null};
    String newName = "Goldeen";
    String newParty = "Water";
    int newVotes = -5;
    String[][] expectedList = {
      {"Slowpoke", "Water", "3"},
      {"Squirtle", "Water", "127"},
      {"Wooper", "Water", "300"},
      null, null, null};
    int size = 3;
    int expected = 3;
    
    // (1b) call the method we are testing
    int actual = ElectionManager.addCandidate(candidateList, size, newName, newParty, newVotes);

    // (2) verify that the expected method return value and the actual return value match
    if (expected != actual) return false;

    // (3) this method modifies the input array; verify that it was modified correctly
    if (!Arrays.deepEquals(candidateList, expectedList)) return false;

    // (4) if we have not yet returned false, we can now return true as all tests have passed!
    return true;
  }
  
    /**
   * Tests the ElectionManager.addCandidate method to ensure that it correctly handles the 
   * scenario where the candidate list is already full and does not add a new candidate.
   * 
   * This test method sets up a full candidate list and attempts to add a new candidate. 
   * The test verifies that the addCandidate method does not add the new candidate, does not 
   * modify the candidate list, and returns the appropriate list size.
   * 
   * @return true if the method behaves as expected (does not add the new candidate, does not 
   *         modify the array, and returns the correct list size), otherwise false.
   */
  public static boolean testAddToFull() {
    
    // (1a) set up the test variables
    String[][] candidateList = {
      {"Slowpoke", "Water", "3"},
      {"Squirtle", "Water", "127"},
      {"Wooper", "Water", "300"} };
    String newName = "Goldeen";
    String newParty = "Water";
    int newVotes = 5;
    String[][] expectedList = {
      {"Slowpoke", "Water", "3"},
      {"Squirtle", "Water", "127"},
      {"Wooper", "Water", "300"} };
    int size = 3;
    int expected = 3;
    
    // (1b) call the method we are testing
    int actual = ElectionManager.addCandidate(candidateList, size, newName, newParty, newVotes);

    // (2) verify that the expected method return value and the actual return value match
    if (expected != actual) return false;

    // (3) this method modifies the input array; verify that it was modified correctly
    if (!Arrays.deepEquals(candidateList, expectedList)) return false;

    // (4) if we have not yet returned false, we can now return true as all tests have passed!
    return true;
  }
  
  // DROP CANDIDATE TESTS:

    /**
   * Tests the ElectionManager.dropCandidate method to ensure that it correctly removes the only 
   * candidate from the list and updates the list size to zero.
   * 
   * This test method sets up a candidate list with only one candidate and verifies that the 
   * dropCandidate method removes that candidate, updates the candidate list to be empty, 
   * and returns the correct list size.
   * 
   * @return true if the method behaves as expected (removes the only candidate, modifies the 
   *         array correctly, and returns the updated list size), otherwise false.
   */  
  public static boolean testDropOnlyCandidate() {

    // (1a) set up the test variables
    String[][] candidateList = {
      {"Slowpoke", "Water", "3"},
      null, null, null};
    String[][] expectedList = {null, null, null, null};
    String name = "Slowpoke";
    String party = "Water";
    int size = 1;
    int expected = 0;
  
    // (1b) call the method we are testing
    int actual = ElectionManager.dropCandidate(candidateList, size, name, party);

    // (2) verify that the expected method return value and the actual return value match
    if (expected != actual) return false;
    
    // (3) this method modifies the input array; verify that it was modified correctly
    if (!Arrays.deepEquals(candidateList, expectedList)) return false;
    
    // (4) if we have not yet returned false, we can now return true as all tests have passed!
    return true;
  }
  
  /**
 * Tests the ElectionManager.dropCandidate method to ensure that it correctly removes 
 * the first candidate from the list and shifts the remaining candidates accordingly.
 * 
 * This test method sets up a candidate list with three candidates and verifies that 
 * the dropCandidate method correctly removes the first candidate, shifts the remaining 
 * candidates up in the list, and returns the updated list size. The method also checks 
 * that the candidate list is modified correctly.
 * 
 * @return true if the method behaves as expected (removes the first candidate, shifts 
 *         the remaining candidates, and updates the list size), otherwise false.
 */
  public static boolean testDropFirstCandidate() {
      
    // (1a) set up the test variables
    String[][] candidateList = {
      {"Slowpoke", "Water", "3"},
      {"Squirtle", "Water", "127"},
      {"Wooper", "Water", "300"},
      null, null, null};
    String[][] expectedList = {
      {"Squirtle", "Water", "127"},
      {"Wooper", "Water", "300"},
      null, null, null, null};
    String name = "Slowpoke";
    String party = "Water";

    int size = 3;
    int expected = 2;
    
    // (1b) call the method we are testing
    int actual = ElectionManager.dropCandidate(candidateList, size, name, party);
    
    // (2) verify that the expected method return value and the actual return value match
    if (expected != actual) return false;
    
    // (2a) sometimes you may want to REPEAT the process with slightly different variables:
    
    if (expected != actual) return false;
    
    // (3) this scenario should NOT modify the input array; check it against a copy we made
    if (!Arrays.deepEquals(candidateList, expectedList)) return false;
    
    // (4) if we have not yet returned false, we can now return true as all tests have passed!
    return true;

  }
  
  /**
   * PROVIDED TESTER METHOD: example test method for verifying whether trying to drop a
   * candidate who is not running in the race correctly has NO effect on the candidate list.
   * 
   * @return false if any of the scenarios we test have results other than what we expect;
   * true ONLY if all of our expectations are met by the method we are testing
   */
  public static boolean testDropCandidateNotRunning() {
    
    // (1a) set up the test variables
    String[][] candidateList = {
        {"Slowpoke", "Water", "3"},
        {"Squirtle", "Water", "127"},
        {"Wooper", "Water", "300"},
        null, null, null};
    String[][] candidateCopy = Arrays.copyOf(candidateList, candidateList.length);
    String name = "Goldeen";
    String party = "Water";
    int size = 3;
    int expected = 3;
    
    // (1b) call the method we are testing
    int actual =
        ElectionManager.dropCandidate(candidateList, size, name, party);
    
    // (2) verify that the expected method return value and the actual return value match
    if (expected != actual) return false;
    
    // (2a) sometimes you may want to REPEAT the process with slightly different variables:
    name = "Slowpoke";
    party = "Fire"; // try with a name that's present but a different PARTY; should still not drop
    actual = ElectionManager.dropCandidate(candidateList, size, name, party);
    if (expected != actual) return false;
    
    // (3) this scenario should NOT modify the input array; check it against a copy we made
    if (!Arrays.deepEquals(candidateList, candidateCopy)) return false;
    
    // (4) if we have not yet returned false, we can now return true as all tests have passed!
    return true;
    
  }
  
  // FIND WINNER TESTS:
  
    /**
   * Tests the ElectionManager.findWinner method to ensure that it correctly identifies 
   * the winner in an uncontested election where there is only one candidate.
   * 
   * This test method sets up a candidate list with only one candidate and verifies that 
   * the findWinner method correctly returns the winner's name, party, and vote percentage. 
   * It also checks that the format of the result is correct and that the percentage 
   * is calculated accurately. The method ensures that the candidate list is not modified 
   * during the process.
   * 
   * @return true if the method behaves as expected (returns the correct winner, with proper 
   *         formatting and percentage calculation, and does not modify the array), otherwise false.
   */
  public static boolean testUncontestedWinner() {
    // (1a) set up the test variables
    String[][] candidateList = {
      {"Slowpoke", "Water", "3"},
      null, null, null};  
    String[][] candidateCopy = Arrays.copyOf(candidateList, candidateList.length);
    String expectedName = "Slowpoke";
    String expectedParty = "(Water)";
    double expectedVotePct = 3/3.0*100;
    int size = 1;
    
    // (1b) call the method we are testing
    String result = ElectionManager.findWinner(candidateList, size);
        
    // (2) verify that the expected method return value and the actual return value match
    // NOTE: for a String, this takes a little more processing to do sensitively.
    // We expect this result to be "Wooper (Water) - 75.0%" but there may be some weirdness
    // especially with that percentage. See how we do it here:
    
    String[] resultPieces = result.split(" "); // get the space-separated pieces of the string
    
    if (resultPieces.length != 4) return false; // incorrect formatting
    if (!resultPieces[3].endsWith("%")) return false; // no % at the end
    
    if (!resultPieces[0].equals(expectedName) || !resultPieces[1].equals(expectedParty))
      return false; // wrong name or wrong party
    
    if (!resultPieces[2].equals("-")) return false; // forgot the "-" between party and %
    
    // do a range check on the calculated vote percentage, since it's not always going to come out
    // exactly the same:
    double actualVotePct = Double.valueOf(resultPieces[3].substring(0,resultPieces[3].length()-1));
    if (Math.abs(actualVotePct-expectedVotePct) > 0.01) return false;
    
    // (3) this scenario should NOT modify the input array; check it against a copy we made
    if (!Arrays.deepEquals(candidateList, candidateCopy)) return false;
    
    // (4) if we have not yet returned false, we can now return true as all tests have passed!
    return true;
  }
  
  /**
   * PROVIDED TESTER METHOD: example test method for verifying the results of an election
   * where one candidate has received a clear majority of the votes cast.
   * 
   * @return false if any of the scenarios we test have results other than what we expect;
   * true ONLY if all of our expectations are met by the method we are testing
   */
  public static boolean testClearWinner() {
    
    // (1a) set up the test variables
    String[][] candidateList = {
        {"Slowpoke", "Water", "3"},
        {"Squirtle", "Water", "97"},
        {"Wooper", "Water", "300"},
        null, null, null};
    String[][] candidateCopy = Arrays.copyOf(candidateList, candidateList.length);
    String expectedName = "Wooper";
    String expectedParty = "(Water)";
    double expectedVotePct = 300.0/(300+97+3)*100;
    int size = 3;
    
    // (1b) call the method we are testing
    String result = ElectionManager.findWinner(candidateList, size);
        
    // (2) verify that the expected method return value and the actual return value match
    // NOTE: for a String, this takes a little more processing to do sensitively.
    // We expect this result to be "Wooper (Water) - 75.0%" but there may be some weirdness
    // especially with that percentage. See how we do it here:
    
    String[] resultPieces = result.split(" "); // get the space-separated pieces of the string
    
    if (resultPieces.length != 4) return false; // incorrect formatting
    if (!resultPieces[3].endsWith("%")) return false; // no % at the end
    
    if (!resultPieces[0].equals(expectedName) || !resultPieces[1].equals(expectedParty))
      return false; // wrong name or wrong party
    
    if (!resultPieces[2].equals("-")) return false; // forgot the "-" between party and %
    
    // do a range check on the calculated vote percentage, since it's not always going to come out
    // exactly the same:
    double actualVotePct = Double.valueOf(resultPieces[3].substring(0,resultPieces[3].length()-1));
    if (Math.abs(actualVotePct-expectedVotePct) > 0.01) return false;
    
    // (3) this scenario should NOT modify the input array; check it against a copy we made
    if (!Arrays.deepEquals(candidateList, candidateCopy)) return false;
    
    // (4) if we have not yet returned false, we can now return true as all tests have passed!
    return true;
    
  }
  
    /**
   * Tests the ElectionManager.findWinner method to ensure that it correctly identifies 
   * a contingent election, where no candidate receives more than 50% of the votes.
   * 
   * This test method sets up a candidate list where no candidate has a majority of votes 
   * and verifies that the findWinner method returns "CONTINGENT" to indicate that no clear 
   * winner was found. The test also checks that the candidate list is not modified during 
   * the process.
   * 
   * @return true if the method behaves as expected (returns "CONTINGENT" and does not 
   *         modify the array), otherwise false.
   */
  public static boolean testContingentElection() {
    // (1a) set up the test variables
    String[][] candidateList = {
      {"Slowpoke", "Water", "150"},
      {"Squirtle", "Water", "75"},
      {"Wooper", "Water", "175"},
      null, null, null};
    int size = 3;
    String[][] candidateCopy = Arrays.copyOf(candidateList, candidateList.length);
    String expected = "CONTINGENT";
    
    // (1b) call the method we are testing
    String result = ElectionManager.findWinner(candidateList, size);
        
    // (2) verify that the expected method return value and the actual return value match
    if (result != expected) return false;
    
    // (3) this scenario should NOT modify the input array; check it against a copy we made
    if (!Arrays.deepEquals(candidateList, candidateCopy)) return false;
    
    // (4) if we have not yet returned false, we can now return true as all tests have passed!
    return true;
    
  }
  
  // FIND LOWEST-POLLING TESTS:
  
    /**
   * Tests the ElectionManager.findLowestPollingCandidate method to ensure that it correctly 
   * identifies an uncontested election, where there are no candidates, and returns "UNCONTESTED".
   * 
   * This test method sets up an empty candidate list and verifies that the findLowestPollingCandidate 
   * method returns "UNCONTESTED" when there are no candidates in the election. The test also 
   * checks that the candidate list is not modified during the process.
   * 
   * @return true if the method behaves as expected (returns "UNCONTESTED" and does not modify 
   *         the array), otherwise false.
   */
  public static boolean testUncontestedLowestPolling() {
    
    // (1a) set up the test variables
    String[][] candidateList = {null, null, null, null, null, null};
    int size = 0;
    String[][] candidateCopy = Arrays.copyOf(candidateList, candidateList.length);
    String expected = "UNCONTESTED";

    // (1b) call the method we are testing
    String result = ElectionManager.findLowestPollingCandidate(candidateList, size);

    // (2) verify that the expected method return value and the actual return value match
    if (result != expected) return false;

    // (3) this scenario should NOT modify the input array; check it against a copy we made
    if (!Arrays.deepEquals(candidateList, candidateCopy)) return false;

    // (4) if we have not yet returned false, we can now return true as all tests have passed!
    return true;
  }
  
  /**
   * Tests the ElectionManager.findLowestPollingCandidate method to ensure that it correctly 
   * identifies the candidate with the lowest unique vote count.
   * 
   * This test method sets up a candidate list where one candidate has a distinct lowest vote count 
   * and verifies that the findLowestPollingCandidate method correctly returns that candidate's name, 
   * party, and vote count. The method also checks that the format of the result is correct and 
   * that the vote count, name, and party are as expected.
   * 
   * @return true if the method behaves as expected (returns the correct candidate with the lowest 
   *         unique vote count, formatted correctly), otherwise false.
   */
  public static boolean testLowestUniqueVoteCount() {
    
    // (1a) set up the test variables
    String[][] candidateList = {
      {"Slowpoke", "Water", "150"},
      {"Squirtle", "Water", "75"},
      {"Wooper", "Water", "175"},
      null, null, null};
    int size = 3;
    String[][] candidateCopy = Arrays.copyOf(candidateList, candidateList.length);
    String expectedName = "Squirtle";
    String expectedParty = "(Water)";
    int expectedVotes = 75;

    // (1b) call the method we are testing
    String result = ElectionManager.findLowestPollingCandidate(candidateList, size);

    String[] resultPieces = result.split(" "); // (2a) get the space-separated pieces of the string
    
    if (resultPieces.length != 4) return false; // (2b) incorrect formatting

    if (!resultPieces[3].endsWith(Integer.toString(expectedVotes))) return false; // (2c) wrong votes
      
    if (!resultPieces[0].equals(expectedName) || !resultPieces[1].equals(expectedParty)) return false; // (2d) wrong name or wrong party
      
    if (!resultPieces[2].equals("-")) return false; // (2f) forgot the "-" 

    // (4) if we have not yet returned false, we can now return true as all tests have passed!
    return true;
  }

    /**
   * Tests the ElectionManager.findLowestPollingCandidate method to ensure that it correctly 
   * identifies the lowest polling candidate when multiple candidates have the same vote count.
   * 
   * This test method sets up a candidate list where all candidates have the same number of votes 
   * and verifies that the findLowestPollingCandidate method correctly returns the first candidate 
   * with the lowest vote count. It also checks that the format of the result is correct and that 
   * the vote count, name, and party are as expected.
   * 
   * @return true if the method behaves as expected (returns the correct candidate with the 
   *         lowest vote count, formatted correctly), otherwise false.
   */
  public static boolean testLowestVoteCountTied() {
    
    // (1a) set up the test variables
    String[][] candidateList = {
      {"Slowpoke", "Water", "75"},
      {"Squirtle", "Water", "75"},
      {"Wooper", "Water", "75"},
      null, null, null};
    int size = 3;
    String expectedName = "Slowpoke";
    String expectedParty = "(Water)";
    int expectedVotes = 75;
  
    
    // (1b) call the method we are testing
    String result = ElectionManager.findLowestPollingCandidate(candidateList, size);


    String[] resultPieces = result.split(" "); // (2a) get the space-separated pieces of the string
    
    if (resultPieces.length != 4) return false; // (2b) incorrect formatting

    if (!resultPieces[3].endsWith(Integer.toString(expectedVotes))) return false; // (2c) wrong votes
      
    if (!resultPieces[0].equals(expectedName) || !resultPieces[1].equals(expectedParty)) return false; // (2d) wrong name or wrong party
      
    if (!resultPieces[2].equals("-")) return false; // (2e) forgot the "-" 

    // if we have not yet returned false, we can now return true as all tests have passed!
    return true;
  }

  /**
   * PROVIDED MAIN METHOD to manage the tester methods above.
   * 
   * We're getting a little esoteric here to take advantage of loops to keep the code short;
   * each pass through the loop could also be written as follows:
   * 
   *   boolean singleTest = testMethodCall();
   *   allPass &= singleTest;
   *   System.out.println("testMethodCall : " + singleTest);
   * 
   * @throws NoSuchMethodException if you spell a method name incorrectly
   * 
   * And a couple of other "checked" exceptions that should never happen with our usage here:
   * @throws IllegalAccessException
   * @throws java.lang.reflect.InvocationTargetException
   */
  public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, 
    java.lang.reflect.InvocationTargetException {
    boolean allPass = true, singlePass = true;
    String printFormat = "%-29s: %s\n";
    
    // NOTE TO STUDENTS: If you create any additional tests for any of the methods in
    // ElectionManager, add their names to the appropriate array below!
    String[] containsTests = {"testContainsEmpty", "testDoesNotContain", "testDoesContain"};
    String[] addTests = {"testAddToEmpty", "testAddToNonEmpty", "testAddCandidateErrors",
        "testAddToFull"};
    String[] dropTests = {"testDropOnlyCandidate", "testDropFirstCandidate", 
        "testDropCandidateNotRunning"};
    String[] winTests = {"testUncontestedWinner", "testClearWinner", "testContingentElection"};
    String[] lowTests = {"testUncontestedLowestPolling", "testLowestUniqueVoteCount", 
        "testLowestVoteCountTied"};
    
    String[][] testNames = {containsTests, addTests, dropTests, winTests, lowTests};
    
    // NOTE TO STUDENTS: this for-loop is moving through the method names we've added to the 2D 
    // array testNames and attempting to call methods with those names from this tester
    // (specifically line 286 here). See Java's reflection framework for more details!
    for (String[] testSet : testNames) {
      for (String name : testSet) {
        singlePass = (boolean) ElectionManagerTester.class.getDeclaredMethod(name).invoke(null);
        allPass &= singlePass;
        System.out.printf(printFormat, name, singlePass);
      }
      System.out.println();
    }
 
    System.out.println("ALL TESTS: "+allPass);

  }

}