diff --git a/.idea/misc.xml b/.idea/misc.xml
index 6f29fee..5af9c98 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -1,4 +1,3 @@
-<?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="ProjectRootManager" version="2" languageLevel="JDK_21" default="true" project-jdk-name="21" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/out" />
diff --git a/SDEV333-Term-Project.iml b/SDEV333-Term-Project.iml
index c90834f..0f07f6c 100644
--- a/SDEV333-Term-Project.iml
+++ b/SDEV333-Term-Project.iml
@@ -4,8 +4,25 @@
     <exclude-output />
     <content url="file://$MODULE_DIR$">
       <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/tests" isTestSource="true" />
     </content>
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="module-library" scope="TEST">
+      <library name="JUnit5.8.1">
+        <CLASSES>
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter/5.8.1/junit-jupiter-5.8.1.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter-api/5.8.1/junit-jupiter-api-5.8.1.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/opentest4j/opentest4j/1.2.0/opentest4j-1.2.0.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-commons/1.8.1/junit-platform-commons-1.8.1.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/apiguardian/apiguardian-api/1.1.2/apiguardian-api-1.1.2.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter-params/5.8.1/junit-jupiter-params-5.8.1.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter-engine/5.8.1/junit-jupiter-engine-5.8.1.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-engine/1.8.1/junit-platform-engine-1.8.1.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
   </component>
 </module>
\ No newline at end of file
diff --git a/src/ArrayList.java b/src/ArrayList.java
new file mode 100644
index 0000000..eb1cafe
--- /dev/null
+++ b/src/ArrayList.java
@@ -0,0 +1,238 @@
+/**
+ * Author: Levi Miller
+ * File: ArrayList.java implements arraylist
+ */
+import java.util.Arrays;
+import java.util.Iterator;
+
+public class ArrayList<E> implements List<E>{
+
+    private int size;
+    private E[] buffer;
+
+    public ArrayList(){
+        buffer = (E[]) new Object[10];
+        size = 0;
+    }
+    /**
+     * Add item to the front.
+     * Runtime analysis: the O level is O(n) so linear time
+     * The program has to run over the size(n) of the list
+     * @param item the item to be added
+     */
+    @Override
+    public void addFront(E item) {
+       if(size == buffer.length){ // +1
+           resize(buffer.length * 2); // +1
+       }
+        for (int i = size - 1; i >= 0; i--) {
+            buffer[i+1] = buffer[i]; // +2
+        }
+        buffer[0] = item; // + 1
+        size++; // + 2
+    }
+    /**
+     * Add item to the back.
+     * Runtime analysis: the O level is worst case is O(1) it is constant f(n) = n + 5
+     * The program checks the size of list then adds to back of list
+     * @param item the item to be added
+     */
+    @Override
+    public void addBack(E item) throws IllegalArgumentException{
+     if(size == buffer.length){  // + 1
+         resize(size * 2); // +1
+     }
+        buffer[size] = item; //+ 1
+        size++; // +2
+    }
+    /**
+     * Add an item at specified index (position).
+     * RunTime analysis: is constant or O(1) there are no loops
+     * @param i    the index where the item should be added
+     * @param item the item to be added
+     */
+    @Override
+    public void add(int i, E item) {
+        if(i < 0){ // +1
+            throw new IndexOutOfBoundsException("Index can not be negative");
+        }
+        if(size == buffer.length){ // + 1
+            buffer[i+1] = buffer[i]; // + 2
+        }
+        buffer[i] = item; // +1
+        size++; // +2
+    }
+    /**
+     * Get the item at a specified index.
+     * RunTime analysis: constant O(1) no loops worse case in constant
+     * @param i the index where the item should be retrieved
+     * @return the item located at that index
+     */
+    @Override
+    public E get(int i) {
+        if(i < 0){
+            throw new IndexOutOfBoundsException("Index can not be negative");
+        }
+        if (i >= size){
+            throw new IndexOutOfBoundsException("Index is higher than size");
+        }
+        return buffer[i];
+    }
+    /**
+     * Set (save) an item at a specified index. Previous
+     * item at that index is overwritten.
+     * RunTime analysis: O(1) constant no loops worst case constant
+     *
+     * @param i    the index where the item should be saved
+     * @param item the item to be saved
+     */
+    @Override
+    public void set(int i, E item) {
+        if (i < 0) {
+            throw new IndexOutOfBoundsException("Index can not be negative");
+        }
+        if (size == buffer.length) {
+            resize(size + 2);
+        }
+       E removed = buffer[i];
+       buffer[i] = item;
+       size++;
+    }
+    /**
+     * Remove item at the front of the list.
+     * RunTime analysis: one loop so linear time worse cast O(n)
+     * @return the item that was removed
+     */
+    @Override
+    public E removeFront() {
+        for (int i = 0; i < size - 1; i++) {
+            buffer[i] = buffer[i + 1];
+        }
+        E removed = buffer[0];
+        buffer[size - 1] = null;
+        size--;
+        return removed;
+    }
+    /**
+     * Remove item at the back of the list
+     * RunTime analysis: constant O(1) no loops worse case in constant
+     * @return the item that was removed
+     */
+    @Override
+    public E removeBack() {
+       E removed = buffer[size - 1];
+        buffer[size - 1] = null;
+        size--;
+        return removed;
+    }
+    /**
+     * Remove item from the list
+     * RunTime analysis: nested loop worse cast O(n^2)
+     * @param item the item to be removed
+     */
+    @Override
+    public void remove(E item) {
+        for (int i = 0; i < size; i++) {
+            if(item.equals(buffer[i])){
+                for (int j = i; j < size; j++) {
+                    if(size == buffer.length){
+                        resize(size * 2);
+                    }
+                    buffer[j] = buffer[j + 1];
+                }
+                size--;
+                i--;
+            }
+        }
+    }
+    /**
+     * Remove item at a specified index.
+     * RunTime analysis: one loop so linear time worse cast O(n)
+     * @param i the index where the item should be removed
+     * @return the item that was removed
+     */
+    @Override
+    public E remove(int i) {
+        if (i < 0){
+            throw new IndexOutOfBoundsException("Index can not be negative");
+        }
+        if(i >= size){
+            throw new IndexOutOfBoundsException("Index is higher than size");
+        }
+        E removed = buffer[i];
+        for (int j = i; j <= size-1 ; j++) {
+            buffer[i] = buffer[1 + i];
+        }
+        buffer[size - 1] = null;
+        return removed;
+    }
+    /**
+     * Checks if an item is in the list.
+     * RunTime analysis: one loop so linear time worse cast O(n)
+     * @param item the item to search for
+     * @return true if the item is in the list, false otherwise
+     */
+    @Override
+    public boolean contains(E item) {
+        for (int i = 0; i < size; i++) {
+            if(item.equals(buffer[i])){
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Checks if the list is empty.
+     * RunTime analysis: constant O(1) no loops worse case in constant
+     * @return true if the list is empty, false otherwise
+     */
+    @Override
+    public boolean isEmpty() {
+        return size == 0;
+    }
+    /**
+     * Provides a count of the number of items in the list.
+     * RunTime analysis: constant O(1) no loops worse case in constant
+     * @return number of items in the list
+     */
+    @Override
+    public int size() {
+        if(size < 0){
+            throw new IndexOutOfBoundsException("size can not be negative");
+        }
+        return size;
+    }
+    /**
+     * RunTime analysis: one loop so linear time worse cast O(n)
+     * resizes array when the array is full and copy over previous array
+     * */
+    private void resize(int newSize){
+        // create a new space separate from the old buffer
+        E[] temp =  (E[]) new Object[(int) newSize];
+        // copy everything over from the buffer into new buffer
+        for (int i = 0; i < buffer.length; i++) {
+            temp[i] = buffer[i];
+        }
+        // reassign temp data back to buffer with bigger array
+        buffer = temp;
+    }
+
+    /**
+     * Returns an iterator over elements of type {@code T}.
+     * RunTime analysis: constant O(1) no loops worse case in constant
+     * @return an Iterator.
+     */
+    @Override
+    public Iterator<E> iterator() {
+        ArrayList theIterator = new ArrayList();
+        return (Iterator<E>) theIterator;
+    }
+
+    @Override
+    public String toString() {
+        return "ArrayList{" +
+                "size=" + size +
+                ", buffer=" + Arrays.toString(buffer) +
+                '}';
+    }
+}
diff --git a/src/Bag.java b/src/Bag.java
new file mode 100644
index 0000000..cae104f
--- /dev/null
+++ b/src/Bag.java
@@ -0,0 +1,32 @@
+/**
+ * Author : Levi Miller
+ * file: Bag.java, Bag interface
+ */
+
+/**
+ * Collect and iterate over items Bag API
+ *
+ * @param <Item>> class / data type of the items in the bag
+ */
+public interface Bag<Item> extends Iterable<Item> {
+    /**
+     * Add an item to the bag.
+     *
+     * @param item the item to be added
+     */
+    void add(Item item);
+
+    /**
+     * Checks to see if the bag is empty.
+     *
+     * @return true if the bag is empty, false otherwise
+     */
+    boolean isEmpty();
+
+    /**
+     * Returns a count of the number of items in the stack.
+     *
+     * @return the number of items in the bag
+     */
+    int size();
+}
diff --git a/src/Deque.java b/src/Deque.java
index 0107f47..d9f9352 100644
--- a/src/Deque.java
+++ b/src/Deque.java
@@ -1,3 +1,7 @@
+/**
+ * Author : Levi Miller
+ * file: Deque, deque interface
+ */
 /**
  * Deque: double-ended queue API
  * Supports adding and removing items at both ends.
diff --git a/src/LinkedBag.java b/src/LinkedBag.java
new file mode 100644
index 0000000..b08d0eb
--- /dev/null
+++ b/src/LinkedBag.java
@@ -0,0 +1,88 @@
+/**
+ * Author : Levi Miller
+ * file: LinkedBag.java, implements bag interface
+ */
+import java.util.Iterator;
+
+public class LinkedBag<E> implements Bag<E> {
+    private Node first;  // first node in list
+    private int size;
+
+    public class Node {
+        E item;
+        Node next;
+    }
+    /**
+     * default constructor: initializing fields
+     * RunTime analysis: constant O(1) no loops worse case in constant
+     */
+    public LinkedBag() {
+        this.first = null;
+        this.size = 0;
+    }
+
+    /**
+     * Adds an item to the front of the bag
+     * RunTime analysis: constant O(1) no loops worse case in constant
+     */
+    public void add(E item) {  // same as push() in Stack
+        Node first = this.first;
+        this.first = new Node();
+        this.first.item = item;
+        this.first.next = first;
+        size++;
+    }
+
+    /**
+     * Checks to see if the bag is empty.
+     * RunTime analysis: constant O(1) no loops worse case in constant
+     *
+     * @return true if the bag is empty, false otherwise
+     */
+    @Override
+    public boolean isEmpty() {
+        return size == 0;
+    }
+
+    /**
+     * Returns a count of the number of items in the stack.
+     * RunTime analysis: constant O(1) no loops worse case in constant
+     *
+     * @return the number of items in the bag
+     */
+    @Override
+    public int size() {
+        return size;
+    }
+
+    /**
+     * RunTime analysis: no loop so constant time worse cast O(1)
+     * returns items from bag
+     */
+    public Iterator<E> iterator() {
+        return new ListIterator();
+    }
+
+    private class ListIterator implements Iterator<E> {
+        private Node current = first;
+
+        /**
+         * RunTime analysis: no loop so constant time worse cast O(1)
+         * returns if there is a next element in bag is ,so it's true if not it's false
+         */
+        public boolean hasNext() {
+            return current != null;
+        }
+
+        /**
+         * RunTime analysis: no loop so constant time worse cast O(1)
+         * returns next element in list
+         */
+        public E next() {
+            E item = current.item;
+            current = current.next;
+            return item;
+
+        }
+    }
+}
diff --git a/src/LinkedList.java b/src/LinkedList.java
new file mode 100644
index 0000000..b573298
--- /dev/null
+++ b/src/LinkedList.java
@@ -0,0 +1,356 @@
+/**
+ * Author: Levi Miller
+ * file: LinkedList.java, implements Linked-list interface
+ * only errors are from unchecked cast
+ */
+import java.util.Iterator;
+
+public class LinkedList<E> implements List<E> {
+    // define  what a node is
+    private class Node {
+        E data;
+        Node next;
+
+        @Override
+        public String toString() {
+            return data +
+                    ", " + next;
+        }
+    }
+
+    // set up the head
+    private Node head;
+
+    // set up the size field
+    private int size;
+
+    /**
+     * default constructor: initializing fields
+     * RunTime analysis: constant O(1) no loops worse case in constant
+     */
+    public LinkedList() {
+        head = null;
+
+        size = 0;
+    }
+
+    /**
+     * Add item to the front.
+     * RunTime analysis: is constant or O(1) there are no loops
+     * @param item the item to be added
+     */
+    @Override
+    public void addFront(E item) {
+        //set up new node
+        Node theNewOne = new Node();
+        theNewOne.data = item;
+
+        if (head != null) {
+            //this list currently has some nodes in it
+            theNewOne.next = head;
+            //everything from the right gets saved to the left
+        }  //this list is currently empty
+
+        head = theNewOne;
+        size++;
+    }
+
+    /**
+     * Add item to the back.
+     * RunTime analysis: one loop so linear time worse cast O(n)
+     * @param item the item to be added
+     */
+    @Override
+    public void addBack(E item) {
+        Node theNewOne = new Node();
+        theNewOne.data = item;
+        if (size != 0) {
+            // keeps track of where you are in the list
+            Node temp = head;
+            // if temp. next is not null
+            while (temp.next != null) {
+                // then iterate through the list
+                temp = temp.next;
+            }
+            // if temp.next is null then theNewOne is temp.next
+            temp.next = theNewOne;
+        } else {
+            head = theNewOne;
+        }
+        size++;
+    }
+
+    /**
+     * Add an item at specified index (position).
+     * RunTime analysis: one loop so linear time worse cast O(n)
+     * @param i    the index where the item should be added
+     * @param item the item to be added
+     */
+    @Override
+    public void add(int i, E item) {
+        Node theNewOne = new Node();
+        theNewOne.data = item;
+        if (i > size || i < 0) {
+            throw new IndexOutOfBoundsException();
+        } else {
+            if (size == 0) {
+                head = theNewOne;
+            } else {
+                Node prev = null;
+                Node temp = head;
+                for (int j = 0; j < i; j++) {
+                    prev = temp;
+                    temp = temp.next;
+                }
+                theNewOne.next = temp;
+                if (prev == null) {
+                    head = theNewOne;
+                } else {
+                    prev.next = theNewOne;
+                }
+            }
+            size++;
+        }
+    }
+
+    /**
+     * Get the item at a specified index.
+     * RunTime analysis: one loop  so linear time worse cast O(n)
+     * @param i the index where the item should be retrieved
+     * @return the item located at that index
+     */
+    @Override
+    public E get(int i) {
+        Node temp;
+        E result = null;
+        if (i >= size || i < 0) {
+            throw new IndexOutOfBoundsException();
+        } else {
+            temp = head;
+            for (int j = 0; j < size; j++) {
+                // then iterate through the list
+                if (j == i) {
+                    result = temp.data;
+                } else {
+                    temp = temp.next;
+                }
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Set (save) an item at a specified index. Previous
+     * item at that index is overwritten.
+     * RunTime analysis: one loop so linear time worse case O(n)
+     *
+     * @param i    the index where the item should be saved
+     * @param item the item to be saved
+     */
+    @Override
+    public void set(int i, E item) {
+        Node theNewOne = new Node();
+        theNewOne.data = item;
+        if (i > size) {
+            throw new IndexOutOfBoundsException();
+        } else {
+            if (size == 0) {
+                head = theNewOne;
+            } else {
+                Node temp = head;
+                for (int j = 0; j < size; j++) {
+                    if (j == i) {
+                        temp.data = theNewOne.data;
+                    } else {
+                        temp = temp.next;
+                    }
+
+                }
+
+            }
+        }
+        size++;
+    }
+
+    /**
+     * Remove item at the front of the list.
+     * RunTime analysis: constant O(1) no loops worse case in constant
+     * @return the item that was removed
+     */
+    @Override
+    public E removeFront() {
+        if (size <= 0) {
+            throw new IndexOutOfBoundsException();
+        }
+        E removed = (E) head;
+        if (head == null) {
+            //this list is currently empty
+            System.out.println("this list is empty");
+        } else {
+            //this list currently has some nodes in it
+            head = head.next;
+            //everything from the right gets saved to the left
+            size--;
+        }
+        return removed;
+    }
+
+    /**
+     * Remove item at the back of the list
+     * RunTime analysis: one loop so linear time worse case O(n)
+     * @return the item that was removed
+     */
+    @Override
+    public E removeBack() {
+        if (size <= 0) {
+            throw new IndexOutOfBoundsException();
+        }
+        Node temp = null;
+        if (head == null) {
+            //this list is currently empty
+            System.out.println("this list is empty");
+        } else {
+            // keeps track of where you are in the list
+            temp = head;
+            // if temp. next .next is not null
+            while (temp.next != null) {
+                // then iterate through the list
+                temp = temp.next;
+            }
+            // if temp.next is null then theNewOne is temp.next
+            size--;
+        }
+        return (E) temp;
+    }
+
+    /**
+     * Remove item from the list
+     * RunTime analysis: one loop so linear time worse case O(n)
+     * @param item the item to be removed
+     */
+    @Override
+    public void remove(E item) {
+        Node prev = null;
+        Node temp = head;
+        for (int i = 0; i < size; i++) {
+            if (temp.data.equals(item)) {
+                prev = temp;
+                temp = temp.next;
+            }
+        }
+        if (prev == null) {
+            head = temp.next;
+        } else {
+            prev.next = temp.next;
+        }
+        size--;
+    }
+
+    /**
+     * Remove item at a specified index.
+     * RunTime analysis: one loop so linear time worse case O(n)
+     * @param i the index where the item should be removed
+     * @return the item that was removed
+     */
+    @Override
+    public E remove(int i) {
+        if (i >= size || i < 0) {
+            throw new IndexOutOfBoundsException();
+        }
+        Node prev = null;
+        Node temp = head;
+        for (int j = 0; j < i; j++) {
+            prev = temp;
+            temp = temp.next;
+        }
+        if (prev == null) {
+            head = temp.next;
+        } else {
+            prev.next = temp.next;
+        }
+        size--;
+        return temp.data;
+    }
+
+    /**
+     * Checks if an item is in the list.
+     * RunTime analysis: one loop so linear time worse case O(n)
+     * @param item the item to search for
+     * @return true if the item is in the list, false otherwise
+     */
+    @Override
+    public boolean contains(E item) {
+        Node temp = head;
+        // if temp. next is not null
+        while (temp != null) {
+            // then iterate through the list
+            if (temp.data.equals(item)) {
+                return true;
+            } else {
+                temp = temp.next;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Checks if the list is empty.
+     * RunTime analysis: constant O(1) no loops worse case in constant
+     * @return true if the list is empty, false otherwise
+     */
+    @Override
+    public boolean isEmpty() {
+        return size == 0;
+    }
+
+    /**
+     * Provides a count of the number of items in the list.
+     * RunTime analysis: constant O(1) no loops worse case in constant
+     * @return number of items in the list
+     */
+    @Override
+    public int size() {
+        return size;
+    }
+
+    /**
+     * Returns an iterator over elements of type {@code T}.
+     * RunTime analysis: constant O(1) no loops worse case in constant
+     * @return an Iterator.
+     */
+    @Override
+    public Iterator<E> iterator() {
+        return new LinkedIterator();
+    }
+
+    private class LinkedIterator implements Iterator<E> {
+
+        // private int i;   // index of the item I am on in the arraylist
+        private Node current;
+
+        public LinkedIterator() {
+            current = head;
+        }
+
+        @Override
+        public boolean hasNext() {
+            return current != null;
+        }
+
+        @Override
+        public E next() {
+            E item = current.data;
+            current = current.next;
+            return item;
+        }
+    }
+
+    @Override
+    public String toString() {
+        return "LinkedList{" + head +
+                ", size=" + size +
+                '}';
+    }
+
+
+}
\ No newline at end of file
diff --git a/src/LinkedQueue.java b/src/LinkedQueue.java
new file mode 100644
index 0000000..6c1bd50
--- /dev/null
+++ b/src/LinkedQueue.java
@@ -0,0 +1,109 @@
+/**
+ * Author: Levi Miller
+ * file: LinkedQueue.java, implements Queue interface
+ */
+import java.util.Iterator;
+
+public class LinkedQueue<E> implements Queue<E> {
+    private Node head; // link to least recently added node
+    private Node tail;  // link to most recently added node
+    private int size;      // number of items on the queue
+
+    private class Node {  // nested class to define nodes
+        E item;
+        Node next;
+    }
+
+    /**
+     * default constructor: initializing fields
+     * RunTime analysis: constant O(1) no loops worse case in constant
+     */
+    public LinkedQueue() {
+        this.head = null;
+        this.tail = null;
+        this.size = 0;
+    }
+
+    /**
+     * Checks if the queue is empty.
+     * RunTime analysis: constant O(1) no loops worse case in constant
+     *
+     * @return true if the list is empty, false otherwise
+     */
+    public boolean isEmpty() {
+        return head == null;
+    }  // Or: N == 0.
+
+    /**
+     * Provides a count of the number of items in the queue
+     * RunTime analysis: constant O(1) no loops worse case in constant
+     *
+     * @return number of items in the queue
+     */
+    public int size() {
+        return size;
+    }
+
+    /**
+     * Add an item at the end of the queue
+     * RunTime analysis: constant O(1) no loops worse case in constant
+     */
+    public void enqueue(E item) {  // Add item to the end of the list.
+        Node outlast = tail;
+        tail = new Node();
+        tail.item = item;
+        tail.next = null;
+        if (isEmpty()) head = tail;
+        else outlast.next = tail;
+        size++;
+    }
+
+    /**
+     * removes an item at the front of the queue
+     * RunTime analysis: constant O(1) no loops worse case in constant
+     */
+    public E dequeue() {  // Remove item from the beginning of the list.
+        E item = head.item;
+        head = head.next;
+        if (isEmpty()) tail = null;
+        size--;
+        return item;
+    }
+
+    /**
+     * RunTime analysis: no loop so constant time worse cast O(1)
+     * returns iterated nodes
+     */
+    public Iterator<E> iterator() {
+        return new ListIterator();
+    }
+
+    private class ListIterator implements Iterator<E> {
+        private Node current = head;
+
+        /**
+         * RunTime analysis: no loop so constant time worse cast O(1)
+         * returns if there is a next element in queue is ,so it's true if not it's false
+         */
+        public boolean hasNext() {
+            return current != null;
+        }
+
+        /**
+         * RunTime analysis: no loop so constant time worse cast O(1)
+         */
+        public void remove() {
+        }
+
+        /**
+         * RunTime analysis: no loop so constant time worse cast O(1)
+         * returns next element in list
+         */
+        public E next() {
+            E item = current.item;
+            current = current.next;
+            return item;
+        }
+    }
+}
+
diff --git a/src/LinkedStack.java b/src/LinkedStack.java
new file mode 100644
index 0000000..b452ded
--- /dev/null
+++ b/src/LinkedStack.java
@@ -0,0 +1,110 @@
+/**
+ * Author : Levi Miller
+ * file: LinkedStack.java, implements LinkedStack interface
+ */
+import java.util.Iterator;
+public class LinkedStack<E> implements Stack<E> {
+
+    private Node head; // top of stack (most recently added node)
+    private int size;
+
+    public class Node {  // nested class to define nodes
+        E item;
+        Node next;
+    }
+    /**
+     * default constructor: initializing fields
+     * RunTime analysis: constant O(1) no loops worse case in constant
+     */
+    public LinkedStack() {
+        this.head = null;
+        this.size = 0;
+
+    }
+
+    /**
+     * Checks if the stack is empty.
+     * RunTime analysis: constant O(1) no loops worse case in constant
+     * @return true if the list is empty, false otherwise
+     */
+    public boolean isEmpty() {
+        return head == null;
+    }  // Or: N == 0.
+
+    /**
+     * Provides a count of the number of items in the stack
+     * RunTime analysis: constant O(1) no loops worse case in constant
+     * @return number of items in the stack
+     */
+    public int size() {
+        return size;
+    }
+
+    /**
+     * RunTime analysis: no loop so constant time worse cast O(1)
+     * push item on stack
+     * */
+    public void push(E item) {  // Add item to top of stack.
+        Node first = head;
+        head = new Node();
+        head.item = item;
+        head.next = first;
+        size++;
+    }
+
+    /**
+     * RunTime analysis: no loop so constant time worse cast O(1)
+     * pop item off stack
+     * */
+    public E pop() {  // Remove item from top of stack.
+        E item = head.item;
+        head = head.next;
+        size--;
+        return item;
+    }
+
+    /**
+     * RunTime analysis: no loop so constant time worse cast O(1)
+     * returns iterated nodes
+     * */
+    public Iterator<E> iterator() {
+        return new ListIterator();
+    }
+
+    private class ListIterator implements Iterator<E> {
+        private Node current = head;
+        /**
+         * RunTime analysis: no loop so constant time worse cast O(1)
+         * returns if there is a next element in stack is ,so it's true if not it's false
+         * */
+        public boolean hasNext() {
+            return current != null;
+        }
+
+        /**
+         * RunTime analysis: no loop so constant time worse cast O(1)
+         * */
+        public void remove() {
+        }
+        /**
+         * RunTime analysis: no loop so constant time worse cast O(1)
+         * returns next element in list
+         * */
+        public E next() {
+            E item = current.item;
+            current = current.next;
+            return item;
+        }
+    }
+
+    /**
+     * RunTime analysis: no loop so constant time worse cast O(1)
+     */
+    @Override
+    public E peek() {
+        return null;
+    }
+
+}
+
+
diff --git a/src/List.java b/src/List.java
index 2bf4aef..5691b1a 100644
--- a/src/List.java
+++ b/src/List.java
@@ -1,3 +1,7 @@
+/**
+ * Author : Levi Miller
+ * file: List.java, list interface
+ */
 /***
  * List interface (API / abstract data type)
  * @param <E> Class or data type of the items in the list.
@@ -32,7 +36,8 @@ public interface List<E> extends Iterable<E> {
     /**
      * Set (save) an item at a specified index. Previous
      * item at that index is overwritten.
-     * @param i the index where the item should be saved
+     *
+     * @param i    the index where the item should be saved
      * @param item the item to be saved
      */
     void set(int i, E item);
diff --git a/src/Main.java b/src/Main.java
index 8f8f984..d56ae31 100644
--- a/src/Main.java
+++ b/src/Main.java
@@ -1,10 +1,19 @@
+import java.util.Iterator;
+import java.util.ListIterator;
+
 //TIP To <b>Run</b> code, press <shortcut actionId="Run"/> or
 // click the <icon src="AllIcons.Actions.Execute"/> icon in the gutter.
 public class Main {
+
+
+
     public static void main(String[] args) {
         //TIP Press <shortcut actionId="ShowIntentionActions"/> with your caret at the highlighted text
         // to see how IntelliJ IDEA suggests fixing it.
         System.out.println("Hello and welcome!");
 
+
+        }
+
+
     }
-}
\ No newline at end of file
diff --git a/src/MathSet.java b/src/MathSet.java
index 5b87e0d..5b61a44 100644
--- a/src/MathSet.java
+++ b/src/MathSet.java
@@ -2,7 +2,6 @@
  * MathSet API (interface / abstract data type)
  * represents a mathematical set. Sets in mathematics
  * have unique elements (keys) and there are no duplicate keys.
- *
  * In this MathSet API, we have an additional constraint that
  * traditional mathematical sets do not have. In mathematical sets,
  * elements are unordered, order of keys does not matter. In this
diff --git a/src/Queue.java b/src/Queue.java
index ab5ca29..491f41b 100644
--- a/src/Queue.java
+++ b/src/Queue.java
@@ -1,3 +1,7 @@
+/**
+ * Author : Levi Miller
+ * file: Queue.java, Queue interface
+ */
 /**
  * FIFO (first-in, first-out) Queue API
  * @param <E> class / data type of the items in the queue
diff --git a/src/QueueTestClient.java b/src/QueueTestClient.java
new file mode 100644
index 0000000..226ab43
--- /dev/null
+++ b/src/QueueTestClient.java
@@ -0,0 +1,19 @@
+/**
+ * Author : Levi Miller
+ * file: QueueTestClient.java, Tests queues
+ */
+import java.util.Scanner;
+
+public class QueueTestClient {
+    public static void main(String[] args) {  // Create a queue and enqueue/dequeue strings.
+        Queue<String> q = new LinkedQueue<>();
+        Scanner in = new Scanner("to be or not to - be - - that - - - is");
+        while (in.hasNext()) {
+            String item = in.next();
+            if (!item.equals("-"))
+                q.enqueue(item);
+            else if (!q.isEmpty()) System.out.print(q.dequeue() + " ");
+        }
+        System.out.print(("(" + q.size() + " left on queue)"));
+    }
+}
diff --git a/src/ResizingArrayStack.java b/src/ResizingArrayStack.java
new file mode 100644
index 0000000..0ac7ce0
--- /dev/null
+++ b/src/ResizingArrayStack.java
@@ -0,0 +1,120 @@
+/**
+ * Author : Levi Miller
+ * file: ResizingArrayStack.java  implements stack interface
+ * only errors are from casting and Resizing isn't being used in the test client per instruction
+ */
+
+import java.util.Iterator;
+
+public class ResizingArrayStack<E> implements Stack<E> {
+    // fields
+    private E[] buffer;  // stack items
+    private int size; // number of items
+
+    /**
+     * default constructor: initializing fields
+     * RunTime analysis: constant O(1) no loops worse case in constant
+     */
+    public ResizingArrayStack() {
+        this.buffer = ((E[]) new Object[10]);
+        this.size = 0;
+    }
+
+    /**
+     * RunTime analysis: no loop so constant time worse cast O(1)
+     * returns if array is empty
+     */
+    public boolean isEmpty() {
+        return size == 0;
+    }
+
+    /**
+     * RunTime analysis: no loop so constant time worse cast O(1)
+     * returns size
+     */
+    public int size() {
+        return size;
+    }
+
+
+    /**
+     * RunTime analysis: one loop so linear time worse cast O(n)
+     * resizes array when the array is full and copy over previous array
+     */
+    private void resize(int max) {  // Move stack to a new array of size max.
+        E[] temp = (E[]) new Object[max];
+        if (size >= 0) System.arraycopy(buffer, 0, temp, 0, size);
+        buffer = temp;
+    }
+
+    /**
+     * RunTime analysis: no loop so constant time worse cast O(1)
+     * push item on stack and checks if array is full
+     */
+    public void push(E item) {  // Add item to top of stack.
+        if (size == buffer.length) resize(2 * buffer.length);
+        buffer[size] = item;
+        size++;
+        //  or buffer[size++] = item;
+
+    }
+
+    /**
+     * RunTime analysis: no loop so constant time worse cast O(1)
+     * pop item off stack and checks if array is not utilising the space
+     */
+    public E pop() {  // Remove item from top of stack.
+        size--;
+        E item = buffer[size];  // or E item = buffer[size--];
+        buffer[size] = null;  // Avoid loitering (see text).
+        if (size > 0 && size == buffer.length / 4) resize(buffer.length / 2);
+        return item;
+    }
+
+    /**
+     * RunTime analysis: no loop so constant time worse cast O(1)
+     */
+    @Override
+    public E peek() {
+        return null;
+    }
+
+    /**
+     * RunTime analysis: no loop so constant time worse cast O(1)
+     * returns reversed array
+     */
+    public Iterator<E> iterator() {
+        return new ReverseArrayIterator();
+    }
+
+
+    private class ReverseArrayIterator implements Iterator<E> {  // Support LIFO iteration.
+        private int i = size;
+
+        /**
+         * RunTime analysis: no loop so constant time worse cast O(1)
+         * returns if there is a next element in array
+         */
+        public boolean hasNext() {
+            return i > 0;
+        }
+
+        /**
+         * RunTime analysis: no loop so constant time worse cast O(1)
+         * returns next element in array and decrement to index
+         */
+        public E next() {
+            i--;
+            return buffer[i];  // or buffer[i--]
+        }
+
+        /**
+         * RunTime analysis: no loop so constant time worse cast O(1)
+         */
+        public void remove() {
+        }
+    }
+
+}
+
+
diff --git a/src/Stack.java b/src/Stack.java
index bb1000d..dd8730c 100644
--- a/src/Stack.java
+++ b/src/Stack.java
@@ -1,3 +1,7 @@
+/**
+ * Author : Levi Miller
+ * file: Stack.java, stack interface
+ */
 /**
  * Stack (LIFO: last-in, first-out) API
  * @param <E> class / data type of the items in the stack
diff --git a/src/StackTestClient.java b/src/StackTestClient.java
new file mode 100644
index 0000000..0bb498f
--- /dev/null
+++ b/src/StackTestClient.java
@@ -0,0 +1,23 @@
+/**
+ * Author : Levi Miller
+ * file: StackTestClient.java testing out stack implementations
+ */
+
+import java.util.Scanner;
+
+public class StackTestClient {
+
+    public static void main(String[] args) {
+        Stack<String> s = new LinkedStack<>();
+        Scanner in = new Scanner("to be or not to - be - - that - - - is");
+        while (in.hasNext()) {
+            String item = in.next();
+            if (!item.equals("-"))
+                s.push(item);
+            else if (!s.isEmpty()) {
+                System.out.println(s.pop());
+            }
+        }
+        System.out.println("(" + s.size() + " left on the stack" + ")");
+    }
+}
diff --git a/src/Stats.java b/src/Stats.java
new file mode 100644
index 0000000..aed613e
--- /dev/null
+++ b/src/Stats.java
@@ -0,0 +1,35 @@
+/**
+ * Author : Levi Miller
+ * file: Stats.java testing out bag implementation
+ */
+import java.util.Scanner;
+
+public class Stats {
+
+    public static void main(String[] args) {
+
+        Scanner in = new Scanner("90 101 81 109 107 98 120 101 99 100");
+
+        Bag<Double> numbers = new LinkedBag<>();
+        while (in.hasNextDouble()) {
+            numbers.add(in.nextDouble());
+        }
+        System.out.println("% java Stats");
+        for (double x : numbers) {
+            String noZero = String.format("%.0f", x);
+            System.out.println(noZero);
+        }
+        int size = numbers.size();
+        double sum = 0.0;
+        for (double x : numbers)
+            sum += x;
+        double mean = sum / size;
+        sum = 0.0;
+        for (double x : numbers)
+            sum += (x - mean) * (x - mean);
+        double std = Math.sqrt(sum / (size - 1));
+        System.out.println();
+        System.out.printf("Mean: %.2f\n", mean);
+        System.out.printf("Std dev: %.2f\n", std);
+    }
+}
diff --git a/tests/ArrayListTest.java b/tests/ArrayListTest.java
new file mode 100644
index 0000000..59b69fb
--- /dev/null
+++ b/tests/ArrayListTest.java
@@ -0,0 +1,472 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+
+class ArrayListTest {
+
+    @Test
+    void addFront() {
+        ArrayList<Integer> linked = new ArrayList<>();
+        linked.addFront(5);
+
+        int expected = 5;
+        int actual = linked.get(0);
+        Assertions.assertEquals(expected, actual);
+
+        ArrayList<String> oneElement = new ArrayList<>();
+        oneElement.addFront("test1");
+        oneElement.addFront("test2");
+
+        String expectedOneElement = "test2";
+        String actualOneElement = oneElement.get(0);
+        Assertions.assertEquals(expectedOneElement, actualOneElement);
+
+       ArrayList<Double> tenElement = new ArrayList<>();
+        tenElement.addFront(6.6);
+        tenElement.addFront(4.6);
+        tenElement.addFront(3.6);
+        tenElement.addFront(39.8);
+        tenElement.addFront(45.7);
+        tenElement.addFront(3.0);
+        tenElement.addFront(4.7);
+        tenElement.addFront(12.12);
+        tenElement.addFront(43.1);
+        tenElement.addFront(1.1);
+
+        Double tenElementsExpected = 1.1;
+        Double tenElementsActual = tenElement.get(0);
+
+        Assertions.assertEquals(tenElementsExpected, tenElementsActual);
+
+    }
+
+    @Test
+    void addBack() {
+        ArrayList<Integer> linked = new ArrayList<>();
+        linked.addBack(5);
+
+        int expected = 5;
+        int actual = linked.get(0);
+        Assertions.assertEquals(expected, actual);
+
+        ArrayList<String> oneElement = new ArrayList<>();
+        oneElement.addBack("test1");
+        oneElement.addBack("test2");
+
+        String expectedOneElement = "test1";
+        String actualOneElement = oneElement.get(0);
+        Assertions.assertEquals(expectedOneElement, actualOneElement);
+
+        ArrayList<Double> tenElement = new ArrayList<>();
+        tenElement.addBack(6.6);
+        tenElement.addBack(4.6);
+        tenElement.addBack(3.6);
+        tenElement.addBack(39.8);
+        tenElement.addBack(45.7);
+        tenElement.addBack(3.0);
+        tenElement.addBack(4.7);
+        tenElement.addBack(12.12);
+        tenElement.addBack(43.1);
+        tenElement.addBack(1.1);
+
+        Double tenElementsExpected = 6.6;
+        Double tenElementsActual = tenElement.get(0);
+
+        Assertions.assertEquals(tenElementsExpected, tenElementsActual);
+    }
+
+    @Test
+    void add() {
+        ArrayList<Integer> linked = new ArrayList<>();
+        linked.add(0,5);
+
+        int expected = 5;
+        int actual = linked.get(0);
+        Assertions.assertEquals(expected, actual);
+
+        ArrayList<String> oneElement = new ArrayList<>();
+        oneElement.add(1,"test1");
+        oneElement.add(0,"test2");
+
+        String expectedOneElement = "test2";
+        String actualOneElement = oneElement.get(0);
+        Assertions.assertEquals(expectedOneElement, actualOneElement);
+
+        ArrayList<Double> tenElement = new ArrayList<>();
+        tenElement.add(0,6.6);
+        tenElement.add(1,4.6);
+        tenElement.add(2,3.6);
+        tenElement.add(3,39.8);
+        tenElement.add(4,5.7);
+        tenElement.add(5,3.0);
+        tenElement.add(6,4.7);
+        tenElement.add(7,12.12);
+        tenElement.add(8,43.1);
+        tenElement.add(9,1.1);
+
+        Double tenElementsExpected = 6.6;
+        Double tenElementsActual = tenElement.get(0);
+
+        Assertions.assertEquals(tenElementsExpected, tenElementsActual);
+    }
+
+    @Test
+    void get() {
+
+        ArrayList<Integer> linked = new ArrayList<>();
+
+        Assertions.assertThrows(IndexOutOfBoundsException.class, () -> {
+            Integer actual = linked.get(0);
+            Assertions.assertNull(actual);
+        });
+
+
+      ArrayList<String> oneElement = new ArrayList<>();
+        oneElement.add(0, "test1");
+        oneElement.add(1, "test2");
+
+
+        String expectedOneElement = "test1";
+        String actualOneElement = oneElement.get(0);
+        Assertions.assertEquals(expectedOneElement, actualOneElement);
+
+
+        LinkedList<Double> tenElement = new LinkedList<>();
+        tenElement.add(0, 1.1);
+        tenElement.add(1, 1.2);
+        tenElement.add(2, 1.3);
+        tenElement.add(3, 1.4);
+        tenElement.add(4, 1.5);
+        tenElement.add(5, 1.6);
+        tenElement.add(6, 1.7);
+        tenElement.add(7, 1.8);
+        tenElement.add(8, 1.9);
+        tenElement.add(9, 2.0);
+
+
+        Double tenElementsExpected = 1.5;
+        Double tenElementsActual = tenElement.get(4);
+
+        Assertions.assertEquals(tenElementsExpected, tenElementsActual);
+    }
+
+    @Test
+    void set() {
+
+
+        ArrayList<Integer> linked = new ArrayList<>();
+        linked.set(0,5);
+
+        int expected = 5;
+        int actual = linked.get(0);
+        Assertions.assertEquals(expected, actual);
+
+        ArrayList<String> oneElement = new ArrayList<>();
+        oneElement.add(0,"test1");
+        oneElement.set(1,"test2");
+
+        String expectedOneElement = "test1";
+        String actualOneElement = oneElement.get(0);
+        Assertions.assertEquals(expectedOneElement, actualOneElement);
+
+        ArrayList<Double> tenElement = new ArrayList<>();
+        tenElement.addFront(6.6);
+        tenElement.addFront(4.6);
+        tenElement.addFront(3.6);
+        tenElement.addFront(39.8);
+        tenElement.addFront(45.7);
+        tenElement.addFront(3.0);
+        tenElement.addFront(4.7);
+        tenElement.addFront(12.12);
+        tenElement.addFront(43.1);
+        tenElement.addFront(1.1);
+        tenElement.set(3,99.9);
+
+        Double tenElementsExpected = 99.9;
+        Double tenElementsActual = tenElement.get(3);
+
+        Assertions.assertEquals(tenElementsExpected, tenElementsActual);
+
+    }
+
+    @Test
+    void removeFront() {
+        ArrayList<Integer> linked = new ArrayList<>();
+
+        Assertions.assertThrows(IndexOutOfBoundsException.class, () -> {
+            Integer actual = linked.removeFront();
+            Assertions.assertNull(actual);
+        });
+
+        ArrayList<String> oneElement = new ArrayList<>();
+        oneElement.add(0, "test1");
+
+        String expectedOneElement = "test1";
+        String actualOneElement = oneElement.get(0);
+        Assertions.assertEquals(expectedOneElement, actualOneElement);
+
+
+        ArrayList<Double> tenElement = new ArrayList<>();
+        tenElement.add(0, 1.1);
+        tenElement.add(1, 1.2);
+        tenElement.add(2, 1.3);
+        tenElement.add(3, 1.4);
+        tenElement.add(4, 1.5);
+        tenElement.add(5, 1.6);
+        tenElement.add(6, 1.7);
+        tenElement.add(7, 1.8);
+        tenElement.add(8, 1.9);
+        tenElement.add(9, 2.0);
+        tenElement.removeFront();
+
+
+        Double tenElementsExpected = 1.2;
+        Double tenElementsActual = tenElement.get(0);
+
+        Assertions.assertEquals(tenElementsExpected, tenElementsActual);
+    }
+
+
+    @Test
+    void removeBack() {
+
+        ArrayList<Integer> linked = new ArrayList<>();
+
+        Assertions.assertThrows(IndexOutOfBoundsException.class, () -> {
+            Integer actual = linked.removeBack();
+            Assertions.assertNull(actual);
+        });
+
+
+        ArrayList<String> oneElement = new ArrayList<>();
+        oneElement.add(0, "test1");
+        oneElement.add(1, "test2");
+        oneElement.removeBack();
+
+        String expectedOneElement = "test1";
+        String actualOneElement = oneElement.get(0);
+        Assertions.assertEquals(expectedOneElement, actualOneElement);
+
+
+        ArrayList<Double> tenElement = new ArrayList<>();
+        tenElement.add(0, 1.1);
+        tenElement.add(1, 1.2);
+        tenElement.add(2, 1.3);
+        tenElement.add(3, 1.4);
+        tenElement.add(4, 1.5);
+        tenElement.add(5, 1.6);
+        tenElement.add(6, 1.7);
+        tenElement.add(7, 1.8);
+        tenElement.add(8, 1.9);
+        tenElement.add(9, 2.0);
+        tenElement.removeBack();
+
+
+        Double tenElementsExpected = 1.9;
+        Double tenElementsActual = tenElement.get(8);
+
+        Assertions.assertEquals(tenElementsExpected, tenElementsActual);
+    }
+
+    @Test
+    void remove() {
+
+        ArrayList<Integer> linked = new ArrayList<>();
+
+        Assertions.assertThrows(IndexOutOfBoundsException.class, () -> {
+            Integer actual = linked.remove(0);
+            Assertions.assertNull(actual);
+        });
+
+
+        ArrayList<String> oneElement = new ArrayList<>();
+        oneElement.add(0, "test1");
+        oneElement.add(1, "test2");
+
+
+        String expectedOneElement = "test1";
+        String actualOneElement = oneElement.remove(0);
+        Assertions.assertEquals(expectedOneElement, actualOneElement);
+
+
+        ArrayList<Double> tenElement = new ArrayList<>();
+        tenElement.add(0, 1.1);
+        tenElement.add(1, 1.2);
+        tenElement.add(2, 1.3);
+        tenElement.add(3, 1.4);
+        tenElement.add(4, 1.5);
+        tenElement.add(5, 1.6);
+        tenElement.add(6, 1.7);
+        tenElement.add(7, 1.8);
+        tenElement.add(8, 1.9);
+        tenElement.add(9, 2.0);
+
+
+        Double tenElementsExpected = 1.4;
+        Double tenElementsActual = tenElement.remove(3);
+
+        Assertions.assertEquals(tenElementsExpected, tenElementsActual);
+    }
+
+    @Test
+    void testRemove() {
+
+        ArrayList<Integer> linked = new ArrayList<>();
+
+        Assertions.assertThrows(IndexOutOfBoundsException.class, () -> {
+            Integer actual = linked.remove(9);
+            Assertions.assertNull(actual);
+        });
+
+
+        ArrayList<String> oneElement = new ArrayList<>();
+        oneElement.add(0, "test1");
+        oneElement.add(1, "test2");
+        oneElement.remove("test1");
+
+        String expectedOneElement = "test2";
+        String actualOneElement = oneElement.get(0);
+        Assertions.assertEquals(expectedOneElement, actualOneElement);
+
+
+        ArrayList<Double> tenElement = new ArrayList<>();
+        tenElement.add(0, 1.1);
+        tenElement.add(1, 1.2);
+        tenElement.add(2, 1.3);
+        tenElement.add(3, 1.4);
+        tenElement.add(4, 1.5);
+        tenElement.add(5, 1.6);
+        tenElement.add(6, 1.7);
+        tenElement.add(7, 1.8);
+        tenElement.add(8, 1.9);
+        tenElement.add(9, 2.0);
+        tenElement.remove(2.0);
+
+
+        Double tenElementsExpected = 1.5;
+        Double tenElementsActual = tenElement.get(4);
+
+        Assertions.assertEquals(tenElementsExpected, tenElementsActual);
+    }
+
+    @Test
+    void contains() {
+
+        ArrayList<Integer> linked = new ArrayList<>();
+
+
+        boolean expected = false;
+        boolean actual = linked.contains(5);
+        Assertions.assertEquals(expected, actual);
+
+
+        ArrayList<String> oneElement = new ArrayList<>();
+        oneElement.add(0, "test1");
+        oneElement.add(1, "test2");
+
+
+        boolean expectedOneElement = false;
+        boolean actualOneElement = oneElement.contains("other");
+
+        Assertions.assertEquals(expectedOneElement, actualOneElement);
+
+
+        ArrayList<Double> tenElement = new ArrayList<>();
+        tenElement.add(0, 1.1);
+        tenElement.add(1, 1.2);
+        tenElement.add(2, 1.3);
+        tenElement.add(3, 1.4);
+        tenElement.add(4, 1.5);
+        tenElement.add(5, 1.6);
+        tenElement.add(6, 1.7);
+        tenElement.add(7, 1.8);
+        tenElement.add(8, 1.9);
+        tenElement.add(9, 2.0);
+
+
+        boolean tenElementsExpected = true;
+        boolean tenElementsActual = tenElement.contains(1.7);
+
+        Assertions.assertEquals(tenElementsExpected, tenElementsActual);
+    }
+
+    @Test
+    void isEmpty() {
+        ArrayList<Integer> linked = new ArrayList<>();
+
+
+        boolean expected = false;
+        boolean actual = linked.contains(5);
+        Assertions.assertEquals(expected, actual);
+
+
+        ArrayList<String> oneElement = new ArrayList<>();
+        oneElement.add(0, "test1");
+
+
+        boolean expectedOneElement = false;
+        boolean actualOneElement = oneElement.contains("other");
+
+        Assertions.assertEquals(expectedOneElement, actualOneElement);
+
+
+        ArrayList<Double> tenElement = new ArrayList<>();
+        tenElement.add(0, 1.1);
+        tenElement.add(1, 1.2);
+        tenElement.add(2, 1.3);
+        tenElement.add(3, 1.4);
+        tenElement.add(4, 1.5);
+        tenElement.add(5, 1.6);
+        tenElement.add(6, 1.7);
+        tenElement.add(7, 1.8);
+        tenElement.add(8, 1.9);
+        tenElement.add(9, 2.0);
+
+
+        boolean tenElementsExpected = true;
+        boolean tenElementsActual = tenElement.contains(1.7);
+
+        Assertions.assertEquals(tenElementsExpected, tenElementsActual);
+
+    }
+
+    @Test
+    void size() {
+
+        ArrayList<Integer> linked = new ArrayList<>();
+
+        int expected = 0;
+        int actual = linked.size();
+        Assertions.assertEquals(expected, actual);
+
+
+        ArrayList<String> oneElement = new ArrayList<>();
+        oneElement.add(0, "test1");
+
+
+        int expectedOneElement = 1;
+        int  actualOneElement = oneElement.size();
+
+        Assertions.assertEquals(expectedOneElement, actualOneElement);
+
+
+        ArrayList<Double> tenElement = new ArrayList<>();
+        tenElement.add(0, 1.1);
+        tenElement.add(1, 1.2);
+        tenElement.add(2, 1.3);
+        tenElement.add(3, 1.4);
+        tenElement.add(4, 1.5);
+        tenElement.add(5, 1.6);
+        tenElement.add(6, 1.7);
+        tenElement.add(7, 1.8);
+        tenElement.add(8, 1.9);
+        tenElement.add(9, 2.0);
+
+
+        int tenElementsExpected = 10;
+        int tenElementsActual = tenElement.size();
+
+        Assertions.assertEquals(tenElementsExpected, tenElementsActual);
+    }
+
+}
\ No newline at end of file
diff --git a/tests/LinkedListTest.java b/tests/LinkedListTest.java
new file mode 100644
index 0000000..966bab5
--- /dev/null
+++ b/tests/LinkedListTest.java
@@ -0,0 +1,474 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+
+
+class LinkedListTest {
+    @Test
+    void addFront() {
+
+        LinkedList<Integer> linked = new LinkedList<>();
+        linked.addFront(5);
+
+        int expected = 5;
+        int actual = linked.get(0);
+        Assertions.assertEquals(expected, actual);
+
+        LinkedList<String> oneElement = new LinkedList<>();
+        oneElement.addFront("test1");
+        oneElement.addFront("test2");
+
+        String expectedOneElement = "test2";
+        String actualOneElement = oneElement.get(0);
+        Assertions.assertEquals(expectedOneElement, actualOneElement);
+
+        LinkedList<Double> tenElement = new LinkedList<>();
+        tenElement.addFront(6.6);
+        tenElement.addFront(4.6);
+        tenElement.addFront(3.6);
+        tenElement.addFront(39.8);
+        tenElement.addFront(45.7);
+        tenElement.addFront(3.0);
+        tenElement.addFront(4.7);
+        tenElement.addFront(12.12);
+        tenElement.addFront(43.1);
+        tenElement.addFront(1.1);
+
+        Double tenElementsExpected = 1.1;
+        Double tenElementsActual = tenElement.get(0);
+
+        Assertions.assertEquals(tenElementsExpected, tenElementsActual);
+
+
+    }
+
+    @Test
+    void addBack() {
+
+        LinkedList<Integer> linked = new LinkedList<>();
+        linked.addBack(5);
+
+        int expected = 5;
+        int actual = linked.get(0);
+        Assertions.assertEquals(expected, actual);
+
+        LinkedList<String> oneElement = new LinkedList<>();
+        oneElement.addBack("test1");
+        oneElement.addBack("test2");
+
+        String expectedOneElement = "test2";
+        String actualOneElement = oneElement.get(1);
+        Assertions.assertEquals(expectedOneElement, actualOneElement);
+
+
+        LinkedList<Double> tenElement = new LinkedList<>();
+        tenElement.addFront(6.6);
+        tenElement.addFront(4.6);
+        tenElement.addFront(3.6);
+        tenElement.addFront(39.8);
+        tenElement.addFront(45.7);
+        tenElement.addFront(3.0);
+        tenElement.addFront(4.7);
+        tenElement.addFront(12.12);
+        tenElement.addFront(43.1);
+        tenElement.addFront(1.1);
+
+        Double tenElementsExpected = 6.6;
+        Double tenElementsActual = tenElement.get(9);
+
+        Assertions.assertEquals(tenElementsExpected, tenElementsActual);
+    }
+
+    @Test
+    void add() {
+        LinkedList<Integer> linked = new LinkedList<>();
+        linked.add(0, 5);
+
+        int expected = 5;
+        int actual = linked.get(0);
+        Assertions.assertEquals(expected, actual);
+
+        LinkedList<String> oneElement = new LinkedList<>();
+        oneElement.add(0, "test1");
+        oneElement.add(1, "test2");
+
+        String expectedOneElement = "test2";
+        String actualOneElement = oneElement.get(1);
+        Assertions.assertEquals(expectedOneElement, actualOneElement);
+
+
+        LinkedList<Double> tenElement = new LinkedList<>();
+        tenElement.add(0, 1.1);
+        tenElement.add(1, 1.2);
+        tenElement.add(2, 1.3);
+        tenElement.add(3, 1.4);
+        tenElement.add(4, 1.5);
+        tenElement.add(5, 1.6);
+        tenElement.add(6, 1.7);
+        tenElement.add(7, 1.8);
+        tenElement.add(8, 1.9);
+        tenElement.add(9, 2.0);
+
+
+        Double tenElementsExpected = 1.5;
+        Double tenElementsActual = tenElement.get(4);
+
+        Assertions.assertEquals(tenElementsExpected, tenElementsActual);
+    }
+
+    @Test
+    void get() {
+
+        LinkedList<Integer> linked = new LinkedList<>();
+
+        Assertions.assertThrows(IndexOutOfBoundsException.class, () -> {
+            Integer actual = linked.get(0);
+            Assertions.assertNull(actual);
+        });
+
+
+        LinkedList<String> oneElement = new LinkedList<>();
+        oneElement.add(0, "test1");
+        oneElement.add(1, "test2");
+        oneElement.get(0);
+
+        String expectedOneElement = "test1";
+        String actualOneElement = oneElement.get(0);
+        Assertions.assertEquals(expectedOneElement, actualOneElement);
+
+
+        LinkedList<Double> tenElement = new LinkedList<>();
+        tenElement.add(0, 1.1);
+        tenElement.add(1, 1.2);
+        tenElement.add(2, 1.3);
+        tenElement.add(3, 1.4);
+        tenElement.add(4, 1.5);
+        tenElement.add(5, 1.6);
+        tenElement.add(6, 1.7);
+        tenElement.add(7, 1.8);
+        tenElement.add(8, 1.9);
+        tenElement.add(9, 2.0);
+
+
+        Double tenElementsExpected = 1.5;
+        Double tenElementsActual = tenElement.get(4);
+
+        Assertions.assertEquals(tenElementsExpected, tenElementsActual);
+    }
+
+    @Test
+    void set() {
+
+
+        LinkedList<Integer> linked = new LinkedList<>();
+        linked.set(0,5);
+
+        int expected = 5;
+        int actual = linked.get(0);
+        Assertions.assertEquals(expected, actual);
+
+        LinkedList<String> oneElement = new LinkedList<>();
+        oneElement.add(0,"test1");
+        oneElement.set(1,"test2");
+
+        String expectedOneElement = "test1";
+        String actualOneElement = oneElement.get(0);
+        Assertions.assertEquals(expectedOneElement, actualOneElement);
+
+        LinkedList<Double> tenElement = new LinkedList<>();
+        tenElement.addFront(6.6);
+        tenElement.addFront(4.6);
+        tenElement.addFront(3.6);
+        tenElement.addFront(39.8);
+        tenElement.addFront(45.7);
+        tenElement.addFront(3.0);
+        tenElement.addFront(4.7);
+        tenElement.addFront(12.12);
+        tenElement.addFront(43.1);
+        tenElement.addFront(1.1);
+        tenElement.set(3,99.9);
+
+        Double tenElementsExpected = 99.9;
+        Double tenElementsActual = tenElement.get(3);
+
+        Assertions.assertEquals(tenElementsExpected, tenElementsActual);
+
+    }
+
+    @Test
+    void removeFront() {
+
+        LinkedList<Integer> linked = new LinkedList<>();
+
+        Assertions.assertThrows(IndexOutOfBoundsException.class, () -> {
+            Integer actual = linked.removeFront();
+            Assertions.assertNull(actual);
+        });
+
+
+        LinkedList<String> oneElement = new LinkedList<>();
+        oneElement.add(0, "test1");
+
+        String expectedOneElement = "test1";
+        String actualOneElement = oneElement.get(0);
+        Assertions.assertEquals(expectedOneElement, actualOneElement);
+
+
+        LinkedList<Double> tenElement = new LinkedList<>();
+        tenElement.add(0, 1.1);
+        tenElement.add(1, 1.2);
+        tenElement.add(2, 1.3);
+        tenElement.add(3, 1.4);
+        tenElement.add(4, 1.5);
+        tenElement.add(5, 1.6);
+        tenElement.add(6, 1.7);
+        tenElement.add(7, 1.8);
+        tenElement.add(8, 1.9);
+        tenElement.add(9, 2.0);
+        tenElement.removeFront();
+
+
+        Double tenElementsExpected = 1.2;
+        Double tenElementsActual = tenElement.get(0);
+
+        Assertions.assertEquals(tenElementsExpected, tenElementsActual);
+    }
+
+    @Test
+    void removeBack() {
+
+        LinkedList<Integer> linked = new LinkedList<>();
+
+        Assertions.assertThrows(IndexOutOfBoundsException.class, () -> {
+            Integer actual = linked.removeBack();
+            Assertions.assertNull(actual);
+        });
+
+
+        LinkedList<String> oneElement = new LinkedList<>();
+        oneElement.add(0, "test1");
+        oneElement.add(1, "test2");
+        oneElement.removeBack();
+
+        String expectedOneElement = "test1";
+        String actualOneElement = oneElement.get(0);
+        Assertions.assertEquals(expectedOneElement, actualOneElement);
+
+
+        LinkedList<Double> tenElement = new LinkedList<>();
+        tenElement.add(0, 1.1);
+        tenElement.add(1, 1.2);
+        tenElement.add(2, 1.3);
+        tenElement.add(3, 1.4);
+        tenElement.add(4, 1.5);
+        tenElement.add(5, 1.6);
+        tenElement.add(6, 1.7);
+        tenElement.add(7, 1.8);
+        tenElement.add(8, 1.9);
+        tenElement.add(9, 2.0);
+        tenElement.removeBack();
+
+
+        Double tenElementsExpected = 1.9;
+        Double tenElementsActual = tenElement.get(8);
+
+        Assertions.assertEquals(tenElementsExpected, tenElementsActual);
+    }
+
+    @Test
+    void remove() {
+        LinkedList<Integer> linked = new LinkedList<>();
+
+        Assertions.assertThrows(IndexOutOfBoundsException.class, () -> {
+            Integer actual = linked.remove(0);
+            Assertions.assertNull(actual);
+        });
+
+
+        LinkedList<String> oneElement = new LinkedList<>();
+        oneElement.add(0, "test1");
+        oneElement.add(1, "test2");
+
+
+        String expectedOneElement = "test1";
+        String actualOneElement = oneElement.remove(0);
+        Assertions.assertEquals(expectedOneElement, actualOneElement);
+
+
+        LinkedList<Double> tenElement = new LinkedList<>();
+        tenElement.add(0, 1.1);
+        tenElement.add(1, 1.2);
+        tenElement.add(2, 1.3);
+        tenElement.add(3, 1.4);
+        tenElement.add(4, 1.5);
+        tenElement.add(5, 1.6);
+        tenElement.add(6, 1.7);
+        tenElement.add(7, 1.8);
+        tenElement.add(8, 1.9);
+        tenElement.add(9, 2.0);
+
+
+        Double tenElementsExpected = 1.4;
+        Double tenElementsActual = tenElement.remove(3);
+
+        Assertions.assertEquals(tenElementsExpected, tenElementsActual);
+    }
+
+    @Test
+    void testRemove() {
+        LinkedList<Integer> linked = new LinkedList<>();
+
+        Assertions.assertThrows(IndexOutOfBoundsException.class, () -> {
+            Integer actual = linked.remove(9);
+            Assertions.assertNull(actual);
+        });
+
+
+        LinkedList<String> oneElement = new LinkedList<>();
+        oneElement.add(0, "test1");
+        oneElement.add(1, "test2");
+        oneElement.remove("test1");
+
+        String expectedOneElement = "test1";
+        String actualOneElement = oneElement.get(0);
+        Assertions.assertEquals(expectedOneElement, actualOneElement);
+
+
+        LinkedList<Double> tenElement = new LinkedList<>();
+        tenElement.add(0, 1.1);
+        tenElement.add(1, 1.2);
+        tenElement.add(2, 1.3);
+        tenElement.add(3, 1.4);
+        tenElement.add(4, 1.5);
+        tenElement.add(5, 1.6);
+        tenElement.add(6, 1.7);
+        tenElement.add(7, 1.8);
+        tenElement.add(8, 1.9);
+        tenElement.add(9, 2.0);
+        tenElement.remove(1.5);
+
+
+        Double tenElementsExpected = 1.6;
+        Double tenElementsActual = tenElement.get(4);
+
+        Assertions.assertEquals(tenElementsExpected, tenElementsActual);
+    }
+
+    @Test
+    void contains() {
+        LinkedList<Integer> linked = new LinkedList<>();
+
+
+        boolean expected = false;
+        boolean actual = linked.contains(5);
+        Assertions.assertEquals(expected, actual);
+
+
+        LinkedList<String> oneElement = new LinkedList<>();
+        oneElement.add(0, "test1");
+        oneElement.add(1, "test2");
+
+
+        boolean expectedOneElement = false;
+        boolean actualOneElement = oneElement.contains("other");
+
+        Assertions.assertEquals(expectedOneElement, actualOneElement);
+
+
+        LinkedList<Double> tenElement = new LinkedList<>();
+        tenElement.add(0, 1.1);
+        tenElement.add(1, 1.2);
+        tenElement.add(2, 1.3);
+        tenElement.add(3, 1.4);
+        tenElement.add(4, 1.5);
+        tenElement.add(5, 1.6);
+        tenElement.add(6, 1.7);
+        tenElement.add(7, 1.8);
+        tenElement.add(8, 1.9);
+        tenElement.add(9, 2.0);
+
+
+        boolean tenElementsExpected = true;
+        boolean tenElementsActual = tenElement.contains(1.7);
+
+        Assertions.assertEquals(tenElementsExpected, tenElementsActual);
+
+    }
+
+    @Test
+    void isEmpty() {
+        LinkedList<Integer> linked = new LinkedList<>();
+
+
+        boolean expected = false;
+        boolean actual = linked.contains(5);
+        Assertions.assertEquals(expected, actual);
+
+
+        LinkedList<String> oneElement = new LinkedList<>();
+        oneElement.add(0, "test1");
+
+
+        boolean expectedOneElement = false;
+        boolean actualOneElement = oneElement.contains("other");
+
+        Assertions.assertEquals(expectedOneElement, actualOneElement);
+
+
+        LinkedList<Double> tenElement = new LinkedList<>();
+        tenElement.add(0, 1.1);
+        tenElement.add(1, 1.2);
+        tenElement.add(2, 1.3);
+        tenElement.add(3, 1.4);
+        tenElement.add(4, 1.5);
+        tenElement.add(5, 1.6);
+        tenElement.add(6, 1.7);
+        tenElement.add(7, 1.8);
+        tenElement.add(8, 1.9);
+        tenElement.add(9, 2.0);
+
+
+        boolean tenElementsExpected = true;
+        boolean tenElementsActual = tenElement.contains(1.7);
+
+        Assertions.assertEquals(tenElementsExpected, tenElementsActual);
+    }
+
+    @Test
+    void size() {
+        LinkedList<Integer> linked = new LinkedList<>();
+
+        int expected = 0;
+        int actual = linked.size();
+        Assertions.assertEquals(expected, actual);
+
+
+        LinkedList<String> oneElement = new LinkedList<>();
+        oneElement.add(0, "test1");
+
+
+        int expectedOneElement = 1;
+        int  actualOneElement = oneElement.size();
+
+        Assertions.assertEquals(expectedOneElement, actualOneElement);
+
+
+        LinkedList<Double> tenElement = new LinkedList<>();
+        tenElement.add(0, 1.1);
+        tenElement.add(1, 1.2);
+        tenElement.add(2, 1.3);
+        tenElement.add(3, 1.4);
+        tenElement.add(4, 1.5);
+        tenElement.add(5, 1.6);
+        tenElement.add(6, 1.7);
+        tenElement.add(7, 1.8);
+        tenElement.add(8, 1.9);
+        tenElement.add(9, 2.0);
+
+
+        int tenElementsExpected = 10;
+        int tenElementsActual = tenElement.size();
+
+        Assertions.assertEquals(tenElementsExpected, tenElementsActual);
+    }
+}
\ No newline at end of file