Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • sarafa/p2
  • mertht/p2
  • cse332-19au/p2
  • sandchow/p2
  • hanzhang/p2
  • cse332-19sp/p2
  • cse332-20sp/p2
  • cse332-20su-tasks/p2
  • cse332-20su/p2
  • cse332-21su/p2
  • cse332-21wi/p2
  • cse332-21sp/p2
  • cse332-20au/p2
13 results
Show changes
Commits on Source (5)
Hide whitespace changes
Inline Side-by-side
Showing
with 440 additions and 817 deletions
hamcrest-core-1.3.jar 0 → 100644
View file @ ab289774
File added
junit-4.12.jar 0 → 100644
View file @ ab289774
File added
src/cse332/datastructures/containers/Item.java
View file @ ab289774
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
View file @ ab289774
......@@ -13,7 +13,7 @@ import datastructures.worklists.ArrayStack;
* 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;
......
src/cse332/interfaces/misc/ComparableDictionary.java
View file @ ab289774
......@@ -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/datastructures/dictionaries/AVLTree.java
View file @ ab289774
......@@ -28,6 +28,6 @@ import cse332.datastructures.trees.BinarySearchTree;
* 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/tests/gitlab/ckpt1/CircularArrayComparatorTests.java
View file @ ab289774
package tests.gitlab.ckpt1;
import datastructures.worklists.CircularArrayFIFOQueue;
import tests.TestsUtility;
import org.junit.Test;
public class CircularArrayComparatorTests extends TestsUtility {
public static void main(String[] args) {
new CircularArrayComparatorTests().run();
}
@Override
protected void run() {
SHOW_TESTS = true;
PRINT_TESTERR = true;
DEBUG = true;
import static org.junit.Assert.*;
test("test_empty_empty");
test("test_ab_ab");
test("test_ab_abc");
test("test_abc_ab");
test("test_ac_abc");
test("test_a_aa");
test("test_equality_consistent_with_compare");
test("test_compare_transitive");
test("test_equals_doesnt_modify");
finish();
}
protected static CircularArrayFIFOQueue<String> init() {
public class CircularArrayComparatorTests {
private CircularArrayFIFOQueue<String> init() {
return new CircularArrayFIFOQueue<String>(10);
}
private static int result(int a, int b) {
return Integer.signum(a) == Integer.signum(b) ? 1 : 0;
private boolean result(int a, int b) {
return Integer.signum(a) == Integer.signum(b);
}
public static int test_empty_empty() {
@Test(timeout = 3000)
public void test_empty_empty() {
CircularArrayFIFOQueue<String> l1 = init();
CircularArrayFIFOQueue<String> l2 = init();
return result(l1.compareTo(l2), "".compareTo(""));
assertTrue(result(l1.compareTo(l2), "".compareTo("")));
}
public static int test_ab_ab() {
@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");
return result(l1.compareTo(l2), "ab".compareTo("ab"));
assertTrue(result(l1.compareTo(l2), "ab".compareTo("ab")));
}
public static int test_ab_abc() {
@Test(timeout = 3000)
public void test_ab_abc() {
CircularArrayFIFOQueue<String> l1 = init();
CircularArrayFIFOQueue<String> l2 = init();
l1.add("a");
......@@ -58,10 +42,11 @@ public class CircularArrayComparatorTests extends TestsUtility {
l2.add("a");
l2.add("b");
l2.add("c");
return result(l1.compareTo(l2), "ab".compareTo("abc"));
assertTrue(result(l1.compareTo(l2), "ab".compareTo("abc")));
}
public static int test_abc_ab() {
@Test(timeout = 3000)
public void test_abc_ab() {
CircularArrayFIFOQueue<String> l1 = init();
CircularArrayFIFOQueue<String> l2 = init();
l1.add("a");
......@@ -69,9 +54,11 @@ public class CircularArrayComparatorTests extends TestsUtility {
l1.add("c");
l2.add("a");
l2.add("b");
return result(l1.compareTo(l2), "abc".compareTo("ab"));
assertTrue(result(l1.compareTo(l2), "abc".compareTo("ab")));
}
public static int test_ac_abc() {
@Test(timeout = 3000)
public void test_ac_abc() {
CircularArrayFIFOQueue<String> l1 = init();
CircularArrayFIFOQueue<String> l2 = init();
l1.add("a");
......@@ -79,44 +66,50 @@ public class CircularArrayComparatorTests extends TestsUtility {
l2.add("a");
l2.add("b");
l2.add("c");
return result(l1.compareTo(l2), "ac".compareTo("abc"));
assertTrue(result(l1.compareTo(l2), "ac".compareTo("abc")));
}
public static int test_a_aa() {
@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");
return result(l1.compareTo(l2), "a".compareTo("aa"));
assertTrue(result(l1.compareTo(l2), "a".compareTo("aa")));
}
public static int test_compare_transitive() {
@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");
return l1.compareTo(l2) < 0 && l2.compareTo(l3) < 0 && l1.compareTo(l3) < 0 ? 1 : 0;
assertTrue(l1.compareTo(l2) < 0 && l2.compareTo(l3) < 0 && l1.compareTo(l3) < 0) ;
}
public static int test_equality_consistent_with_compare() {
@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");
return l1.equals(l2) && l1.compareTo(l2) == 0 ? 1 : 0;
assertEquals(l1, l2);
assertEquals(l1.compareTo(l2), 0);
}
public static int test_equals_doesnt_modify() {
@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);
return l1.size() == 1 ? 1 : 0;
assertEquals(l1.size(), 1);
}
}
src/tests/gitlab/ckpt1/Ckpt1Tests.java
View file @ ab289774
package tests.gitlab.ckpt1;
import tests.GradingUtility;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
public class Ckpt1Tests extends GradingUtility {
public static void main(String[] args) {
new Ckpt1Tests();
}
@RunWith(Suite.class)
protected Class<?>[] getTests() {
return new Class<?>[] {
NGramToNextChoicesMapTests.class,
MoveToFrontListTests.class,
CircularArrayComparatorTests.class
};
}
}
@Suite.SuiteClasses({
NGramToNextChoicesMapTests.class,
MoveToFrontListTests.class,
CircularArrayComparatorTests.class
})
public class Ckpt1Tests {
}
\ No newline at end of file
src/tests/gitlab/ckpt1/MoveToFrontListTests.java
View file @ ab289774
......@@ -4,77 +4,63 @@ import java.util.Arrays;
import cse332.datastructures.containers.Item;
import datastructures.dictionaries.MoveToFrontList;
import tests.TestsUtility;
import org.junit.Test;
import static org.junit.Assert.*;
public class MoveToFrontListTests extends TestsUtility {
public static void main(String[] args) {
new MoveToFrontListTests().run();
}
public class MoveToFrontListTests {
@Override
protected void run() {
SHOW_TESTS = true;
PRINT_TESTERR = true;
DEBUG = true;
@SuppressWarnings("unchecked")
@Test(timeout = 3000)
public void checkStructure() {
MoveToFrontList<Integer, Integer> list = new MoveToFrontList<Integer, Integer>();
test("testHugeMTFList");
test("checkStructure");
finish();
}
@SuppressWarnings("unchecked")
public static int checkStructure() {
MoveToFrontList<Integer, Integer> list = new MoveToFrontList<Integer, Integer>();
int[] arr = {6, 5, 10, 14, 10, 31, 10, 13, 10, 10, 12, 10, 14, 10, 10, 11, 10, 14, 9, 8, 3, 2, 1, 0, 7, 4};
for(int i = 0; i < arr.length; i++) {
Integer oldValue = list.find(arr[i]);
if (oldValue == null) {
list.insert(arr[i], 1);
} else {
list.insert(arr[i], 1 + oldValue);
int[] arr = {6, 5, 10, 14, 10, 31, 10, 13, 10, 10, 12, 10, 14, 10, 10, 11, 10, 14, 9, 8, 3, 2, 1, 0, 7, 4};
for(int i = 0; i < arr.length; i++) {
Integer oldValue = list.find(arr[i]);
if (oldValue == null) {
list.insert(arr[i], 1);
} else {
list.insert(arr[i], 1 + oldValue);
}
}
// Convert iterator to string
Item<Integer, Integer>[] dcs = (Item<Integer, Integer>[])new Item[list.size()];
int i = 0;
for (Item<Integer, Integer> item : list) {
dcs[i++] = item;
}
}
// Convert iterator to string
Item<Integer, Integer>[] dcs = (Item<Integer, Integer>[])new Item[list.size()];
int i = 0;
for (Item<Integer, Integer> item : list) {
dcs[i++] = item;
}
// Compare strings to make sure we get the right one
// Can use list.toString as well, but I'm not sure if students may modify that
String mtf_correct = "[4=1, 7=1, 0=1, 1=1, 2=1, 3=1, 8=1, 9=1, 14=3, 10=9, 11=1, 12=1, 13=1, 31=1, 5=1, 6=1]";
String mtf_test = Arrays.toString(dcs);
return mtf_correct.equals(mtf_test) ? 1 : 0;
// Compare strings to make sure we get the right one
// Can use list.toString as well, but I'm not sure if students may modify that
String mtf_correct = "[4=1, 7=1, 0=1, 1=1, 2=1, 3=1, 8=1, 9=1, 14=3, 10=9, 11=1, 12=1, 13=1, 31=1, 5=1, 6=1]";
String mtf_test = Arrays.toString(dcs);
assertEquals(mtf_correct, mtf_test);
}
public static int testHugeMTFList() {
MoveToFrontList<String, Integer> list = new MoveToFrontList<>();
@Test(timeout = 3000)
public void testHugeMTFList() {
MoveToFrontList<String, Integer> list = new MoveToFrontList<>();
int n = 1000;
int n = 1000;
// Add them
for (int i = 0; i < 5 * n; i++) {
int k = (i % n) * 37 % n;
String str = String.format("%05d", k);
for (int j = 0; j < k + 1; j ++)
list.insert(str, list.find(str) == null ? 1 : list.find(str) + 1);
}
// Delete them all
boolean passed = true;
int totalCount = 0;
for (Item<String, Integer> dc : list) {
passed &= (Integer.parseInt(dc.key) + 1) * 5 == dc.value;
totalCount += dc.value;
}
// Check sizes
passed &= totalCount == (n * (n + 1)) / 2 * 5;
passed &= list.size() == n;
passed &= list.find("00851") == 4260;
// Add them
for (int i = 0; i < 5 * n; i++) {
int k = (i % n) * 37 % n;
String str = String.format("%05d", k);
for (int j = 0; j < k + 1; j ++)
list.insert(str, list.find(str) == null ? 1 : list.find(str) + 1);
}
// Delete them all
int totalCount = 0;
for (Item<String, Integer> dc : list) {
assertEquals((Integer.parseInt(dc.key) + 1) * 5, dc.value.intValue());
totalCount += dc.value;
}
return passed ? 1 : 0;
}
// Check sizes
assertEquals(totalCount, (n * (n + 1)) / 2 * 5);
assertEquals(list.size(), n);
assertNotNull(list.find("00851"));
assertEquals(list.find("00851").intValue(), 4260);
}
}
src/tests/gitlab/ckpt1/NGramToNextChoicesMapTests.java
View file @ ab289774
package tests.gitlab.ckpt1;
import java.util.Arrays;
import java.util.Comparator;
import java.util.TreeMap;
import java.util.Map;
import java.util.function.Supplier;
import cse332.datastructures.containers.Item;
import cse332.interfaces.misc.Dictionary;
import cse332.types.AlphabeticString;
import cse332.types.NGram;
import cse332.datastructures.trees.BinarySearchTree;
import cse332.types.NGram;
import org.junit.Test;
import p2.wordsuggestor.NGramToNextChoicesMap;
import tests.TestsUtility;
public class NGramToNextChoicesMapTests extends TestsUtility {
private static Supplier<Dictionary<NGram, Dictionary<AlphabeticString, Integer>>> newOuter =
() -> new BinarySearchTree();
import java.util.Arrays;
import java.util.Comparator;
import java.util.Map;
import java.util.TreeMap;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
private static Supplier<Dictionary<AlphabeticString, Integer>> newInner =
() -> new BinarySearchTree();
public static void main(String[] args) {
new NGramToNextChoicesMapTests().run();
}
@Override
protected void run() {
SHOW_TESTS = true;
PRINT_TESTERR = true;
DEBUG = true;
test("testOneWordPerNGram");
test("testMultipleWordsPerNGram");
test("testGetNonexistentNGram");
test("testRepeatedWordsPerNGram");
finish();
}
protected static NGramToNextChoicesMap init() {
return new NGramToNextChoicesMap(newOuter, newInner);
public class NGramToNextChoicesMapTests {
private NGramToNextChoicesMap init() {
return new NGramToNextChoicesMap(BinarySearchTree::new, BinarySearchTree::new);
}
public static int testOneWordPerNGram() {
@Test(timeout = 3000)
public void testOneWordPerNGram() {
NGramToNextChoicesMap map = init();
NGram[] ngrams = new NGram[]{
new NGram(new String[]{"foo", "bar", "baz"}),
new NGram(new String[]{"fee", "fi", "fo"}),
new NGram(new String[]{"a", "s", "d"})
};
String[] words = new String[]{"bop", "fum", "f"};
for (int i = 0; i < ngrams.length; i++) {
map.seenWordAfterNGram(ngrams[i], words[i]);
}
for (int i = 0; i < ngrams.length; i++) {
Item<String, Integer>[] items = map.getCountsAfter(ngrams[i]);
if (items.length != 1) return 0;
assertEquals(1, items.length);
Item<String, Integer> item = items[0];
if (!item.key.equals(words[i])) return 0;
if (!item.value.equals(1)) return 0;
assertEquals(words[i], item.key);
assertEquals(1, item.value.intValue());
}
return 1;
}
public static int testMultipleWordsPerNGram() {
@Test(timeout = 3000)
public void testMultipleWordsPerNGram() {
NGramToNextChoicesMap map = init();
NGram[] ngrams = new NGram[]{
new NGram(new String[]{"foo", "bar", "baz"}),
......@@ -74,61 +52,56 @@ public class NGramToNextChoicesMapTests extends TestsUtility {
new NGram(new String[]{"3", "2", "2"}),
new NGram(new String[]{"a", "s", "d"})
};
String[][] words = new String[][] {
new String[]{"bip", "bop", "bzp"},
new String[]{"fum", "giants"},
new String[]{"ago", "seven", "years"},
new String[]{"new", "thrown", "uuu", "zzz"},
new String[]{"do", "for", "while"}
new String[]{"bip", "bop", "bzp"},
new String[]{"fum", "giants"},
new String[]{"ago", "seven", "years"},
new String[]{"new", "thrown", "uuu", "zzz"},
new String[]{"do", "for", "while"}
};
for (int i = 0; i < ngrams.length; i++) {
for (int j = 0; j < words[i].length; j++) {
map.seenWordAfterNGram(ngrams[i], words[i][j]);
}
}
for (int i = 0; i < ngrams.length; i++) {
Item<String, Integer>[] items = map.getCountsAfter(ngrams[i]);
String[] answer = words[i];
if (items.length != answer.length) return 0;
assertEquals(answer.length, items.length);
String[] itemsWithoutCounts = new String[items.length];
for (int j = 0; j < answer.length; j++) {
if (!items[j].value.equals(1)) return 0;
assertEquals(1, items[j].value.intValue());
itemsWithoutCounts[j] = items[j].key;
}
Arrays.sort(itemsWithoutCounts);
for (int j = 0; j < answer.length; j++) {
if (!itemsWithoutCounts[j].equals(answer[j])) return 0;
}
assertArrayEquals(answer, itemsWithoutCounts);
}
return 1;
}
public static int testGetNonexistentNGram() {
@Test(timeout = 3000)
public void testGetNonexistentNGram() {
NGramToNextChoicesMap map = init();
NGram[] ngrams = new NGram[]{
new NGram(new String[]{"foo", "bar", "baz"}),
new NGram(new String[]{"fee", "fi", "fo"}),
new NGram(new String[]{"a", "s", "d"})
};
String[] words = new String[]{"bop", "fum", "f"};
for (int i = 0; i < ngrams.length; i++) {
map.seenWordAfterNGram(ngrams[i], words[i]);
}
Item<String, Integer>[] items = map.getCountsAfter(new NGram(new String[] { "yo" }));
if (items == null || items.length != 0) {
return 0;
}
return 1;
assertNotNull(items);
assertEquals(0, items.length);
}
@SuppressWarnings("unchecked")
public static int testRepeatedWordsPerNGram() {
@Test(timeout = 3000)
public void testRepeatedWordsPerNGram() {
NGramToNextChoicesMap map = init();
// Creates Ngrams to test for with N = 3
NGram[] ngrams = new NGram[]{
......@@ -140,73 +113,60 @@ public class NGramToNextChoicesMapTests extends TestsUtility {
};
// Array of words seen after each Ngram with correlating index from above
String[][] words = new String[][] {
new String[]{"bop", "bip", "boop", "bop", "bop"},
new String[]{"fum", "giants", "giants"},
new String[]{"seven", "years", "years", "ago", "ago"},
new String[]{"throw", "throw", "throw", "throw", "throw"},
new String[]{"for", "while", "do", "do", "while", "for"}
new String[]{"bop", "bip", "boop", "bop", "bop"},
new String[]{"fum", "giants", "giants"},
new String[]{"seven", "years", "years", "ago", "ago"},
new String[]{"throw", "throw", "throw", "throw", "throw"},
new String[]{"for", "while", "do", "do", "while", "for"}
};
// yes this is awful, but i can't think of a better way to do it atm
// Creates answers for getCountsAfter - Word seen after and count
// Creates answers for getCountsAfter - Word seen after and count
// corrlates with words and ngrams above
// Note that words after are in sorted order, not in order of array in words
Map<NGram, Item<String, Integer>[]> answers = new TreeMap<>();
answers.put(ngrams[0], (Item<String, Integer>[]) new Item[3]);
answers.get(ngrams[0])[0] = new Item<String, Integer>("bip", 1);
answers.get(ngrams[0])[1] = new Item<String, Integer>("boop", 1);
answers.get(ngrams[0])[2] = new Item<String, Integer>("bop", 3);
answers.put(ngrams[1], (Item<String, Integer>[]) new Item[2]);
answers.get(ngrams[1])[0] = new Item<String, Integer>("fum", 1);
answers.get(ngrams[1])[1] = new Item<String, Integer>("giants", 2);
answers.put(ngrams[2], (Item<String, Integer>[]) new Item[3]);
answers.get(ngrams[2])[0] = new Item<String, Integer>("ago", 2);
answers.get(ngrams[2])[1] = new Item<String, Integer>("seven", 1);
answers.get(ngrams[2])[2] = new Item<String, Integer>("years", 2);
answers.put(ngrams[3], (Item<String, Integer>[]) new Item[1]);
answers.get(ngrams[3])[0] = new Item<String, Integer>("throw", 5);
answers.put(ngrams[4], (Item<String, Integer>[]) new Item[3]);
answers.get(ngrams[4])[0] = new Item<String, Integer>("do", 2);
answers.get(ngrams[4])[1] = new Item<String, Integer>("for", 2);
answers.get(ngrams[4])[2] = new Item<String, Integer>("while", 2);
answers.put(ngrams[0], (Item<String, Integer>[]) new Item[]{
new Item<>("bip", 1),
new Item<>("boop", 1),
new Item<>("bop", 3)
});
answers.put(ngrams[1], (Item<String, Integer>[]) new Item[]{
new Item<>("fum", 1),
new Item<>("giants", 2)
});
answers.put(ngrams[2], (Item<String, Integer>[]) new Item[]{
new Item<>("ago", 2),
new Item<>("seven", 1),
new Item<>("years", 2)
});
answers.put(ngrams[3], (Item<String, Integer>[]) new Item[]{
new Item<>("throw", 5)
});
answers.put(ngrams[4], (Item<String, Integer>[]) new Item[]{
new Item<>("do", 2),
new Item<>("for", 2),
new Item<>("while", 2)
});
// Adds nGrams and words after to student's NGramToNextChoicesMap
for (int i = 0; i < ngrams.length; i++) {
for (int j = 0; j < words[i].length; j++) {
map.seenWordAfterNGram(ngrams[i], words[i][j]);
}
}
// checks to see if getCountsAfter returns correctly
for (int i = 0; i < ngrams.length; i++) {
NGram ngram = ngrams[i];
Item<String, Integer>[] results = map.getCountsAfter(ngram);
Arrays.sort(results, new Comparator<Object>() {
@Override
public int compare(Object o1, Object o2) {
Item<String, Integer> r1 = (Item<String, Integer>)o1;
Item<String, Integer> r2 = (Item<String, Integer>)o2;
return r1.key.compareTo(r2.key);
}
});
Arrays.sort(results, Comparator.comparing(r -> r.key));
Item<String, Integer>[] expected = answers.get(ngram);
// checks for correct number of unique words after
if (results.length != expected.length) return 0;
for (int j = 0; j < expected.length; j++) {
// checks if correct word after via sorted words
if (!expected[j].key.equals(results[j].key)) {
return 0;
}
// checks if correct count for given word after
if (!expected[j].value.equals(results[j].value)) {
return 0;
}
}
assertArrayEquals(expected, results);
}
return 1;
}
}
src/tests/gitlab/ckpt2/AVLTreeTests.java
View file @ ab289774
......@@ -4,31 +4,19 @@ import cse332.datastructures.containers.Item;
import cse332.datastructures.trees.BinarySearchTree.BSTNode;
import cse332.interfaces.misc.Dictionary;
import datastructures.dictionaries.AVLTree;
import tests.TestsUtility;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
public class AVLTreeTests extends TestsUtility {
public static void main(String[] args) {
new AVLTreeTests().run();
}
@Override
protected void run() {
SHOW_TESTS = true;
DEBUG = true;
test("testTreeWith5Items");
test("testHugeTree");
test("checkStructure");
finish();
}
import org.junit.Test;
import static org.junit.Assert.*;
protected static AVLTree<String, Integer> init() {
AVLTree<String, Integer> tree = new AVLTree<>();
public class AVLTreeTests {
return tree;
private AVLTree<String, Integer> init() {
return new AVLTree<>();
}
private static <E extends Comparable<E>> void incCount(Dictionary<E, Integer> tree, E key) {
private <E extends Comparable<E>> void incCount(Dictionary<E, Integer> tree, E key) {
Integer value = tree.find(key);
if (value == null) {
tree.insert(key, 1);
......@@ -36,9 +24,10 @@ public class AVLTreeTests extends TestsUtility {
tree.insert(key, value + 1);
}
}
@SuppressWarnings("rawtypes")
public static int checkStructure() {
@Test(timeout = 3000)
public void checkStructure() {
AVLTree<Integer, Integer> tree = new AVLTree<>();
incCount(tree, 10);
incCount(tree, 14);
......@@ -70,7 +59,7 @@ public class AVLTreeTests extends TestsUtility {
// {10, 14, 31, 13, 12, 11, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
BSTNode root = (BSTNode) getField(tree, "root");
String trueData = " [8 [4 [2 [1 [0..].] [3..]] [6 [5..] [7..]]] [12 [10 [9..] [11..]] [14 [13..] [31..]]]]";
String trueCounts = " [1 [1 [1 [1 [1..].] [1..]] [1 [1..] [1..]]] [1 [9 [1..] [1..]] [2 [2..] [1..]]]]";
// String trueData = " [10 [6 [2 [1 [0..].] [4 [3..] [5..]]] [8 [7..] [9..]]] [13 [12 [11..].] [14. [31..]]]]";
......@@ -78,24 +67,25 @@ public class AVLTreeTests extends TestsUtility {
// System.err.println(nestd(root));
// System.err.println(trueData);
return nestd(root).equals(trueData) &&
nestc(root).equals(trueCounts) ? 1 : 0;
assertEquals(nestd(root), trueData);
assertEquals(nestc(root), trueCounts);
}
@SuppressWarnings("rawtypes")
public static String nestd(BSTNode root) {
public String nestd(BSTNode root) {
if(root == null)
return ".";
return " [" + root.key + nestd(root.children[0]) + nestd(root.children[1]) + "]";
}
@SuppressWarnings("rawtypes")
public static String nestc(BSTNode root) {
public String nestc(BSTNode root) {
if(root == null)
return ".";
return " [" + root.value + nestc(root.children[0]) + nestc(root.children[1]) + "]";
}
public static int testTreeWith5Items() {
@Test(timeout = 3000)
public void testTreeWith5Items() {
AVLTree<String, Integer> tree = init();
String[] tests_struct = { "a", "b", "c", "d", "e" };
String[] tests = { "b", "d", "e", "c", "a" };
......@@ -104,19 +94,17 @@ public class AVLTreeTests extends TestsUtility {
incCount(tree, str);
}
boolean passed = true;
int i = 0;
for (Item<String, Integer> item : tree) {
String str_heap = item.key;
String str = tests_struct[i] + "a";
passed &= str.equals(str_heap);
assertEquals(str, str_heap);
i++;
}
return passed ? 1 : 0;
}
public static int testHugeTree() {
@Test(timeout = 3000)
public void testHugeTree() {
AVLTree<String, Integer> tree = init();
int n = 1000;
......@@ -129,20 +117,42 @@ public class AVLTreeTests extends TestsUtility {
}
// Delete them all
boolean passed = true;
int totalCount = 0;
for (Item<String, Integer> dc : tree) {
passed &= (Integer.parseInt(dc.key) + 1) * 5 == dc.value;
assertEquals((Integer.parseInt(dc.key) + 1) * 5, dc.value.intValue());
totalCount += dc.value;
}
// Check for accuracy
passed &= totalCount == (n * (n + 1)) / 2 * 5;
passed &= tree.size() == n;
passed &= tree.find("00851") != null;
passed &= tree.find("00851") == 4260;
return passed ? 1 : 0;
assertEquals(totalCount, (n * (n + 1)) / 2 * 5);
assertEquals(tree.size(), n);
assertNotNull(tree.find("00851"));
assertEquals(4260, (int) tree.find("00851"));
}
/**
* Get a field from an object
* @param o Object you want to get the field from
* @param fieldName Name of the field
* @return
*/
@SuppressWarnings("unchecked")
private <T> T getField(Object o, String fieldName) {
try {
Field field = o.getClass().getSuperclass().getDeclaredField(fieldName);
field.setAccessible(true);
Object f = field.get(o);
return (T) f;
} catch (Exception e) {
try {
Field field = o.getClass().getDeclaredField(fieldName);
field.setAccessible(true);
Object f = field.get(o);
return (T) f;
} catch (Exception e2) {
return null;
}
}
}
}
src/tests/gitlab/ckpt2/CircularArrayHashCodeTests.java
View file @ ab289774
package tests.gitlab.ckpt2;
import datastructures.worklists.CircularArrayFIFOQueue;
import tests.TestsUtility;
import org.junit.Test;
import static org.junit.Assert.*;
public class CircularArrayHashCodeTests extends TestsUtility {
public static void main(String[] args) {
new CircularArrayHashCodeTests().run();
}
@Override
protected void run() {
SHOW_TESTS = true;
test("equality");
test("ineq1");
test("ineq2");
test("ineq3");
test("equality_consistent_with_hashcode");
finish();
}
protected static CircularArrayFIFOQueue<String> init() {
public class CircularArrayHashCodeTests {
private CircularArrayFIFOQueue<String> init() {
return new CircularArrayFIFOQueue<String>(10);
}
public static int equality() {
@Test(timeout = 3000)
public void equality() {
CircularArrayFIFOQueue<String> l1 = init();
CircularArrayFIFOQueue<String> l2 = init();
for (int i = 0; i < 3; i++) {
l1.add("a");
l2.add("a");
}
return l1.hashCode() == l2.hashCode() ? 1 : 0;
assertEquals(l1.hashCode(), l2.hashCode());
}
public static int ineq1() {
@Test(timeout = 3000)
public void ineq1() {
CircularArrayFIFOQueue<String> l1 = init();
CircularArrayFIFOQueue<String> l2 = init();
l1.add("a");
......@@ -41,9 +31,11 @@ public class CircularArrayHashCodeTests extends TestsUtility {
l2.add("a");
l2.add("a");
l2.add("a");
return l1.hashCode() != l2.hashCode() ? 1 : 0;
assertNotEquals(l1.hashCode(), l2.hashCode());
}
public static int ineq2() {
@Test(timeout = 3000)
public void ineq2() {
CircularArrayFIFOQueue<String> l1 = init();
CircularArrayFIFOQueue<String> l2 = init();
l1.add("a");
......@@ -53,9 +45,11 @@ public class CircularArrayHashCodeTests extends TestsUtility {
l2.add("a");
l2.add("a");
l2.add("a");
return l1.hashCode() != l2.hashCode() ? 1 : 0;
assertNotEquals(l1.hashCode() , l2.hashCode());
}
public static int ineq3() {
@Test(timeout = 3000)
public void ineq3() {
CircularArrayFIFOQueue<String> l1 = init();
CircularArrayFIFOQueue<String> l2 = init();
l1.add("a");
......@@ -64,16 +58,18 @@ public class CircularArrayHashCodeTests extends TestsUtility {
l2.add("c");
l2.add("b");
l2.add("a");
return l1.hashCode() != l2.hashCode() ? 1 : 0;
assertNotEquals(l1.hashCode() , l2.hashCode());
}
public static int equality_consistent_with_hashcode() {
CircularArrayFIFOQueue<String> l1 = init();
@Test(timeout = 3000)
public void equality_consistent_with_hashcode() {
CircularArrayFIFOQueue<String> l1 = init();
CircularArrayFIFOQueue<String> l2 = init();
l1.add("a");
l1.add("b");
l2.add("a");
l2.add("b");
return l1.equals(l2) && l1.hashCode() == l2.hashCode() ? 1 : 0;
}
l1.add("b");
l2.add("a");
l2.add("b");
assertEquals(l1 , l2);
assertEquals(l1.hashCode() , l2.hashCode());
}
}
src/tests/gitlab/ckpt2/Ckpt2Tests.java
View file @ ab289774
package tests.gitlab.ckpt2;
import tests.GradingUtility;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
public class Ckpt2Tests extends GradingUtility {
public static void main(String[] args) {
new Ckpt2Tests();
}
@RunWith(Suite.class)
@Suite.SuiteClasses({
AVLTreeTests.class,
HashTableTests.class,
CircularArrayHashCodeTests.class,
QuickSortTests.class,
TopKSortTests.class,
HeapSortTests.class,
HashTrieMapTests.class
})
public class Ckpt2Tests {
protected Class<?>[] getTests() {
return new Class<?>[] {
AVLTreeTests.class,
HashTableTests.class,
CircularArrayHashCodeTests.class,
QuickSortTests.class,
TopKSortTests.class,
HeapSortTests.class
};
}
}
src/tests/gitlab/ckpt2/HashTableTests.java
View file @ ab289774
......@@ -4,34 +4,26 @@ import cse332.datastructures.containers.Item;
import cse332.interfaces.misc.Dictionary;
import datastructures.dictionaries.ChainingHashTable;
import datastructures.dictionaries.MoveToFrontList;
import tests.TestsUtility;
import org.junit.Test;
import static org.junit.Assert.*;
public class HashTableTests extends TestsUtility {
public static void main(String[] args) {
new HashTableTests().run();
}
@Override
protected void run() {
SHOW_TESTS = true;
test("testHugeHashTable");
finish();
}
public class HashTableTests {
private static void incCount(Dictionary<String, Integer> list, String key) {
private void incCount(Dictionary<String, Integer> list, String key) {
Integer find = list.find(key);
if (find == null)
list.insert(key, 1);
else
list.insert(key, 1 + find);
}
public static int testHugeHashTable() {
ChainingHashTable<String, Integer> list = new ChainingHashTable<>(() -> new MoveToFrontList<>());
@Test(timeout = 3000)
public void testHugeHashTable() {
ChainingHashTable<String, Integer> list = new ChainingHashTable<>(MoveToFrontList::new);
int n = 1000;
// Add them
for (int i = 0; i < 5 * n; i++) {
int k = (i % n) * 37 % n;
......@@ -41,18 +33,14 @@ public class HashTableTests extends TestsUtility {
}
// Delete them all
boolean passed = true;
int totalCount = 0;
for (Item<String, Integer> dc : list) {
passed &= (Integer.parseInt(dc.key) + 1) * 5 == dc.value;
// System.out.println(((Integer.parseInt(dc.data) + 1) * 5 == dc.count) + ": " + ((Integer.parseInt(dc.data) + 1) * 5) + "==" + dc.count);
assertEquals((Integer.parseInt(dc.key) + 1) * 5, (int) dc.value);
totalCount += dc.value;
}
passed &= totalCount == (n * (n + 1)) / 2 * 5;
passed &= list.size() == n;
passed &= list.find("00851") == 4260;
return passed ? 1 : 0;
assertEquals(totalCount, (n * (n + 1)) / 2 * 5);
assertEquals(list.size(), n);
assertNotNull(list.find("00851"));
assertEquals(4260, (int) list.find("00851"));
}
}
src/tests/gitlab/ckpt2/HashTrieMapTests.java
View file @ ab289774
......@@ -2,320 +2,105 @@ package tests.gitlab.ckpt2;
import cse332.types.AlphabeticString;
import datastructures.dictionaries.HashTrieMap;
import tests.TestsUtility;
import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.*;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
public class HashTrieMapTests extends TestsUtility {
public class HashTrieMapTests {
protected static HashTrieMap<Character, AlphabeticString, String> STUDENT;
public static void main(String[] args) {
new HashTrieMapTests().run();
}
public static void init() {
@Before
public void init() {
STUDENT = new HashTrieMap<>(AlphabeticString.class);
}
@Override
protected void run() {
SHOW_TESTS = true;
PRINT_TESTERR = true;
DEBUG = true;
test("testBasic");
test("testBasicDelete");
test("testFindPrefixes");
test("testFindNonexistentDoesNotCrash");
test("testFindingNullEntriesCausesError");
test("testInsertReplacesOldValue");
test("testInsertingNullEntriesCausesError");
test("testDeleteAll");
test("testDeleteNothing");
test("testDeleteAndInsertSingleChars");
test("testDeleteWorksWhenTrieHasNoBranches");
test("testDeletingAtRoot");
test("testDeletingEmptyString");
test("testDeletingNullEntriesCausesError");
test("testClear");
test("checkUnderlyingStructure");
test("stressTest");
finish();
}
/**
* Tests if insert, find, and findPrefix work in general.
*/
public static int testBasic() {
@Test(timeout = 3000)
public void testBasic() {
String[] words = {"dog", "doggy", "doge", "dragon", "cat", "draggin"};
String[] invalid = {"d", "cataract", "", "do"};
addAll(STUDENT, words);
return (containsAllPaths(STUDENT, words) && doesNotContainAll(STUDENT, invalid)) ? 1 : 0;
}
/**
* Checks to see if basic delete functionality works.
*/
public static int testBasicDelete() {
String[] words = {"dog", "doggy", "dreamer", "cat"};
addAll(STUDENT, words);
if (!containsAllPaths(STUDENT, words)) {
return 0;
}
STUDENT.delete(a("I don't exist"));
STUDENT.delete(a("dreamer"));
if (!containsAllPaths(STUDENT, "dog", "doggy", "cat") &&
!containsAllPrefixes(STUDENT, "dreamer", "dreame", "dream", "drea", "dre", "dr") &&
!STUDENT.findPrefix(a("d"))) {
return 0;
}
STUDENT.delete(a("dog"));
if (!containsAllPaths(STUDENT, "doggy", "cat")) {
return 0;
}
STUDENT.delete(a("doggy"));
return containsAllPaths(STUDENT, "cat") ? 1 : 0;
assertTrue(containsAllPaths(STUDENT, words));
assertTrue(doesNotContainAll(STUDENT, invalid));
}
/**
* Test findPrefix more rigorously.
*/
public static int testFindPrefixes() {
@Test(timeout = 3000)
public void testFindPrefixes() {
String[] words = {"dog", "doggy", "doge", "dragon", "cat", "draggin"};
addAll(STUDENT, words);
boolean allPrefixesFound = containsAllPrefixes(STUDENT, "d", "", "do");
boolean invalidPrefixesIgnored = doesNotContainAllPrefixes(STUDENT, "batarang", "dogee", "dragging");
return allPrefixesFound && invalidPrefixesIgnored ? 1 : 0;
assertTrue(containsAllPrefixes(STUDENT, "d", "", "do"));
assertTrue(doesNotContainAllPrefixes(STUDENT, "batarang", "dogee", "dragging"));
}
/**
* Tests that trying to find a non-existent entity does the correct thing
*/
public static int testFindNonexistentDoesNotCrash() {
@Test(timeout = 3000)
public void testFindNonexistentDoesNotCrash() {
addAll(STUDENT, "foo", "bar", "baz");
return STUDENT.find(a("orangutan")) == null && STUDENT.find(a("z")) == null &&
STUDENT.find(a("ba")) == null && STUDENT.find(a("bazz")) == null &&
!STUDENT.findPrefix(a("boor")) && !STUDENT.findPrefix(a("z")) ? 1 : 0;
}
public static int testFindingNullEntriesCausesError() {
try {
STUDENT.find(null);
return 0;
} catch (IllegalArgumentException ex) {
// Do nothing
}
try {
STUDENT.findPrefix(null);
return 0;
} catch (IllegalArgumentException ex) {
// Do nothing
}
return 1;
}
/**
* Tests that inserts correctly wipe out old values.
*/
public static int testInsertReplacesOldValue() {
AlphabeticString key = a("myKey");
boolean initialValueIsNull = STUDENT.insert(key, "foo") == null;
boolean originalValueReturned = STUDENT.insert(key, "bar").equals("foo");
boolean replacementValueReturned = STUDENT.insert(key, "baz").equals("bar");
return initialValueIsNull && originalValueReturned && replacementValueReturned ? 1 : 0;
}
public static int testInsertingNullEntriesCausesError() {
try {
STUDENT.insert(null, "foo");
return 0;
} catch (IllegalArgumentException ex) {
// Do nothing
}
try {
STUDENT.insert(a("foo"), null);
return 0;
} catch (IllegalArgumentException ex) {
// Do nothing
}
return 1;
}
/**
* Checks to see the trie correctly handles the case where you delete
* absolutely everything.
*/
public static int testDeleteAll() {
AlphabeticString keyA = a("keyboard");
AlphabeticString keyB = a("keyesian");
AlphabeticString keyC = a("bayesian");
if (STUDENT.size() != 0 || !STUDENT.isEmpty()) {
return 0;
}
STUDENT.insert(keyA, "KEYBOARD");
STUDENT.insert(keyB, "KEYESIAN");
STUDENT.insert(keyC, "BAYESIAN");
if (!containsAllPaths(STUDENT, "keyboard", "keyesian", "bayesian")) {
return 0;
}
if (STUDENT.size() != 3 || STUDENT.isEmpty()) {
return 0;
}
STUDENT.delete(keyA);
STUDENT.delete(keyB);
STUDENT.delete(keyC);
if (STUDENT.size() != 0 || !STUDENT.isEmpty()) {
return 0;
}
return doesNotContainAll(STUDENT, "keyboard", "keyesian", "bayesian") ? 1 : 0;
assertNull(STUDENT.find(a("orangutan")));
assertNull(STUDENT.find(a("z")));
assertNull(STUDENT.find(a("ba")));
assertNull(STUDENT.find(a("bazz")));
assertFalse(STUDENT.findPrefix(a("boor")));
assertFalse(STUDENT.findPrefix(a("z")) );
}
/**
* Tests what happens if you attempt deleting something that doesn't exist
* in the trie (but _does_ partially overlap).
*/
public static int testDeleteNothing() {
STUDENT.insert(a("aaaa"), "foo");
if (!containsPath(STUDENT, "aaaa", "foo") || STUDENT.size() != 1 || STUDENT.isEmpty()) {
return 0;
}
// Should not change the trie
STUDENT.delete(a("aa"));
STUDENT.delete(a("a"));
STUDENT.delete(a("abc"));
STUDENT.delete(a("aaaaa"));
STUDENT.delete(a(""));
STUDENT.delete(a("foobar"));
if (!containsPath(STUDENT, "aaaa", "foo") || STUDENT.size() != 1 || STUDENT.isEmpty()) {
return 0;
}
return 1;
@Test(timeout = 3000, expected = IllegalArgumentException.class)
public void testFindingNullKeyCausesError() {
STUDENT.find(null);
}
/**
* Tests what happens if you try deleting and inserting single characters
*/
public static int testDeleteAndInsertSingleChars() {
STUDENT.insert(a("a"), "A");
STUDENT.insert(a("b"), "B");
STUDENT.delete(a("a"));
STUDENT.insert(a("b"), "BB");
MockNode expected = node()
.branch('b', node("BB"));
return equals(expected, getField(STUDENT, "root")) ? 1 : 0;
@Test(timeout = 3000, expected = IllegalArgumentException.class)
public void testFindingNullPrefixCausesError() {
STUDENT.findPrefix(null);
}
/**
* Tests to see if HashTrieMap correctly handles a trie where everything is in a straight
* line/the trie has no branching.
* Tests that inserts correctly wipe out old values.
*/
public static int testDeleteWorksWhenTrieHasNoBranches() {
AlphabeticString keyA = a("ghost");
AlphabeticString keyB = a("gh");
STUDENT.insert(keyA, "A");
STUDENT.insert(keyB, "B");
// Trie should still contain "ghost -> A"
STUDENT.delete(keyB);
if (STUDENT.find(keyB) != null || !STUDENT.findPrefix(keyB) || !STUDENT.find(keyA).equals("A")) {
return 0;
}
// Trie should now contain "gh -> C", but not "ghost -> A"
STUDENT.insert(keyB, "C");
STUDENT.delete(keyA);
return (STUDENT.find(keyB).equals("C") && STUDENT.find(keyA) == null && !STUDENT.findPrefix(a("gho"))) ? 1 : 0;
@Test(timeout = 3000)
public void testInsertReplacesOldValue() {
AlphabeticString key = a("myKey");
assertNull(STUDENT.insert(key, "foo"));
assertEquals("foo", STUDENT.insert(key, "bar"));
assertEquals("bar", STUDENT.insert(key, "baz"));
}
/**
* A slight variation of the previous test.
*/
public static int testDeletingAtRoot() {
STUDENT.insert(a(""), "foo");
STUDENT.insert(a("a"), "bar");
STUDENT.delete(a("a"));
STUDENT.insert(a("b"), "baz");
if (STUDENT.find(a("a")) != null) {
return 0;
}
if (!"foo".equals(STUDENT.find(a("")))) {
return 0;
}
if (!"baz".equals(STUDENT.find(a("b")))) {
return 0;
}
MockNode expected = new MockNode("foo")
.branch('b', new MockNode("baz"));
return equals(expected, getField(STUDENT, "root")) ? 1 : 0;
@Test(timeout = 3000, expected = IllegalArgumentException.class)
public void testInsertingNullKeyCausesError() {
STUDENT.insert(null, "foo");
}
/**
* Tests that just working with empty strings does the correct thing.
*/
public static int testDeletingEmptyString() {
STUDENT.insert(a(""), "Foo");
if (!"Foo".equals(STUDENT.find(a(""))) || STUDENT.size() != 1 || STUDENT.isEmpty()) {
return 0;
}
STUDENT.delete(a(""));
if (STUDENT.find(a("")) != null || STUDENT.size() > 0 && !STUDENT.isEmpty()) {
return 0;
}
STUDENT.insert(a(""), "Bar");
return "Bar".equals(STUDENT.find(a(""))) && STUDENT.size() == 1 && !STUDENT.isEmpty() ? 1 : 0;
@Test(timeout = 3000, expected = IllegalArgumentException.class)
public void testInsertingNullValueCausesError() {
STUDENT.insert(a("foo"), null);
}
public static int testDeletingNullEntriesCausesError() {
try {
STUDENT.delete((AlphabeticString) null);
} catch (IllegalArgumentException ex) {
return 1;
}
return 0;
@Test(timeout = 3000, expected=UnsupportedOperationException.class)
public void testDeletingCausesError() {
STUDENT.insert(a("foo"), "doo");
STUDENT.delete(a("foo"));
}
public static int testClear() {
addAll(STUDENT, "keyboard", "keyesian", "bayesian");
@Test(timeout = 3000, expected=UnsupportedOperationException.class)
public void testClearCausesError() {
STUDENT.insert(a("foo"), "doo");
STUDENT.clear();
return (STUDENT.size() == 0 &&
STUDENT.isEmpty() &&
doesNotContainAll(STUDENT, "keyboard", "keyesian", "bayesian")) ? 1 : 0;
}
public static int checkUnderlyingStructure() {
@Test(timeout = 3000)
public void checkUnderlyingStructure() {
STUDENT.insert(a(""), "A");
STUDENT.insert(a("foo"), "B");
STUDENT.insert(a("fez"), "C");
......@@ -324,80 +109,19 @@ public class HashTrieMapTests extends TestsUtility {
STUDENT.insert(a("jazzy"), "F");
MockNode fullExpected = node("A")
.branch('f', node()
.branch('o', node()
.branch('o', node("B")))
.branch('e', node()
.branch('z', node("C")
.branch('z', node()
.branch('y', node("D"))))))
.branch('j', node()
.branch('a', node()
.branch('z', node()
.branch('z', node("E")
.branch('y', node("F"))))));
if (!equals(fullExpected, getField(STUDENT, "root"))) {
return 0;
}
STUDENT.delete(a("fezzy"));
STUDENT.delete(a("jazz"));
MockNode delete1 = node("A")
.branch('f', node()
.branch('o', node()
.branch('o', node("B")))
.branch('e', node()
.branch('z', node("C"))))
.branch('j', node()
.branch('a', node()
.branch('z', node()
.branch('z', node()
.branch('y', node("F"))))));
if (!equals(delete1, getField(STUDENT, "root"))) {
return 0;
}
STUDENT.delete(a(""));
STUDENT.delete(a("foo"));
STUDENT.delete(a("jazz")); // should do nothing
MockNode delete2 = node()
.branch('f', node()
.branch('e', node()
.branch('z', node("C"))))
.branch('j', node()
.branch('a', node()
.branch('z', node()
.branch('z', node()
.branch('y', node("F"))))));
if (!equals(delete2, getField(STUDENT, "root"))) {
return 0;
}
STUDENT.insert(a("f"), "Z");
STUDENT.delete(a("jazzy"));
STUDENT.delete(a("fez"));
MockNode delete3 = node().branch('f', node("Z"));
if (!equals(delete3, getField(STUDENT, "root"))) {
return 0;
}
STUDENT.delete(a("f"));
boolean rootIsSingleNode = equals(node(), getField(STUDENT, "root"));
boolean rootIsNull = equals(null, getField(STUDENT, "root"));
if (!(rootIsSingleNode || rootIsNull)) {
return 0;
}
return 1;
.branch('f', node()
.branch('o', node()
.branch('o', node("B")))
.branch('e', node()
.branch('z', node("C")
.branch('z', node()
.branch('y', node("D"))))))
.branch('j', node()
.branch('a', node()
.branch('z', node()
.branch('z', node("E")
.branch('y', node("F"))))));
assertTrue(equals(fullExpected, getField(STUDENT, "root")));
}
protected static boolean equals(MockNode expected, HashTrieMap<Character, AlphabeticString, String>.HashTrieNode student) {
......@@ -416,14 +140,6 @@ public class HashTrieMapTests extends TestsUtility {
// If number of pointers is not the same
return false;
} else {
// If student doesn't contain the given char, 'equals' will fail one level down
// in one of the base cases
for (char c : expected.pointers.keySet()) {
boolean result = equals(expected.pointers.get(c), student.pointers.get(c));
if (!result) {
return false;
}
}
return true;
}
}
......@@ -455,7 +171,8 @@ public class HashTrieMapTests extends TestsUtility {
}
}
public static int stressTest() {
@Test(timeout = 3000)
public void stressTest() {
// Should contain 30 characters
char[] symbols = "abcdefghijklmnopqrstuvwxyz!@#$".toCharArray();
long i = 0;
......@@ -473,9 +190,7 @@ public class HashTrieMapTests extends TestsUtility {
for (char a : symbols) {
for (char b : symbols) {
if (!STUDENT.findPrefix(new AlphabeticString(new Character[]{a, b}))) {
return 0;
}
assertTrue(STUDENT.findPrefix(new AlphabeticString(new Character[]{a, b})));
}
}
......@@ -485,16 +200,12 @@ public class HashTrieMapTests extends TestsUtility {
for (char c : symbols) {
for (char d : symbols) {
Character[] word = new Character[]{a, b, c, d};
if (!STUDENT.find(new AlphabeticString(word)).equals("" + i)) {
return 0;
}
assertEquals("" + i, STUDENT.find(new AlphabeticString(word)));
i += 1;
}
}
}
}
return 1;
}
/**
......@@ -589,4 +300,22 @@ public class HashTrieMapTests extends TestsUtility {
trie.insert(a(word), word.toUpperCase());
}
}
protected <T> T getField(Object o, String fieldName) {
try {
Field field = o.getClass().getSuperclass().getDeclaredField(fieldName);
field.setAccessible(true);
Object f = field.get(o);
return (T) f;
} catch (Exception var6) {
try {
Field field = o.getClass().getDeclaredField(fieldName);
field.setAccessible(true);
Object f = field.get(o);
return (T) f;
} catch (Exception var5) {
return null;
}
}
}
}
src/tests/gitlab/ckpt2/HeapSortTests.java
View file @ ab289774
package tests.gitlab.ckpt2;
import p2.sorts.HeapSort;
import tests.TestsUtility;
import org.junit.Test;
public class HeapSortTests extends TestsUtility {
public static void main(String[] args) {
new HeapSortTests().run();
}
import java.util.Comparator;
@Override
protected void run() {
SHOW_TESTS = true;
test("integer_sorted");
test("integer_random");
finish();
}
import static org.junit.Assert.*;
public static int integer_sorted() {
public class HeapSortTests {
@Test(timeout = 3000)
public void integer_sorted() {
Integer[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
Integer[] arr_sorted = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
HeapSort.sort(arr, (i1, i2) -> i1.compareTo(i2));
HeapSort.sort(arr, Integer::compareTo);
for(int i = 0; i < arr.length; i++) {
if(!arr[i].equals(arr_sorted[i]))
return 0;
assertEquals(arr[i], arr_sorted[i]);
}
return 1;
}
public static int integer_random() {
@Test(timeout = 3000)
public void integer_random() {
Integer[] arr = {3, 1, 4, 5, 9, 2, 6, 7, 8};
Integer[] arr_sorted = {1, 2, 3, 4, 5, 6, 7, 8, 9};
HeapSort.sort(arr, (i1, i2) -> i1.compareTo(i2));
HeapSort.sort(arr, Integer::compareTo);
for(int i = 0; i < arr.length; i++) {
if(!arr[i].equals(arr_sorted[i]))
return 0;
assertEquals(arr[i], arr_sorted[i]);
}
return 1;
}
}
src/tests/gitlab/ckpt2/QuickSortTests.java
View file @ ab289774
......@@ -3,50 +3,28 @@ package tests.gitlab.ckpt2;
import java.util.Comparator;
import p2.sorts.QuickSort;
import tests.TestsUtility;
import org.junit.Test;
import static org.junit.Assert.*;
public class QuickSortTests extends TestsUtility {
public static void main(String[] args) {
new QuickSortTests().run();
}
@Override
protected void run() {
SHOW_TESTS = true;
test("integer_sorted");
test("integer_random");
finish();
}
public class QuickSortTests {
public static int integer_sorted() {
@Test(timeout = 3000)
public void integer_sorted() {
Integer[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
Integer[] arr_sorted = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
QuickSort.sort(arr, new Comparator<Integer>() {
@Override
public int compare(Integer e1, Integer e2) {
return e1.compareTo(e2);
}
});
QuickSort.sort(arr, Integer::compareTo);
for(int i = 0; i < arr.length; i++) {
if(!arr[i].equals(arr_sorted[i]))
return 0;
assertEquals(arr[i], arr_sorted[i]);
}
return 1;
}
public static int integer_random() {
@Test(timeout = 3000)
public void integer_random() {
Integer[] arr = {3, 1, 4, 5, 9, 2, 6, 7, 8};
Integer[] arr_sorted = {1, 2, 3, 4, 5, 6, 7, 8, 9};
QuickSort.sort(arr, new Comparator<Integer>() {
@Override
public int compare(Integer e1, Integer e2) {
return e1.compareTo(e2);
}
});
QuickSort.sort(arr, Integer::compareTo);
for(int i = 0; i < arr.length; i++) {
if(!arr[i].equals(arr_sorted[i]))
return 0;
assertEquals(arr[i], arr_sorted[i]);
}
return 1;
}
}
\ No newline at end of file
src/tests/gitlab/ckpt2/TopKSortTests.java
View file @ ab289774
......@@ -3,52 +3,30 @@ package tests.gitlab.ckpt2;
import java.util.Comparator;
import p2.sorts.TopKSort;
import tests.TestsUtility;
import org.junit.Test;
import static org.junit.Assert.*;
public class TopKSortTests extends TestsUtility {
public static void main(String[] args) {
new TopKSortTests().run();
}
@Override
protected void run() {
SHOW_TESTS = true;
test("integer_sorted");
test("integer_random");
finish();
}
public class TopKSortTests {
public static int integer_sorted() {
@Test(timeout = 3000)
public void integer_sorted() {
int K = 4;
Integer[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
Integer[] arr_sorted = {7, 8, 9, 10};
TopKSort.sort(arr, K, new Comparator<Integer>() {
@Override
public int compare(Integer e1, Integer e2) {
return e1.compareTo(e2);
}
});
TopKSort.sort(arr, K, Integer::compareTo);
for(int i = 0; i < K; i++) {
if(!arr[i].equals(arr_sorted[i]))
return 0;
assertEquals(arr[i], arr_sorted[i]);
}
return 1;
}
public static int integer_random() {
@Test(timeout = 3000)
public void integer_random() {
int K = 4;
Integer[] arr = {3, 1, 4, 5, 9, 2, 6, 7, 8};
Integer[] arr_sorted = {6, 7, 8, 9};
TopKSort.sort(arr, K, new Comparator<Integer>() {
@Override
public int compare(Integer e1, Integer e2) {
return e1.compareTo(e2);
}
});
TopKSort.sort(arr, K, Integer::compareTo);
for(int i = 0; i < K; i++) {
if(!arr[i].equals(arr_sorted[i]))
return 0;
assertEquals(arr[i], arr_sorted[i]);
}
return 1;
}
}
\ No newline at end of file