{"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/**\n * You can write autograded tests here.\n * Test format:\n * * Autograder grader = new Autograder();\n * grader.assertEqual(String testName, T studentOutput,\n * T solutionOutput, String messagePass, String messageFail)\n * Alternative test format:\n * * boolean test = false;\n * grader.addTest(String testName, boolean testStatus,\n * T studentOutput, T solutionOutput, String message);\n * \n * The autograder will automatically track and store all output from println and\n * print. This can be done with the following Autograder functions:\n * * grader.getOutput(String className);\n * grader.getOutputArrayList(String className);\n * \n * You can set the inputs that will be used on System.in. You need to do this\n * before each .main() call, and if you may need to clear them after using .clearInput().\n * This is in case the student's code doesn't consume all input. If you use\n * .setInputs() after, it overwrites and you're fine.\n * * MyProgram p1;\n * p1 = new MyProgram();\n * grader.setInputs(String[] inputs);\n * p1.main(new String[0]);\n * Solution p2;\n * p2 = new Solution();\n * grader.setInputs(String[] inputs);\n * p1.main(new String[0]);\n * \n * Something of note, files in the autograder will overwrite files of the\n * same name in the student code. This can be useful if you want an alterantive\n * version of the master code for a particular file.\n * \n * You can find some example tests in the code below.\n * See documentation for further information.\n */\npublic class Grader\n{\n public static void main(String [] args)\n {\n Autograder grader = new Autograder();\n \n // Create a student object. No solution object will be used\n // as the coede is pretty basic and the output may not match due\n // to different memory locations.\n \n TestEquals student = new TestEquals();\n student.main(new String[0]);\n \n String studentOutput = grader.getOutput(\"TestEquals\");\n \n // Split the student code on the *** Ball *** part\n \n int ballLoc = studentOutput.indexOf(\"** Ball **\");\n \n // If ballLoc == -1, student changed code. Fail one test and\n // don't run the others.\n \n if (ballLoc == -1) {\n grader.addTest(\"Checking the Starter Code\",\n false, \"\", \"** Ball **\", \n \"Make sure you leave the ** Object ** and ** Ball ** markers in the code\");\n } else {\n String studentObj = studentOutput.substring(0,ballLoc);\n String studentBall = studentOutput.substring(ballLoc);\n \n // Count true/false in each half\n int trueObj = returnCount(studentObj, \"true\");\n int falseObj = returnCount(studentObj, \"false\");\n int trueBall = returnCount(studentBall, \"true\");\n int falseBall = returnCount(studentBall, \"false\");\n \n // Count object prints\n int objPrint = returnCount(studentObj, \"java.lang.Object\");\n \n // Count ball prints\n int ballPrint = returnCount(studentBall, \"Ball@\");\n \n \n // Test 1 - Test for 3 object prints\n grader.assertEqual(\"Testing that you printed 3 objects\",\n objPrint, 3, \"Great!\", \"Make sure you print each object one time.\");\n \n // Test 2,3 - Test fort true and false statements\n grader.assertEqual(\"Testing that you printed 2 true statements\",\n trueObj, 2, \"Good Job!\", \n \"Make sure you print 2 true statements for the Objects.\");\n \n grader.assertEqual(\"Testing that you printed 2 false statements\",\n falseObj, 2, \"Good Job!\", \n \"Make sure you print 2 false statements for the Objects.\");\n \n // Test 4 - Test for 3 Ball prints\n grader.assertEqual(\"Testing that you printed 3 Ball Objects\",\n ballPrint, 3, \"Great!\", \"Make sure you print each Ball one time.\");\n \n // Test 5,6 - Test fort true and false statements\n grader.assertEqual(\"Testing that you printed 2 true statements\",\n trueBall, 2, \"Good Job!\", \n \"Make sure you print 2 true statements for the Ball.\");\n \n grader.assertEqual(\"Testing that you printed 2 false statements\",\n falseBall, 2, \"Good Job!\", \n \"Make sure you print 2 false statements for the Ball.\");\n\n }\n \n System.out.println(grader);\n }\n \n private static int returnCount(String phrase, String word){\n int count = 0;\n while (true) {\n int wordLoc = phrase.indexOf(word);\n if (wordLoc == -1) break;\n count ++;\n phrase = phrase.substring(wordLoc + 1);\n }\n return count;\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