first commit

.gitignore

@@ -0,0 +1,115 @@
+# Created by .ignore support plugin (hsz.mobi)
+### Java template
+# Compiled class file
+*.class
+
+# Log file
+*.log
+
+# BlueJ files
+*.ctxt
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files #
+*.jar
+*.war
+*.ear
+*.zip
+*.tar.gz
+*.rar
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+### Eclipse template
+
+.metadata
+bin/
+tmp/
+*.tmp
+*.bak
+*.swp
+*~.nib
+local.properties
+.settings/
+.loadpath
+.recommenders
+
+# Eclipse Core
+.project
+
+# External tool builders
+.externalToolBuilders/
+
+# Locally stored "Eclipse launch configurations"
+*.launch
+
+# PyDev specific (Python IDE for Eclipse)
+*.pydevproject
+
+# CDT-specific (C/C++ Development Tooling)
+.cproject
+
+# JDT-specific (Eclipse Java Development Tools)
+.classpath
+
+# Java annotation processor (APT)
+.factorypath
+
+# PDT-specific (PHP Development Tools)
+.buildpath
+
+# sbteclipse plugin
+.target
+
+# Tern plugin
+.tern-project
+
+# TeXlipse plugin
+.texlipse
+
+# STS (Spring Tool Suite)
+.springBeans
+
+# Code Recommenders
+.recommenders/
+
+# Scala IDE specific (Scala & Java development for Eclipse)
+.cache-main
+.scala_dependencies
+.worksheet
+### macOS template
+*.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+#Intellij files
+.idea
+*.iml
+
+#maven build target
+target/

README.md

@@ -0,0 +1,233 @@
+
+# Delete Duplicates 
+* **Objective**
+	* To write a method which removes duplicate elements from an array.
+* **Purpose**
+	* To demonstrate practical understanding of `while`, `for`, and `for each` loops.
+* **Instructions**
+    * Given an object, `DuplicateDeleter`, with a composite `Integer[]` object, write a method
+        * `removeDuplicatesExactly` which removes all values in the array which occur exactly the specified number of times.
+        * `removeDuplicates` which removes all values in the array which occur at least the specified number of times.
+
+* **Restrictions**
+    * No use of any built-in data structures, (`Collection`, `List`, `Map`)
+    * Operations should be [idempotent](https://stackoverflow.com/questions/1077412/what-is-an-idempotent-operation)
+        * The output of the methods should always be the same if the input is the same.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# Sample Behavior - DuplicateDeleter.removeDuplicateExactly(n)
+
+## Example 1
+* Sample Script
+    ```
+    // : Given
+    Integer[] array = new Integer[]{1,1,1,23,23,56,57,58};
+    DuplicateDeleter deleter = new DuplicateDeleter(array);
+    
+    // : When
+    Integer[] actual = deleter.removeDuplicateExactly(3);
+    
+    // : Then
+    System.out.println(Arrays.toString(actual));
+    ```
+
+* Sample Output
+    ```
+    [23,23,56,57,58]
+    ```
+    
+
+## Example 2
+* Sample Script
+    ```
+    // : Given
+    Integer[] array = new Integer[]{1,1,1,23,23,56,57,58};
+    DuplicateDeleter deleter = new DuplicateDeleter(array);
+    
+    // : When
+    Integer[] actual = deleter.removeDuplicateExactly(1);
+    
+    // : Then
+    System.out.println(Arrays.toString(actual));
+    ```
+
+* Sample Output
+    ```
+    [1,1,1,23,23]
+    ```
+    
+
+## Example 3
+* Sample Script
+    ```
+    // : Given
+    Integer[] array = new Integer[]{0, 0, 0, 1, 1, 2, 3, 3, 3, 4, 4, 5, 5, 5, 5};
+    DuplicateDeleter deleter = new DuplicateDeleter(array);
+    
+    // : When
+    Integer[] actual = deleter.removeDuplicateExactly(3);
+    
+    // : Then
+    System.out.println(Arrays.toString(actual));
+    ```
+
+* Sample Output
+    ```
+    [1, 1, 2, 4, 4, 5, 5, 5, 5]
+    ```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# Sample Behavior - DuplicateDeleter.removeDuplicates(n)
+
+## Example 1
+* Sample Script
+    ```
+    // : Given
+    Integer[] array = new Integer[]{1,1,1,23,23,56,57,58};
+    DuplicateDeleter deleter = new DuplicateDeleter(array);
+    
+    // : When
+    Integer[] actual = deleter.removeDuplicateExactly(1);
+    
+    // : Then
+    System.out.println(Arrays.toString(actual));
+    ```
+
+* Sample Output
+    ```
+    []
+    ```
+
+
+
+
+## Example 2
+* Sample Script
+    ```
+    // : Given
+    Integer[] array = new Integer[]{0, 0, 0, 1, 1, 2, 3, 3, 3, 4, 4, 5, 5, 5, 5};
+    DuplicateDeleter deleter = new DuplicateDeleter(array);
+    
+    // : When
+    Integer[] actual = deleter.removeDuplicates(2);
+    
+    // : Then
+    System.out.println(Arrays.toString(actual));
+    ```
+
+* Sample Output
+    ```
+    [2]
+    ```
+
+
+
+## Example 3
+* Sample Script
+    ```
+    // : Given
+    Integer[] array = new Integer[]{0, 0, 0, 1, 1, 2, 3, 3, 3, 4, 4, 5, 5, 5, 5};
+    DuplicateDeleter deleter = new DuplicateDeleter(array);
+    
+    // : When
+    Integer[] actual = deleter.removeDuplicates(3);
+    
+    // : Then
+    System.out.println(Arrays.toString(actual));
+    ```
+
+* Sample Output
+    ```
+    [1,1,2,4,4]
+    ```
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+# Sample Behavior - Idempotence
+
+## Example 1
+* Sample Script
+    ```
+    // : Given
+    Integer[] array = new Integer[]{0, 0, 0, 1, 1, 2, 3, 3, 3, 4, 4, 5, 5, 5, 5};
+    DuplicateDeleter deleter = new DuplicateDeleter(array);
+    deleter.removeDuplicates(0);
+    deleter.removeDuplicates(1);
+    deleter.removeDuplicates(2);
+    
+    // : When
+    Integer[] actual = deleter.removeDuplicates(3);
+    
+    // : Then
+    System.out.println(Arrays.toString(actual));
+    ```
+
+* Sample Output
+    ```
+    [1,1,2,4,4]
+    ```
+    
+
+## Example 2
+* Sample Script
+    ```
+    // : Given
+    Integer[] array = new Integer[]{1,1,1,23,23,56,57,58};
+    DuplicateDeleter deleter = new DuplicateDeleter(array);
+    deleter.removeDuplicates(0);
+    deleter.removeDuplicates(1);
+    deleter.removeDuplicates(2);
+    
+    // : When
+    Integer[] actual = deleter.removeDuplicatesExactly(3);
+    
+    // : Then
+    System.out.println(Arrays.toString(actual));
+    ```
+
+* Sample Output
+    ```
+    [23,23,56,57,58]
+    ```

pom.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>com.zipcodewilmington.looplabs</groupId>
+    <artifactId>deleteduplicates</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+        </dependency>
+    </dependencies>
+    <properties>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+    </properties>
+
+</project>

src/main/java/com/zipcodewilmington/looplabs/DuplicateDeleter.java

@@ -0,0 +1,15 @@
+package com.zipcodewilmington.looplabs;
+
+/**
+ * Created by leon on 1/25/18.
+ */
+public abstract class DuplicateDeleter<T> implements DuplicateDeleterInterface<T> {
+    protected final T[] array;
+
+    public DuplicateDeleter(T[] intArray) {
+        this.array = intArray;
+    }
+
+    abstract public T[] removeDuplicates(int maxNumberOfDuplications);
+    abstract public T[] removeDuplicatesExactly(int exactNumberOfDuplications);
+}

src/main/java/com/zipcodewilmington/looplabs/DuplicateDeleterInterface.java

@@ -0,0 +1,10 @@
+package com.zipcodewilmington.looplabs;
+
+/**
+ * Created by leon on 1/28/18.
+ * @ATTENTION_TO_STUDENTS You are forbidden from modifying this class.
+ */
+public interface DuplicateDeleterInterface<T> {
+    T[] removeDuplicates(int maxNumberOfDuplications);
+    T[] removeDuplicatesExactly(int exactNumberOfDuplications);
+}

src/main/java/com/zipcodewilmington/looplabs/IntegerDuplicateDeleter.java

@@ -0,0 +1,8 @@
+package com.zipcodewilmington.looplabs;
+
+/**
+ * Created by leon on 1/29/18.
+ * @ATTENTION_TO_STUDENTS You are forbidden from modifying the signature of this class.
+ */
+public final class IntegerDuplicateDeleter extends DuplicateDeleter<Integer> {
+}

src/main/java/com/zipcodewilmington/looplabs/RandomNumberFactory.java

@@ -0,0 +1,80 @@
+package com.zipcodewilmington.looplabs;
+
+import java.util.Random;
+
+/**
+ * @author leon.hunter
+ * @ATTENTION_TO_STUDENTS You are forbidden from modifying this class.
+ */
+public final class RandomNumberFactory {
+    private static volatile Random random = new Random();
+
+    private RandomNumberFactory() {
+    }
+    /**
+     * @param min
+     * @param max
+     * @return a random character between the specified min and max character range
+     */
+    public static Character createCharacter(char min, char max) {
+        return (char) createInteger((int) min, (int) max).intValue();
+    }
+
+    /**
+     * @param min
+     * @param max
+     * @return a random float between the specified minimum and maximum numeric range
+     */
+    public static synchronized Float createFloat(float min, float max) {
+        return random.nextFloat() * (max - min) + min;
+    }
+
+    /**
+     * @param min
+     * @param max
+     * @return a random integer between the specified minimum and maximum numeric range
+     */
+    public static Integer createInteger(Integer min, Integer max) {
+        return createFloat(min, max).intValue();
+    }
+
+    /**
+     * @param min
+     * @param max
+     * @return an array the specified length containing integers in the specified range
+     */
+    public static Integer[] createIntegers(int min, int max, int length) {
+        Integer[] integers = new Integer[length];
+        for(int i=0; i<length; i++) {
+            integers[i] = createInteger(min, max);
+        }
+        return integers;
+    }
+
+    /**
+     * @param min
+     * @param max
+     * @return a random string of the specified length containing characters in the specified range
+     */
+    public static String createString(char min, char max, int length) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < length; i++) {
+            sb.append(createCharacter(min, max));
+        }
+        return sb.toString();
+    }
+
+
+    /**
+     * @param min
+     * @param max
+     * @return an array containing arrays of specified length containing characters in the specified range
+     */
+    public static String[] createStrings(char min, char max, int stringLength, int arrayLength) {
+        String[] array = new String[arrayLength];
+        for(int i=0; i<arrayLength; i++) {
+            array[i] = createString(min, max, stringLength);
+        }
+        return array;
+    }
+}

src/main/java/com/zipcodewilmington/looplabs/StringDuplicateDeleter.java

@@ -0,0 +1,8 @@
+package com.zipcodewilmington.looplabs;
+
+/**
+ * Created by leon on 1/28/18.
+ * @ATTENTION_TO_STUDENTS You are forbidden from modifying the signature of this class.
+ */
+public final class StringDuplicateDeleter extends DuplicateDeleter<String> {
+}

src/test/java/com/zipcodewilmington/looplabs/IntegerDuplicateDeleterTest.java

@@ -0,0 +1,183 @@
+package com.zipcodewilmington.looplabs;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Arrays;
+
+/**
+ * Created by leon on 1/25/18.
+ * @ATTENTION_TO_STUDENTS You are forbidden from modifying this class.
+ */
+public class IntegerDuplicateDeleterTest {
+
+    private static Integer[] intArray;
+    private static DuplicateDeleter<Integer> deleter;
+
+    @Before
+    public void setup() {
+        this.intArray = new Integer[]{0, 0, 0, 1, 2, 2, 4, 4, 5, 5, 5, 6, 9, 9, 9};
+        this.deleter = new IntegerDuplicateDeleter(intArray);
+    }
+
+
+    @Test
+    public void testRemoveDuplicatesExactlyExactly() {
+        Integer[] expected = new Integer[]{1, 2, 2, 4, 4, 6};
+        Integer[] actual = deleter.removeDuplicatesExactly(3);
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+    @Test
+    public void testRemoveDuplicatesExactly1() {
+        Integer[] expected = new Integer[]{0, 0, 0, 1, 5, 5, 5, 6, 9, 9, 9};
+        Integer[] actual = deleter.removeDuplicatesExactly(2);
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+
+    @Test
+    public void testRemoveDuplicatesExactly2() {
+        Integer[] expected = new Integer[]{0, 0, 0, 2, 2, 4, 4, 5, 5, 5, 9, 9, 9};
+        Integer[] actual = deleter.removeDuplicatesExactly(1);
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+    @Test
+    public void testRemoveDuplicatesExactly3() {
+        Integer[] expected = new Integer[]{1, 2, 2, 4, 4, 6};
+        deleter.removeDuplicates(3);
+        deleter.removeDuplicatesExactly(2);
+        deleter.removeDuplicatesExactly(1);
+
+        Integer[] actual = deleter.removeDuplicatesExactly(3);
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    @Test
+    public void testRemoveDuplicates0() {
+        Integer[] array = new Integer[]{0, 0, 0, 1, 1, 2, 3, 3, 3, 4, 4, 5, 5, 5, 5};
+        DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(array);
+        Integer[] expected = new Integer[]{};
+        Integer[] actual = deleter.removeDuplicates(0);
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+    @Test
+    public void testRemoveDuplicates1() {
+        Integer[] array = new Integer[]{0, 0, 0, 1, 1, 2, 3, 3, 3, 4, 4, 5, 5, 5, 5};
+        DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(array);
+        Integer[] expected = new Integer[]{};
+        Integer[] actual = deleter.removeDuplicates(1);
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+    @Test
+    public void testRemoveDuplicates2() {
+        Integer[] array = new Integer[]{0, 0, 0, 1, 1, 2, 3, 3, 3, 4, 4, 5, 5, 5, 5};
+        DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(array);
+        Integer[] expected = new Integer[]{2};
+        Integer[] actual = deleter.removeDuplicates(2);
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+    @Test
+    public void testRemoveDuplicates3() {
+        Integer[] array = new Integer[]{0, 0, 0, 1, 1, 2, 3, 3, 3, 4, 4, 5, 5, 5, 5};
+        DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(array);
+        Integer[] expected = new Integer[]{1,1,2,4,4};
+        Integer[] actual = deleter.removeDuplicates(3);
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+    @Test
+    public void testRemoveDuplicates4() {
+        Integer[] array = new Integer[]{0, 0, 0, 1, 1, 2, 3, 3, 3, 4, 4, 5, 5, 5, 5};
+        DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(array);
+        Integer[] expected = new Integer[]{0,0,0,1,1,2,3,3,3,4,4};
+        Integer[] actual = deleter.removeDuplicates(4);
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    @Test
+    public void testRemoveDuplicatesExactlyIdempotence() {
+        Integer[] input = RandomNumberFactory.createIntegers(0,50,150);
+        DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(input);
+        Integer[] expected = deleter.removeDuplicatesExactly(5);
+
+        for (int i = 0; i < input.length; i++) {
+            deleter.removeDuplicatesExactly(i);
+        }
+
+        Integer[] actual = deleter.removeDuplicatesExactly(5);
+
+        Arrays.sort(input);
+        System.out.println("Input:\n\t" + Arrays.toString(input));
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+    @Test
+    public void testRemoveDuplicatesIdempotence() {
+        Integer[] input = RandomNumberFactory.createIntegers(0,50,150);
+        DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(input);
+        Integer[] expected = deleter.removeDuplicates(5);
+
+        for (int i = 0; i < input.length; i++) {
+            deleter.removeDuplicates(i);
+        }
+
+        Integer[] actual = deleter.removeDuplicates(5);
+
+        Arrays.sort(input);
+        System.out.println("Input:\n\t" + Arrays.toString(input));
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+}

src/test/java/com/zipcodewilmington/looplabs/StringDuplicateDeleterTest.java

@@ -0,0 +1,171 @@
+package com.zipcodewilmington.looplabs;
+
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Arrays;
+
+/**
+ * Created by leon on 1/28/18.
+ * @ATTENTION_TO_STUDENTS You are forbidden from modifying this class.
+ */
+public class StringDuplicateDeleterTest {
+    private static String[] stringArray;
+    private static volatile DuplicateDeleter<String> deleter;
+
+    @Before
+    public void setup() {
+        this.stringArray = new String[]{"aba", "aba", "baa", "bab", "bba", "bba", "bba", "bba", "bbb", "bbb"};
+        this.deleter = new StringDuplicateDeleter(stringArray);
+    }
+
+
+    @Test
+    public void testRemoveDuplicatesExactly1() {
+        String[] expected = new String[]{"aba", "aba", "bba", "bba", "bba", "bba", "bbb", "bbb"};
+        String[] actual = deleter.removeDuplicatesExactly(1);
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+    @Test
+    public void testRemoveDuplicatesExactly2() {
+        String[] expected = new String[]{"baa", "bab", "bba", "bba", "bba", "bba"};
+        String[] actual = deleter.removeDuplicatesExactly(2);
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+    @Test
+    public void testRemoveDuplicatesExactly3() {
+        String[] expected = new String[]{"aba", "aba", "baa", "bab", "bba", "bba", "bba", "bba", "bbb", "bbb"};
+        String[] actual = deleter.removeDuplicatesExactly(3);
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+    @Test
+    public void testRemoveDuplicatesExactly4() {
+        String[] expected = new String[]{"aba", "aba", "baa", "bab", "bbb", "bbb"};
+        String[] actual = deleter.removeDuplicatesExactly(4);
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+    @Test
+    public void testRemoveDuplicatesExactly5() {
+        String[] input = new String[]{"aa", "aa", "aa", "aa", "aa", "ab", "ba", "ba", "ba", "ba", "bb", "bb", "bb", "bb", "bb"};
+        DuplicateDeleter<String> deleter = new StringDuplicateDeleter(input);
+        String[] expected = new String[]{"ab", "ba", "ba", "ba", "ba"};
+        String[] actual = deleter.removeDuplicatesExactly(5);
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    @Test
+    public void testRemoveDuplicates0() {
+        String[] input = new String[]{"aa", "aa", "aa", "aa", "aa", "ab", "ba", "ba", "ba", "ba", "bb", "bb", "bb", "bb", "bb"};
+        DuplicateDeleter<String> deleter = new StringDuplicateDeleter(input);
+        String[] expected = new String[]{};
+        String[] actual = deleter.removeDuplicates(0);
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+
+    @Test
+    public void testRemoveDuplicates1() {
+        String[] input = new String[]{"aa", "aa", "aa", "aa", "aa", "ab", "ba", "ba", "ba", "ba", "bb", "bb", "bb", "bb", "bb"};
+        DuplicateDeleter<String> deleter = new StringDuplicateDeleter(input);
+        String[] expected = new String[]{};
+        String[] actual = deleter.removeDuplicates(1);
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+    @Test
+    public void testRemoveDuplicates2() {
+        String[] input = new String[]{"aa", "aa", "aa", "aa", "aa", "ab", "ba", "ba", "ba", "ba", "bb", "bb", "bb", "bb", "bb"};
+        DuplicateDeleter<String> deleter = new StringDuplicateDeleter(input);
+        String[] expected = new String[]{"ab"};
+        String[] actual = deleter.removeDuplicates(2);
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+    @Test
+    public void testRemoveDuplicates3() {
+        String[] input = new String[]{"aa", "aa", "aa", "aa", "aa", "ab", "ba", "ba", "ba", "ba", "bb", "bb", "bb", "bb", "bb"};
+        DuplicateDeleter<String> deleter = new StringDuplicateDeleter(input);
+        String[] expected = new String[]{"ab"};
+        String[] actual = deleter.removeDuplicates(3);
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    @Test
+    public void testRemoveDuplicatesExactlyIdempotence() {
+        String[] input = RandomNumberFactory.createStrings('a', 'c', 2, 15);
+        DuplicateDeleter<String> deleter = new StringDuplicateDeleter(input);
+        String[] expected = deleter.removeDuplicatesExactly(5);
+
+        for (int i = 0; i < input.length; i++) {
+            deleter.removeDuplicatesExactly(i);
+        }
+
+        String[] actual = deleter.removeDuplicatesExactly(5);
+
+        Arrays.sort(input);
+        System.out.println("Input:\n\t" + Arrays.toString(input));
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+    @Test
+    public void testRemoveDuplicatesIdempotence() {
+        String[] input = RandomNumberFactory.createStrings('a', 'c', 2, 15);
+        DuplicateDeleter<String> deleter = new StringDuplicateDeleter(input);
+        String[] expected = deleter.removeDuplicates(5);
+
+        for (int i = 0; i < input.length; i++) {
+            deleter.removeDuplicates(i);
+        }
+
+        String[] actual = deleter.removeDuplicates(5);
+
+        Arrays.sort(input);
+        System.out.println("Input:\n\t" + Arrays.toString(input));
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+}

src/test/java/com/zipcodewilmington/looplabs/TestSuite.java

@@ -0,0 +1,17 @@
+package com.zipcodewilmington.looplabs;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+
+/**
+ * Created by leon on 1/28/18.
+ * @ATTENTION_TO_STUDENTS You are forbidden from modifying this class.
+ */
+@RunWith(Suite.class)
+
+@Suite.SuiteClasses({
+        IntegerDuplicateDeleterTest.class,
+        StringDuplicateDeleterTest.class
+})
+public class TestSuite {
+}

src/test/java/com/zipcodewilmington/looplabs/TestUtils.java

@@ -0,0 +1,26 @@
+package com.zipcodewilmington.looplabs;
+
+import org.junit.Assert;
+
+import java.util.Arrays;
+
+/**
+ * Created by leon on 1/28/18.
+ * @ATTENTION_TO_STUDENTS You are forbidden from modifying this class.
+ */
+public class TestUtils {
+    public synchronized static <T, E> void assertArrayEquality(T[] expected, E[] actual) {
+        Arrays.sort(expected);
+        Arrays.sort(actual);
+        String expectedString = Arrays.toString(expected);
+        String actualString = Arrays.toString(actual);
+        boolean equality = expectedString.equals(actualString);
+
+        System.out.println("\n\nExpected:\n\t" + expectedString);
+        System.out.println("\nActual:\n\t" + actualString);
+        System.out.println("\nEquivalence:\n\t" + equality);
+
+        Assert.assertEquals(expectedString, actualString);
+        Assert.assertEquals(expected, actual);
+    }
+}