The following code compiles and runs. The problem is that two tests in the JUnit test class aren't working properly. They are testing the contains method and indexOf method from the LinkedList class. I have highlighted the two tests below. Any suggestions on how to fix this?

--------------------------------------------------------------------------------------

import static org.junit.Assert.*; import org.junit.Test;

/** * A JUnit test class for class LinkedList. */ public class LinkedListTest {

Dog fifi = new Dog("Fifi", 12, 8); Dog butch = new Dog("Butch", 10, 10); Dog leonard = new Dog("Leonard", 22, 13); Dog spot = new Dog("Spot", 17, 9);

@Test public void test() { LinkedList myDogList = new LinkedList(); myDogList.add(fifi); assertEquals(myDogList.get(0), fifi); }

//test method for contains method @Test public void test2() { LinkedList myDogList = new LinkedList(); myDogList.add(fifi); myDogList.add(butch); assertEquals(myDogList.contains(butch), true); }

//test method for add method with index @Test public void test3() { LinkedList myDogList = new LinkedList(); myDogList.add(fifi); myDogList.add(butch); myDogList.add(leonard); myDogList.add(spot,1); assertEquals(myDogList.get(1), spot); }

//test method for indexOf method @Test public void test4() { LinkedList myDogList = new LinkedList(); myDogList.add(fifi); myDogList.add(butch); myDogList.add(leonard); assertEquals(myDogList.indexOf(leonard), 2); }

//test method for Iterator hasNext method @Test public void test5() { LinkedList myDogList = new LinkedList(); myDogList.add(fifi); myDogList.add(butch); Iterator iter1 = myDogList.getIterator(); assertEquals(iter1.hasNext(),true); }

@Test public void test6() { LinkedList myDogList = new LinkedList(); myDogList.add(butch); myDogList.add(leonard); Iterator iter1 = myDogList.getIterator(); assertEquals(iter1.hasPrior(),false); }

} // end class LinkedListTest

---------------------------------------------------------------------------------------

public class LinkedList { Node itsFirstNode; Node itsLastNode; private int size;

public LinkedList() { itsFirstNode = null; itsLastNode = null; size = 0; }

public Iterator getIterator() { return new Iterator(this); }

/** * A doubly-linked list * @param element */ public void add(T element) {

Node node = new Node(element);

if (itsFirstNode == null) { itsFirstNode = node; itsLastNode = node; } else { itsLastNode.setNextNode(node); node.setPriorNode(itsLastNode);//prior node set from new node to last node itsLastNode = node; } size++; }

/** * A doubly-linked list * @param element */ public void add(T element, int index) {

int counter = 0; Node newNode = new Node(element); Node current = itsFirstNode;

while (current.getNextNode() != null ) {

if (counter == index - 1 ) break;

current = current.getNextNode(); counter++; } newNode.setNextNode(current.getNextNode()); Node temp=current.getNextNode();//temp node is next node of current node temp.setPriorNode(newNode); current.setNextNode(newNode); newNode.setPriorNode(current); size++; }

/** * A doubly-linked list * @param element */ public T get(int index) {

int counter = 0; Node current = itsFirstNode;

while (current.getNextNode() != null ) {

if (counter == index) break;

current = current.getNextNode(); counter++; } return current.getData(); }

/** * A doubly-linked list * @param element * @return if element is in the list result is true, false if not */ public boolean contains(T element) {

Node head = itsFirstNode; boolean res = false;

if (itsFirstNode == null) return res;

else {

while (head != null) {

if(head.getData() == element){ res = true; break; } head.setNextNode(head.getNextNode()); } } return res; }

/** * A doubly-linked list * @param element * @return the index of the element if it is in the list, -1 if not found */ public int indexOf(T element) {

Node head = itsFirstNode; int index = 0;

if(itsFirstNode == null) return -1;

else {

while (head != null) {

if (head.getData() == element) { break; } head.setNextNode(head.getNextNode()); index++; } } return index; }

/** * We cannot get Java iterator to an user defined object unless implementing * iterable interface, therefore the return type is Node in order to * return reference to current node * @return an Iterator at the location of the element if it is in the list * and returns the null reference if the element is not found * @param element */ public Node iteratorAt(T element) {

Node head = itsFirstNode;

if (itsFirstNode == null) return null;

else {

while (head != null) {

if (head.getData() == element) { break; } head.setNextNode(head.getNextNode()); } } return head; }

public String toString() {

String returnVal = ""; Node current = itsFirstNode;

if (size != 0 ) {

while (current.getNextNode() != null ) { returnVal += current.toString(); returnVal += " "; current = current.getNextNode(); } returnVal += current.toString(); } return returnVal; } // end toString

class Node { private T data; private Node itsNext; private Node itsPrior;

public Node(T data) { itsNext = null; itsPrior = null; this.data = data; }

public T getData() { return this.data; }

public Node getNextNode() { return itsNext; }

public Node getPriorNode() { return itsPrior; }

public void setNextNode(Node next) { itsNext = next; }

public void setPriorNode(Node prior) { itsPrior=prior; }

public String toString() { return data.toString(); }

} // end of Node

} // end LinkedList class

---------------------------------------------------------------------------------------

public class Iterator {

private LinkedList myList; private LinkedList.Node myCurrentNode;

public Iterator(LinkedList list) { myList = list; myCurrentNode = myList.itsFirstNode; }

/** * @return true if there is a "next" element, otherwise returns false */ public boolean hasNext() { if (myCurrentNode != null) return true; return false; }

/** * @return true if there is a "prior" element, otherwise returns false */ public boolean hasPrior() { if (myCurrentNode.getPriorNode() != null) return true; return false; }

/** * @return the "next" node (really the current one) * and moves the Iterator forward by one node */ public T next() { T data = myCurrentNode.getData(); myCurrentNode = myCurrentNode.getNextNode(); return data; }

/** * @return the "prior" node (really the current one) * and moves the Iterator backward by one node */ public T prior() { T data = myCurrentNode.getData(); myCurrentNode = myCurrentNode.getPriorNode(); return data; }

/** * Sets this iterator to point to the last Node in the list */ public void setToEnd() { while (myCurrentNode.getNextNode() != null) myCurrentNode = myCurrentNode.getNextNode(); }

} //end Iterator class

---------------------------------------------------------------------------------------

public class Dog {

private int weight; private int heightAtShoulder; private String name;

public Dog (String name, int w, int h) { this.name = name; this.weight = w; this.heightAtShoulder = h; }

public String getName() {return this.name;} public int getHeight() {return this.heightAtShoulder;} public int getWeight() {return this.weight;}

public void bark() {System.out.println("woof");}

public String toString() { return "Dog: " + name + " , height: " + heightAtShoulder + " weight: " + weight; }

@Override public boolean equals(Object o) {

if (o instanceof Dog) { //now we can do checks Dog tempDogRef = (Dog)(o); if (tempDogRef.getName().equals(this.name) && tempDogRef.getHeight() == this.heightAtShoulder && tempDogRef.getWeight() == this.weight) return true; } return false; }

} // end class Dog

---------------------------------------------------------------------------------------

public class ListRunner {

public static void main(String[] args) {

Dog fifi = new Dog("Fifi", 12, 8); Dog butch = new Dog("Butch", 10, 10); Dog leonard = new Dog("Leonard", 22, 13); Dog spot = new Dog("Spot", 17, 9);

LinkedList myDogList = new LinkedList(); System.out.println();

myDogList.add(fifi); System.out.println("Added Fifi to list."); System.out.println(myDogList); System.out.println();

myDogList.add(butch); myDogList.add(leonard); myDogList.add(spot); System.out.println("Added Butch, Leonard, and Spot to list."); System.out.println(myDogList); System.out.println();

Dog jack = new Dog("Jack", 18, 18); myDogList.add(jack,1); System.out.println("Added Jack to list."); System.out.println(myDogList); System.out.println();

// the following lines build Iterators, and provide an example // of how you would use an Iterator to step through this data // structure Iterator iter1 = myDogList.getIterator(); Iterator iter2 = myDogList.getIterator();

System.out.println("Iterating using Iterators!!!"); while (iter1.hasNext()) { Dog foo = iter1.next(); System.out.println(foo); }

System.out.println();

// In a doubly-linked list, an iterator can move either forward or backward, // so this should print the list out in reverse order if you've correctly // implemented everything System.out.println("Iterating backwards using Iterators!!!"); iter2.setToEnd(); while (iter2.hasPrior()) { Dog foo = iter2.prior(); System.out.println(foo); } Dog foo = iter2.prior(); System.out.println(foo);

}// end main

} // end class ListRunner