Hello need help with this lab, Im leaving the program and the test, thank you for your help

/** A class of bags whose entries are stored in a chain of linked nodes. The bag is never full. INCOMPLETE DEFINITION; includes definitions for the methods add, toArray, isEmpty, and getCurrentSize. @author Frank M. Carrano, Timothy M. Henry @version 5.0 * * Extra methods added for lab exercise by Charles Hoot * //- * @version 5.1 */ public final class LinkedBag implements BagInterface { private Node firstNode; // Reference to first node private int numberOfEntries;

public LinkedBag() { firstNode = null; numberOfEntries = 0; } // end default constructor

/** Adds a new entry to this bag. @param newEntry The object to be added as a new entry. @return True. */ public boolean add(T newEntry) // OutOfMemoryError possible { // Add to beginning of chain: Node newNode = new Node(newEntry); newNode.next = firstNode; // Make new node reference rest of chain // (firstNode is null if chain is empty) firstNode = newNode; // New node is at beginning of chain numberOfEntries++;

return true; } // end add

/** Retrieves all entries that are in this bag. @return A newly allocated array of all the entries in this bag. */ public T[] toArray() { // The cast is safe because the new array contains null entries. @SuppressWarnings("unchecked") T[] result = (T[]) new Object[numberOfEntries]; // Unchecked cast

int index = 0; Node currentNode = firstNode; while ((index

return result; // Note: The body of this method could consist of one return statement, // if you call Arrays.copyOf } // end toArray

/** Sees whether this bag is empty. @return True if the bag is empty, or false if not. */ public boolean isEmpty() { return numberOfEntries == 0; } // end isEmpty

/** Gets the number of entries currently in this bag. @return The integer number of entries currently in the bag. */ public int getCurrentSize() { return numberOfEntries; } // end getCurrentSize

/** Removes one unspecified entry from this bag, if possible. @return Either the removed entry, if the removal was successful, or null. */ public T remove() { T result = null;

// MODIFY THIS METHOD TO REMOVE A RANDOM ITEM FROM THE BAG

if (firstNode != null) { result = firstNode.data; firstNode = firstNode.next; // Remove first node from chain numberOfEntries--; } // end if

return result; } // end remove

/** Removes one occurrence of a given entry from this bag. @param anEntry The entry to be removed. @return True if the removal was successful, or false otherwise. */ public boolean remove(T anEntry) { boolean result = false; Node nodeN = getReferenceTo(anEntry); if (nodeN != null) { nodeN.data = firstNode.data; // Teplace located entry with entry // in first node firstNode = firstNode.next; // Remove first node numberOfEntries--; result = true; } // end if return result; } // end remove

// Locates a given entry within this bag. // Returns a reference to the node containing the entry, if located, // or null otherwise. private Node getReferenceTo(T anEntry) { boolean found = false; Node currentNode = firstNode; while (!found && (currentNode != null)) { if (anEntry.equals(currentNode.data)) { found = true; } else { currentNode = currentNode.next; } } // end while return currentNode; } // end getReferenceTo

/** Removes all entries from this bag. */ public void clear() { while (!isEmpty()) { remove(); } } // end clear

/** Counts the number of times a given entry appears in this bag. @param anEntry The entry to be counted. @return The number of times anEntry appears in the bag. */ public int getFrequencyOf(T anEntry) { int frequency = 0; int loopCounter = 0; Node currentNode = firstNode; while ((loopCounter

/** Tests whether this bag contains a given entry. @param anEntry The entry to locate. @return True if the bag contains anEntry, or false otherwise. */ public boolean contains(T anEntry) { boolean found = false; Node currentNode = firstNode; while (!found && (currentNode != null)) { if (anEntry.equals(currentNode.data)) found = true; else currentNode = currentNode.next; } // end while return found; } // end contains

private class Node { private T data; // Entry in bag private Node next; // Link to next node

private Node(T dataPortion) { this(dataPortion, null); } // end constructor

private Node(T dataPortion, Node nextNode) { data = dataPortion; next = nextNode; } // end constructor } // end Node

/********************************************************************* * * METHODS TO BE COMPLETED * * ************************************************************************/

/** Check to see if two bags are equals. * @param aBag Another object to check this bag against. * @return True if the two bags contain the same objects with the same frequencies. */ public boolean equals(LinkedBag aBag) { // COMPLETE THIS METHOD return false; } // end equals

/** Duplicate all the items in a bag. * @return True if the duplication is possible. */ public boolean duplicateAll() { // COMPLETE THIS METHOD return false; } // end duplicateAll

/** Remove all duplicate items from a bag */ public void removeDuplicates() {

// COMPLETE THIS METHOD

return; } // end removeDuplicates } // end LinkedBag

import static org.junit.jupiter.api.Assertions.*;

import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test;

class LinkedBagTest {

LinkedBag constructBag(int size) { return constructBag(size, size); }

LinkedBag constructBag(int size, int elements) { LinkedBag bag = new LinkedBag(); for (int i = 0; i

@Test // @Disabled void testRemove() { LinkedBag bag = constructBag(2); String removed = bag.remove(); assertEquals(1, bag.getCurrentSize()); }

@Test // @Disabled void testEqualsLinkedBagOfT() { LinkedBag bag1 = constructBag(2), bag2 = constructBag(2); assertTrue(bag1.equals(bag1)); assertTrue(bag1.equals(bag2)); assertTrue(bag2.equals(bag1)); bag2.remove(); assertFalse(bag1.equals(bag2)); assertFalse(bag2.equals(bag1)); bag2.add("x"); assertFalse(bag1.equals(bag2)); assertFalse(bag2.equals(bag1)); }

@Test // @Disabled void testDuplicateAll() { LinkedBag bag = constructBag(2, 1); assertTrue(bag.duplicateAll()); assertEquals(2, bag.getCurrentSize()); Object[] elements = bag.toArray(); assertEquals(elements[0], elements[1]); assertEquals(2, bag.getFrequencyOf("s0")); assertTrue(bag.duplicateAll()); }

@Test // @Disabled void testRemoveDuplicates() { LinkedBag bag = constructBag(4, 1); bag.duplicateAll(); assertEquals(2, bag.getCurrentSize()); assertEquals(2, bag.getFrequencyOf("s0")); bag.duplicateAll(); assertEquals(4, bag.getCurrentSize()); assertEquals(4, bag.getFrequencyOf("s0")); bag.removeDuplicates(); assertEquals(1, bag.getCurrentSize()); assertEquals(1, bag.getFrequencyOf("s0")); }

}

In this lab you will explore the implementation of the ADT bag using a linked chain. Refer to the lab manual for specific instructions and completed algorithms. Note that the algorithms in the lab manual are described in Java code that you can use directly to implement your solutions. To get started, download the Eclipse Project [L ] and import into Eclipse. Students should focus on completing the implementation of the starting code following the steps in the Directed Lab Work section of the manual. Only the equals method is allowed to use other class methods to implement. When you have completed the lab, you should submit the Eclipse Project file LinkedBag.java as the solution to this assignment. If you are unable to complete the lab in class, you should still submit your files with a comment that the lab is incomplete. You are welcome to complete the lab either on your own device or in class during Office Hours. Hints - The lab manual contains the Java code of the solutions