{"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","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 final double COST = 4.5;\n String[] empty = new String[0];\n String[][] tests = new String[][]{{\"3\"}, {\"5\"}, {\"10\"}, {\"100\"}};\n\n\n for(String[] test : tests){\n grader.setInputs(test); \n Discounts.main(empty);\n String output = grader.getOutput(\"Discounts\");\n String[] lines = output.trim().split(\"\\n\");\n grader.clearOutput();\n \n double amnt = Double.parseDouble(test[0]) * COST;\n String expected = amnt > 30 ? \"$\" + 30 : \"$\" + amnt;\n \n boolean status = output.contains(expected);\n grader.addTest(\"Testing \" + test[0] + \" hours\",\n status,\n output,\n \"You owe \" + expected,\n status ? \"Great!\" : \"Make sure the last line tells how much is owed\"\n );\n }\n \n \n System.out.println(grader);\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