Remove unnecessary parts and ascertain whether there are means to make it perform faster.

Write test cases to check if:
-The given input is interpreted correctly.
-Exceptions are thrown when the input is incorrect.

Write JUnit Test-cases to verify if:
-A file is written to the right location.
-That file contains the correct input.
-Exceptions are thrown and caught appropriately.

Write a test-case to verify if the returned array returns the right legal moves (right position order) as they are given by the LegalMoveChecker.

Remove/Improve variables, methods and remove unused code.

Write test cases to check if:
-The "unsaved" files loop works correctly.
-The method terminates the UI.

Write test-cases to verify that the variables are correctly allocated/constructed.

Write an input to verify that each exception is thrown when it is meant to be. (E.g too small board). Also make sure it doesn't throw anything when a correct board is inputted (make this a board with a lot of pieces on it).

Refactor methods, variables, e.t.c.

Decide who should best develop the heuristics.

Fix mostly the mass of nested IF statements to be more legible.

Write test-cases that verify the successful construction and allocation of attributes for each Board type.

Use Arrays.deepEquals() to do this. Also make sure to respectively update:
-the Test cases in GameEngine.java and LegalMoveChecker.java.
-The SuperKo method in LegalMoveChecker.java

This is essential for when the project is turned into a jar. These folders should be /saveData/logs/ and /saveData/boards/ respectively

This should be an ongoing (logged) testing process to verify LegalMoveChecker doesn't do anything funny.

Create an algorithm that ensures that the board state which the GameEngine constructor takes in, is not illegal. A board state is illegal if there are either black and white groups that have no liberties on the board.

It might be of interest to know why a move is illegal from either UI. To enable this, write an exception that is thrown by checkMove(), passed on by the GameEngine and caught by the UI. It should then display the msg variable of the exception as it sees fit.

Remove old code, unused variables and methods.

Generally neaten up code.

Write JUnit testcases to:
-Test both methods of readBoard.java to see whether the correct paths are used.
-Verify whether the board data read in is what is returned.
-Verify that if a BoardFormatException is thrown, a default board is returned.

Write Test cases to verify if a windows path is correctly translated into unix one and vice versa.

Write test cases to check if:
-The given input is interpreted correctly.
-Exceptions are thrown when the input is incorrect.

Write JUnit testcases to:
-Test both methods of writeBoard.java. Verify whether a board is written to the given directories or file names.
-Verify the Board is written correctly and whether it adheres to the appropriate format.
-Also check whether inputting a board with bad data (e.g. not 0, 1, 2) generates a BoardFormatException.

This test-case should evaluates its performance in the worst case scenario.
A decent worst-case should be:
-A game on a large board with at least 50 previous moves.

Recall that this class will need to check EVERY move the AI tries, so even the slightest performance analysis and improvement is helpful.

Write JUnit tests to:
-Verify whether the method correctly formats lines from an ArrayList to a String.
-Whether it correctly handles a non-existent file.

This hashing algorithm should have a fairly low collision rate. It is valuable though, as it improve performance on the LegalMoveChecker and especially all game tree AIs.

Note from author: I will probably heavily refactor the if-statement abomination.
Write test cases to check if:
-The given input is interpreted correctly.
-The appropriate exceptions are thrown when the input is incorrect.

Write test cases to check if:
-The given input is interpreted correctly.
-Exceptions are thrown when the input is incorrect.

Write test-cases to:
-Verify that moves are made to the right coordinates on the board.
-The method returns correctly as to whether the move succeeded.

Write test cases to check if:
-The given input is interpreted correctly.
-Exceptions are thrown when the input is incorrect.

Take Coordinate out of LegalMoveChecker and adjust all x,y parameters in methods in the program.

Write JUnit testcases to:
Verify the functionality of the clone() method. This is whether or not it successfully creates a complete a separate, identical copy of the original.

Write JUnit testcases to:
-Make sure the exception can be thrown with/without a message and that it returns it when called.

Write test-cases to:
-Verify if a whole file is read from right path.
-Ascertain IOExceptions are thrown and caught a required.

Write Test-Cases to verify:
-If commands are read in correctly.
-Whether commands are handled correctly (whether they are mapped to the right method).

Write a test case to check that the method only displays a board when there actually is one and throws an exception otherwise.

Write test cases to check if:
-The given input is interpreted correctly.
-Exceptions are thrown when the input is incorrect or when there is nothing to log.

Write test cases to check if:
-The given input is interpreted correctly.
-Exceptions are thrown when the input is incorrect or there is no Board to save.

Write JUnit testcases to:
Make sure the exception can be thrown with/without a message and that it returns it when called.

Create a method that will allow the user to begin the Go problem again. Maybe using the undo() function?

Download the package branch, then run "ant resolve" to resolve dependencies.
Then, in Eclipse, use the build file to create a new project:
(File>New>Other...>Java Project From Existing Ant Buildfile)
Choose the ant buildfile from our project, then select the "javac" task found in target "compile" and click finish.
The project should now be in Eclipse without any bugs.

Write test cases to verify if the method correctly rewrites filenames to avoid overwriting another file.

Write Test-cases to:
-Verify if the method correctly reverts to a previous move and returns true.
-Returns false (and does not crash horribly) if there is either no board or no prior moves to undo.