{"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 InputProvider inputProvider;\n private HashMap> outputs;\n private PrintStream origOut;\n private InputStream origIn;\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 origIn = System.in;\n interceptor = new Interceptor(origOut, this);\n inputProvider = new InputProvider();\n System.setOut(interceptor);// just add the interceptor\n System.setIn(inputProvider);// just add the provider\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 public void setInputs(String[] inputs)\n {\n inputProvider.setInputs(inputs);\n }\n\n public void addInput(String input)\n {\n inputProvider.addInput(input);\n }\n\n public void clearInput() throws IOException\n {\n inputProvider.clearInput();\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","Grader.java":"import java.util.*;\n\n\npublic class Grader\n{\n public static void main(String [] args)\n {\n Autograder grader = new Autograder();\n\n \n DogTester student = new DogTester();\n student.main(new String[0]);\n String output = grader.getOutput(\"DogTester\");\n String[] lines = output.split(\"\\n\");\n \n boolean status = lines.length > 1; \n grader.addTest(\"Test your work in DogTester\", status,\n \"\", \"\", \n status? \"Great!\": \"Make sure you print at least two lines in DogTester\");\n \n LoudDog stuLoud = new LoudDog(\"Jake\");\n \n grader.assertEqual(\n \"Testing LoudDog Speak\",\n stuLoud.speak(), \"BARK!\",\n \"Awesome!\", \"Make sure you override the speak method\");\n \n grader.assertEqual(\n \"Testing LoudDog toString()\",\n stuLoud.toString(), \"Jake is loud and likes to BARK!\",\n \"Excellent!\", \"Check your toString. Did you override in LoudDog?\");\n \n \n System.out.println(grader);\n }\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","InputProvider.java":"import java.io.*;\nimport java.lang.*;\nimport java.util.*;\nimport java.nio.charset.Charset;\n\n/**\n * This class provides an InputStream to mock System.in.\n * It stores its own InputStream internally, which is created from a String, or array\n * of strings, then feeds it to the running program.\n */\npublic class InputProvider extends InputStream\n{\n\n private Autograder prog;\n private InputStream input;\n\n /**\n * Setups up a provider for input.\n */\n public InputProvider()\n {\n super();\n }\n\n public void clearInput() throws IOException\n {\n this.input.reset();\n }\n\n /**\n * Creates an InputStream from the array of inputs and assigns to\n * `input`\n * @param inputStrings ArrayList\n */\n public void setInputs(String[] inputStrings)\n {\n String inputString = String.join(\"\\n\", inputStrings);\n byte b [] = inputString.getBytes(Charset.forName(\"UTF-8\"));\n input = new ByteArrayInputStream(b);\n }\n\n /**\n * Adds a single string to the InputStream.\n * Because they can't be concatenated, it copies everything over into a new\n * InputStream.\n * @param inputString String\n */\n public void addInput(String inputString)\n {\n try {\n if (input == null)\n {\n input = new ByteArrayInputStream(inputString.getBytes(Charset.forName(\"UTF-8\")));\n } \n if (input.available() > 0)\n {\n // add a newline\n inputString = \"\\n\" + inputString;\n }\n // convert input to bytebuffer in order to concat\n ByteArrayOutputStream buffer = new ByteArrayOutputStream();\n int nRead;\n byte[] data = new byte[0xFFFF];\n while ((nRead = input.read(data, 0, data.length)) != -1) {\n buffer.write(data, 0, nRead);\n }\n\n byte [] inputBytes = inputString.getBytes(Charset.forName(\"UTF-8\"));\n byte [] oldInput = buffer.toByteArray();\n byte [] newInput = new byte[oldInput.length + inputBytes.length];\n System.arraycopy(oldInput, 0, newInput, 0, oldInput.length);\n System.arraycopy(inputBytes, 0, newInput, oldInput.length, inputBytes.length);\n input = new ByteArrayInputStream(newInput);\n } catch(IOException e) {\n return;\n }\n }\n\n /**\n * The below functions are overrides of the InputStream functions.\n * These are what Scanners (or anything) use when reading from an InputStream.\n * The most commonly used one is the second, read(byte[], int, int).\n */\n @Override\n public int read() throws IOException\n {\n return this.input.read();\n }\n\n @Override\n public int read(byte[] data, int offset, int length) throws IOException\n {\n return this.input.read(data, offset, length);\n }\n\n @Override\n public int read(byte[] data) throws IOException {\n return this.input.read(data);\n }\n\n @Override\n public long skip(long bytesToSkip) throws IOException {\n return this.input.skip(bytesToSkip);\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