myset is basically done

src/main/java/MyArrayList.java

@@ -97,6 +97,10 @@ public class MyArrayList<T> {
         return false;
     }
 
+    public T[] toArray(){
+        return getOriginalArray();
+    }
+
 //    public int indexOf(T value) {
 //        return 0;
 //    }

src/main/java/MySet.java

@@ -1,2 +1,103 @@
-public class MySet {
+//MySet must be a generic type, which can store any other type of object
+//An instance of MySet must contain no duplicates
+//MySet must not use List, ArrayList, or any other built-in collection types in its implementation. You may use Arrays, and you may use your implementation of MyArrayList (if it helps -- you don't have to use it)
+//MySet must have all of the methods listed on the Java Set documentation
+
+import java.lang.reflect.Array;
+import java.util.Collection;
+import java.util.Set;
+
+public class MySet<T> {
+
+    private T[] originalArray;
+    private int size;
+
+    public MySet() {
+        this.size = 0;
+        this.originalArray = (T[]) new Object[0];
+    }
+
+    public void add(T value) {
+        if (!contains(value)) {
+            T[] newArray = (T[]) Array.newInstance(originalArray.getClass().getComponentType(), originalArray.length + 1);
+
+            for (int i = 0; i < originalArray.length; i++) {
+                newArray[i] = originalArray[i];
+            }
+
+            newArray[newArray.length - 1] = value;
+            setOriginalArray(newArray);
+            setSize(newArray.length);
+        }
+    }
+
+    public void addAll(Collection<? extends T> collection) {
+        for (T element : collection) {
+            if (!contains(element)) {
+                this.add(element);
+            }
+        }
+    }
+
+    public void clear() {
+        setOriginalArray((T[]) Array.newInstance(originalArray.getClass().getComponentType(), 0));
+        setSize(0);
+    }
+
+    public boolean contains(T value) {
+        for (T element : originalArray) {
+            if (element == value) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public boolean containsAll(Collection<? extends T> collection) {
+        boolean[] allTrue = new boolean[collection.size()];
+        int j = 0;
+
+        for (T element : collection) {
+            for (T value : originalArray) {
+                if (element == value) {
+                    allTrue[j] = true;
+                    j++;
+                }
+            }
+        }
+
+        for (boolean result : allTrue) {
+            if (!result) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public boolean isEmpty() {
+        if (size() == 0) {
+            return true;
+        }
+        return false;
+    }
+
+    public T get(int index) {
+        return originalArray[index];
+    }
+
+    public T[] getOriginalArray() {
+        return originalArray;
+    }
+
+    public void setOriginalArray(T[] originalArray) {
+        this.originalArray = originalArray;
+    }
+
+    public int size() {
+        return size;
+    }
+
+    public void setSize(int size) {
+        this.size = size;
+    }
 }

src/test/java/MySetTest.java

@@ -0,0 +1,178 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.ArrayList;
+
+public class MySetTest {
+
+    MySet<Integer> testSet = new MySet<>();
+
+    public void populateSet() {
+        testSet.add(10);
+        testSet.add(3);
+        testSet.add(9);
+        testSet.add(2);
+    }
+
+    @Test
+    public void testAdd() {
+        testSet.add(10);
+
+        Integer expected = 10;
+        Integer actual = testSet.get(0);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testAdd_Multiple() {
+        populateSet();
+
+        Integer expected = 2;
+        Integer actual = testSet.get(3);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test(expected = IndexOutOfBoundsException.class)
+    public void testAdd_IfDuplicate() {
+        testSet.add(10);
+        testSet.add(10);
+
+        testSet.get(2);
+    }
+
+    @Test
+    public void testAdd_IfDuplicate_Size() {
+        populateSet();
+        testSet.add(9);
+
+        int expected = 4;
+        int actual = testSet.size();
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testAddAll_NoDuplicates() {
+        populateSet();
+        ArrayList<Integer> addArray = new ArrayList<>();
+        addArray.add(5);
+        addArray.add(7);
+        addArray.add(8);
+
+        testSet.addAll(addArray);
+
+        int expected = 7;
+        int actual = testSet.size();
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testAddAll_OneDuplicate() {
+        populateSet();
+        ArrayList<Integer> addArray = new ArrayList<>();
+        addArray.add(5);
+        addArray.add(7);
+        addArray.add(10);
+
+        testSet.addAll(addArray);
+
+        int expected = 6;
+        int actual = testSet.size();
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testAddAll_AllDuplicates() {
+        populateSet();
+        ArrayList<Integer> addArray = new ArrayList<>();
+        addArray.add(9);
+        addArray.add(3);
+        addArray.add(10);
+
+        testSet.addAll(addArray);
+
+        int expected = 4;
+        int actual = testSet.size();
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testClear(){
+        populateSet();
+        int expected = 4;
+        int actual = testSet.size();
+
+        Assert.assertEquals(expected, actual);
+
+        testSet.clear();
+        int newExpected = 0;
+        int newActual = testSet.size();
+
+        Assert.assertEquals(newExpected, newActual);
+    }
+
+    @Test
+    public void testContains_EmptySet(){
+        Assert.assertFalse(testSet.contains(10));
+    }
+
+    @Test
+    public void testContains_True(){
+        populateSet();
+
+        Assert.assertTrue(testSet.contains(10));
+    }
+
+    @Test
+    public void testContains_False(){
+        populateSet();
+
+        Assert.assertFalse(testSet.contains(7));
+    }
+
+    @Test
+    public void testContainsAll_False() {
+        populateSet();
+        ArrayList<Integer> newArray = new ArrayList<>();
+        newArray.add(2);
+        newArray.add(3);
+        newArray.add(7);
+
+        Assert.assertFalse(testSet.containsAll(newArray));
+    }
+
+    @Test
+    public void testContainsAll_True() {
+        populateSet();
+        ArrayList<Integer> newArray = new ArrayList<>();
+        newArray.add(9);
+        newArray.add(3);
+        newArray.add(10);
+
+        Assert.assertTrue(testSet.containsAll(newArray));
+    }
+
+    @Test
+    public void testIsEmpty_True(){
+        Assert.assertTrue(testSet.isEmpty());
+    }
+
+    @Test
+    public void testIsEmpty_False(){
+        populateSet();
+
+        Assert.assertFalse(testSet.isEmpty());
+    }
+
+    @Test
+    public void testEquals(){
+        MySet<Object> object = new MySet<>();
+        testSet.equals(object);
+    }
+
+}