src/cse332/datastructures/containers/Item.java

 package cse332.datastructures.containers;
 
+import java.util.Objects;
+
 /**
  * Simple class to hold a piece of data and its value.
  * 
@@ -40,4 +42,18 @@ public class Item<K, V> {
     public String toString() {
         return this.key + "=" + this.value + "";
     }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Item<?, ?> item = (Item<?, ?>) o;
+        return Objects.equals(key, item.key) &&
+                Objects.equals(value, item.value);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(key, value);
+    }
 }

src/cse332/datastructures/trees/BinarySearchTree.java

@@ -10,11 +10,10 @@ import cse332.interfaces.worklists.WorkList;
 import datastructures.worklists.ArrayStack;
 
 /**
- * BinarySearchTree implements the DataCounter interface using a binary search
- * tree. The constructor takes a Comparator<? super E> "function object" so that
- * items of type E can be compared. Each tree node associates a count with an E.
+ * BinarySearchTree implements the ComparableDictionary interface using a binary
+ * search tree. Notice that the key type must be Comparable.
  */
-public class BinarySearchTree<K extends Comparable<K>, V>
+public class BinarySearchTree<K extends Comparable<? super K>, V>
         extends ComparableDictionary<K, V> {
     // The root of the BST. Root is null if and only if the tree is empty.
     protected BSTNode root;
@@ -32,13 +31,15 @@ public class BinarySearchTree<K extends Comparable<K>, V>
      * type E and an integer count. The class is protected so that subclasses of
      * BinarySearchTree can access it.
      */
-    protected class BSTNode extends Item<K, V> {
+    public class BSTNode extends Item<K, V> {
         public BSTNode[] children; // The children of this node.
 
         /**
-         * Create a new data node and increment the enclosing tree's size.
+         * Create a new data node.
          *
-         * @param data
+         * @param key
+         *            key with which the specified value is to be associated
+         * @param value
          *            data element to be stored at this node.
          */
         @SuppressWarnings("unchecked")
@@ -48,7 +49,7 @@ public class BinarySearchTree<K extends Comparable<K>, V>
         }
     }
 
-    private BSTNode find(K key, V value) {
+    protected BSTNode find(K key, V value) {
         BSTNode prev = null;
         BSTNode current = this.root;
 
@@ -59,9 +60,6 @@ public class BinarySearchTree<K extends Comparable<K>, V>
 
             // We found the key!
             if (direction == 0) {
-                if (value != null) {
-                    current.value = value;
-                }
                 return current;
             }
             else {
@@ -72,9 +70,9 @@ public class BinarySearchTree<K extends Comparable<K>, V>
             }
         }
 
-        // If value is null, we need to actually add in the new value
+        // If value is not null, we need to actually add in the new value
         if (value != null) {
-            current = new BSTNode(key, value);
+            current = new BSTNode(key, null);
             if (this.root == null) {
                 this.root = current;
             }
@@ -91,6 +89,9 @@ public class BinarySearchTree<K extends Comparable<K>, V>
 
     @Override
     public V find(K key) {
+        if (key == null) {
+            throw new IllegalArgumentException();
+        }
         BSTNode result = find(key, null);
         if (result == null) {
             return null;
@@ -100,7 +101,13 @@ public class BinarySearchTree<K extends Comparable<K>, V>
 
     @Override
     public V insert(K key, V value) {
-        return find(key, value).value;
+        if (key == null || value == null) {
+            throw new IllegalArgumentException();
+        }
+        BSTNode current = find(key, value);
+        V oldValue = current.value;
+        current.value = value;
+        return oldValue;
     }
 
     @Override

src/cse332/interfaces/misc/BString.java

@@ -6,8 +6,7 @@ import java.util.Iterator;
 import cse332.interfaces.worklists.FixedSizeFIFOWorkList;
 import datastructures.worklists.CircularArrayFIFOQueue;
 
-public abstract class BString<Alphabet>
-        implements Iterable<Alphabet>, Comparable<BString<Alphabet>> {
+public abstract class BString<Alphabet extends Comparable<Alphabet>> implements Iterable<Alphabet>, Comparable<BString<Alphabet>> {
     protected FixedSizeFIFOWorkList<Alphabet> str;
 
     public BString(Alphabet[] str) {
@@ -27,7 +26,7 @@ public abstract class BString<Alphabet>
     }
 
     @SuppressWarnings("unchecked")
-    public static <A, X extends BString<A>> Class<A> getLetterType(Class<X> clz) {
+    public static <A extends Comparable<A>, X extends BString<A>> Class<A> getLetterType(Class<X> clz) {
         try {
             return (Class<A>) clz.getMethod("getLetterType", (Class<?>[]) null)
                     .invoke(null, (Object[]) null);

src/cse332/interfaces/misc/ComparableDictionary.java

@@ -10,6 +10,6 @@ package cse332.interfaces.misc;
  *
  * @author Adam Blank
  */
-public abstract class ComparableDictionary<K extends Comparable<K>, V>
+public abstract class ComparableDictionary<K extends Comparable<? super K>, V>
         extends DeletelessDictionary<K, V> {
 }

src/cse332/interfaces/trie/TrieMap.java

@@ -30,7 +30,7 @@ import datastructures.worklists.ListFIFOQueue;
  *
  * @author Adam Blank
  */
-public abstract class TrieMap<A, K extends BString<A>, V> extends Dictionary<K, V> {
+public abstract class TrieMap<A extends Comparable<A>, K extends BString<A>, V> extends Dictionary<K, V> {
     protected TrieNode<?, ?> root;
 
     /**

src/cse332/interfaces/trie/TrieSet.java

@@ -3,7 +3,7 @@ package cse332.interfaces.trie;
 import cse332.interfaces.misc.BString;
 import cse332.interfaces.misc.Set;
 
-public abstract class TrieSet<A, E extends BString<A>> extends Set<E> {
+public abstract class TrieSet<A extends Comparable<A>, E extends BString<A>> extends Set<E> {
     protected TrieSet(TrieMap<A, E, Boolean> backingMap) {
         super(backingMap);
     }

src/cse332/interfaces/worklists/WorkList.java

@@ -89,22 +89,23 @@ public abstract class WorkList<E> implements Iterable<E> {
     }
 
     /**
-     * Note that the toString() method of a WorkList _consumes_ the WorkList.
-     * This can lead to odd and unpredictable behavior.
-     * 
-     * @postcondition hasWork() is false
+     * Returns some basic information about this particular worklist.
+     *
+     * Calling this method does not consume the worklist.
+     *
+     * @return a string representation of this worklist
      */
     @Override
     public String toString() {
-        StringBuilder result = new StringBuilder();
-        result.append("[");
-        while (this.hasWork()) {
-            result.append(this.next().toString() + ", ");
-        }
-        if (result.length() > 1) {
-            result.replace(result.length() - 2, result.length(), "");
+        if (this.hasWork()) {
+            return String.format("%s(size = %d, peek = %s)",
+                    this.getClass().getSimpleName(),
+                    this.size(),
+                    this.peek());
+        } else {
+            return String.format("%s(size = %d)",
+                    this.getClass().getSimpleName(),
+                    this.size());
         }
-        result.append("]");
-        return result.toString();
     }
 }

src/datastructures/dictionaries/AVLTree.java

@@ -6,7 +6,7 @@ import cse332.datastructures.trees.BinarySearchTree;
  * TODO: Replace this comment with your own as appropriate.
  *
  * AVLTree must be a subclass of BinarySearchTree<E> and must use
- * inheritance and callst o superclass methodst o avoid unnecessary
+ * inheritance and calls to superclass methods to avoid unnecessary
  * duplication or copying of functionality.
  *
  * 1. Create a subclass of BSTNode, perhaps named AVLNode.
@@ -24,10 +24,10 @@ import cse332.datastructures.trees.BinarySearchTree;
  *    penalized.
  * 5. Cast children array to AVLNode whenever necessary in your
  *    AVLTree. This will result a lot of casts, so we recommend you make
- *    private methodst hat encapsulatet hose casts.
+ *    private methods that encapsulate those casts.
  * 6. Do NOT override the toString method. It is used for grading.
  */
 
-public class AVLTree<K extends Comparable<K>, V> extends BinarySearchTree<K, V>  {
+public class AVLTree<K extends Comparable<? super K>, V> extends BinarySearchTree<K, V>  {
     // TODO: Implement me!
 }

src/datastructures/dictionaries/ChainingHashTable.java

@@ -3,7 +3,7 @@ package datastructures.dictionaries;
 import java.util.Iterator;
 import java.util.function.Supplier;
 
-import cse332.datastructures.containers.*;
+import cse332.datastructures.containers.Item;
 import cse332.exceptions.NotYetImplementedException;
 import cse332.interfaces.misc.DeletelessDictionary;
 import cse332.interfaces.misc.Dictionary;
@@ -14,11 +14,16 @@ import cse332.interfaces.misc.Dictionary;
  *    restrict the size of the input domain (i.e., it must accept 
  *    any key) or the number of inputs (i.e., it must grow as necessary).
  * 3. Your HashTable should rehash as appropriate (use load factor as
- *    shown in class).
- * 5. HashTable should be able to grow at least up to 200,000 elements. 
+ *    shown in class!). 
+ * 5. HashTable should be able to resize its capacity to prime numbers for more 
+ *    than 200,000 elements. After more than 200,000 elements, it should 
+ *    continue to resize using some other mechanism.
  * 6. We suggest you hard code some prime numbers. You can use this
  *    list: http://primes.utm.edu/lists/small/100000.txt 
  *    NOTE: Do NOT copy the whole list!
+ * 7. When implementing your iterator, you should NOT copy every item to another
+ *    dictionary/list and return that dictionary/list's iterator. 
+
  */
 public class ChainingHashTable<K, V> extends DeletelessDictionary<K, V> {
     private Supplier<Dictionary<K, V>> newChain;  

src/datastructures/dictionaries/MoveToFrontList.java

@@ -2,21 +2,23 @@ package datastructures.dictionaries;
 
 import java.util.Iterator;
 
-import cse332.datastructures.containers.*;
+import cse332.datastructures.containers.Item;
 import cse332.exceptions.NotYetImplementedException;
 import cse332.interfaces.misc.DeletelessDictionary;
 
 /**
  * TODO: Replace this comment with your own as appropriate.
  * 1. The list is typically not sorted.
- * 2. Add new items to the front oft he list.
+ * 2. Add new items to the front of the list.
  * 3. Whenever find is called on an item, move it to the front of the 
  *    list. This means you remove the node from its current position 
  *    and make it the first node in the list.
  * 4. You need to implement an iterator. The iterator SHOULD NOT move
  *    elements to the front.  The iterator should return elements in
  *    the order they are stored in the list, starting with the first
- *    element in the list.
+ *    element in the list. When implementing your iterator, you should 
+ *    NOT copy every item to another dictionary/list and return that 
+ *    dictionary/list's iterator. 
  */
 public class MoveToFrontList<K, V> extends DeletelessDictionary<K, V> {
     @Override

src/datastructures/worklists/MinFourHeap.java

+package datastructures.worklists;
+
+import cse332.exceptions.NotYetImplementedException;
+import cse332.interfaces.worklists.PriorityWorkList;
+
+import java.util.Comparator;
+
+/**
+ * See cse332/interfaces/worklists/PriorityWorkList.java
+ * for method specifications.
+ */
+public class MinFourHeap<E> extends PriorityWorkList<E> {
+    /* Do not change the name of this field; the tests rely on it to work correctly. */
+    private E[] data;
+    
+    public MinFourHeap(Comparator<E> c) {
+        throw new NotYetImplementedException();
+    }
+
+    @Override
+    public boolean hasWork() {
+        throw new NotYetImplementedException();
+    }
+
+    @Override
+    public void add(E work) {
+        throw new NotYetImplementedException();
+    }
+
+    @Override
+    public E peek() {
+        throw new NotYetImplementedException();
+    }
+
+    @Override
+    public E next() {
+        throw new NotYetImplementedException();
+    }
+
+    @Override
+    public int size() {
+        throw new NotYetImplementedException();
+    }
+
+    @Override
+    public void clear() {
+        throw new NotYetImplementedException();
+    }
+}

src/datastructures/worklists/MinFourHeapComparable.java

+package datastructures.worklists;
+
+import cse332.exceptions.NotYetImplementedException;
+import cse332.interfaces.worklists.PriorityWorkList;
+
+/**
+ * See cse332/interfaces/worklists/PriorityWorkList.java
+ * for method specifications.
+ */
+public class MinFourHeapComparable<E extends Comparable<E>> extends PriorityWorkList<E> {
+    /* Do not change the name of this field; the tests rely on it to work correctly. */
+    private E[] data;
+
+    public MinFourHeapComparable() {
+        throw new NotYetImplementedException();
+    }
+
+    @Override
+    public boolean hasWork() {
+        throw new NotYetImplementedException();
+    }
+
+    @Override
+    public void add(E work) {
+        throw new NotYetImplementedException();
+    }
+
+    @Override
+    public E peek() {
+        throw new NotYetImplementedException();
+    }
+
+    @Override
+    public E next() {
+        throw new NotYetImplementedException();
+    }
+
+    @Override
+    public int size() {
+        throw new NotYetImplementedException();
+    }
+
+    @Override
+    public void clear() {
+        throw new NotYetImplementedException();
+    }
+}

src/p2/clients/NGramTester.java

@@ -3,17 +3,18 @@ package p2.clients;
 import java.io.IOException;
 import java.util.function.Supplier;
 
+import cse332.datastructures.trees.BinarySearchTree;
 import cse332.interfaces.misc.BString;
 import cse332.interfaces.misc.Dictionary;
 import cse332.types.AlphabeticString;
 import cse332.types.NGram;
+import datastructures.dictionaries.AVLTree;
 import datastructures.dictionaries.ChainingHashTable;
 import datastructures.dictionaries.HashTrieMap;
 import p2.wordsuggestor.WordSuggestor;
 
 public class NGramTester {
-    public static <A, K extends BString<A>, V> Supplier<Dictionary<K, V>> trieConstructor(
-            Class<K> clz) {
+    public static <A extends Comparable<A>, K extends BString<A>, V> Supplier<Dictionary<K, V>> trieConstructor(Class<K> clz) {
         return () -> new HashTrieMap<A, K, V>(clz);
     }
 
@@ -21,6 +22,17 @@ public class NGramTester {
             Supplier<Dictionary<K, V>> constructor) {
         return () -> new ChainingHashTable<K, V>(constructor);
     }
+    
+    @SuppressWarnings({ "rawtypes", "unchecked" })
+    public static <K, V> Supplier<Dictionary<K, V>> binarySearchTreeConstructor() {
+        return () -> new BinarySearchTree();
+    }
+    
+    @SuppressWarnings({ "rawtypes", "unchecked" })
+    public static <K, V> Supplier<Dictionary<K, V>> avlTreeConstructor() {
+        return () -> new AVLTree();
+    }
+
 
     public static void main(String[] args) {
         try {

src/p2/wordsuggestor/NGramToNextChoicesMap.java

 package p2.wordsuggestor;
 
 import java.util.Comparator;
+import java.util.Iterator;
 import java.util.function.Supplier;
 
 import cse332.datastructures.containers.Item;
@@ -26,7 +27,18 @@ public class NGramToNextChoicesMap {
      * Increments the count of word after the particular NGram ngram.
      */
     public void seenWordAfterNGram(NGram ngram, String word) {
-        throw new NotYetImplementedException();
+        Dictionary<AlphabeticString, Integer> counter = map.find(ngram);
+        if (counter == null) {
+            counter = newInner.get();
+            map.insert(ngram, counter);
+        }
+
+        Integer prev = counter.find(new AlphabeticString(word));
+        if (prev == null) {
+            prev = 0;
+        }
+        counter.insert(new AlphabeticString(word), prev + 1);
+
     }
 
     /**
@@ -39,7 +51,23 @@ public class NGramToNextChoicesMap {
      * @return An array of all the Items for the requested ngram.
      */
     public Item<String, Integer>[] getCountsAfter(NGram ngram) {
-        throw new NotYetImplementedException();
+        if (ngram == null) {
+            return (Item<String, Integer>[]) new Item[0];
+        }
+        Dictionary<AlphabeticString, Integer> counter = map.find(ngram);
+        Item<String, Integer>[] result = (Item<String, Integer>[]) new Item[counter != null
+                ? counter.size() : 0];
+        if (counter != null) {
+            Iterator<Item<AlphabeticString, Integer>> it = counter.iterator();
+
+            for (int i = 0; i < result.length; i++) {
+                Item<AlphabeticString, Integer> item = it.next();
+                result[i] = new Item<String, Integer>(item.key.toString(),
+                        item.value);
+            }
+        }
+        return result;
+
     }
 
     public String[] getWordsAfter(NGram ngram, int k) {

src/p2/wordsuggestor/ParseFBMessages.java

 package p2.wordsuggestor;
 
 import java.io.File;
+import java.io.FileReader;
 import java.io.IOException;
 import java.io.PrintWriter;
+import java.util.Stack;
 
-import org.jsoup.Jsoup;
-import org.jsoup.nodes.Document;
-import org.jsoup.nodes.Element;
-import org.jsoup.select.Elements;
-
-import cse332.interfaces.worklists.LIFOWorkList;
-import datastructures.worklists.ArrayStack;
+import org.json.simple.JSONObject;
+import org.json.simple.parser.JSONParser;
+import org.json.simple.parser.ParseException;
+import org.json.simple.JSONArray;
 
 public final class ParseFBMessages {
     private ParseFBMessages() {
         /* should not be instantiated */ }
 
+    // INSTRUCTIONS:
+    //
+    // <Your FB Name> may be either:
+    //  1) Your name on Messenger (e.g. "Danny Allen")
+    //  2) Your username on facebook, which can be found by looking at the URL on your profile
+    // It's typically 1), but for whatever reason Facebook sometimes labels them
+    // with 2) (sorry!). You can check which one your messages are labeled with by
+    // opening up one of the message files and taking a look.
+    //
+    // <Your FB Archive> is the directory on your computer where the archive is stored.
+    // (e.g. "/Users/Me/Downloads/MyArchiveName" or "C:\Users\Me\Downloads\MyArchiveName")
+    // You may be able to use a relative path like "./MyArchiveName", but results can
+    // vary from machine to machine.
+    //
+    // DO NOT PUSH YOUR ME.TXT FILE TO GITLAB. WE DO NOT WANT YOUR PRIVATE CONVERSATIONS!!!!
     public static void main(String[] args) throws IOException {
-        if (args.length != 2) {
-            System.out.println("USAGE: ParseFBMessages <Your FB Name> <Your FB Archive>");
-            System.exit(1);
-        }
-
-        String name = args[0];
-        String archive = args[1];
+        String name = "<Your FB Name>"; // e.g. "Ruth Anderson"
+        String archive = "<Your FB Archive>"; // e.g. "/Users/rea/workspace/332/facebook-rea/messages"
 
-        LIFOWorkList<String> messages = new ArrayStack<String>();
-        Document doc = Jsoup
-                .parse(new File(archive + File.separator + "html/messages.htm"), "UTF-8");
-        Elements messagesElements = doc.getElementsByTag("p");
+        Stack<String> corpus = new Stack<>();
+        File[] listOfFiles = (new File(archive + File.separator + "inbox")).listFiles();
 
-        for (Element content : messagesElements) {
-            if (content.previousElementSibling().getElementsByClass("user").text()
-                    .equals(name)) {
-                messages.add(content.text());
+        for (int i = 0; i < listOfFiles.length; i++) {
+            File conversation = new File(listOfFiles[i], "message.json");
+            if (conversation.isFile()) {
+                try {
+                    JSONObject obj = (JSONObject) new JSONParser().parse(new FileReader(conversation));
+                    JSONArray messages = (JSONArray) obj.get("messages");
+                    for (Object m: messages) {
+                        JSONObject msg = (JSONObject) m;
+                        String sender = (String) msg.get("sender_name");
+                        if(sender != null && sender.equals(name)) {
+                            corpus.push((String) msg.get("content"));
+                        }
+                    }
+                } catch (ParseException e) {
+                    System.err.println("Could not parse: " + conversation.toString());
+                }
             }
         }
 
         PrintWriter out = new PrintWriter("me.txt", "UTF-8");
 
-        while (messages.hasWork()) {
-            out.println(messages.next());
+        while (!corpus.isEmpty()) {
+            out.println(corpus.pop());
         }
 
         out.close();

src/p2/wordsuggestor/WordSuggestor.java

@@ -15,7 +15,6 @@ import datastructures.worklists.ArrayStack;
 
 /**
  * An executable that generates text in the style of the provided input file.
- * You will need to modify this file.
  */
 public class WordSuggestor {
     private final int N, K;
@@ -73,6 +72,12 @@ public class WordSuggestor {
             words[i] = allWords.next();
             i--;
         }
+       
+        for (i = 0; i < words.length; i++) {
+            if (words[i] == null) {
+                words[i] = "NULL";
+            }
+        }
 
         return new NGram(words);
     }

src/p2/writeup/WriteUp.md

-# Project 2 (uMessage) Write-Up #
---------
-
-## Project Enjoyment ##
-- How Was Your Partnership?
-  <pre>TODO</pre>
-  
-- What was your favorite part of the project?
-  <pre>TODO</pre>
-
-- What was your least favorite part of the project?
-  <pre>TODO</pre>
-
-- How could the project be improved?
-  <pre>TODO</pre>
-
-- Did you enjoy the project?
-  <pre>TODO</pre>
-    
------
-
-## Experiments ##
-Throughout p1 and p2, you have written (or used) several distinct implementations of the Dictionary interface:
- - HashTrieMap 
- - MoveToFrontList
- - BinarySearchTree
- - AVLTree
- - ChainingHashTable
- 
- In this Write-Up, you will compare various aspects of these data structures.  This will take a significant amount of
- time, and you should not leave it to the last minute.  For each experiment, we expect you to:
- - Explain how you constructed the inputs to make your conclusions
- - Explain why your data supports your conclusions
- - Explain your methodology (e.g., if we wanted to re-run your experiment, we would be able to)
- - Include the inputs themselves in the experiments folder
- - Include your data either directly in the write-up or in the experiments folder
- - If you think it helps your explanation, you can include graphs of the outputs (we recommend that you do this for some of them)
- - We recommend that you keep your "N" (as in "N-gram") constant throughout these experiments. (N = 2 and N = 3 are reasonable.) 
- 
-### BST vs. AVLTree ###
-Construct input files to NGramTester of your choosing to demonstrate that an AVL Tree is asymptotically better
-than a Binary Search Tree.
-<pre>TODO</pre>
-
-### BST Worst Case vs. BST Best Case ###
-We know that the worst case for a BST insertion is O(n) and the best case is O(lg n).  Construct input
-files of your choosing that demonstrate these best and worst cases for a large n.  How big is the difference?
-Is it surprising?
-<pre>TODO</pre>
- 
-### ChainingHashTable ###
-Your ChainingHashTable should take as an argument to its constructor the type of "chains" it uses.  Determine
-which type of chain is (on average) best: an MTFList, a BST, or an AVL Tree.  Explain your intuition on why
-the answer you got makes sense (or doesn't!). 
-<pre>TODO</pre>
- 
-### Hash Functions ###
-Write a new hash function (it doesn't have to be any good, but remember to include the code in your repository).
-Compare the runtime of your ChainingHashTable when the hash function is varied.  How big of a difference can the
-hash function make?  (You should keep all other inputs (e.g., the chain type) constant.)
-<pre>TODO</pre>
-
-### General Purpose Dictionary ###
-Compare all of the dictionaries (on their best settings, as determined above) on several large input files.  Is
-there a clear winner?  Why or why not?  Is the winner surprising to you?
-<pre>TODO</pre>
-
-### General Sorts ###
-You have several general purpose sorts (InsertionSort, HeapSort, TopKSort).  We would like you to compare these
-sorts using *step counting*. That is, for all other experiments, you likely compared the time it took for the various
-things to run, but for this one, we want you to (1) choose a definition of step, (2) modify the sorting algorithms to
-calculate the number of steps, and (3) compare the results.  In this case, there is a "good" definition of step, and
-there are many bad ones.  We expect you to justify your choice.
-<pre>TODO</pre>
-
-### Top K Sort ###
-TopKSort should theoretically be better for small values of k.  Determine (using timing or step-counting--your choice)
-which n (input size) and k (number of elements sorted) makes TopKSort worthwhile over your best sort from the previous
-experiment. 
-<pre>TODO</pre>
-
-### uMessage ###
-Use uMessage to test out your implementations.  Using N=3, uMessage should take less than a minute to load using
-your best algorithms and data structures on a reasonable machine.
-
- -  How are the suggestions uMessage gives with the default corpus?
-    <pre>TODO</pre>
-
- - Now, switch uMessage to use a corpus of YOUR OWN text. To do this, you will need a corpus. 
-   You can use anything you like (Facebook, google talk, e-mails, etc.)  We provide
-   instructions and a script to format Facebook data correctly as we expect it will be the most common
-   choice.  If you are having problems getting data, please come to office hours and ask for help.
-   Alternatively, you can concatenate a bunch of English papers you've written together to get a corpus
-   of your writing.  PLEASE DO NOT INCLUDE "me.txt" IN YOUR REPOSITORY.  WE DO NOT WANT YOUR PRIVATE CONVERSATIONS.
-     * Follow these instructions to get your Facebook data: https://www.facebook.com/help/212802592074644
-     * Run the ParseFBMessages program in the main package.
-     * Use the output file "me.txt" as the corpus for uMessage.
- 
- - How are the suggestions uMessage gives wth the new corpus?
-   <pre>TODO</pre>
-
-
------
-
-## Above and Beyond ##
--   Did you do any Above and Beyond?  Describe exactly what you implemented.
- <pre>TODO</pre>
\ No newline at end of file

src/tests/gitlab/ckpt1/CircularArrayComparatorTests.java

+package tests.gitlab.ckpt1;
+
+import datastructures.worklists.CircularArrayFIFOQueue;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class CircularArrayComparatorTests {
+
+    private CircularArrayFIFOQueue<String> init() {
+        return new CircularArrayFIFOQueue<String>(10);
+    }
+
+    private boolean result(int a, int b) {
+        return Integer.signum(a) == Integer.signum(b);
+    }
+
+    @Test(timeout = 3000)
+    public void test_empty_empty() {
+        CircularArrayFIFOQueue<String> l1 = init();
+        CircularArrayFIFOQueue<String> l2 = init();
+        assertTrue(result(l1.compareTo(l2), "".compareTo("")));
+    }
+
+    @Test(timeout = 3000)
+    public void test_ab_ab() {
+        CircularArrayFIFOQueue<String> l1 = init();
+        CircularArrayFIFOQueue<String> l2 = init();
+        l1.add("a");
+        l1.add("b");
+        l2.add("a");
+        l2.add("b");
+        assertTrue(result(l1.compareTo(l2), "ab".compareTo("ab")));
+    }
+
+    @Test(timeout = 3000)
+    public void test_ab_abc() {
+        CircularArrayFIFOQueue<String> l1 = init();
+        CircularArrayFIFOQueue<String> l2 = init();
+        l1.add("a");
+        l1.add("b");
+        l2.add("a");
+        l2.add("b");
+        l2.add("c");
+        assertTrue(result(l1.compareTo(l2), "ab".compareTo("abc")));
+    }
+
+    @Test(timeout = 3000)
+    public void test_abc_ab() {
+        CircularArrayFIFOQueue<String> l1 = init();
+        CircularArrayFIFOQueue<String> l2 = init();
+        l1.add("a");
+        l1.add("b");
+        l1.add("c");
+        l2.add("a");
+        l2.add("b");
+        assertTrue(result(l1.compareTo(l2), "abc".compareTo("ab")));
+    }
+
+    @Test(timeout = 3000)
+    public void test_ac_abc() {
+        CircularArrayFIFOQueue<String> l1 = init();
+        CircularArrayFIFOQueue<String> l2 = init();
+        l1.add("a");
+        l1.add("c");
+        l2.add("a");
+        l2.add("b");
+        l2.add("c");
+        assertTrue(result(l1.compareTo(l2), "ac".compareTo("abc")));
+    }
+
+    @Test(timeout = 3000)
+    public void test_a_aa() {
+        CircularArrayFIFOQueue<String> l1 = init();
+        CircularArrayFIFOQueue<String> l2 = init();
+        l1.add("a");
+        l2.add("a");
+        l2.add("a");
+        assertTrue(result(l1.compareTo(l2), "a".compareTo("aa")));
+    }
+
+    @Test(timeout = 3000)
+    public void test_compare_transitive() {
+        CircularArrayFIFOQueue<String> l1 = init();
+        CircularArrayFIFOQueue<String> l2 = init();
+        CircularArrayFIFOQueue<String> l3 = init();
+
+        l1.add("abc");
+        l2.add("def");
+        l3.add("efg");
+        assertTrue(l1.compareTo(l2) < 0 && l2.compareTo(l3) < 0 && l1.compareTo(l3) < 0) ;
+    }
+
+    @Test(timeout = 3000)
+    public void test_equality_consistent_with_compare() {
+        CircularArrayFIFOQueue<String> l1 = init();
+        CircularArrayFIFOQueue<String> l2 = init();
+        l1.add("a");
+        l1.add("b");
+        l2.add("a");
+        l2.add("b");
+        assertEquals(l1, l2);
+        assertEquals(l1.compareTo(l2), 0);
+    }
+
+    @Test(timeout = 3000)
+    public void test_equals_doesnt_modify() {
+        CircularArrayFIFOQueue<String> l1 = init();
+        CircularArrayFIFOQueue<String> l2 = init();
+        l1.add("a");
+        l2.add("a");
+        l1.equals(l2);
+        assertEquals(l1.size(), 1);
+    }
+}

src/tests/gitlab/ckpt1/Ckpt1Tests.java

+package tests.gitlab.ckpt1;
+
+import datastructures.worklists.MinFourHeap;
+import datastructures.worklists.MinFourHeapComparable;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+
+@RunWith(Suite.class)
+
+@Suite.SuiteClasses({
+        MoveToFrontListTests.class,
+        CircularArrayComparatorTests.class,
+        MinFourHeapComparableTests.class
+})
+
+public class Ckpt1Tests {
+
+}
\ No newline at end of file