{"Autograder.java":"import java.io.*;\nimport java.lang.*;\nimport java.util.*;\n\nimport org.json.*;\n\npublic class Autograder\n{\n\n /**\n * Necessary private fields for the Autograder class.\n */\n private Interceptor interceptor;\n private HashMap> outputs;\n private PrintStream origOut;\n\n /**\n * Autograders contain the main logic for autograding and are used by\n * Grader.java\n */\n public Autograder()\n {\n tests = new ArrayList();\n outputs = new HashMap>();\n origOut = System.out;\n interceptor = new Interceptor(origOut, this);\n System.setOut(interceptor);// just add the interceptor\n }\n\n /**\n * This adds a TestCase. Instead of doing the comparisons itself, it takes\n * a boolean which is the result of some custom test. Also allows for any\n * custom message.\n * @param This allows for any type of output\n * @param testName Name of the test being run\n * @param status Boolean result of anything\n * @param studentOutput Student output that was tested\n * @param solutionOutput Solution output that was tested\n * @param message Message to show\n */\n public void addTest(String testName, boolean status,\n T studentOutput, T solutionOutput, String message)\n {\n tests.add(new TestCase(testName, status, message, studentOutput, solutionOutput));\n }\n\n /**\n * This will do a standard comparison between studentOutput and\n * solutionOutput. And depending on the result will create a TestCase with\n * the result and either the messagePass or messageFail\n * @param This allows for any type of output\n * @param testName Name of the test being run\n * @param studentOutput Student output to test\n * @param solutionOutput Solution output to test\n * @param messagePass Message to show if assertEqual passes\n * @param messageFail Message to show if assertEqual fails\n */\n public void assertEqual(String testName, T studentOutput,\n T solutionOutput, String messagePass, String messageFail)\n {\n String studentOutputString;\n String solutionOutputString;\n if (studentOutput == null)\n {\n studentOutputString = \"\";\n } else\n {\n studentOutputString = studentOutput.toString();\n }\n if (solutionOutput == null)\n {\n solutionOutputString = \"\";\n } else\n {\n solutionOutputString = solutionOutput.toString();\n }\n boolean success = solutionOutput.equals(studentOutput);\n String message = success ? messagePass : messageFail;\n addTest(testName, success, studentOutputString, solutionOutputString,\n message);\n }\n\n /**\n * Allows you to get the original output stream.\n * @return System.out\n */\n public PrintStream getOriginal()\n {\n return origOut;\n }\n\n /**\n * Adds an output from the Interceptor to outputs\n * @param className Name of the class the output came from\n * @param s Output string\n */\n public void addOutput(String className, String s)\n {\n ArrayList arr = outputs.get(className);\n if(arr == null)\n {\n arr = new ArrayList();\n }\n arr.add(s);\n outputs.put(className, arr);\n }\n\n /**\n * Get a string of all the outputs for a given class name.\n * @param className Name of the class to retriev output from.\n * @return Returns output for the given className as a concated string\n */\n public String getOutput(String className)\n {\n ArrayList output = outputs.get(className);\n if (output == null)\n {\n return \"You forgot to print something.\";\n }\n String outputString = \"\";\n for (String s : output)\n {\n outputString += s;\n }\n return outputString;\n }\n\n /**\n * Get an ArrayList of all outputs for a given class name.\n * @param className Name of the class to retriev output from.\n * @return Returns output for the given className as an ArrayList.\n */\n public ArrayList getOutputArrayList(String className)\n {\n ArrayList output = outputs.get(className);\n return output;\n }\n\n /**\n * This resets the current outputs. This should be used after\n * create a new test so that tests don't also test previous\n * outputs.\n */\n public void clearOutput()\n {\n outputs = new HashMap>();\n }\n\n /**\n * Similar to the method above, however, instead of clearing out all output\n * it will only clear output for a given classname. However, it only does\n * this if output exists for the class. Otherwise, it does nothing.\n * @param className Class to clear output for\n */\n public void clearOutput(String className)\n {\n ArrayList output = outputs.get(className);\n if (output != null)\n {\n ArrayList arr = new ArrayList();\n outputs.put(className, arr);\n }\n }\n\n /**\n * Used for printing the output of all test results.\n * @return string of JSON-like results\n */\n public String toString() {\n JSONObject jsonResults = new JSONObject();\n JSONArray jsonTests = new JSONArray();\n jsonResults.put(\"tests\", jsonTests);\n for (int i = 0; i < tests.size(); i++) {\n TestCase test = tests.get(i);\n JSONObject jsonTest = new JSONObject();\n jsonTest.put(\"success\", test.success);\n jsonTest.put(\"test\", test.test);\n jsonTest.put(\"message\", test.message);\n jsonTest.put(\"studentOutput\", test.studentOutput);\n jsonTest.put(\"solutionOutput\", test.solutionOutput);\n jsonTests.put(jsonTest);\n }\n return \"__unittests__\" + jsonResults.toString();\n }\n\n /**\n * Contains all created test cases.\n */\n private ArrayList tests;\n\n /**\n * Contains the results a of single test case.\n */\n class TestCase\n {\n public TestCase(String test, boolean success, String message,\n Object studentOutput, Object solutionOutput)\n {\n this.success = success;\n this.message = message;\n this.studentOutput = studentOutput;\n this.solutionOutput = solutionOutput;\n this.test = test;\n }\n\n private String message;\n private boolean success;\n private Object studentOutput;\n private Object solutionOutput;\n private String test;\n }\n}\n","ConsoleProgram.java":"import java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.Scanner;\n\npublic class ConsoleProgram\n{\n\n /**\n * Private variables for ConsoleProgram\n */\n private Scanner scanner;\n private ArrayList inputs;\n private int curInputIndex = 0;\n\n /**\n * Setups a new Scanner for System.in and the inputs variable for storring\n * inputs.\n */\n public ConsoleProgram()\n {\n scanner = new Scanner(System.in);\n inputs = new ArrayList();\n }\n\n /**\n * This is a run method for the class. It is intentionally empty as it gets\n * overwritten by the subclass.\n *\n * All code to be run by a student or user should go in the overridden run\n * method.\n */\n public void run()\n {\n }\n\n /**\n * Allows you to set all inputs at once as strings.\n * @param inputStrings Array of strings to be inputs\n */\n public void setInputs(String[] inputStrings)\n {\n inputs = new ArrayList(Arrays.asList(inputStrings));\n }\n\n /**\n * Allows you to add an input to your inputs.\n * @param s String to add\n */\n public void addInput(String s)\n {\n if (inputs == null)\n {\n inputs = new ArrayList();\n }\n inputs.add(s);\n }\n\n /**\n * ConsoleProgram can also be run as the main class. However this is not\n * necessary.\n * @param args class name to run should be the first argument\n */\n public static void main(String[] args){\n\n if(args.length == 0){\n System.out.println(\"Please provide the name of the main class as an argument.\");\n return;\n }\n\n String mainClassName = args[0];\n\n try{\n Class mainClass = Class.forName(mainClassName);\n Object obj = mainClass.newInstance();\n ConsoleProgram program = (ConsoleProgram)obj;\n program.run();\n } catch (IllegalAccessException ex) {\n System.out.println(\"Error in program. Make sure you extend ConsoleProgram\");\n } catch (InstantiationException ex) {\n System.out.println(\"Error in program. Make sure you extend ConsoleProgram\");\n } catch (ClassNotFoundException ex) {\n System.out.println(\"Error in program. Make sure you extend ConsoleProgram\");\n }\n }\n\n /**\n * This is a dual purpose function. It both allows the user to get a\n * string input, as well as, get the next input for all other readers.\n * In all cases, it will return the next input as a string, either to the\n * user or another reader.\n * @param prompt String prompt to show user\n * @return inputed string\n */\n public String readLine(String prompt){\n System.out.print(prompt);\n\n if (curInputIndex >= inputs.size())\n {\n System.out.println();\n return null;\n }\n\n String next = inputs.get(curInputIndex);\n System.out.println(next);\n curInputIndex++;\n return next;\n }\n\n /**\n * Allow the user to get a boolean.\n * @param prompt String prompt to show user\n * @return inputed boolean\n */\n public boolean readBoolean(String prompt){\n\n while(true){\n String input = readLine(prompt);\n\n if (input == null) {\n return false;\n }\n\n if(input.equalsIgnoreCase(\"true\")){\n return true;\n }\n\n if(input.equalsIgnoreCase(\"false\")){\n return false;\n }\n }\n }\n\n /**\n * Allow the user to get a double.\n * @param prompt String prompt to show user\n * @return inputed double\n */\n public double readDouble(String prompt){\n\n while(true){\n String input = readLine(prompt);\n\n if (input == null) {\n return -1.0;\n }\n\n try {\n double n = Double.valueOf(input).doubleValue();\n return n;\n } catch (NumberFormatException e){\n\n }\n }\n }\n\n /**\n * Allow the user to get an integer.\n * @param prompt String prompt to show user\n * @return inputed integer\n */\n public int readInt(String prompt){\n\n while(true){\n String input = readLine(prompt);\n\n if (input == null) {\n return -1;\n }\n\n try {\n int n = Integer.parseInt(input);\n return n;\n } catch (NumberFormatException e){\n\n }\n }\n }\n\n /**\n * Allows us to use a shorthand version for System.out.println()\n */\n public void println() {\n System.out.println();\n }\n\n /**\n * Allows us to use a shorthand version for System.out.println(String s)\n * @param s String to print\n */\n public void println(String s) {\n System.out.println(s);\n }\n\n /**\n * Allows us to use a shorthand version for System.out.println(boolean x)\n * @param x Boolean to print\n */\n public void println(boolean x) {\n System.out.println(x);\n }\n\n /**\n * Allows us to use a shorthand version for System.out.println(char x)\n * @param x Character to print\n */\n public void println(char x) {\n System.out.println(x);\n }\n\n /**\n * Allows us to use a shorthand version for System.out.println(char[] x)\n * @param x Character arry to print\n */\n public void println(char[] x) {\n System.out.println(x);\n }\n\n /**\n * Allows us to use a shorthand version for System.out.println(int x)\n * @param x Integer to print\n */\n public void println(int x) {\n System.out.println(x);\n }\n\n /**\n * Allows us to use a shorthand version for System.out.println(long x)\n * @param x Long to print\n */\n public void println(long x) {\n System.out.println(x);\n }\n\n /**\n * Allows us to use a shorthand version for System.out.println(float x)\n * @param x Float to print\n */\n public void println(float x) {\n System.out.println(x);\n }\n\n /**\n * Allows us to use a shorthand version for System.out.println(double x)\n * @param x Double to print\n */\n public void println(double x) {\n System.out.println(x);\n }\n\n /**\n * Allows us to use a shorthand version for System.out.println(Object o)\n * @param o Object to print\n */\n public void println(Object o) {\n System.out.println(o);\n }\n\n /**\n * Allows us to use a shorthand version for System.out.print()\n */\n public void print() {\n System.out.print(\"\");\n }\n\n /**\n * Allows us to use a shorthand version for System.out.print(String s)\n * @param s String to print with a new line\n */\n public void print(String s) {\n System.out.print(s);\n }\n\n /**\n * Allows us to use a shorthand version for System.out.print(boolean x)\n * @param x Boolean to print with a new line\n */\n public void print(boolean x) {\n System.out.print(x);\n }\n\n /**\n * Allows us to use a shorthand version for System.out.print(char x)\n * @param x Character to print with a new line\n */\n public void print(char x) {\n System.out.print(x);\n }\n\n /**\n * Allows us to use a shorthand version for System.out.print(char[] x)\n * @param x Character arry to print with a new line\n */\n public void print(char[] x) {\n System.out.print(x);\n }\n\n /**\n * Allows us to use a shorthand version for System.out.print(int x)\n * @param x Integer to print with a new line\n */\n public void print(int x) {\n System.out.print(x);\n }\n\n /**\n * Allows us to use a shorthand version for System.out.print(long x)\n * @param x Long to print with a new line\n */\n public void print(long x) {\n System.out.print(x);\n }\n\n /**\n * Allows us to use a shorthand version for System.out.print(float x)\n * @param x Float to print with a new line\n */\n public void print(float x) {\n System.out.print(x);\n }\n\n /**\n * Allows us to use a shorthand version for System.out.print(double x)\n * @param x Double to print with a new line\n */\n public void print(double x) {\n System.out.print(x);\n }\n\n /**\n * Allows us to use a shorthand version for System.out.print(Object o)\n * @param o Object to print with a new line\n */\n public void print(Object o) {\n System.out.print(o);\n }\n}\n","Grader.java":"/**\n * This is where autograded tests should live.\n */\nimport java.util.*;\n\npublic class Grader\n{\n public static void main(String [] args)\n {\n Autograder grader = new Autograder();\n \n // No way to test if student modified the Cat constructor\n // to accept 2 Strings as parameters before trying it here. \n // Throws a compile time error not a run time.\n \n try{\n // Test 1\n Cat studentRussianBlue = new Cat(\"Russian Blue\", \"Grey\");\n CatSolution solutionRussianBlue = new CatSolution(\"Russian Blue\", \"Grey\");\n grader.assertEqual(\"Testing a name with spaces\", studentRussianBlue.toString(),\n solutionRussianBlue.toString(), \"Great!\", \"Make sure you updated the constructor!\");\n \n // Test 2\n Cat studentSiamese = new Cat(\"Siamese\", \"Brown\");\n CatSolution solutionSiamese = new CatSolution(\"Siamese\", \"Brown\");\n grader.assertEqual(\"Testing Siamese Brown\", studentSiamese.toString(),\n solutionSiamese.toString(), \"Meow! Great Work!\", \"Not quite!\");\n \n // Test 3\n Cat studentNoName = new Cat(\"Robocat\", \"\");\n CatSolution solutionNoName = new CatSolution(\"Robocat\", \"\");\n grader.assertEqual(\"Testing the empty string name\", studentNoName.toString(),\n solutionNoName.toString(), \"Nice!\", \"Catch every edge case! new Cat(\\\"Robocat\\\", \\\"\\\"\");\n \n } catch(Exception e){\n grader.addTest(\"Testing the constructor was updated\", false, \"*Your code threw an error*\",\n \"*Your code threw an error*\", \"The constructor should take two arguments, the breed and color, in that order!\"); \n }\n \n System.out.println(grader);\n }\n}\n","CatSolution.java":"public class CatSolution \n{\n private String breed;\n private String color;\n \n public CatSolution(String theBreed, String theColor)\n {\n breed = theBreed;\n color = theColor;\n }\n \n public String toString()\n {\n return \"A \" + breed + \"cat is\" + color;\n }\n}","Interceptor.java":"import java.io.*;\nimport java.lang.*;\n\n/**\n * This class intercepts output destined for System.out so it can be tracked.\n */\npublic class Interceptor extends PrintStream\n{\n\n private Autograder prog;\n private static final int CLASS_STACK_POS = 3;\n\n /**\n * Setups up an interceptor for System.out\n * @param out The output stream being used (should be System.out)\n * @param prog The autograder that is using this Incerceptor\n */\n public Interceptor(OutputStream out, Autograder prog)\n {\n super(out, true);\n this.prog = prog;\n }\n\n /**\n * This handles the general logic for printing to System.out. Based on the\n * `newLine` boolean, we decide whether we print or add a line break. After,\n * we determine which class it came from, based on the stacktrace. If the\n * class is `ConsoleProgram`, we look one level up on the stack trace.\n * @param output The output to print to System.out and store\n * @param newLine Boolean for whether this is using print or println\n */\n private void addOutput(String output, boolean newLine)\n {\n if (newLine)\n {\n super.println(output);\n output += \"\\n\";\n } else {\n super.print(output);\n }\n StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();\n String className = stackTraceElements[CLASS_STACK_POS].getClassName();\n int stackPos = CLASS_STACK_POS;\n while (className == \"ConsoleProgram\")\n {\n stackPos += 1;\n className = stackTraceElements[stackPos].getClassName();\n }\n this.prog.addOutput(className, output);\n }\n\n /**\n * This overrides System.out.print. It prints out to System.out like normal.\n * Afterwards, it stores the output in the Autograder along with the class\n * name that is trying to print based on the stack trace (up one for\n * ConsoleProgram).\n * @param s String to be printed\n */\n @Override\n public void print(String s)\n {\n this.addOutput(s, false);\n }\n\n /**\n * This overrides System.out.print. It prints out to System.out like normal.\n * Afterwards, it stores the output in the Autograder along with the class\n * name that is trying to print based on the stack trace (up one for\n * ConsoleProgram).\n * @param x Boolean to be printed\n */\n @Override\n public void print(boolean x)\n {\n String output = Boolean.toString(x);\n this.addOutput(output, false);\n }\n\n /**\n * This overrides System.out.print. It prints out to System.out like normal.\n * Afterwards, it stores the output in the Autograder along with the class\n * name that is trying to print based on the stack trace (up one for\n * ConsoleProgram).\n * @param x Character to be printed\n */\n @Override\n public void print(char x)\n {\n String output = Character.toString(x);\n this.addOutput(output, false);\n }\n\n /**\n * This overrides System.out.print. It prints out to System.out like normal.\n * Afterwards, it stores the output in the Autograder along with the class\n * name that is trying to print based on the stack trace (up one for\n * ConsoleProgram).\n * @param x Character array to be printed\n */\n @Override\n public void print(char[] x)\n {\n String output = new String(x);\n this.addOutput(output, false);\n }\n\n /**\n * This overrides System.out.print. It prints out to System.out like normal.\n * Afterwards, it stores the output in the Autograder along with the class\n * name that is trying to print based on the stack trace (up one for\n * ConsoleProgram).\n * @param x Integer to be printed\n */\n @Override\n public void print(int x)\n {\n String output = Integer.toString(x);\n this.addOutput(output, false);\n }\n\n /**\n * This overrides System.out.print. It prints out to System.out like normal.\n * Afterwards, it stores the output in the Autograder along with the class\n * name that is trying to print based on the stack trace (up one for\n * ConsoleProgram).\n * @param x Long to be printed\n */\n @Override\n public void print(long x)\n {\n String output = Long.toString(x);\n this.addOutput(output, false);\n }\n\n /**\n * This overrides System.out.print. It prints out to System.out like normal.\n * Afterwards, it stores the output in the Autograder along with the class\n * name that is trying to print based on the stack trace (up one for\n * ConsoleProgram).\n * @param x Float to be printed\n */\n @Override\n public void print(float x)\n {\n String output = Float.toString(x);\n this.addOutput(output, false);\n }\n\n /**\n * This overrides System.out.print. It prints out to System.out like normal.\n * Afterwards, it stores the output in the Autograder along with the class\n * name that is trying to print based on the stack trace (up one for\n * ConsoleProgram).\n * @param x Double to be printed\n */\n @Override\n public void print(double x)\n {\n String output = Double.toString(x);\n this.addOutput(output, false);\n }\n\n /**\n * This overrides System.out.print. It prints out to System.out like normal.\n * Afterwards, it stores the output in the Autograder along with the class\n * name that is trying to print based on the stack trace (up one for\n * ConsoleProgram).\n * @param o Object to be printed\n */\n @Override\n public void print(Object o)\n {\n String output = o.toString();\n this.addOutput(output, false);\n }\n\n /**\n * This overrides System.out.println. It prints out to System.out like\n * normal. Afterwards, it stores the output in the Autograder along with\n * the class name that is trying to print based on the stack trace (up one\n * for ConsoleProgram).\n * @param s String to be printed\n */\n @Override\n public void println(String s)\n {\n this.addOutput(s, true);\n }\n\n /**\n * This overrides System.out.println. It prints out to System.out like\n * normal. Afterwards, it stores the output in the Autograder along with\n * the class name that is trying to print based on the stack trace (up one\n * for ConsoleProgram).\n */\n @Override\n public void println()\n {\n this.addOutput(\"\", true);\n }\n\n /**\n * This overrides System.out.println. It prints out to System.out like\n * normal. Afterwards, it stores the output in the Autograder along with\n * the class name that is trying to print based on the stack trace (up one\n * for ConsoleProgram).\n * @param x Boolean to be printed\n */\n @Override\n public void println(boolean x)\n {\n String output = Boolean.toString(x);\n this.addOutput(output, true);\n }\n\n /**\n * This overrides System.out.println. It prints out to System.out like\n * normal. Afterwards, it stores the output in the Autograder along with\n * the class name that is trying to print based on the stack trace (up one\n * for ConsoleProgram).\n * @param x Character to be printed\n */\n @Override\n public void println(char x)\n {\n String output = Character.toString(x);\n this.addOutput(output, true);\n }\n\n /**\n * This overrides System.out.println. It prints out to System.out like\n * normal. Afterwards, it stores the output in the Autograder along with\n * the class name that is trying to print based on the stack trace (up one\n * for ConsoleProgram).\n * @param x Character array to be printed\n */\n @Override\n public void println(char[] x)\n {\n String output = new String(x);\n this.addOutput(output, true);\n }\n\n /**\n * This overrides System.out.println. It prints out to System.out like\n * normal. Afterwards, it stores the output in the Autograder along with\n * the class name that is trying to print based on the stack trace (up one\n * for ConsoleProgram).\n * @param x Integer to be printed\n */\n @Override\n public void println(int x)\n {\n String output = Integer.toString(x);\n this.addOutput(output, true);\n }\n\n /**\n * This overrides System.out.println. It prints out to System.out like\n * normal. Afterwards, it stores the output in the Autograder along with\n * the class name that is trying to print based on the stack trace (up one\n * for ConsoleProgram).\n * @param x Long to be printed\n */\n @Override\n public void println(long x)\n {\n String output = Long.toString(x);\n this.addOutput(output, true);\n }\n\n /**\n * This overrides System.out.println. It prints out to System.out like\n * normal. Afterwards, it stores the output in the Autograder along with\n * the class name that is trying to print based on the stack trace (up one\n * for ConsoleProgram).\n * @param x Float to be printed\n */\n @Override\n public void println(float x)\n {\n String output = Float.toString(x);\n this.addOutput(output, true);\n }\n\n /**\n * This overrides System.out.println. It prints out to System.out like\n * normal. Afterwards, it stores the output in the Autograder along with\n * the class name that is trying to print based on the stack trace (up one\n * for ConsoleProgram).\n * @param x Double to be printed\n */\n @Override\n public void println(double x)\n {\n String output = Double.toString(x);\n this.addOutput(output, true);\n }\n\n /**\n * This overrides System.out.println. It prints out to System.out like\n * normal. Afterwards, it stores the output in the Autograder along with\n * the class name that is trying to print based on the stack trace (up one\n * for ConsoleProgram).\n * @param o Object to be printed\n */\n @Override\n public void println(Object o)\n {\n String output = o.toString();\n this.addOutput(output, true);\n }\n}\n","ObjectTracker.java":"import java.util.*;\nimport java.lang.*;\n\n/**\n * This class can be used to track other instances of classes. All that is\n * required is to have said class extend ObjectTracker. Then anytime, a instance\n * of said class is created, it will be tracked by ObjectTracker.\n */\npublic class ObjectTracker{\n\n private static HashMap> objTracker = new HashMap>();\n private static final int CALLER_INDEX = 3;\n\n /**\n * This will print out the names of all classes currently being tracked as\n * well as the class instances that are being tracked for those classes.\n */\n public static void printObjectTracker()\n {\n for(String className: objTracker.keySet())\n {\n System.out.println(\"Objects for \" + className);\n ArrayList