Project 1: Implementing a Solution to the Open Knight's Tour Problem

To Deliver: Release 1.0 in your SVN repository

Upload KnightsTourP1.java, TourTestP1.java, AllTests.java to Web-Cat (for info on Web-Cat usage check Wiki).

To Download: 

Due date for submission: September 16, at noon (12.00 PM)

Drop out date: September 18, at noon (12.00 PM)

Motivation

The first project asks you to implement a solution to a chess problem, the so-called Knight's tour problem. 

• Problem description: The knight's tour is a mathematical problem involving a single knight on a chess board. The knight is placed on the empty board and, moving according to the rules of chess, must visit each square exactly once. So on an 8 x 8 board, we have 64 squares and a valid tour is a sequence of 64 positions on the chess board which can be performed by a knight. 
• Closed tour: we do not(!) do the closed tour version of the problem. Wiki page for the Knight's tour problem mainly discusses the more special problem of a Closed Knight's Tour. Please use the wiki page only to better understand the problem of an OPEN knight's tour. The page has a different focus and may mislead you for this project assignment if you go too much through its details. 
• Open tour: this is what you need to consider! The open tour is a simpler problem. It does not require the knight to end at a position such that it could jump to the initial position next. In other words, the open tour does NOT describe a cycle. 
• Solution Algorithm: Please follow a simple brute-force search. You can implement your solution a recursive or an iterative manner. Note that you can add as many additional methods to the class skeletons as you like.  All you need to preserve and support is the externally visible (accessible) interface. 
• Testing: 
• Own tests: You should create a new Junit test file TourTestP1.java in the project's test directory and create some test of your own. You can check the existing TourTest.java for examples.  
• Tests used for grading: The test cases you find in TestTour.java will be used to grade your implementation.
• Test driven development: You can use these test cases for a test-driven development: 
• Assume that you wrote the test cases yourself first. The initial (and basically empty) implementation of KnightsTourP1.java fails all the tests. 
• In following steps you implement individual pieces of functionality in a piecemeal manner such that your code passes one more test in each step. Basically you use each test that the code fails as an intermediate goal to refine your implementation until it passes this test / this requirement. 
• Once all tests are passed your are all set and your code fulfills all the requirements.

I selected the problem to connect to CS 241 which asked you to implement a solution to this problem in Python. This time you are asked to implement a solution in Java and with a set of regenerated class files. 

This first project covers multiple topics that are relevant for this class:

1. Basic Java programming skills
2. Unit testing with Junit
3. Test-driven development

To do list:

• If you have not performed Homework 1, do so as a first step since this will yield the Eclipse cs301/knightstour project with code skeletons to work on and the Junit test cases in file test/TourTest.java.
• Create a documentation in html format with javadoc  for your Eclipse project for your own productivity
• In Eclipse: call menu-Project-Generate Javadoc, let generated files reside in directory knightstour/doc
• Implement a solution to the knight's tour problem in class KnightsTourP1.java such that it implements the Tour.java interface.
• Suggestion: methods setDimension and getDimension are easy to implement. Use those to figure out how the Junit testing works. Write a small Junit test in TourTestP1.java to check if your setDimension / getDimension implementation works. 
• Note: printTour method is just a convenience method to make it easier to see what getTour computed. This implies that the correctness of getTour should be tested with a test for getTour and correctness of printTour should focus on the aspect if a tour is properly transformed into a string.
• Note: getTour does not throw any exceptions, so the only proper way for the method to respond to input that does not lead to a tour is to return an empty array of length 0. For this assignment, we do not(!) want to deal with the extra complexity of error handling mechanisms in Java.
• Implement further test cases in file TourTestP1.java to see if your code works. 
• Web-Cat checks if your test cases execute all lines of code in the tested classes (test coverage) and computes a percentage it (covered lines of code/total lines of code). The test coverage is an indicator for the quality of your test code.
• Create a Junit test suite AllTests.java that executes tests in both files TourTest.java and TourTestP1.java. (check the CS 301 wiki pages for instructions)
• Update your subversion repository whenever you made progress and got a particular feature or method going. 
• Create a tag with a Release 1.0 before the drop out date (due date is recommended for your own sanity). Include your junit test cases in your release. 
• We will use Web-Cat to run and evaluate your tests as well as our own that will test your KnightsTourP1.java class.
• Export your solution into a mytour.jar file, sign it and update your public_html directory with it (as in Homework 1) such that one can open the webpage KnightsTour.html there and your app now computes a solution to the Knight's tour problem!

Grading: 

You will receive points if:

• Your SVN Repository works: your subversion repository is set up correctly and the grader can download your release 1.0 from it.
• Your implementation passes the given test cases: for every test of TourTest.java that your implementation of KnightsTourP1 passes. This will be checked with the code you upload to Web-Cat.
• Your public_html directory contains a webpage KnightsTour.html that successfully computes a knight's tour on a 5 x 5 board (if the initial position allows for one).