CS 201 Advanced Object-Oriented Programming Lab 5 - Sudoku, Part 1 Due: March 3/4, 11:30 PM

Size: px

Start display at page:

Download "CS 201 Advanced Object-Oriented Programming Lab 5 - Sudoku, Part 1 Due: March 3/4, 11:30 PM"

Virgil Mathews
5 years ago
Views:

CS 201 Advanced Object-Oriented Programming Lab 5 - Sudoku, Part 1 Due: March 3/4, 11:30 PM Introduction to the Assignment This is the 1 st part of a 2 week lab.

1 CS 201 Advanced Object-Oriented Programming Lab 5 - Sudoku, Part 1 Due: March 3/4, 11:30 PM Introduction to the Assignment This is the 1 st part of a 2 week lab. When done, you will have a game that allows a user to solve Sudoku puzzles. This week you will gain experience learning how to test a program carefully using JUnit. Sudoku is a popular puzzle in which the player is given a 9 x 9 grid, which can also be viewed as a 3 x 3 grid, where each entry in the grid is itself a 3 x 3 grid. Each entry can hold a number from 1 to 9. Initially, a grid is shown with some numbers filled in. The player s goal is to fill in the empty squares such that each row contains the numbers 1 through 9, each column contains the numbers 1 through 9 and each 3 x 3 square contains the numbers 1 through 9. If you are unfamiliar with this puzzle, I recommend that you try Websudoku ( to get a better understanding. Here are some snapshots from my implementation of Sudoku: This is the starting screen. Notice that the Check and Reveal solution buttons are enabled while Next game is disabled. The user is able to type values into the cells of the Sudoku grid. The buttons do nothing when clicked. 1

The Program Design This week you will create 2 classes. These classes are: Sudoku - this is the class that sets up the user interface and contains the main method.

2 The Program Design This week you will create 2 classes. These classes are: Sudoku - this is the class that sets up the user interface and contains the main method. Sudoku3By3 - this is one of the 3 x 3 squares in the grid. It manages the user interface of a small square of grids. The Sudoku class will have 9 of these to make the entire grid. We have not talked about packages in class. I encourage you to read Section 2.3 of the textbook for a description of packages. In this and all future labs, we will place classes within packages. For this lab, you will have 1 package named sudoku (by convention, package names begin with small letters) and both of these classes will be within that package. Writing the Program Create a new Eclipse project called Sudoku. Create a package named sudoku. You can do this by clicking on the icon in the toolbar at the top of the Eclipse window. When you construct your classes, be sure that the package is listed as sudoku on the window that comes up, as shown at the right. This will insert the line: package sudoku; at the top of the file, before the import statements. Step 1: Construct 1 3x3 grid Java provides a GridLayout class that allows you to create displays where the display is broken into equally-sized areas using a specific number of rows and columns. Looking at the screen shots above, you should see that the screen consists of 3 rows and 3 columns, each identified by a red border. Thus, at the top level, we have a 3 x 3 grid. Within each of the red squares is another, smaller 3 x 3 grid, which is where the numbers appear. Each entry of the inner grid contains a JTextField where the user can enter their answers. By default, JPanels use FlowLayout. You can tell a JPanel to use a GridLayout instead, like this: mypanel.setlayout (new GridLayout (numrows, num- Cols)); At first, let s create a display that contains just 1 3 x 3 grid as shown to the right. The grid shown here is an instance of the Sudoku3By3 class. In each cell of this grid, add a JTextField. 2

3 When you add a component to a grid, you do not need to indicate where in the grid it will go, Java will just fill up the grid from left to right and top to bottom, like words on a page. Each entry will have the same size square and Java draws the grid lines automatically. To get the red border, you need to call the setborder method on the component (in this case a panel) that you want to put the border around. public void setborder(border border) To get a Border object, you call one of the methods in Java s BorderFactory class. For a border as in the demo, you would say: Border myborder = BorderFactory.createLineBorder (Color.RED, 3); This creates a border that is drawn as a simple red line that is 3 pixels wide. You would then pass this border as the parameter in your setborder call. You can produce many other types of borders with BorderFactory. Look at the online Java API at and feel free to experiment if you like. To center the text that appears in the JTextFields, use public void sethorizontalalignment (int alignment) passing JTextField.CENTER as the alignment parameter. To change the font used in a JTextField, call: public void setfont (font f) creating the fonts the same way as you did for the IDCard lab. The demo uses Arial, size 20. You will need to be able to refer to the JTextFields later in the lab so you can put numbers into grid cells and also to find out what number a user types in a grid cell. Therefore, the JTextFields within the Sudoku3By3 class must be stored in instance variables. The natural way to store them is in a 2-dimensional array that has 3 rows and 3 columns. (Remember Minesweeper from 101 where you used a 2D array?) Step 2: Completing the grid Your Sudoku class should contain a 3 x 3 grid as well. Construct 9 instances of Sudoku3By3 and place each of them in this outer grid and you should have the complete Sudoku grid! You will also need a 2D array in the Sudoku class to hold your 9 Sudoku3By3 instances. Step 3: Writing the Sudoku3By3 class The Sudoku3By3 class needs setvalue and getvalue methods. This methods will be used next week when we complete the program. They will allow your program to compare the user s entries with the solution and to display the correct solution to the user. This week, you will write and test the methods using JUnit. setvalue will be passed row and column numbers in the range 0-2 and an integer in the range 1-9. It should put the number in the appropriate text field. This is an excellent place for you to use assert statements. At the beginning of the setvalue method, add 3 assert statements, one to check that the row number is between 0 and 3, one to check that the column number is between 0 and 3, and one to check that the value is between 1 and 9. If you did not use assert statements last week, please refer back to the week 4 handout to see how to enable assertion checking. After writing your setvalue method, we will use JUnit to test it. In Eclipse, open the File menu, select New and then JUnit Test Case. In the window that comes up, select the radio 3

button New JUnit 4 test. Make the name Sudoku3By3Test and make sure the Package is sudoku and the Class under test is sudoku.sudokeu3by3. Select the setup() method in the list of methods to create.

Select Perform the following action and click ok. Eclipse will create a new class for you that should be defined as follows: package sudoku; import static org.junit.assert.*; import org.junit.before; import org.

4 button New JUnit 4 test. Make the name Sudoku3By3Test and make sure the Package is sudoku and the Class under test is sudoku.sudokeu3by3. Select the setup() method in the list of methods to create. Click the Next button. In the screen that comes up, select setvalue. Click Finish. A window will come up asking if Eclipse should add JUnit 4 to your build path. Select Perform the following action and click ok. Eclipse will create a new class for you that should be defined as follows: package sudoku; import static org.junit.assert.*; import org.junit.before; import org.junit.test; public class Sudoku3By3Test public void setup() throws Exception public void testsetvalue() {!! fail("not yet implemented"); } Let s run this test program and see what happens. To run it, select Sudoku3By3Test.java in the Package Explorer and right-click. Select Run As and then JUnit Test. You should see the following appear on the left side of the Eclipse window. The red bar across the top is an indication that the test program failed. It will draw a green bar when it succeeds. In the top pane it lists each test method in the test class. In this case, there is just one: testsetvalue. In the bottom pane, it shows a stack trace for the method selected in the top pane. Here we see the error AssertionError: Not yet implemented. Clicking on the top (only!) line in the stack will take us to the line of code that failed in the test program. When we do that we will see that it failed inside testsetvalue on the method call to fail! 4

5 When Eclipse created the test case, it put this in as the stub test method to be sure that we would define one, so let s do that now. What we should do in our test method is call setvalue and then check that the right JText- Field got set to the right value. If your array of JTextFields in your Sudoku3By3 class is named values, you could change the test class to be defined like shown below. (Note that the values instance variable will need to be protected, rather than private, so that it can be referenced in your test class.) public class Sudoku3By3Test {! private Sudoku3By3 public void setup() throws Exception {!! smallgrid = new public void testsetvalue() {!! smallgrid.setvalue(0, 0, 1);!! assertequals ("1", smallgrid.values[0][0].gettext()); } Let s see what is here. First, your test case should have an instance variable to hold the object being tested. The setup method should construct a new instance and assign it to the variable. In testsetvalue, we first call setvalue. Then we use assertequals to compare the expected value of 1, to the value that is in the JTextField that we just set. If setvalue is implemented correctly, when we run the test program, we should now see the JUnit output shown on the right, indicating that the test passed. You should think about whether there are any special cases that you should test. For example, you might check one of the cells that you did not set and make sure it is still empty. Next, write the getvalue method. This method will be given a row and column number in the range 0-2 and will return the integer value in the JTextField at that location. Use assert statements again to make sure the parameter values are in the correct range. When you extract the value from the JText- Field, its type will be String. To convert it to an int, call public static int parseint(string s) Since parseint is a static method, you call it using the class name, like this (using variable names of your choice): int somenumber = Integer.parseInt(someString); 5

For this lab, assume that the user always types a number between 1 and 9. Next week, we will look at how to handle situations where the user provides unexpected input.

6 For this lab, assume that the user always types a number between 1 and 9. Next week, we will look at how to handle situations where the user provides unexpected input. If the JTextField is empty, the getvalue method should return -1. After writing getvalue, add another test method to your JUnit test case. Be sure that you put the before the test method or it will not be executed. Set the value of a JTextField using JText- Field s settext method, then check that getvalue returns the value you expect. Be sure to test that a filled field returns the right value, and that an empty field returns -1. Step 4: Putting numbers on the grid The user may think of the Sudoku grid as 3 x 3 blocks, with each block containing a grid of 3 x 3 numbers. For much of your program, though, it will be easier to treat it as a single 9 x 9 grid. However, we have just created a representation that mirrors the user s view. We will therefore need a way to figure out which JTextField we are referring to when we want to know what value is in row 2, column 5 for example. In the figure below, we see a 1 in that square. So, where is that? First, we need to determine which cell of the outer grid it is in. That is row 0, column 1. Then we need to determine which row and column it is in in the inner grid, considering just that 3 x 3 grid. There it is row 2, column 2. How do we do this mapping? Let s first focus on the rows. Row 0 of the outer grid covers rows 0-2 of the overall grid. Row 1 covers rows 3-5 and Row 2 covers rows 6-8. So, to determine which row of the outer grid we need, we can take the row number and divide by 3, using integer arithmetic, so we drop any fractional part. In this case 2 / 3 = 0. So, we know that the row that is row 2 overall is in row 0 of the outer grid. We could do the same thing for the columns and determine that we are interested in column 1 of the outer grid (5 / 3 = 1). In this way, we could identify a single red square. Now, how can we figure out which JTextField is involved? Here we can use the modulus operator (often just called mod, and written using % in Java). mod does the integer division, but this time it evaluates to the remainder and throws away the quotient. This will identify the position of the JTextField we want within the red square. So, 2 % 3 = 2. (The remainder after integer division is 2.) And 5 % 3 = 2 (again because the remainder after integer division is 2). So, the JTextField is in row 2, column 2 of the red square located at outer row 0, outer column 1. You should write a setvalue method in the Sudoku class that takes a row number and column number, in the range 0-8, for the overall grid (like row 2, column 5) as well as a value. (Use assert statements again.) It should determine which Sudoku3By3 object is in that position and call a setvalue method that you define in the Sudoku3By3 class. This should also take a row number, column number and value, but this time the row number and column number must range between 0 and 2. The Sudoku3By3 method should find the JTextField in that part of the grid and call settext to display the value. After writing this method, create a new JUnit Test Case to test the Sudoku class. Add a test method for the setvalue method that you just wrote. After setvalue works, write a similar getvalue method (with assert statements) and testget- Value method. 6

7 Step 5: Add the buttons Laying out the buttons should be very similar to what you did for the Shape Explorer lab. We will add the listeners for the buttons next week. For now, just add them to the display. You should disable the Next game button by calling the setenabled method in the JButton class. Please refer to the online Java API at to learn how to use this method. After going to the URL shown above, click on JButton in the class list. Scroll down to the methods. You will see that setenabled is inherited from AbstractButton. Click on the setenabled link in the inherited method list to find the contract for setenabled. Grading 10 Step 1: Construct 1 3x3 grid 5 Step 2: Complete the grid 10 Step 3: setvalue & getvalue in Sudoku3By3 10 Step 4: setvalue & getvalue in Sudoku 10 Step 5: Add the buttons 10 JUnit test classes 15 Comments (including javadoc comments) 5 Assert statements 20 Style Turning in Your Work Create a jar file, being sure to include your source code. To make your jar file doubleclickable, do the following. After telling Eclipse which files to include in the jar file (in the Jar File Specification window), click Next instead of Finish. Click Next again in the Jar Packaging Options window. At the bottom of the Jar Manifest Specification window, there is a field for Main class. Either enter the name of your class that contains the main method or click the Browse button to find your class. Then, go to ella. Click on COMSC 201 in the toolbar menu across the top. Then click on Assignments in the left column. Click the submit link for this assignment. Click the Add Attachment button. Use the Browse button to upload a local file. You should submit your jar file. Click Continue. Then click the Submit button. 7

CS 201 Advanced Object-Oriented Programming Lab 6 - Sudoku, Part 2 Due: March 10/11, 11:30 PM

CS 201 Advanced Object-Oriented Programming Lab 6 - Sudoku, Part 2 Due: March 10/11, 11:30 PM Introduction to the Assignment In this lab, you will finish the program to allow a user to solve Sudoku puzzles.