Java Using Eclipse

BuggySearchAndSort defines a search subroutine that is supposed to check whether or not a given integer occurs in a given array of integers. It also contains three different sorting subroutines that are supposed to be able to sort an array of integers into non-decreasing order. There is also a main program that tests the four subroutines (along with a sorting subroutine from one of Java's standard classes that is there to remind you that you don't necessarily need to write your own subroutines to perform common tasks).

If all the subroutines that are defined in BuggySearchAndSort were correct, then running the program would produce output that looks something like this:

The array is: 4 3 6 9 3 9 5 4 1 9

This array DOES contain 5.

Sorted by Arrays.sort(): 1 3 3 4 4 5 6 9 9 9

Sorted by Sweep Sort: 1 3 3 4 4 5 6 9 9 9

Sorted by Selection Sort: 1 3 3 4 4 5 6 9 9 9

Sorted by Insertion Sort: 1 3 3 4 4 5 6 9 9 9

Unfortunately, (or fortunately, for the purposes of this lab), each of the four subroutines in BuggySearchAndSort has a bug that can either produce incorrect results or an infinite loop. If you run the buggy program without modifying it, it will go into an infinite loop.

Your job in this lab is to use the Eclipse debugger to find each of the four bugs. In the written lab report that you will turn in, you should describe each bug, say how you fixed it, and explain briefly how you used the Eclipse debugger to find the bug.

(Note: It's possible that you could find some or all of the bugs just by inspecting the code. However, the main purpose of this part of the lab is to get some experience with the debugger, so I would like you to do that rather than simply eyeball the code!)

The main point of the debugger is that it allows you to pause the execution of a program and inspect the values of variables. Once the program has been paused, you can also step through the program line-by-line to see what is going on. The program will not pause, however, unless you have added a breakpoint to the program source code. If you run a program that has no breakpoints under the debugger, it behaves just as it would if it were run normally.

To add a breakpoint, simply double-click in the left margin of the source code, next to one of the lines of code. (By left margin, I mean the same part of the window where the error and warning "light bulbs" appear.) The breakpoint appears as a small dot:5. You can remove the breakpoint by double-clicking this dot. There is also a "Remove All Breakpoints" command in the "Run" menu. I should also note that you can use the "Add Java Exception Breakpoint" command in the "Run" menu to set up a breakpoint that is triggered whenever an exception of a given type occurs.

When a program is running in Eclipse under the debugger, and the execution gets to a line that contains a breakpoint, the execution is paused. If Eclipse is showing the regular Java perspective when this happens, Eclipse will want to switch to the Debug perspective -- another screen full of views (or panes) that are useful for debugging. The first time this happens, Eclipse will put up a dialog box that asks whether you want to switch to the Debug perspective. I suggest that you check the box that says "Remember my decision" and say "Yes".

Debugging is complicated, and so is Java's Debug perspective. The most important view is the "Variables" view in the top-right corner. Here, you can inspect the values of variables. An array or object variable has a small triangle next to its name; you can click this triangle to open and close the variable so that you can inspect its contents. If a variable is selected (by clicking it), its value is also shown at the bottom of the view.

The green triangle means "Resume" and can be used to resume normal execution of the program (until it next encounters a breakpoint). There is a red "Stop" button that can be used to terminate the program. Most important are the three "arrow" buttons for the "Step Into", "Step Over", and "Step Out" commands. "Step Over" is easiest to understand -- clicking it causes one line of code to be executed. "Step In" is similar, except that if the line of code contains a subroutine call, it takes you to the first line of the subroutine so that you can continue from there. "Step Out" continues execution until the current subroutine returns, and it stops at the line to which the subroutine returns. Note that these "Step" commands can also be found in the "Run" menu, and that the F5, F6, and F7 keys can be used as keyboard equivalents for the step commands.

In the left center area of the Debug perspective, you'll find an edit view where the source code files for the program are displayed. The current line is marked in this view with an arrow in the left margin, and you can watch this arrow move as you step through the program. You can even edit your program in the Debug perspective.

One final remark: There is a list of open perspectives on the right end of the toolbar at the top of the Eclipse window. You can move from one perspective to another by clicking on the name of one of the perspectives in this list. So, when you want to get out of the Debug perspective and back to the normal Java perspective, just click "Java" in the list of perspectives:

HERE is the provided code:

import java.util.Arrays;

/**

* This class looks like it's meant to provide a few public static methods

* for searching and sorting arrays. It also has a main method that tests

* the searching and sorting methods.

*

* TODO: The search and sort methods in this class contain bugs that can

* cause incorrect output or infinite loops. Use the Eclipse debugger to

* find the bugs and fix them

*/

public class BuggySearchAndSort {

public static void main(String[] args) {

int[] A = new int[10]; // Create an array and fill it with small random ints.

for (int i = 0; i < 10; i++)

A[i] = 1 + (int)(10 * Math.random());

int[] B = A.clone(); // Make copies of the array.

int[] C = A.clone();

int[] D = A.clone();

System.out.print("The array is:");

printArray(A);

if (contains(A,5))

System.out.println("This array DOES contain 5.");

else

System.out.println("This array DOES NOT contain 5.");

Arrays.sort(A); // Sort using Java's built-in sort method!

System.out.print("Sorted by Arrays.sort(): ");

printArray(A); // (Prints a correctly sorted array.)

bubbleSort(B);

System.out.print("Sorted by Bubble Sort: ");

printArray(B);

selectionSort(C);

System.out.print("Sorted by Selection Sort: ");

printArray(C);

insertionSort(D);

System.out.print("Sorted by Insertion Sort: ");

printArray(D);

}

/**

* Tests whether an array of ints contains a given value.

* @param array a non-null array that is to be searched

* @param val the value for which the method will search

* @return true if val is one of the items in the array, false if not

*/

public static boolean contains(int[] array, int val) {

for (int i = 0; i < array.length; i++) {

if (array[i] == val)

return true;

else

return false;

}

return false;

}

/**

* Sorts an array into non-decreasing order. This inefficient sorting

* method simply sweeps through the array, exchanging neighboring elements

* that are out of order. The number of times that it does this is equal

* to the length of the array.

*/

public static void bubbleSort(int[] array) {

for (int i = 0; i < array.length; i++) {

for (int j = 0; j < array.length-1; i++) {

if (array[j] > array[j+1]) { // swap elements j and j+1

int temp = array[j];

array[j] = array[j+1];

array[j+1] = temp;

}

}

}

}

/**

* Sorts an array into non-decreasing order. This method uses a selection

* sort algorithm, in which the largest item is found and placed at the end of

* the list, then the second-largest in the next to last place, and so on.

*/

public static void selectionSort(int[] array) {

for (int top = array.length - 1; top > 0; top--) {

int positionOfMax = 0;

for (int i = 1; i <= top; i++) {

if (array[1] > array[positionOfMax])

positionOfMax = i;

}

int temp = array[top]; // swap top item with biggest item

array[top] = array[positionOfMax];

array[positionOfMax] = temp;

}

}

/**

* Sorts an array into non-decreasing order. This method uses a standard

* insertion sort algorithm, in which each element in turn is moved downwards

* past any elements that are greater than it.

*/

public static void insertionSort(int[] array) {

for (int top = 1; top < array.length; top++) {

int temp = array[top]; // copy item that into temp variable

int pos = top - 1;

while (pos > 0 && array[pos] > temp) {

// move items that are bigger than temp up one position

array[pos+1] = array[pos];

pos--;

}

array[pos] = temp; // place temp into last vacated position

}

}

/**

* Outputs the ints in an array on one line, separated by spaces,

* with a line feed at the end.

*/

private static void printArray(int[] array) {

for (int i = 0; i < array.length; i++) {

System.out.print(" ");

System.out.print(array[i]);

}

System.out.println();

}

}