Instructions
Requirements and Specifications
Source Code
ABSTRACT TEST SORT
import java.util.Arrays;
import java.util.Comparator;
import java.util.Random;
import edu.uwm.cs351.ImmutableSortObject;
import edu.uwm.cs351.SortHarness;
import edu.uwm.cs351.SortObject;
import edu.uwm.cs351.Sorter;
import edu.uwm.cs351.SortStat;
import junit.framework.TestCase;
public abstract class AbstractTestSort extends TestCase {
protected abstract Sorter getAlgorithm();
// for internal tests:
protected Sorter algorithm = getAlgorithm();
protected SortObject self;
protected void setUp(Comparator comp, int... values) {
Integer[] array = new Integer[values.length];
for (int i=0; i < values.length; ++i) {
array[i] = values[i];
}
self = new ImmutableSortObject<>(array, comp);
}
protected void setUp(int ... values) {
setUp((Comparator)null, values);
}
// for numbered tests:
protected void assertStatsRange(int[] lo, int[] stats, int[] hi) {
// System.out.println("stats = " + Arrays.toString(stats) +": in range " + Arrays.toString(lo) + "..." + Arrays.toString(hi));
for (SortStat stat : SortStat.values()) {
int i = stat.ordinal();
if (stats[i] < lo[i] || stats[i] > hi[i]) {
assertFalse(stat + " stats = " + stats[i] + " out or required range [" + lo[i] + "," + hi[i] + "]", true);
}
}
}
protected int[] s(int g, int s, int c) {
return new int[] {g, s, c};
}
protected Sorter sorter = getAlgorithm();
SortHarness harness;
SortObject object;
protected abstract int[] lo(int n, boolean isAdd);
protected abstract int[] hi(int n, boolean isAdd, int ni);
public void test10() {
harness = new SortHarness("Hello");
object = harness.sortObject();
harness.setSize(0);
assertNull(sorter.violation(object, 0));
harness.setSize(1);
harness.clearStats();
sorter.add(object, 0);
assertStatsRange(lo(0,true), harness.getStats(), hi(0,true, 0));
assertNull(sorter.violation(object, 1));
harness.clearStats();
sorter.remove(object, 0);
assertStatsRange(lo(0,false), harness.getStats(), hi(0,false, 0));
assertEquals("Hello", object.get(0));
assertNull(sorter.violation(object, 0));
}
public void test20() {
harness = new SortHarness(String.CASE_INSENSITIVE_ORDER, "Hello", "hello");
object = harness.sortObject();
harness.setSize(0);
assertNull(sorter.violation(object, 0));
harness.setSize(1);
harness.clearStats();
sorter.add(object, 0);
assertStatsRange(lo(0,true), harness.getStats(), hi(0,true, 0));
assertNull(sorter.violation(object, 1));
harness.setSize(2);
harness.clearStats();
sorter.add(object, 1);
assertStatsRange(lo(1,true), harness.getStats(), hi(1,true, 1));
assertNull(sorter.violation(object, 2));
harness.clearStats();
sorter.remove(object, 1);
assertStatsRange(lo(1,false), harness.getStats(), hi(1,false, 0));
String a1 = object.get(1);
assertTrue("Wrong: " + a1, a1 == "Hello" || a1 == "hello");
assertNull(sorter.violation(object, 1));
harness.setSize(1);
harness.clearStats();
sorter.remove(object, 0);
assertStatsRange(lo(0,false), harness.getStats(), hi(0,false, 0));
String a0 = object.get(0);
assertTrue("Wrong: " + a0, a0 == "Hello" || a0 == "hello");
assertTrue("Duplicate: " + a0, a0 != a1);
assertNull(sorter.violation(object, 0));
}
public void test21() {
harness = new SortHarness((s1,s2) -> s2.compareTo(s1), "Hello", "Bye");
object = harness.sortObject();
harness.setSize(0);
assertNull(sorter.violation(object, 0));
harness.setSize(1);
harness.clearStats();
sorter.add(object, 0);
assertStatsRange(lo(0,true), harness.getStats(), hi(0,true, 0));
assertNull(sorter.violation(object, 1));
harness.setSize(2);
harness.clearStats();
sorter.add(object, 1);
assertStatsRange(lo(1,true), harness.getStats(), hi(1,true, 1));
assertNull(sorter.violation(object, 2));
harness.clearStats();
sorter.remove(object, 1);
assertStatsRange(lo(1,false), harness.getStats(), hi(1,false, 0));
assertEquals("Bye", object.get(1));
assertNull(sorter.violation(object, 1));
harness.setSize(1);
harness.clearStats();
sorter.remove(object, 0);
assertStatsRange(lo(0,false), harness.getStats(), hi(0,false, 0));
assertEquals("Hello", object.get(0));
assertNull(sorter.violation(object, 0));
}
public void test22() {
harness = new SortHarness("Hello", "Bye");
object = harness.sortObject();
harness.setSize(0);
assertNull(sorter.violation(object, 0));
harness.setSize(1);
harness.clearStats();
sorter.add(object, 0);
assertStatsRange(lo(0,true), harness.getStats(), hi(0,true, 0));
assertNull(sorter.violation(object, 1));
harness.setSize(2);
harness.clearStats();
sorter.add(object, 1);
assertStatsRange(lo(1,true), harness.getStats(), hi(1,true, 0));
assertNull(sorter.violation(object, 2));
harness.clearStats();
sorter.remove(object, 1);
assertStatsRange(lo(1,false), harness.getStats(), hi(1,false, 0));
assertEquals("Hello", object.get(1));
assertNull(sorter.violation(object, 1));
harness.setSize(1);
harness.clearStats();
sorter.remove(object, 0);
assertStatsRange(lo(0,false), harness.getStats(), hi(0,false, 0));
assertEquals("Bye", object.get(0));
assertNull(sorter.violation(object, 0));
}
public void test30() {
harness = new SortHarness(String.CASE_INSENSITIVE_ORDER, "Hello", "hello", "HELLO");
object = harness.sortObject();
harness.setSize(0);
assertNull(sorter.violation(object, 0));
harness.setSize(1);
harness.clearStats();
sorter.add(object, 0);
assertStatsRange(lo(0,true), harness.getStats(), hi(0,true, 0));
assertNull(sorter.violation(object, 1));
harness.setSize(2);
harness.clearStats();
sorter.add(object, 1);
assertStatsRange(lo(1,true), harness.getStats(), hi(1,true, 1));
assertNull(sorter.violation(object, 2));
harness.setSize(3);
harness.clearStats();
sorter.add(object, 2);
assertStatsRange(lo(2,true), harness.getStats(), hi(2,true, 2));
assertNull(sorter.violation(object, 3));
harness.clearStats();
sorter.remove(object, 2);
assertStatsRange(lo(2,false), harness.getStats(), hi(2,false, 0));
String a2 = object.get(2);
assertTrue(a2 == "Hello" || a2 == "hello" || a2 == "HELLO");
assertNull(sorter.violation(object, 2));
harness.setSize(2);
harness.clearStats();
sorter.remove(object, 1);
assertStatsRange(lo(1,false), harness.getStats(), hi(1,false, 0));
String a1 = object.get(1);
assertTrue("Wrong: " + a1, a1 == "Hello" || a1 == "hello" || a1 == "HELLO");
assertTrue("Duplicate: " + a1, a1 != a2);
assertNull(sorter.violation(object, 1));
harness.setSize(1);
harness.clearStats();
sorter.remove(object, 0);
assertStatsRange(lo(0,false), harness.getStats(), hi(0,false, 0));
String a0 = object.get(0);
assertTrue("Wrong: " + a0, a0 == "Hello" || a0 == "hello" || a0 == "HELLO");
assertTrue("Duplicate: " + a0, a1 != a0);
assertTrue("Duplicate: " + a0, a2 != a0);
assertNull(sorter.violation(object, 0));
}
public void test31() {
harness = new SortHarness(String.CASE_INSENSITIVE_ORDER, "Hello", "hello", "Bye");
object = harness.sortObject();
harness.setSize(0);
assertNull(sorter.violation(object, 0));
harness.setSize(1);
harness.clearStats();
sorter.add(object, 0);
assertStatsRange(lo(0,true), harness.getStats(), hi(0,true, 0));
assertNull(sorter.violation(object, 1));
harness.setSize(2);
harness.clearStats();
sorter.add(object, 1);
assertStatsRange(lo(1,true), harness.getStats(), hi(1,true, 1));
assertNull(sorter.violation(object, 2));
harness.setSize(3);
harness.clearStats();
sorter.add(object, 2);
assertStatsRange(lo(2,true), harness.getStats(), hi(2,true, 0));
assertNull(sorter.violation(object, 3));
harness.clearStats();
sorter.remove(object, 2);
assertStatsRange(lo(2,false), harness.getStats(), hi(2,false, 0));
String a2 = object.get(2);
assertTrue("Wrong: " + a2, a2 == "Hello" || a2 == "hello");
assertNull(sorter.violation(object, 2));
harness.setSize(2);
harness.clearStats();
sorter.remove(object, 1);
assertStatsRange(lo(1,false), harness.getStats(), hi(1,false, 0));
String a1 = object.get(1);
assertTrue("Wrong: " + a1, a1 == "Hello" || a1 == "hello");
assertTrue("Duplicate: " + a1, a1 != a2);
assertNull(sorter.violation(object, 1));
harness.setSize(1);
harness.clearStats();
sorter.remove(object, 0);
assertStatsRange(lo(0,false), harness.getStats(), hi(0,false, 0));
String a0 = object.get(0);
assertEquals("Bye", a0);
assertNull(sorter.violation(object, 0));
}
public void test32() {
harness = new SortHarness(String.CASE_INSENSITIVE_ORDER, "Hello", "hello", "world");
object = harness.sortObject();
harness.setSize(0);
assertNull(sorter.violation(object, 0));
harness.setSize(1);
harness.clearStats();
sorter.add(object, 0);
assertStatsRange(lo(0,true), harness.getStats(), hi(0,true, 0));
assertNull(sorter.violation(object, 1));
harness.setSize(2);
harness.clearStats();
sorter.add(object, 1);
assertStatsRange(lo(1,true), harness.getStats(), hi(1,true, 1));
assertNull(sorter.violation(object, 2));
harness.setSize(3);
harness.clearStats();
sorter.add(object, 2);
assertStatsRange(lo(2,true), harness.getStats(), hi(2,true, 2));
assertNull(sorter.violation(object, 3));
harness.clearStats();
sorter.remove(object, 2);
assertStatsRange(lo(2,false), harness.getStats(), hi(2,false, 0));
assertEquals("world", object.get(2));
assertNull(sorter.violation(object, 2));
harness.setSize(2);
harness.clearStats();
sorter.remove(object, 1);
assertStatsRange(lo(1,false), harness.getStats(), hi(1,false, 0));
String a1 = object.get(1);
assertTrue("Wrong: " + a1, a1 == "Hello" || a1 == "hello");
assertNull(sorter.violation(object, 1));
harness.setSize(1);
harness.clearStats();
sorter.remove(object, 0);
assertStatsRange(lo(0,false), harness.getStats(), hi(0,false, 0));
String a0 = object.get(0);
assertTrue("Wrong: " + a0, a0 == "Hello" || a0 == "hello");
assertTrue("Duplicate: " + a0, a1 != a0);
assertNull(sorter.violation(object, 0));
}
public void test33() {
harness = new SortHarness(String.CASE_INSENSITIVE_ORDER, "Well", "Hello", "hello");
object = harness.sortObject();
harness.setSize(0);
assertNull(sorter.violation(object, 0));
harness.setSize(1);
harness.clearStats();
sorter.add(object, 0);
assertStatsRange(lo(0,true), harness.getStats(), hi(0,true, 0));
assertNull(sorter.violation(object, 1));
harness.setSize(2);
harness.clearStats();
sorter.add(object, 1);
assertStatsRange(lo(1,true), harness.getStats(), hi(1,true, 0));
assertNull(sorter.violation(object, 2));
harness.setSize(3);
harness.clearStats();
sorter.add(object, 2);
assertStatsRange(lo(2,true), harness.getStats(), hi(2,true, 1));
assertNull(sorter.violation(object, 3));
harness.clearStats();
sorter.remove(object, 2);
assertStatsRange(lo(2,false), harness.getStats(), hi(2,false, 0));
assertEquals("Well", object.get(2));
assertNull(sorter.violation(object, 2));
harness.setSize(2);
harness.clearStats();
sorter.remove(object, 1);
assertStatsRange(lo(1,false), harness.getStats(), hi(1,false, 0));
String a1 = object.get(1);
assertTrue("Wrong: " + a1, a1 == "Hello" || a1 == "hello");
assertNull(sorter.violation(object, 1));
harness.setSize(1);
harness.clearStats();
sorter.remove(object, 0);
assertStatsRange(lo(0,false), harness.getStats(), hi(0,false, 0));
String a0 = object.get(0);
assertTrue("Wrong: " + a0, a0 == "Hello" || a0 == "hello");
assertTrue("Duplicate: " + a0, a1 != a0);
assertNull(sorter.violation(object, 0));
}
public void test34() {
harness = new SortHarness(String.CASE_INSENSITIVE_ORDER, "Hello", "and", "hello");
object = harness.sortObject();
harness.setSize(0);
assertNull(sorter.violation(object, 0));
harness.setSize(1);
harness.clearStats();
sorter.add(object, 0);
assertStatsRange(lo(0,true), harness.getStats(), hi(0,true, 0));
assertNull(sorter.violation(object, 1));
harness.setSize(2);
harness.clearStats();
sorter.add(object, 1);
assertStatsRange(lo(1,true), harness.getStats(), hi(1,true, 0));
assertNull(sorter.violation(object, 2));
harness.setSize(3);
harness.clearStats();
sorter.add(object, 2);
assertStatsRange(lo(2,true), harness.getStats(), hi(2,true, 2));
assertNull(sorter.violation(object, 3));
harness.clearStats();
sorter.remove(object, 2);
assertStatsRange(lo(2,false), harness.getStats(), hi(2,false, 0));
String a2 = object.get(2);
assertTrue("Wrong: " + a2, a2 == "Hello" || a2 == "hello");
assertNull(sorter.violation(object, 2));
harness.setSize(2);
harness.clearStats();
sorter.remove(object, 1);
assertStatsRange(lo(1,false), harness.getStats(), hi(1,false, 0));
String a1 = object.get(1);
assertTrue("Wrong: " + a1, a1 == "Hello" || a1 == "hello");
assertTrue("Duplicate: " + a1, a1 != a2);
assertNull(sorter.violation(object, 1));
harness.setSize(1);
harness.clearStats();
sorter.remove(object, 0);
assertStatsRange(lo(0,false), harness.getStats(), hi(0,false, 0));
String a0 = object.get(0);
assertEquals("and", a0);
assertNull(sorter.violation(object, 0));
}
public void test35() {
harness = new SortHarness(String.CASE_INSENSITIVE_ORDER, "Hello", "and", "goodbye");
object = harness.sortObject();
harness.setSize(0);
assertNull(sorter.violation(object, 0));
harness.setSize(1);
harness.clearStats();
sorter.add(object, 0);
assertStatsRange(lo(0,true), harness.getStats(), hi(0,true, 0));
assertNull(sorter.violation(object, 1));
harness.setSize(2);
harness.clearStats();
sorter.add(object, 1);
assertStatsRange(lo(1,true), harness.getStats(), hi(1,true, 0));
assertNull(sorter.violation(object, 2));
harness.setSize(3);
harness.clearStats();
sorter.add(object, 2);
assertStatsRange(lo(2,true), harness.getStats(), hi(2,true, 1));
assertNull(sorter.violation(object, 3));
harness.clearStats();
sorter.remove(object, 2);
assertStatsRange(lo(2,false), harness.getStats(), hi(2,false, 0));
assertEquals("Hello", object.get(2));
assertNull(sorter.violation(object, 2));
harness.setSize(2);
harness.clearStats();
sorter.remove(object, 1);
assertStatsRange(lo(1,false), harness.getStats(), hi(1,false, 0));
assertEquals("goodbye", object.get(1));
assertNull(sorter.violation(object, 1));
harness.setSize(1);
harness.clearStats();
sorter.remove(object, 0);
assertStatsRange(lo(0,false), harness.getStats(), hi(0,false, 0));
assertEquals("and", object.get(0));
assertNull(sorter.violation(object, 0));
}
public void test36() {
harness = new SortHarness("Hello", "and", "goodbye"); // uppercase before lowercase
object = harness.sortObject();
harness.setSize(0);
assertNull(sorter.violation(object, 0));
harness.setSize(1);
harness.clearStats();
sorter.add(object, 0);
assertStatsRange(lo(0,true), harness.getStats(), hi(0,true, 0));
assertNull(sorter.violation(object, 1));
harness.setSize(2);
harness.clearStats();
sorter.add(object, 1);
assertStatsRange(lo(1,true), harness.getStats(), hi(1,true, 1));
assertNull(sorter.violation(object, 2));
harness.setSize(3);
harness.clearStats();
sorter.add(object, 2);
assertStatsRange(lo(2,true), harness.getStats(), hi(2,true, 2));
assertNull(sorter.violation(object, 3));
harness.clearStats();
sorter.remove(object, 2);
assertStatsRange(lo(2,false), harness.getStats(), hi(2,false, 0));
assertEquals("goodbye", object.get(2));
assertNull(sorter.violation(object, 2));
harness.setSize(2);
harness.clearStats();
sorter.remove(object, 1);
assertStatsRange(lo(1,false), harness.getStats(), hi(1,false, 0));
assertEquals("and", object.get(1));
assertNull(sorter.violation(object, 1));
harness.setSize(1);
harness.clearStats();
sorter.remove(object, 0);
assertStatsRange(lo(0,false), harness.getStats(), hi(0,false, 0));
assertEquals("Hello", object.get(0));
assertNull(sorter.violation(object, 0));
}
public void test37() {
harness = new SortHarness("hello", "good", "world");
object = harness.sortObject();
harness.setSize(0);
assertNull(sorter.violation(object, 0));
harness.setSize(1);
harness.clearStats();
sorter.add(object, 0);
assertStatsRange(lo(0,true), harness.getStats(), hi(0,true, 0));
assertNull(sorter.violation(object, 1));
harness.setSize(2);
harness.clearStats();
sorter.add(object, 1);
assertStatsRange(lo(1,true), harness.getStats(), hi(1,true, 0));
assertNull(sorter.violation(object, 2));
harness.setSize(3);
harness.clearStats();
sorter.add(object, 2);
assertStatsRange(lo(2,true), harness.getStats(), hi(2,true, 2));
assertNull(sorter.violation(object, 3));
harness.clearStats();
sorter.remove(object, 2);
assertStatsRange(lo(2,false), harness.getStats(), hi(2,false, 0));
assertEquals("world", object.get(2));
assertNull(sorter.violation(object, 2));
harness.setSize(2);
harness.clearStats();
sorter.remove(object, 1);
assertStatsRange(lo(1,false), harness.getStats(), hi(1,false, 0));
assertEquals("hello", object.get(1));
assertNull(sorter.violation(object, 1));
harness.setSize(1);
harness.clearStats();
sorter.remove(object, 0);
assertStatsRange(lo(0,false), harness.getStats(), hi(0,false, 0));
assertEquals("good", object.get(0));
assertNull(sorter.violation(object, 0));
}
public void test38() {
harness = new SortHarness("hello", "good", "earth");
object = harness.sortObject();
harness.setSize(0);
assertNull(sorter.violation(object, 0));
harness.setSize(1);
harness.clearStats();
sorter.add(object, 0);
assertStatsRange(lo(0,true), harness.getStats(), hi(0,true, 0));
assertNull(sorter.violation(object, 1));
harness.setSize(2);
harness.clearStats();
sorter.add(object, 1);
assertStatsRange(lo(1,true), harness.getStats(), hi(1,true, 0));
assertNull(sorter.violation(object, 2));
harness.setSize(3);
harness.clearStats();
sorter.add(object, 2);
assertStatsRange(lo(2,true), harness.getStats(), hi(2,true, 0));
assertNull(sorter.violation(object, 3));
harness.clearStats();
sorter.remove(object, 2);
assertStatsRange(lo(2,false), harness.getStats(), hi(2,false, 0));
assertEquals("hello", object.get(2));
assertNull(sorter.violation(object, 2));
harness.setSize(2);
harness.clearStats();
sorter.remove(object, 1);
assertStatsRange(lo(1,false), harness.getStats(), hi(1,false, 0));
assertEquals("good", object.get(1));
assertNull(sorter.violation(object, 1));
harness.setSize(1);
harness.clearStats();
sorter.remove(object, 0);
assertStatsRange(lo(0,false), harness.getStats(), hi(0,false, 0));
assertEquals("earth", object.get(0));
assertNull(sorter.violation(object, 0));
}
public void test40() {
harness = new SortHarness(String.CASE_INSENSITIVE_ORDER, "Beat", "beat", "BeAt", "BEAT");
object = harness.sortObject();
harness.setSize(0);
assertNull(sorter.violation(object, 0));
harness.setSize(1);
harness.clearStats();
sorter.add(object, 0);
assertStatsRange(lo(0,true), harness.getStats(), hi(0,true, 0));
assertNull(sorter.violation(object, 1));
harness.setSize(2);
harness.clearStats();
sorter.add(object, 1);
assertStatsRange(lo(1,true), harness.getStats(), hi(1,true, 1));
assertNull(sorter.violation(object, 2));
harness.setSize(3);
harness.clearStats();
sorter.add(object, 2);
assertStatsRange(lo(2,true), harness.getStats(), hi(2,true, 2));
assertNull(sorter.violation(object, 3));
harness.setSize(4);
harness.clearStats();
sorter.add(object, 3);
assertStatsRange(lo(3,true), harness.getStats(), hi(3,true, 3));
assertNull(sorter.violation(object, 4));
harness.clearStats();
sorter.remove(object, 3);
assertStatsRange(lo(3,false), harness.getStats(), hi(3,false, 0));
String a3 = object.get(3);
assertTrue("Wrong: " + a3, a3 == "beat" || a3 == "Beat" || a3 == "BeAt" || a3 == "BEAT");
assertNull(sorter.violation(object, 3));
harness.setSize(3);
harness.clearStats();
sorter.remove(object, 2);
assertStatsRange(lo(2,false), harness.getStats(), hi(2,false, 0));
String a2 = object.get(2);
assertTrue("Wrong: " + a2, a2 == "beat" || a2 == "Beat" || a2 == "BeAt" || a2 == "BEAT");
assertTrue("Duplicate: " + a2, a2 != a3);
assertNull(sorter.violation(object, 2));
harness.setSize(2);
harness.clearStats();
sorter.remove(object, 1);
assertStatsRange(lo(1,false), harness.getStats(), hi(1,false, 0));
String a1 = object.get(1);
assertTrue("Wrong: " + a1, a1 == "beat" || a1 == "Beat" || a1 == "BeAt" || a1 == "BEAT");
assertTrue("Duplicate: " + a1, a1 != a3);
assertTrue("Duplicate: " + a1, a1 != a2);
assertNull(sorter.violation(object, 1));
harness.setSize(1);
harness.clearStats();
sorter.remove(object, 0);
assertStatsRange(lo(0,false), harness.getStats(), hi(0,false, 0));
String a0 = object.get(0);
assertTrue("Wrong: " + a0, a0 == "beat" || a0 == "Beat" || a0 == "BeAt" || a0 == "BEAT");
assertTrue("Duplicate: " + a0, a0 != a3);
assertTrue("Duplicate: " + a0, a0 != a2);
assertTrue("Duplicate: " + a0, a0 != a1);
assertNull(sorter.violation(object, 0));
}
public void test41() {
harness = new SortHarness(String.CASE_INSENSITIVE_ORDER, "Beat", "drum", "beat", "DRUM");
object = harness.sortObject();
harness.setSize(0);
assertNull(sorter.violation(object, 0));
harness.setSize(1);
harness.clearStats();
sorter.add(object, 0);
assertStatsRange(lo(0,true), harness.getStats(), hi(0,true, 0));
assertNull(sorter.violation(object, 1));
harness.setSize(2);
harness.clearStats();
sorter.add(object, 1);
assertStatsRange(lo(1,true), harness.getStats(), hi(1,true, 1));
assertNull(sorter.violation(object, 2));
harness.setSize(3);
harness.clearStats();
sorter.add(object, 2);
assertStatsRange(lo(2,true), harness.getStats(), hi(2,true, 1));
assertNull(sorter.violation(object, 3));
harness.setSize(4);
harness.clearStats();
sorter.add(object, 3);
assertStatsRange(lo(3,true), harness.getStats(), hi(3,true, 3));
assertNull(sorter.violation(object, 4));
harness.clearStats();
sorter.remove(object, 3);
assertStatsRange(lo(3,false), harness.getStats(), hi(3,false, 0));
String a3 = object.get(3);
assertTrue("Wrong: " + a3, a3 == "drum" || a3 == "DRUM");
assertNull(sorter.violation(object, 3));
harness.setSize(3);
harness.clearStats();
sorter.remove(object, 2);
assertStatsRange(lo(2,false), harness.getStats(), hi(2,false, 0));
String a2 = object.get(2);
assertTrue("Wrong: " + a2, a2 == "drum" || a2 == "DRUM");
assertTrue("Duplicate: " + a2, a2 != a3);
assertNull(sorter.violation(object, 2));
harness.setSize(2);
harness.clearStats();
sorter.remove(object, 1);
assertStatsRange(lo(1,false), harness.getStats(), hi(1,false, 0));
String a1 = object.get(1);
assertTrue("Wrong: " + a1, a1 == "beat" || a1 == "Beat");
assertNull(sorter.violation(object, 1));
harness.setSize(1);
harness.clearStats();
sorter.remove(object, 0);
assertStatsRange(lo(0,false), harness.getStats(), hi(0,false, 0));
String a0 = object.get(0);
assertTrue("Wrong: " + a0, a0 == "beat" || a0 == "Beat");
assertTrue("Duplicate: " + a0, a0 != a1);
assertNull(sorter.violation(object, 0));
}
public void test42() {
harness = new SortHarness(String.CASE_INSENSITIVE_ORDER, "Beat", "drum", "in", "time");
object = harness.sortObject();
harness.setSize(0);
assertNull(sorter.violation(object, 0));
harness.setSize(1);
harness.clearStats();
sorter.add(object, 0);
assertStatsRange(lo(0,true), harness.getStats(), hi(0,true, 0));
assertNull(sorter.violation(object, 1));
harness.setSize(2);
harness.clearStats();
sorter.add(object, 1);
assertStatsRange(lo(1,true), harness.getStats(), hi(1,true, 1));
assertNull(sorter.violation(object, 2));
harness.setSize(3);
harness.clearStats();
sorter.add(object, 2);
assertStatsRange(lo(2,true), harness.getStats(), hi(2,true, 2));
assertNull(sorter.violation(object, 3));
harness.setSize(4);
harness.clearStats();
sorter.add(object, 3);
assertStatsRange(lo(3,true), harness.getStats(), hi(3,true, 3));
assertNull(sorter.violation(object, 4));
harness.clearStats();
sorter.remove(object, 3);
assertStatsRange(lo(3,false), harness.getStats(), hi(3,false, 0));
assertEquals("time", object.get(3));
assertNull(sorter.violation(object, 3));
harness.setSize(3);
harness.clearStats();
sorter.remove(object, 2);
assertStatsRange(lo(2,false), harness.getStats(), hi(2,false, 0));
assertEquals("in", object.get(2));
assertNull(sorter.violation(object, 2));
harness.setSize(2);
harness.clearStats();
sorter.remove(object, 1);
assertStatsRange(lo(1,false), harness.getStats(), hi(1,false, 0));
assertEquals("drum", object.get(1));
assertNull(sorter.violation(object, 1));
harness.setSize(1);
harness.clearStats();
sorter.remove(object, 0);
assertStatsRange(lo(0,false), harness.getStats(), hi(0,false, 0));
assertEquals("Beat", object.get(0));
assertNull(sorter.violation(object, 0));
}
public void test43() {
harness = new SortHarness(String.CASE_INSENSITIVE_ORDER, "Once", "upon", "a", "time");
object = harness.sortObject();
harness.setSize(0);
assertNull(sorter.violation(object, 0));
harness.setSize(1);
harness.clearStats();
sorter.add(object, 0);
assertStatsRange(lo(0,true), harness.getStats(), hi(0,true, 0));
assertNull(sorter.violation(object, 1));
harness.setSize(2);
harness.clearStats();
sorter.add(object, 1);
assertStatsRange(lo(1,true), harness.getStats(), hi(1,true, 1));
assertNull(sorter.violation(object, 2));
harness.setSize(3);
harness.clearStats();
sorter.add(object, 2);
assertStatsRange(lo(2,true), harness.getStats(), hi(2,true, 0));
assertNull(sorter.violation(object, 3));
harness.setSize(4);
harness.clearStats();
sorter.add(object, 3);
assertStatsRange(lo(3,true), harness.getStats(), hi(3,true, 2));
assertNull(sorter.violation(object, 4));
harness.clearStats();
sorter.remove(object, 3);
assertStatsRange(lo(3,false), harness.getStats(), hi(3,false, 0));
assertEquals("upon", object.get(3));
assertNull(sorter.violation(object, 3));
harness.setSize(3);
harness.clearStats();
sorter.remove(object, 2);
assertStatsRange(lo(2,false), harness.getStats(), hi(2,false, 0));
assertEquals("time", object.get(2));
assertNull(sorter.violation(object, 2));
harness.setSize(2);
harness.clearStats();
sorter.remove(object, 1);
assertStatsRange(lo(1,false), harness.getStats(), hi(1,false, 0));
assertEquals("Once", object.get(1));
assertNull(sorter.violation(object, 1));
harness.setSize(1);
harness.clearStats();
sorter.remove(object, 0);
assertStatsRange(lo(0,false), harness.getStats(), hi(0,false, 0));
assertEquals("a", object.get(0));
assertNull(sorter.violation(object, 0));
}
public void test44() {
harness = new SortHarness(String.CASE_INSENSITIVE_ORDER, "All", "in", "good", "time");
object = harness.sortObject();
harness.setSize(0);
assertNull(sorter.violation(object, 0));
harness.setSize(1);
harness.clearStats();
sorter.add(object, 0);
assertStatsRange(lo(0,true), harness.getStats(), hi(0,true, 0));
assertNull(sorter.violation(object, 1));
harness.setSize(2);
harness.clearStats();
sorter.add(object, 1);
assertStatsRange(lo(1,true), harness.getStats(), hi(1,true, 1));
assertNull(sorter.violation(object, 2));
harness.setSize(3);
harness.clearStats();
sorter.add(object, 2);
assertStatsRange(lo(2,true), harness.getStats(), hi(2,true, 1));
assertNull(sorter.violation(object, 3));
harness.setSize(4);
harness.clearStats();
sorter.add(object, 3);
assertStatsRange(lo(3,true), harness.getStats(), hi(3,true, 3));
assertNull(sorter.violation(object, 4));
harness.clearStats();
sorter.remove(object, 3);
assertStatsRange(lo(3,false), harness.getStats(), hi(3,false, 0));
assertEquals("time", object.get(3));
assertNull(sorter.violation(object, 3));
harness.setSize(3);
harness.clearStats();
sorter.remove(object, 2);
assertStatsRange(lo(2,false), harness.getStats(), hi(2,false, 0));
assertEquals("in", object.get(2));
assertNull(sorter.violation(object, 2));
harness.setSize(2);
harness.clearStats();
sorter.remove(object, 1);
assertStatsRange(lo(1,false), harness.getStats(), hi(1,false, 0));
assertEquals("good", object.get(1));
assertNull(sorter.violation(object, 1));
harness.setSize(1);
harness.clearStats();
sorter.remove(object, 0);
assertStatsRange(lo(0,false), harness.getStats(), hi(0,false, 0));
assertEquals("All", object.get(0));
assertNull(sorter.violation(object, 0));
}
public void test50() {
harness = new SortHarness(String.CASE_INSENSITIVE_ORDER, "A", "rose", "is", "a", "ROSE");
object = harness.sortObject();
harness.setSize(0);
assertNull(sorter.violation(object, 0));
harness.setSize(1);
harness.clearStats();
sorter.add(object, 0);
assertStatsRange(lo(0,true), harness.getStats(), hi(0,true, 0));
assertNull(sorter.violation(object, 1));
harness.setSize(2);
harness.clearStats();
sorter.add(object, 1);
assertStatsRange(lo(1,true), harness.getStats(), hi(1,true, 1));
assertNull(sorter.violation(object, 2));
harness.setSize(3);
harness.clearStats();
sorter.add(object, 2);
assertStatsRange(lo(2,true), harness.getStats(), hi(2,true, 1));
assertNull(sorter.violation(object, 3));
harness.setSize(4);
harness.clearStats();
sorter.add(object, 3);
assertStatsRange(lo(3,true), harness.getStats(), hi(3,true, 1));
assertNull(sorter.violation(object, 4));
harness.setSize(5);
harness.clearStats();
sorter.add(object, 4);
assertStatsRange(lo(4,true), harness.getStats(), hi(4,true, 4));
assertNull(sorter.violation(object, 5));
harness.clearStats();
sorter.remove(object, 4);
assertStatsRange(lo(4,false), harness.getStats(), hi(4,false, 0));
String a4 = object.get(4);
assertTrue("Wrong: " + a4, a4 == "rose" || a4 == "ROSE");
assertNull(sorter.violation(object, 4));
harness.setSize(4);
harness.clearStats();
sorter.remove(object, 3);
assertStatsRange(lo(3,false), harness.getStats(), hi(3,false, 0));
String a3 = object.get(3);
assertTrue("Wrong: " + a3, a3 == "rose" || a3 == "ROSE");
assertTrue("Duplicate: " + a3, a4 != a3);
assertNull(sorter.violation(object, 3));
harness.setSize(3);
harness.clearStats();
sorter.remove(object, 2);
assertStatsRange(lo(2,false), harness.getStats(), hi(2,false, 0));
assertEquals("is", object.get(2));
assertNull(sorter.violation(object, 2));
harness.setSize(2);
harness.clearStats();
sorter.remove(object, 1);
assertStatsRange(lo(1,false), harness.getStats(), hi(1,false, 0));
String a1 = object.get(1);
assertTrue("Wrong: " + a1, a1 == "A" || a1 == "a");
assertNull(sorter.violation(object, 1));
harness.setSize(1);
harness.clearStats();
sorter.remove(object, 0);
assertStatsRange(lo(0,false), harness.getStats(), hi(0,false, 0));
String a0 = object.get(0);
assertTrue("Wrong: " + a0, a0 == "a" || a0 == "A");
assertTrue("Duplicate: " + a0, a0 != a1);
assertNull(sorter.violation(object, 0));
}
public void test51() {
harness = new SortHarness("one", "two", "three", "four", "five");
object = harness.sortObject();
harness.setSize(0);
assertNull(sorter.violation(object, 0));
harness.setSize(1);
harness.clearStats();
sorter.add(object, 0);
assertStatsRange(lo(0,true), harness.getStats(), hi(0,true, 0));
assertNull(sorter.violation(object, 1));
harness.setSize(2);
harness.clearStats();
sorter.add(object, 1);
assertStatsRange(lo(1,true), harness.getStats(), hi(1,true, 1));
assertNull(sorter.violation(object, 2));
harness.setSize(3);
harness.clearStats();
sorter.add(object, 2);
assertStatsRange(lo(2,true), harness.getStats(), hi(2,true, 1));
assertNull(sorter.violation(object, 3));
harness.setSize(4);
harness.clearStats();
sorter.add(object, 3);
assertStatsRange(lo(3,true), harness.getStats(), hi(3,true, 0));
assertNull(sorter.violation(object, 4));
harness.setSize(5);
harness.clearStats();
sorter.add(object, 4);
assertStatsRange(lo(4,true), harness.getStats(), hi(4,true, 0));
assertNull(sorter.violation(object, 5));
harness.clearStats();
sorter.remove(object, 4);
assertStatsRange(lo(4,false), harness.getStats(), hi(4,false, 0));
assertEquals("two", object.get(4));
assertNull(sorter.violation(object, 4));
harness.setSize(4);
harness.clearStats();
sorter.remove(object, 3);
assertStatsRange(lo(3,false), harness.getStats(), hi(3,false, 0));
assertEquals("three", object.get(3));
assertNull(sorter.violation(object, 3));
harness.setSize(3);
harness.clearStats();
sorter.remove(object, 2);
assertStatsRange(lo(2,false), harness.getStats(), hi(2,false, 0));
assertEquals("one", object.get(2));
assertNull(sorter.violation(object, 2));
harness.setSize(2);
harness.clearStats();
sorter.remove(object, 1);
assertStatsRange(lo(1,false), harness.getStats(), hi(1,false, 0));
assertEquals("four", object.get(1));
assertNull(sorter.violation(object, 1));
harness.setSize(1);
harness.clearStats();
sorter.remove(object, 0);
assertStatsRange(lo(0,false), harness.getStats(), hi(0,false, 0));
assertEquals("five", object.get(0));
assertNull(sorter.violation(object, 0));
}
public void test52() {
harness = new SortHarness("1", "2", "3", "4", "5");
object = harness.sortObject();
harness.setSize(0);
assertNull(sorter.violation(object, 0));
harness.setSize(1);
harness.clearStats();
sorter.add(object, 0);
assertStatsRange(lo(0,true), harness.getStats(), hi(0,true, 0));
assertNull(sorter.violation(object, 1));
harness.setSize(2);
harness.clearStats();
sorter.add(object, 1);
assertStatsRange(lo(1,true), harness.getStats(), hi(1,true, 1));
assertNull(sorter.violation(object, 2));
harness.setSize(3);
harness.clearStats();
sorter.add(object, 2);
assertStatsRange(lo(2,true), harness.getStats(), hi(2,true, 2));
assertNull(sorter.violation(object, 3));
harness.setSize(4);
harness.clearStats();
sorter.add(object, 3);
assertStatsRange(lo(3,true), harness.getStats(), hi(3,true, 3));
assertNull(sorter.violation(object, 4));
harness.setSize(5);
harness.clearStats();
sorter.add(object, 4);
assertStatsRange(lo(4,true), harness.getStats(), hi(4,true, 4));
assertNull(sorter.violation(object, 5));
harness.clearStats();
sorter.remove(object, 4);
assertStatsRange(lo(4,false), harness.getStats(), hi(4,false, 0));
assertEquals("5", object.get(4));
assertNull(sorter.violation(object, 4));
harness.setSize(4);
harness.clearStats();
sorter.remove(object, 3);
assertStatsRange(lo(3,false), harness.getStats(), hi(3,false, 0));
assertEquals("4", object.get(3));
assertNull(sorter.violation(object, 3));
harness.setSize(3);
harness.clearStats();
sorter.remove(object, 2);
assertStatsRange(lo(2,false), harness.getStats(), hi(2,false, 0));
assertEquals("3", object.get(2));
assertNull(sorter.violation(object, 2));
harness.setSize(2);
harness.clearStats();
sorter.remove(object, 1);
assertStatsRange(lo(1,false), harness.getStats(), hi(1,false, 0));
assertEquals("2", object.get(1));
assertNull(sorter.violation(object, 1));
harness.setSize(1);
harness.clearStats();
sorter.remove(object, 0);
assertStatsRange(lo(0,false), harness.getStats(), hi(0,false, 0));
assertEquals("1", object.get(0));
assertNull(sorter.violation(object, 0));
}
public void test60() {
harness = new SortHarness(String.CASE_INSENSITIVE_ORDER,
"To", "be", "or", "not", "to", "BE");
object = harness.sortObject();
harness.setSize(0);
assertNull(sorter.violation(object, 0));
harness.setSize(1);
harness.clearStats();
sorter.add(object, 0);
assertStatsRange(lo(0,true), harness.getStats(), hi(0,true, 0));
assertNull(sorter.violation(object, 1));
harness.setSize(2);
harness.clearStats();
sorter.add(object, 1);
assertStatsRange(lo(1,true), harness.getStats(), hi(1,true, 0));
assertNull(sorter.violation(object, 2));
harness.setSize(3);
harness.clearStats();
sorter.add(object, 2);
assertStatsRange(lo(2,true), harness.getStats(), hi(2,true, 1));
assertNull(sorter.violation(object, 3));
harness.setSize(4);
harness.clearStats();
sorter.add(object, 3);
assertStatsRange(lo(3,true), harness.getStats(), hi(3,true, 1));
assertNull(sorter.violation(object, 4));
harness.setSize(5);
harness.clearStats();
sorter.add(object, 4);
assertStatsRange(lo(4,true), harness.getStats(), hi(4,true, 4));
assertNull(sorter.violation(object, 5));
harness.setSize(6);
harness.clearStats();
sorter.add(object, 5);
assertStatsRange(lo(5,true), harness.getStats(), hi(5,true, 1));
assertNull(sorter.violation(object, 6));
harness.clearStats();
sorter.remove(object, 5);
assertStatsRange(lo(5,false), harness.getStats(), hi(5,false, 0));
String a5 = object.get(5);
assertTrue("Wrong: " + a5, a5 == "To" || a5 == "to");
assertNull(sorter.violation(object, 5));
harness.setSize(5);
harness.clearStats();
sorter.remove(object, 4);
assertStatsRange(lo(4,false), harness.getStats(), hi(4,false, 0));
String a4 = object.get(4);
assertTrue("Wrong: " + a4, a4 == "To" || a4 == "to");
assertTrue("Duplicate: " + a4, a4 != a5);
assertNull(sorter.violation(object, 4));
harness.setSize(4);
harness.clearStats();
sorter.remove(object, 3);
assertStatsRange(lo(3,false), harness.getStats(), hi(3,false, 0));
assertEquals("or", object.get(3));
assertNull(sorter.violation(object, 3));
harness.setSize(3);
harness.clearStats();
sorter.remove(object, 2);
assertStatsRange(lo(2,false), harness.getStats(), hi(2,false, 0));
assertEquals("not", object.get(2));
assertNull(sorter.violation(object, 2));
harness.setSize(2);
harness.clearStats();
sorter.remove(object, 1);
assertStatsRange(lo(1,false), harness.getStats(), hi(1,false, 0));
String a1 = object.get(1);
assertTrue("Wrong: " + a1, a1 == "be" || a1 == "BE");
assertNull(sorter.violation(object, 1));
harness.setSize(1);
harness.clearStats();
sorter.remove(object, 0);
assertStatsRange(lo(0,false), harness.getStats(), hi(0,false, 0));
String a0 = object.get(0);
assertTrue("Wrong: " + a0, a0 == "be" || a0 == "BE");
assertTrue("Duplicate: " + a0, a0 != a1);
assertNull(sorter.violation(object, 0));
}
public void test61() {
harness = new SortHarness("uno", "dos", "tres", "cuatro", "cinco", "seis");
object = harness.sortObject();
harness.setSize(0);
assertNull(sorter.violation(object, 0));
harness.setSize(1);
harness.clearStats();
sorter.add(object, 0);
assertStatsRange(lo(0,true), harness.getStats(), hi(0,true, 0));
assertNull(sorter.violation(object, 1));
harness.setSize(2);
harness.clearStats();
sorter.add(object, 1);
assertStatsRange(lo(1,true), harness.getStats(), hi(1,true, 0));
assertNull(sorter.violation(object, 2));
harness.setSize(3);
harness.clearStats();
sorter.add(object, 2);
assertStatsRange(lo(2,true), harness.getStats(), hi(2,true, 1));
assertNull(sorter.violation(object, 3));
harness.setSize(4);
harness.clearStats();
sorter.add(object, 3);
assertStatsRange(lo(3,true), harness.getStats(), hi(3,true, 0));
assertNull(sorter.violation(object, 4));
harness.setSize(5);
harness.clearStats();
sorter.add(object, 4);
assertStatsRange(lo(4,true), harness.getStats(), hi(4,true, 0));
assertNull(sorter.violation(object, 5));
harness.setSize(6);
harness.clearStats();
sorter.add(object, 5);
assertStatsRange(lo(5,true), harness.getStats(), hi(5,true, 3));
assertNull(sorter.violation(object, 6));
harness.clearStats();
sorter.remove(object, 5);
assertStatsRange(lo(5,false), harness.getStats(), hi(5,false, 0));
assertEquals("uno", object.get(5));
assertNull(sorter.violation(object, 5));
harness.setSize(5);
harness.clearStats();
sorter.remove(object, 4);
assertStatsRange(lo(4,false), harness.getStats(), hi(4,false, 0));
assertEquals("tres", object.get(4));
assertNull(sorter.violation(object, 4));
harness.setSize(4);
harness.clearStats();
sorter.remove(object, 3);
assertStatsRange(lo(3,false), harness.getStats(), hi(3,false, 0));
assertEquals("seis", object.get(3));
assertNull(sorter.violation(object, 3));
harness.setSize(3);
harness.clearStats();
sorter.remove(object, 2);
assertStatsRange(lo(2,false), harness.getStats(), hi(2,false, 0));
assertEquals("dos", object.get(2));
assertNull(sorter.violation(object, 2));
harness.setSize(2);
harness.clearStats();
sorter.remove(object, 1);
assertStatsRange(lo(1,false), harness.getStats(), hi(1,false, 0));
assertEquals("cuatro", object.get(1));
assertNull(sorter.violation(object, 1));
harness.setSize(1);
harness.clearStats();
sorter.remove(object, 0);
assertStatsRange(lo(0,false), harness.getStats(), hi(0,false, 0));
assertEquals("cinco", object.get(0));
assertNull(sorter.violation(object, 0));
}
public void test62() {
harness = new SortHarness("A", "B", "C", "D", "E", "F");
object = harness.sortObject();
harness.setSize(0);
assertNull(sorter.violation(object, 0));
harness.setSize(1);
harness.clearStats();
sorter.add(object, 0);
assertStatsRange(lo(0,true), harness.getStats(), hi(0,true, 0));
assertNull(sorter.violation(object, 1));
harness.setSize(2);
harness.clearStats();
sorter.add(object, 1);
assertStatsRange(lo(1,true), harness.getStats(), hi(1,true, 1));
assertNull(sorter.violation(object, 2));
harness.setSize(3);
harness.clearStats();
sorter.add(object, 2);
assertStatsRange(lo(2,true), harness.getStats(), hi(2,true, 2));
assertNull(sorter.violation(object, 3));
harness.setSize(4);
harness.clearStats();
sorter.add(object, 3);
assertStatsRange(lo(3,true), harness.getStats(), hi(3,true, 3));
assertNull(sorter.violation(object, 4));
harness.setSize(5);
harness.clearStats();
sorter.add(object, 4);
assertStatsRange(lo(4,true), harness.getStats(), hi(4,true, 4));
assertNull(sorter.violation(object, 5));
harness.setSize(6);
harness.clearStats();
sorter.add(object, 5);
assertStatsRange(lo(5,true), harness.getStats(), hi(5,true, 5));
assertNull(sorter.violation(object, 6));
harness.clearStats();
sorter.remove(object, 5);
assertStatsRange(lo(5,false), harness.getStats(), hi(5,false, 0));
assertEquals("F", object.get(5));
assertNull(sorter.violation(object, 5));
harness.setSize(5);
harness.clearStats();
sorter.remove(object, 4);
assertStatsRange(lo(4,false), harness.getStats(), hi(4,false, 0));
assertEquals("E", object.get(4));
assertNull(sorter.violation(object, 4));
harness.setSize(4);
harness.clearStats();
sorter.remove(object, 3);
assertStatsRange(lo(3,false), harness.getStats(), hi(3,false, 0));
assertEquals("D", object.get(3));
assertNull(sorter.violation(object, 3));
harness.setSize(3);
harness.clearStats();
sorter.remove(object, 2);
assertStatsRange(lo(2,false), harness.getStats(), hi(2,false, 0));
assertEquals("C", object.get(2));
assertNull(sorter.violation(object, 2));
harness.setSize(2);
harness.clearStats();
sorter.remove(object, 1);
assertStatsRange(lo(1,false), harness.getStats(), hi(1,false, 0));
assertEquals("B", object.get(1));
assertNull(sorter.violation(object, 1));
harness.setSize(1);
harness.clearStats();
sorter.remove(object, 0);
assertStatsRange(lo(0,false), harness.getStats(), hi(0,false, 0));
assertEquals("A", object.get(0));
assertNull(sorter.violation(object, 0));
}
public void test63() {
harness = new SortHarness(String.CASE_INSENSITIVE_ORDER, "A", "stitch", "in", "time", "saves", "nine");
object = harness.sortObject();
harness.setSize(0);
assertNull(sorter.violation(object, 0));
harness.setSize(1);
harness.clearStats();
sorter.add(object, 0);
assertStatsRange(lo(0,true), harness.getStats(), hi(0,true, 0));
assertNull(sorter.violation(object, 1));
harness.setSize(2);
harness.clearStats();
sorter.add(object, 1);
assertStatsRange(lo(1,true), harness.getStats(), hi(1,true, 1));
assertNull(sorter.violation(object, 2));
harness.setSize(3);
harness.clearStats();
sorter.add(object, 2);
assertStatsRange(lo(2,true), harness.getStats(), hi(2,true, 1));
assertNull(sorter.violation(object, 3));
harness.setSize(4);
harness.clearStats();
sorter.add(object, 3);
assertStatsRange(lo(3,true), harness.getStats(), hi(3,true, 3));
assertNull(sorter.violation(object, 4));
harness.setSize(5);
harness.clearStats();
sorter.add(object, 4);
assertStatsRange(lo(4,true), harness.getStats(), hi(4,true, 2));
assertNull(sorter.violation(object, 5));
harness.setSize(6);
harness.clearStats();
sorter.add(object, 5);
assertStatsRange(lo(5,true), harness.getStats(), hi(5,true, 2));
assertNull(sorter.violation(object, 6));
harness.clearStats();
sorter.remove(object, 5);
assertStatsRange(lo(5,false), harness.getStats(), hi(5,false, 0));
assertEquals("time", object.get(5));
assertNull(sorter.violation(object, 5));
harness.setSize(5);
harness.clearStats();
sorter.remove(object, 4);
assertStatsRange(lo(4,false), harness.getStats(), hi(4,false, 0));
assertEquals("stitch", object.get(4));
assertNull(sorter.violation(object, 4));
harness.setSize(4);
harness.clearStats();
sorter.remove(object, 3);
assertStatsRange(lo(3,false), harness.getStats(), hi(3,false, 0));
assertEquals("saves", object.get(3));
assertNull(sorter.violation(object, 3));
harness.setSize(3);
harness.clearStats();
sorter.remove(object, 2);
assertStatsRange(lo(2,false), harness.getStats(), hi(2,false, 0));
assertEquals("nine", object.get(2));
assertNull(sorter.violation(object, 2));
harness.setSize(2);
harness.clearStats();
sorter.remove(object, 1);
assertStatsRange(lo(1,false), harness.getStats(), hi(1,false, 0));
assertEquals("in", object.get(1));
assertNull(sorter.violation(object, 1));
harness.setSize(1);
harness.clearStats();
sorter.remove(object, 0);
assertStatsRange(lo(0,false), harness.getStats(), hi(0,false, 0));
assertEquals("A", object.get(0));
assertNull(sorter.violation(object, 0));
}
public void test70() {
harness = new SortHarness(String.CASE_INSENSITIVE_ORDER,
"Bear", "with", "me", "not", "ME", "WITH", "BEAR");
object = harness.sortObject();
harness.setSize(0);
assertNull(sorter.violation(object, 0));
harness.setSize(1);
harness.clearStats();
sorter.add(object, 0);
assertStatsRange(lo(0,true), harness.getStats(), hi(0,true, 0));
assertNull(sorter.violation(object, 1));
harness.setSize(2);
harness.clearStats();
sorter.add(object, 1);
assertStatsRange(lo(1,true), harness.getStats(), hi(1,true, 1));
assertNull(sorter.violation(object, 2));
harness.setSize(3);
harness.clearStats();
sorter.add(object, 2);
assertStatsRange(lo(2,true), harness.getStats(), hi(2,true, 1));
assertNull(sorter.violation(object, 3));
harness.setSize(4);
harness.clearStats();
sorter.add(object, 3);
assertStatsRange(lo(3,true), harness.getStats(), hi(3,true, 2));
assertNull(sorter.violation(object, 4));
harness.setSize(5);
harness.clearStats();
sorter.add(object, 4);
assertStatsRange(lo(4,true), harness.getStats(), hi(4,true, 2));
assertNull(sorter.violation(object, 5));
harness.setSize(6);
harness.clearStats();
sorter.add(object, 5);
assertStatsRange(lo(5,true), harness.getStats(), hi(5,true, 5));
assertNull(sorter.violation(object, 6));
harness.setSize(7);
harness.clearStats();
sorter.add(object, 6);
assertStatsRange(lo(6,true), harness.getStats(), hi(6,true, 1));
assertNull(sorter.violation(object, 7));
harness.clearStats();
sorter.remove(object, 6);
assertStatsRange(lo(6,false), harness.getStats(), hi(6,false, 0));
String a6 = object.get(6);
assertTrue("Wrong: " + a6, a6 == "with" || a6 == "WITH");
assertNull(sorter.violation(object, 6));
harness.setSize(6);
harness.clearStats();
sorter.remove(object, 5);
assertStatsRange(lo(5,false), harness.getStats(), hi(5,false, 0));
String a5 = object.get(5);
assertTrue("Wrong: " + a5, a5 == "with" || a5 == "WITH");
assertTrue("Duplicate: " + a5, a6 != a5);
assertNull(sorter.violation(object, 5));
harness.setSize(5);
harness.clearStats();
sorter.remove(object, 4);
assertStatsRange(lo(4,false), harness.getStats(), hi(4,false, 0));
assertEquals("not", object.get(4));
assertNull(sorter.violation(object, 4));
harness.setSize(4);
harness.clearStats();
sorter.remove(object, 3);
assertStatsRange(lo(3,false), harness.getStats(), hi(3,false, 0));
String a3 = object.get(3);
assertTrue("Wrong: " + a3, a3 == "me" || a3 == "ME");
assertNull(sorter.violation(object, 3));
harness.setSize(3);
harness.clearStats();
sorter.remove(object, 2);
assertStatsRange(lo(2,false), harness.getStats(), hi(2,false, 0));
String a2 = object.get(2);
assertTrue("Wrong: " + a2, a2 == "me" || a2 == "ME");
assertTrue("Duplicate: " + a2, a2 != a3);
assertNull(sorter.violation(object, 2));
harness.setSize(2);
harness.clearStats();
sorter.remove(object, 1);
assertStatsRange(lo(1,false), harness.getStats(), hi(1,false, 0));
String a1 = object.get(1);
assertTrue("Wrong: " + a1, a1 == "Bear" || a1 == "BEAR");
assertNull(sorter.violation(object, 1));
harness.setSize(1);
harness.clearStats();
sorter.remove(object, 0);
assertStatsRange(lo(0,false), harness.getStats(), hi(0,false, 0));
String a0 = object.get(0);
assertTrue("Wrong: " + a0, a0 == "Bear" || a0 == "BEAR");
assertTrue("Duplicate: " + a0, a0 != a1);
assertNull(sorter.violation(object, 0));
}
public void test71() {
harness = new SortHarness("yī", "èr", "sān", "sì", "wǔ", "liù", "qī");
object = harness.sortObject();
harness.setSize(0);
assertNull(sorter.violation(object, 0));
harness.setSize(1);
harness.clearStats();
sorter.add(object, 0);
assertStatsRange(lo(0,true), harness.getStats(), hi(0,true, 0));
assertNull(sorter.violation(object, 1));
harness.setSize(2);
harness.clearStats();
sorter.add(object, 1);
assertStatsRange(lo(1,true), harness.getStats(), hi(1,true, 1));
assertNull(sorter.violation(object, 2));
harness.setSize(3);
harness.clearStats();
sorter.add(object, 2);
assertStatsRange(lo(2,true), harness.getStats(), hi(2,true, 0));
assertNull(sorter.violation(object, 3));
harness.setSize(4);
harness.clearStats();
sorter.add(object, 3);
assertStatsRange(lo(3,true), harness.getStats(), hi(3,true, 0));
assertNull(sorter.violation(object, 4));
harness.setSize(5);
harness.clearStats();
sorter.add(object, 4);
assertStatsRange(lo(4,true), harness.getStats(), hi(4,true, 0));
assertNull(sorter.violation(object, 5));
harness.setSize(6);
harness.clearStats();
sorter.add(object, 5);
assertStatsRange(lo(5,true), harness.getStats(), hi(5,true, 0));
assertNull(sorter.violation(object, 6));
harness.setSize(7);
harness.clearStats();
sorter.add(object, 6);
assertStatsRange(lo(6,true), harness.getStats(), hi(6,true, 0));
assertNull(sorter.violation(object, 7));
harness.clearStats();
sorter.remove(object, 6);
assertStatsRange(lo(6,false), harness.getStats(), hi(6,false, 0));
assertEquals("èr", object.get(6));
assertNull(sorter.violation(object, 6));
harness.setSize(6);
harness.clearStats();
sorter.remove(object, 5);
assertStatsRange(lo(5,false), harness.getStats(), hi(5,false, 0));
assertEquals("yī", object.get(5));
assertNull(sorter.violation(object, 5));
harness.setSize(5);
harness.clearStats();
sorter.remove(object, 4);
assertStatsRange(lo(4,false), harness.getStats(), hi(4,false, 0));
assertEquals("wǔ", object.get(4));
assertNull(sorter.violation(object, 4));
harness.setSize(4);
harness.clearStats();
sorter.remove(object, 3);
assertStatsRange(lo(3,false), harness.getStats(), hi(3,false, 0));
assertEquals("sān", object.get(3));
assertNull(sorter.violation(object, 3));
harness.setSize(3);
harness.clearStats();
sorter.remove(object, 2);
assertStatsRange(lo(2,false), harness.getStats(), hi(2,false, 0));
assertEquals("sì", object.get(2));
assertNull(sorter.violation(object, 2));
harness.setSize(2);
harness.clearStats();
sorter.remove(object, 1);
assertStatsRange(lo(1,false), harness.getStats(), hi(1,false, 0));
assertEquals("qī", object.get(1));
assertNull(sorter.violation(object, 1));
harness.setSize(1);
harness.clearStats();
sorter.remove(object, 0);
assertStatsRange(lo(0,false), harness.getStats(), hi(0,false, 0));
assertEquals("liù", object.get(0));
assertNull(sorter.violation(object, 0));
}
public void test72() {
harness = new SortHarness("0", "00", "000", "0000", "00000", "000000", "0000000");
object = harness.sortObject();
harness.setSize(0);
assertNull(sorter.violation(object, 0));
harness.setSize(1);
harness.clearStats();
sorter.add(object, 0);
assertStatsRange(lo(0,true), harness.getStats(), hi(0,true, 0));
assertNull(sorter.violation(object, 1));
harness.setSize(2);
harness.clearStats();
sorter.add(object, 1);
assertStatsRange(lo(1,true), harness.getStats(), hi(1,true, 1));
assertNull(sorter.violation(object, 2));
harness.setSize(3);
harness.clearStats();
sorter.add(object, 2);
assertStatsRange(lo(2,true), harness.getStats(), hi(2,true, 2));
assertNull(sorter.violation(object, 3));
harness.setSize(4);
harness.clearStats();
sorter.add(object, 3);
assertStatsRange(lo(3,true), harness.getStats(), hi(3,true, 3));
assertNull(sorter.violation(object, 4));
harness.setSize(5);
harness.clearStats();
sorter.add(object, 4);
assertStatsRange(lo(4,true), harness.getStats(), hi(4,true, 4));
assertNull(sorter.violation(object, 5));
harness.setSize(6);
harness.clearStats();
sorter.add(object, 5);
assertStatsRange(lo(5,true), harness.getStats(), hi(5,true, 5));
assertNull(sorter.violation(object, 6));
harness.setSize(7);
harness.clearStats();
sorter.add(object, 6);
assertStatsRange(lo(6,true), harness.getStats(), hi(6,true, 6));
assertNull(sorter.violation(object, 7));
harness.clearStats();
sorter.remove(object, 6);
assertStatsRange(lo(6,false), harness.getStats(), hi(6,false, 0));
assertEquals("0000000", object.get(6));
assertNull(sorter.violation(object, 6));
harness.setSize(6);
harness.clearStats();
sorter.remove(object, 5);
assertStatsRange(lo(5,false), harness.getStats(), hi(5,false, 0));
assertEquals("000000", object.get(5));
assertNull(sorter.violation(object, 5));
harness.setSize(5);
harness.clearStats();
sorter.remove(object, 4);
assertStatsRange(lo(4,false), harness.getStats(), hi(4,false, 0));
assertEquals("00000", object.get(4));
assertNull(sorter.violation(object, 4));
harness.setSize(4);
harness.clearStats();
sorter.remove(object, 3);
assertStatsRange(lo(3,false), harness.getStats(), hi(3,false, 0));
assertEquals("0000", object.get(3));
assertNull(sorter.violation(object, 3));
harness.setSize(3);
harness.clearStats();
sorter.remove(object, 2);
assertStatsRange(lo(2,false), harness.getStats(), hi(2,false, 0));
assertEquals("000", object.get(2));
assertNull(sorter.violation(object, 2));
harness.setSize(2);
harness.clearStats();
sorter.remove(object, 1);
assertStatsRange(lo(1,false), harness.getStats(), hi(1,false, 0));
assertEquals("00", object.get(1));
assertNull(sorter.violation(object, 1));
harness.setSize(1);
harness.clearStats();
sorter.remove(object, 0);
assertStatsRange(lo(0,false), harness.getStats(), hi(0,false, 0));
assertEquals("0", object.get(0));
assertNull(sorter.violation(object, 0));
}
public void test80() {
harness = new SortHarness(String.CASE_INSENSITIVE_ORDER,
"A", "Rose", "is", "a", "rose", "IS", "a", "ROSE");
object = harness.sortObject();
harness.setSize(0);
assertNull(sorter.violation(object, 0));
harness.setSize(1);
harness.clearStats();
sorter.add(object, 0);
assertStatsRange(lo(0,true), harness.getStats(), hi(0,true, 0));
assertNull(sorter.violation(object, 1));
harness.setSize(2);
harness.clearStats();
sorter.add(object, 1);
assertStatsRange(lo(1,true), harness.getStats(), hi(1,true, 1));
assertNull(sorter.violation(object, 2));
harness.setSize(3);
harness.clearStats();
sorter.add(object, 2);
assertStatsRange(lo(2,true), harness.getStats(), hi(2,true, 1));
assertNull(sorter.violation(object, 3));
harness.setSize(4);
harness.clearStats();
sorter.add(object, 3);
assertStatsRange(lo(3,true), harness.getStats(), hi(3,true, 1));
assertNull(sorter.violation(object, 4));
harness.setSize(5);
harness.clearStats();
sorter.add(object, 4);
assertStatsRange(lo(4,true), harness.getStats(), hi(4,true, 4));
assertNull(sorter.violation(object, 5));
harness.setSize(6);
harness.clearStats();
sorter.add(object, 5);
assertStatsRange(lo(5,true), harness.getStats(), hi(5,true, 2));
assertNull(sorter.violation(object, 6));
harness.setSize(7);
harness.clearStats();
sorter.add(object, 6);
assertStatsRange(lo(6,true), harness.getStats(), hi(6,true, 2));
assertNull(sorter.violation(object, 7));
harness.setSize(8);
harness.clearStats();
sorter.add(object, 7);
assertStatsRange(lo(7,true), harness.getStats(), hi(7,true, 7));
assertNull(sorter.violation(object, 8));
harness.clearStats();
sorter.remove(object, 7);
assertStatsRange(lo(7,false), harness.getStats(), hi(7,false, 0));
String a7 = object.get(7);
assertTrue("Wrong: " + a7, a7 == "Rose" || a7 == "rose" || a7 == "ROSE");
assertNull(sorter.violation(object, 7));
harness.setSize(7);
harness.clearStats();
sorter.remove(object, 6);
assertStatsRange(lo(6,false), harness.getStats(), hi(6,false, 0));
String a6 = object.get(6);
assertTrue("Wrong: " + a6, a6 == "Rose" || a6 == "rose" || a6 == "ROSE");
assertTrue("Duplicate: " + a6, a6 != a7);
assertNull(sorter.violation(object, 6));
harness.setSize(6);
harness.clearStats();
sorter.remove(object, 5);
assertStatsRange(lo(5,false), harness.getStats(), hi(5,false, 0));
String a5 = object.get(5);
assertTrue("Wrong: " + a5, a5 == "Rose" || a5 == "rose" || a5 == "ROSE");
assertTrue("Duplicate: " + a5, a6 != a5);
assertTrue("Duplicate: " + a5, a7 != a5);
assertNull(sorter.violation(object, 5));
harness.setSize(5);
harness.clearStats();
sorter.remove(object, 4);
assertStatsRange(lo(4,false), harness.getStats(), hi(4,false, 0));
String a4 = object.get(4);
assertTrue("Wrong: " + a4, a4 == "is" || a4 == "IS");
assertNull(sorter.violation(object, 4));
harness.setSize(4);
harness.clearStats();
sorter.remove(object, 3);
assertStatsRange(lo(3,false), harness.getStats(), hi(3,false, 0));
String a3 = object.get(3);
assertTrue("Wrong: " + a3, a3 == "is" || a3 == "IS");
assertTrue("Duplicate: " + a3, a3 != a4);
assertNull(sorter.violation(object, 3));
harness.setSize(3);
harness.clearStats();
sorter.remove(object, 2);
assertStatsRange(lo(2,false), harness.getStats(), hi(2,false, 0));
String a2 = object.get(2);
assertTrue("Wrong: " + a2, a2 == "A" || a2 == "a");
assertNull(sorter.violation(object, 2));
harness.setSize(2);
harness.clearStats();
sorter.remove(object, 1);
assertStatsRange(lo(1,false), harness.getStats(), hi(1,false, 0));
String a1 = object.get(1);
assertTrue("Wrong: " + a1, a1 == "A" || a1 == "a");
assertNull(sorter.violation(object, 1));
harness.setSize(1);
harness.clearStats();
sorter.remove(object, 0);
assertStatsRange(lo(0,false), harness.getStats(), hi(0,false, 0));
String a0 = object.get(0);
assertTrue("Wrong: " + a0, a0 == "A" || a0 == "a");
assertNull(sorter.violation(object, 0));
}
public void test81() {
harness = new SortHarness("un", "deux", "trois", "quatre", "cinq", "six", "sept", "huit");
object = harness.sortObject();
harness.setSize(0);
assertNull(sorter.violation(object, 0));
harness.setSize(1);
harness.clearStats();
sorter.add(object, 0);
assertStatsRange(lo(0,true), harness.getStats(), hi(0,true, 0));
assertNull(sorter.violation(object, 1));
harness.setSize(2);
harness.clearStats();
sorter.add(object, 1);
assertStatsRange(lo(1,true), harness.getStats(), hi(1,true, 0));
assertNull(sorter.violation(object, 2));
harness.setSize(3);
harness.clearStats();
sorter.add(object, 2);
assertStatsRange(lo(2,true), harness.getStats(), hi(2,true, 1));
assertNull(sorter.violation(object, 3));
harness.setSize(4);
harness.clearStats();
sorter.add(object, 3);
assertStatsRange(lo(3,true), harness.getStats(), hi(3,true, 1));
assertNull(sorter.violation(object, 4));
harness.setSize(5);
harness.clearStats();
sorter.add(object, 4);
assertStatsRange(lo(4,true), harness.getStats(), hi(4,true, 0));
assertNull(sorter.violation(object, 5));
harness.setSize(6);
harness.clearStats();
sorter.add(object, 5);
assertStatsRange(lo(5,true), harness.getStats(), hi(5,true, 3));
assertNull(sorter.violation(object, 6));
harness.setSize(7);
harness.clearStats();
sorter.add(object, 6);
assertStatsRange(lo(6,true), harness.getStats(), hi(6,true, 3));
assertNull(sorter.violation(object, 7));
harness.setSize(8);
harness.clearStats();
sorter.add(object, 7);
assertStatsRange(lo(7,true), harness.getStats(), hi(7,true, 2));
assertNull(sorter.violation(object, 8));
harness.clearStats();
sorter.remove(object, 7);
assertStatsRange(lo(7,false), harness.getStats(), hi(7,false, 0));
assertEquals("un", object.get(7));
assertNull(sorter.violation(object, 7));
harness.setSize(7);
harness.clearStats();
sorter.remove(object, 6);
assertStatsRange(lo(6,false), harness.getStats(), hi(6,false, 0));
assertEquals("trois", object.get(6));
assertNull(sorter.violation(object, 6));
harness.setSize(6);
harness.clearStats();
sorter.remove(object, 5);
assertStatsRange(lo(5,false), harness.getStats(), hi(5,false, 0));
assertEquals("six", object.get(5));
assertNull(sorter.violation(object, 5));
harness.setSize(5);
harness.clearStats();
sorter.remove(object, 4);
assertStatsRange(lo(4,false), harness.getStats(), hi(4,false, 0));
assertEquals("sept", object.get(4));
assertNull(sorter.violation(object, 4));
harness.setSize(4);
harness.clearStats();
sorter.remove(object, 3);
assertStatsRange(lo(3,false), harness.getStats(), hi(3,false, 0));
assertEquals("quatre", object.get(3));
assertNull(sorter.violation(object, 3));
harness.setSize(3);
harness.clearStats();
sorter.remove(object, 2);
assertStatsRange(lo(2,false), harness.getStats(), hi(2,false, 0));
assertEquals("huit", object.get(2));
assertNull(sorter.violation(object, 2));
harness.setSize(2);
harness.clearStats();
sorter.remove(object, 1);
assertStatsRange(lo(1,false), harness.getStats(), hi(1,false, 0));
assertEquals("deux", object.get(1));
assertNull(sorter.violation(object, 1));
harness.setSize(1);
harness.clearStats();
sorter.remove(object, 0);
assertStatsRange(lo(0,false), harness.getStats(), hi(0,false, 0));
assertEquals("cinq", object.get(0));
assertNull(sorter.violation(object, 0));
}
public void test82() {
harness = new SortHarness("a", "b", "c", "d", "e", "f", "g", "h");
object = harness.sortObject();
harness.setSize(0);
assertNull(sorter.violation(object, 0));
harness.setSize(1);
harness.clearStats();
sorter.add(object, 0);
assertStatsRange(lo(0,true), harness.getStats(), hi(0,true, 0));
assertNull(sorter.violation(object, 1));
harness.setSize(2);
harness.clearStats();
sorter.add(object, 1);
assertStatsRange(lo(1,true), harness.getStats(), hi(1,true, 1));
assertNull(sorter.violation(object, 2));
harness.setSize(3);
harness.clearStats();
sorter.add(object, 2);
assertStatsRange(lo(2,true), harness.getStats(), hi(2,true, 2));
assertNull(sorter.violation(object, 3));
harness.setSize(4);
harness.clearStats();
sorter.add(object, 3);
assertStatsRange(lo(3,true), harness.getStats(), hi(3,true, 3));
assertNull(sorter.violation(object, 4));
harness.setSize(5);
harness.clearStats();
sorter.add(object, 4);
assertStatsRange(lo(4,true), harness.getStats(), hi(4,true, 4));
assertNull(sorter.violation(object, 5));
harness.setSize(6);
harness.clearStats();
sorter.add(object, 5);
assertStatsRange(lo(5,true), harness.getStats(), hi(5,true, 5));
assertNull(sorter.violation(object, 6));
harness.setSize(7);
harness.clearStats();
sorter.add(object, 6);
assertStatsRange(lo(6,true), harness.getStats(), hi(6,true, 6));
assertNull(sorter.violation(object, 7));
harness.setSize(8);
harness.clearStats();
sorter.add(object, 7);
assertStatsRange(lo(7,true), harness.getStats(), hi(7,true, 7));
assertNull(sorter.violation(object, 8));
harness.clearStats();
sorter.remove(object, 7);
assertStatsRange(lo(7,false), harness.getStats(), hi(7,false, 0));
assertEquals("h", object.get(7));
assertNull(sorter.violation(object, 7));
harness.setSize(7);
harness.clearStats();
sorter.remove(object, 6);
assertStatsRange(lo(6,false), harness.getStats(), hi(6,false, 0));
assertEquals("g", object.get(6));
assertNull(sorter.violation(object, 6));
harness.setSize(6);
harness.clearStats();
sorter.remove(object, 5);
assertStatsRange(lo(5,false), harness.getStats(), hi(5,false, 0));
assertEquals("f", object.get(5));
assertNull(sorter.violation(object, 5));
harness.setSize(5);
harness.clearStats();
sorter.remove(object, 4);
assertStatsRange(lo(4,false), harness.getStats(), hi(4,false, 0));
assertEquals("e", object.get(4));
assertNull(sorter.violation(object, 4));
harness.setSize(4);
harness.clearStats();
sorter.remove(object, 3);
assertStatsRange(lo(3,false), harness.getStats(), hi(3,false, 0));
assertEquals("d", object.get(3));
assertNull(sorter.violation(object, 3));
harness.setSize(3);
harness.clearStats();
sorter.remove(object, 2);
assertStatsRange(lo(2,false), harness.getStats(), hi(2,false, 0));
assertEquals("c", object.get(2));
assertNull(sorter.violation(object, 2));
harness.setSize(2);
harness.clearStats();
sorter.remove(object, 1);
assertStatsRange(lo(1,false), harness.getStats(), hi(1,false, 0));
assertEquals("b", object.get(1));
assertNull(sorter.violation(object, 1));
harness.setSize(1);
harness.clearStats();
sorter.remove(object, 0);
assertStatsRange(lo(0,false), harness.getStats(), hi(0,false, 0));
assertEquals("a", object.get(0));
assertNull(sorter.violation(object, 0));
}
public void test90() {
harness = new SortHarness(String.CASE_INSENSITIVE_ORDER,
"Don't", "count", "the", "days", "just", "make", "The", "Days", "COUNT");
object = harness.sortObject();
harness.setSize(0);
assertNull(sorter.violation(object, 0));
harness.setSize(1);
harness.clearStats();
sorter.add(object, 0);
assertStatsRange(lo(0,true), harness.getStats(), hi(0,true, 0));
assertNull(sorter.violation(object, 1));
harness.setSize(2);
harness.clearStats();
sorter.add(object, 1);
assertStatsRange(lo(1,true), harness.getStats(), hi(1,true, 0));
assertNull(sorter.violation(object, 2));
harness.setSize(3);
harness.clearStats();
sorter.add(object, 2);
assertStatsRange(lo(2,true), harness.getStats(), hi(2,true, 2));
assertNull(sorter.violation(object, 3));
harness.setSize(4);
harness.clearStats();
sorter.add(object, 3);
assertStatsRange(lo(3,true), harness.getStats(), hi(3,true, 1));
assertNull(sorter.violation(object, 4));
harness.setSize(5);
harness.clearStats();
sorter.add(object, 4);
assertStatsRange(lo(4,true), harness.getStats(), hi(4,true, 3));
assertNull(sorter.violation(object, 5));
harness.setSize(6);
harness.clearStats();
sorter.add(object, 5);
assertStatsRange(lo(5,true), harness.getStats(), hi(5,true, 4));
assertNull(sorter.violation(object, 6));
harness.setSize(7);
harness.clearStats();
sorter.add(object, 6);
assertStatsRange(lo(6,true), harness.getStats(), hi(6,true, 6));
assertNull(sorter.violation(object, 7));
harness.setSize(8);
harness.clearStats();
sorter.add(object, 7);
assertStatsRange(lo(7,true), harness.getStats(), hi(7,true, 2));
assertNull(sorter.violation(object, 8));
harness.setSize(9);
harness.clearStats();
sorter.add(object, 8);
assertStatsRange(lo(8,true), harness.getStats(), hi(8,true, 1));
assertNull(sorter.violation(object, 9));
harness.clearStats();
sorter.remove(object, 8);
assertStatsRange(lo(8,false), harness.getStats(), hi(8,false, 0));
String a8 = object.get(8);
assertTrue("Wrong: " + a8, a8 == "the" || a8 == "The");
assertNull(sorter.violation(object, 8));
harness.setSize(8);
harness.clearStats();
sorter.remove(object, 7);
assertStatsRange(lo(7,false), harness.getStats(), hi(7,false, 0));
String a7 = object.get(7);
assertTrue("Wrong: " + a7, a7 == "the" || a7 == "The");
assertTrue("Duplicate: " + a7, a8 != a7);
assertNull(sorter.violation(object, 7));
harness.setSize(7);
harness.clearStats();
sorter.remove(object, 6);
assertStatsRange(lo(6,false), harness.getStats(), hi(6,false, 0));
assertEquals("make", object.get(6));
assertNull(sorter.violation(object, 6));
harness.setSize(6);
harness.clearStats();
sorter.remove(object, 5);
assertStatsRange(lo(5,false), harness.getStats(), hi(5,false, 0));
assertEquals("just", object.get(5));
assertNull(sorter.violation(object, 5));
harness.setSize(5);
harness.clearStats();
sorter.remove(object, 4);
assertStatsRange(lo(4,false), harness.getStats(), hi(4,false, 0));
assertEquals("Don't", object.get(4));
assertNull(sorter.violation(object, 4));
harness.setSize(4);
harness.clearStats();
sorter.remove(object, 3);
assertStatsRange(lo(3,false), harness.getStats(), hi(3,false, 0));
String a3 = object.get(3);
assertTrue("Wrong: " + a3, a3 == "days" || a3 == "Days");
assertNull(sorter.violation(object, 3));
harness.setSize(3);
harness.clearStats();
sorter.remove(object, 2);
assertStatsRange(lo(2,false), harness.getStats(), hi(2,false, 0));
String a2 = object.get(2);
assertTrue("Wrong: " + a2, a2 == "days" || a2 == "Days");
assertTrue("Duplicate: " + a2, a2 != a3);
assertNull(sorter.violation(object, 2));
harness.setSize(2);
harness.clearStats();
sorter.remove(object, 1);
assertStatsRange(lo(1,false), harness.getStats(), hi(1,false, 0));
String a1 = object.get(1);
assertTrue("Wrong: " + a1, a1 == "count" || a1 == "COUNT");
assertNull(sorter.violation(object, 1));
harness.setSize(1);
harness.clearStats();
sorter.remove(object, 0);
assertStatsRange(lo(0,false), harness.getStats(), hi(0,false, 0));
String a0 = object.get(0);
assertTrue("Wrong: " + a0, a0 == "count" || a0 == "COUNT");
assertTrue("Duplicate: " + a0, a0 != a1);
assertNull(sorter.violation(object, 0));
}
public void test91() {
harness = new SortHarness(
"eins", "zwei", "drei", "vier", "fünf", "sechs", "sieben", "acht", "neun");
object = harness.sortObject();
harness.setSize(0);
assertNull(sorter.violation(object, 0));
harness.setSize(1);
harness.clearStats();
sorter.add(object, 0);
assertStatsRange(lo(0,true), harness.getStats(), hi(0,true, 0));
assertNull(sorter.violation(object, 1));
harness.setSize(2);
harness.clearStats();
sorter.add(object, 1);
assertStatsRange(lo(1,true), harness.getStats(), hi(1,true, 1));
assertNull(sorter.violation(object, 2));
harness.setSize(3);
harness.clearStats();
sorter.add(object, 2);
assertStatsRange(lo(2,true), harness.getStats(), hi(2,true, 0));
assertNull(sorter.violation(object, 3));
harness.setSize(4);
harness.clearStats();
sorter.add(object, 3);
assertStatsRange(lo(3,true), harness.getStats(), hi(3,true, 2));
assertNull(sorter.violation(object, 4));
harness.setSize(5);
harness.clearStats();
sorter.add(object, 4);
assertStatsRange(lo(4,true), harness.getStats(), hi(4,true, 2));
assertNull(sorter.violation(object, 5));
harness.setSize(6);
harness.clearStats();
sorter.add(object, 5);
assertStatsRange(lo(5,true), harness.getStats(), hi(5,true, 3));
assertNull(sorter.violation(object, 6));
harness.setSize(7);
harness.clearStats();
sorter.add(object, 6);
assertStatsRange(lo(6,true), harness.getStats(), hi(6,true, 4));
assertNull(sorter.violation(object, 7));
harness.setSize(8);
harness.clearStats();
sorter.add(object, 7);
assertStatsRange(lo(7,true), harness.getStats(), hi(7,true, 0));
assertNull(sorter.violation(object, 8));
harness.setSize(9);
harness.clearStats();
sorter.add(object, 8);
assertStatsRange(lo(8,true), harness.getStats(), hi(8,true, 4));
assertNull(sorter.violation(object, 9));
harness.clearStats();
sorter.remove(object, 8);
assertStatsRange(lo(8,false), harness.getStats(), hi(8,false, 0));
String a8 = object.get(8);
assertEquals("zwei", a8);
assertNull(sorter.violation(object, 8));
harness.setSize(8);
harness.clearStats();
sorter.remove(object, 7);
assertStatsRange(lo(7,false), harness.getStats(), hi(7,false, 0));
String a7 = object.get(7);
assertEquals("vier", a7);
assertNull(sorter.violation(object, 7));
harness.setSize(7);
harness.clearStats();
sorter.remove(object, 6);
assertStatsRange(lo(6,false), harness.getStats(), hi(6,false, 0));
assertEquals("sieben", object.get(6));
assertNull(sorter.violation(object, 6));
harness.setSize(6);
harness.clearStats();
sorter.remove(object, 5);
assertStatsRange(lo(5,false), harness.getStats(), hi(5,false, 0));
assertEquals("sechs", object.get(5));
assertNull(sorter.violation(object, 5));
harness.setSize(5);
harness.clearStats();
sorter.remove(object, 4);
assertStatsRange(lo(4,false), harness.getStats(), hi(4,false, 0));
assertEquals("neun", object.get(4));
assertNull(sorter.violation(object, 4));
harness.setSize(4);
harness.clearStats();
sorter.remove(object, 3);
assertStatsRange(lo(3,false), harness.getStats(), hi(3,false, 0));
String a3 = object.get(3);
assertEquals("fünf", a3);
assertNull(sorter.violation(object, 3));
harness.setSize(3);
harness.clearStats();
sorter.remove(object, 2);
assertStatsRange(lo(2,false), harness.getStats(), hi(2,false, 0));
String a2 = object.get(2);
assertEquals("eins", a2);
assertNull(sorter.violation(object, 2));
harness.setSize(2);
harness.clearStats();
sorter.remove(object, 1);
assertStatsRange(lo(1,false), harness.getStats(), hi(1,false, 0));
assertEquals("drei", object.get(1));
assertNull(sorter.violation(object, 1));
harness.setSize(1);
harness.clearStats();
sorter.remove(object, 0);
assertStatsRange(lo(0,false), harness.getStats(), hi(0,false, 0));
String a0 = object.get(0);
assertEquals("acht", a0);
assertNull(sorter.violation(object, 0));
}
public void test92() {
harness = new SortHarness(
"A1", "B2", "C3", "D4", "E5", "F6", "G7", "H8", "I9");
object = harness.sortObject();
harness.setSize(0);
assertNull(sorter.violation(object, 0));
harness.setSize(1);
harness.clearStats();
sorter.add(object, 0);
assertStatsRange(lo(0,true), harness.getStats(), hi(0,true, 0));
assertNull(sorter.violation(object, 1));
harness.setSize(2);
harness.clearStats();
sorter.add(object, 1);
assertStatsRange(lo(1,true), harness.getStats(), hi(1,true, 1));
assertNull(sorter.violation(object, 2));
harness.setSize(3);
harness.clearStats();
sorter.add(object, 2);
assertStatsRange(lo(2,true), harness.getStats(), hi(2,true, 2));
assertNull(sorter.violation(object, 3));
harness.setSize(4);
harness.clearStats();
sorter.add(object, 3);
assertStatsRange(lo(3,true), harness.getStats(), hi(3,true, 3));
assertNull(sorter.violation(object, 4));
harness.setSize(5);
harness.clearStats();
sorter.add(object, 4);
assertStatsRange(lo(4,true), harness.getStats(), hi(4,true, 4));
assertNull(sorter.violation(object, 5));
harness.setSize(6);
harness.clearStats();
sorter.add(object, 5);
assertStatsRange(lo(5,true), harness.getStats(), hi(5,true, 5));
assertNull(sorter.violation(object, 6));
harness.setSize(7);
harness.clearStats();
sorter.add(object, 6);
assertStatsRange(lo(6,true), harness.getStats(), hi(6,true, 6));
assertNull(sorter.violation(object, 7));
harness.setSize(8);
harness.clearStats();
sorter.add(object, 7);
assertStatsRange(lo(7,true), harness.getStats(), hi(7,true, 7));
assertNull(sorter.violation(object, 8));
harness.setSize(9);
harness.clearStats();
sorter.add(object, 8);
assertStatsRange(lo(8,true), harness.getStats(), hi(8,true, 8));
assertNull(sorter.violation(object, 9));
harness.clearStats();
sorter.remove(object, 8);
assertStatsRange(lo(8,false), harness.getStats(), hi(8,false, 0));
String a8 = object.get(8);
assertEquals("I9", a8);
assertNull(sorter.violation(object, 8));
harness.setSize(8);
harness.clearStats();
sorter.remove(object, 7);
assertStatsRange(lo(7,false), harness.getStats(), hi(7,false, 0));
String a7 = object.get(7);
assertEquals("H8", a7);
assertNull(sorter.violation(object, 7));
harness.setSize(7);
harness.clearStats();
sorter.remove(object, 6);
assertStatsRange(lo(6,false), harness.getStats(), hi(6,false, 0));
assertEquals("G7", object.get(6));
assertNull(sorter.violation(object, 6));
harness.setSize(6);
harness.clearStats();
sorter.remove(object, 5);
assertStatsRange(lo(5,false), harness.getStats(), hi(5,false, 0));
assertEquals("F6", object.get(5));
assertNull(sorter.violation(object, 5));
harness.setSize(5);
harness.clearStats();
sorter.remove(object, 4);
assertStatsRange(lo(4,false), harness.getStats(), hi(4,false, 0));
assertEquals("E5", object.get(4));
assertNull(sorter.violation(object, 4));
harness.setSize(4);
harness.clearStats();
sorter.remove(object, 3);
assertStatsRange(lo(3,false), harness.getStats(), hi(3,false, 0));
String a3 = object.get(3);
assertEquals("D4", a3);
assertNull(sorter.violation(object, 3));
harness.setSize(3);
harness.clearStats();
sorter.remove(object, 2);
assertStatsRange(lo(2,false), harness.getStats(), hi(2,false, 0));
String a2 = object.get(2);
assertEquals("C3", a2);
assertNull(sorter.violation(object, 2));
harness.setSize(2);
harness.clearStats();
sorter.remove(object, 1);
assertStatsRange(lo(1,false), harness.getStats(), hi(1,false, 0));
assertEquals("B2", object.get(1));
assertNull(sorter.violation(object, 1));
harness.setSize(1);
harness.clearStats();
sorter.remove(object, 0);
assertStatsRange(lo(0,false), harness.getStats(), hi(0,false, 0));
String a0 = object.get(0);
assertEquals("A1", a0);
assertNull(sorter.violation(object, 0));
}
public void test93() {
harness = new SortHarness(String.CASE_INSENSITIVE_ORDER,
"In", "two", "days", "from", "now", "tomorrow", "will", "be", "yesterday");
object = harness.sortObject();
harness.setSize(0);
assertNull(sorter.violation(object, 0));
harness.setSize(1);
harness.clearStats();
sorter.add(object, 0);
assertStatsRange(lo(0,true), harness.getStats(), hi(0,true, 0));
assertNull(sorter.violation(object, 1));
harness.setSize(2);
harness.clearStats();
sorter.add(object, 1);
assertStatsRange(lo(1,true), harness.getStats(), hi(1,true, 1));
assertNull(sorter.violation(object, 2));
harness.setSize(3);
harness.clearStats();
sorter.add(object, 2);
assertStatsRange(lo(2,true), harness.getStats(), hi(2,true, 0));
assertNull(sorter.violation(object, 3));
harness.setSize(4);
harness.clearStats();
sorter.add(object, 3);
assertStatsRange(lo(3,true), harness.getStats(), hi(3,true, 1));
assertNull(sorter.violation(object, 4));
harness.setSize(5);
harness.clearStats();
sorter.add(object, 4);
assertStatsRange(lo(4,true), harness.getStats(), hi(4,true, 3));
assertNull(sorter.violation(object, 5));
harness.setSize(6);
harness.clearStats();
sorter.add(object, 5);
assertStatsRange(lo(5,true), harness.getStats(), hi(5,true, 4));
assertNull(sorter.violation(object, 6));
harness.setSize(7);
harness.clearStats();
sorter.add(object, 6);
assertStatsRange(lo(6,true), harness.getStats(), hi(6,true, 6));
assertNull(sorter.violation(object, 7));
harness.setSize(8);
harness.clearStats();
sorter.add(object, 7);
assertStatsRange(lo(7,true), harness.getStats(), hi(7,true, 0));
assertNull(sorter.violation(object, 8));
harness.setSize(9);
harness.clearStats();
sorter.add(object, 8);
assertStatsRange(lo(8,true), harness.getStats(), hi(8,true, 8));
assertNull(sorter.violation(object, 9));
harness.clearStats();
sorter.remove(object, 8);
assertStatsRange(lo(8,false), harness.getStats(), hi(8,false, 0));
String a8 = object.get(8);
assertEquals("yesterday", a8);
assertNull(sorter.violation(object, 8));
harness.setSize(8);
harness.clearStats();
sorter.remove(object, 7);
assertStatsRange(lo(7,false), harness.getStats(), hi(7,false, 0));
String a7 = object.get(7);
assertEquals("will", a7);
assertNull(sorter.violation(object, 7));
harness.setSize(7);
harness.clearStats();
sorter.remove(object, 6);
assertStatsRange(lo(6,false), harness.getStats(), hi(6,false, 0));
assertEquals("two", object.get(6));
assertNull(sorter.violation(object, 6));
harness.setSize(6);
harness.clearStats();
sorter.remove(object, 5);
assertStatsRange(lo(5,false), harness.getStats(), hi(5,false, 0));
assertEquals("tomorrow", object.get(5));
assertNull(sorter.violation(object, 5));
harness.setSize(5);
harness.clearStats();
sorter.remove(object, 4);
assertStatsRange(lo(4,false), harness.getStats(), hi(4,false, 0));
assertEquals("now", object.get(4));
assertNull(sorter.violation(object, 4));
harness.setSize(4);
harness.clearStats();
sorter.remove(object, 3);
assertStatsRange(lo(3,false), harness.getStats(), hi(3,false, 0));
String a3 = object.get(3);
assertEquals("In", a3);
assertNull(sorter.violation(object, 3));
harness.setSize(3);
harness.clearStats();
sorter.remove(object, 2);
assertStatsRange(lo(2,false), harness.getStats(), hi(2,false, 0));
String a2 = object.get(2);
assertEquals("from", a2);
assertNull(sorter.violation(object, 2));
harness.setSize(2);
harness.clearStats();
sorter.remove(object, 1);
assertStatsRange(lo(1,false), harness.getStats(), hi(1,false, 0));
assertEquals("days", object.get(1));
assertNull(sorter.violation(object, 1));
harness.setSize(1);
harness.clearStats();
sorter.remove(object, 0);
assertStatsRange(lo(0,false), harness.getStats(), hi(0,false, 0));
String a0 = object.get(0);
assertEquals("be", a0);
assertNull(sorter.violation(object, 0));
}
private static final int TEST_SIZE = 10;
private static final int RANDOM_TESTS = 10000;
protected String randomString(Random r) {
return (""+(1000+r.nextInt(1000))).substring(1);
}
public void test99() {
Random random = new Random();
String[] subject = new String[TEST_SIZE];
for (int test=0; test < RANDOM_TESTS; ++test) {
for (int i=0; i < TEST_SIZE; ++i) {
subject[i] = randomString(random);
}
System.out.println("Sorting: " + Arrays.toString(subject));
harness = new SortHarness<>(subject.clone());
object = harness.sortObject();
harness.setSize(0);
for (int i=0; i < TEST_SIZE; ++i) {
assertNull(sorter.violation(object, i));
harness.setSize(i+1);
harness.clearStats();
sorter.add(object, i);
int count = 0;
for (int j=0; j < i; ++j) {
if (subject[j].compareTo(subject[i]) <= 0) ++count;
}
assertStatsRange(lo(i,true), harness.getStats(), hi(i,true, count));
}
assertNull(sorter.violation(object, TEST_SIZE));
Arrays.sort(subject);
for (int i=TEST_SIZE-1; i >= 0; --i) {
harness.clearStats();
sorter.remove(object, i);
assertStatsRange(lo(i,false), harness.getStats(), hi(i,false, 0));
assertEquals("Wrong entry for element " + i, subject[i], object.get(i));
harness.setSize(i);
assertNull(sorter.violation(object, i));
}
}
}
}
TEST HEAP SORT
import edu.uwm.cs351.HeapSorter;
import edu.uwm.cs351.Sorter;
public class TestHeapSort extends AbstractTestSort {
protected Sorter getAlgorithm() {
return new HeapSorter<>();
}
@Override
protected int[] lo(int n, boolean isAdd) {
switch(n) {
case 0: return s(0,0,0);
case 1:
if (isAdd) {
return s(1,0,1);
} else {
return s(0,0,0);
}
case 2:
return s(1,0,1);
default:
if (isAdd) {
return s(1,0,1);
} else {
return s(1,0,2);
}
}
}
@Override
protected int[] hi(int n, boolean isAdd, int ni) {
int log = 0;
for (int i=isAdd ? n+1 : n; i > 0; i/=2) {
++log;
}
switch (n) {
case 0:
if (isAdd) {
return s(1,1,0);
} else {
return s(0,0,0);
}
default:
if (isAdd) {
return s(log,log,log-1);
} else {
return s(log*2, log+1, (log-1)*2);
}
}
}
public void testA() {
setUp(42);
assertNull(algorithm.violation(self, 0));
assertNull(algorithm.violation(self, 1));
}
public void testB() {
setUp(10,20);
assertNull(algorithm.violation(self, 0));
assertNull(algorithm.violation(self, 1));
assertNotNull(algorithm.violation(self, 2));
}
public void testC() {
setUp((a,b) -> b-a, 10, 20);
assertNull(algorithm.violation(self, 0));
assertNull(algorithm.violation(self, 1));
assertNull(algorithm.violation(self, 2));
}
public void testD() {
setUp(10,20,5);
assertNull(algorithm.violation(self, 0));
assertNull(algorithm.violation(self, 1));
assertNotNull(algorithm.violation(self, 2));
assertNotNull(algorithm.violation(self, 3));
}
public void testE() {
setUp(10,5,15);
assertNull(algorithm.violation(self, 0));
assertNull(algorithm.violation(self, 1));
assertNull(algorithm.violation(self, 2));
assertNotNull(algorithm.violation(self, 3));
}
public void testF() {
setUp((a,b)-> 0, 10,50,1000000);
assertNull(algorithm.violation(self, 0));
assertNull(algorithm.violation(self, 1));
assertNull(algorithm.violation(self, 2));
assertNull(algorithm.violation(self, 3));
}
public void testG() {
setUp(10,5,7,6,4,5,2,1);
assertNull(algorithm.violation(self, 0));
assertNull(algorithm.violation(self, 1));
assertNull(algorithm.violation(self, 2));
assertNull(algorithm.violation(self, 3));
assertNotNull(algorithm.violation(self, 4));
assertNotNull(algorithm.violation(self, 5));
assertNotNull(algorithm.violation(self, 6));
assertNotNull(algorithm.violation(self, 7));
assertNotNull(algorithm.violation(self, 8));
}
public void testH() {
setUp(10,10,10,10,10,9,8,7,10,10,10,10,10);
assertNull(algorithm.violation(self, 0));
assertNull(algorithm.violation(self, 1));
assertNull(algorithm.violation(self, 2));
assertNull(algorithm.violation(self, 3));
assertNull(algorithm.violation(self, 4));
assertNull(algorithm.violation(self, 5));
assertNull(algorithm.violation(self, 6));
assertNull(algorithm.violation(self, 7));
assertNull(algorithm.violation(self, 8));
assertNull(algorithm.violation(self, 9));
assertNull(algorithm.violation(self, 10));
assertNull(algorithm.violation(self, 11));
assertNotNull(algorithm.violation(self, 12));
assertNotNull(algorithm.violation(self, 13));
}
public void testI() {
setUp(100, 70, 40, 50, 60, 15, 35, 45, 55, 11, 13);
assertNull(algorithm.violation(self, 0));
assertNull(algorithm.violation(self, 1));
assertNull(algorithm.violation(self, 2));
assertNull(algorithm.violation(self, 3));
assertNull(algorithm.violation(self, 4));
assertNull(algorithm.violation(self, 5));
assertNull(algorithm.violation(self, 6));
assertNull(algorithm.violation(self, 7));
assertNull(algorithm.violation(self, 8));
assertNotNull(algorithm.violation(self, 9));
assertNotNull(algorithm.violation(self, 10));
assertNotNull(algorithm.violation(self, 11));
}
public void testJ() {
setUp(100,80,90,60,70,85,75,50,40,65,55,77,82,68,54,42,48,30,35,61,58,51,57,72,63,62,74);
assertNull(algorithm.violation(self, 0));
assertNull(algorithm.violation(self, 1));
assertNull(algorithm.violation(self, 2));
assertNull(algorithm.violation(self, 3));
assertNull(algorithm.violation(self, 4));
assertNull(algorithm.violation(self, 5));
assertNull(algorithm.violation(self, 6));
assertNull(algorithm.violation(self, 7));
assertNull(algorithm.violation(self, 8));
assertNull(algorithm.violation(self, 9));
assertNull(algorithm.violation(self, 10));
assertNull(algorithm.violation(self, 11));
assertNull(algorithm.violation(self, 12));
assertNull(algorithm.violation(self, 13));
assertNull(algorithm.violation(self, 14));
assertNull(algorithm.violation(self, 15));
assertNull(algorithm.violation(self, 16));
assertNull(algorithm.violation(self, 17));
assertNull(algorithm.violation(self, 18));
assertNull(algorithm.violation(self, 19));
assertNull(algorithm.violation(self, 20));
assertNull(algorithm.violation(self, 21));
assertNull(algorithm.violation(self, 22));
assertNotNull(algorithm.violation(self, 23));
assertNotNull(algorithm.violation(self, 24));
assertNotNull(algorithm.violation(self, 25));
assertNotNull(algorithm.violation(self, 26));
assertNotNull(algorithm.violation(self, 27));
}
}
TEST INSERTION SORT
import edu.uwm.cs351.InsertionSorter;
import edu.uwm.cs351.Sorter;
public class TestInsertionSort extends AbstractTestSort {
protected Sorter getAlgorithm() {
return new InsertionSorter<>();
}
@Override
protected int[] lo(int n, boolean isAdd) {
if (isAdd && n > 0) return s(1,0,1);
return s(0,0,0);
}
@Override
protected int[] hi(int n, boolean isAdd, int ni) {
if (isAdd) return s((n-ni)+2,(n-ni)+1,(n-ni)+1);
return s(0,0,0);
}
public void testA() {
setUp(42);
assertNull(algorithm.violation(self, 0));
assertNull(algorithm.violation(self, 1));
}
public void testB() {
setUp(10,20);
assertNull(algorithm.violation(self, 0));
assertNull(algorithm.violation(self, 1));
assertNull(algorithm.violation(self, 2));
}
public void testC() {
setUp(3,2,6);
assertNull(algorithm.violation(self, 0));
assertNull(algorithm.violation(self, 1));
assertNotNull(algorithm.violation(self, 2));
assertNotNull(algorithm.violation(self, 3));
}
public void testD() {
setUp((a,b)->b-a, 3,2,6);
assertNull(algorithm.violation(self, 0));
assertNull(algorithm.violation(self, 1));
assertNull(algorithm.violation(self, 2));
assertNotNull(algorithm.violation(self, 3));
}
public void testE() {
setUp((a,b)->0, 3,2,6);
assertNull(algorithm.violation(self, 0));
assertNull(algorithm.violation(self, 1));
assertNull(algorithm.violation(self, 2));
assertNull(algorithm.violation(self, 3));
}
public void testF() {
setUp((a,b) -> a/10 - b/10, 4, 2, 15, 13, 9, 14);
assertNull(algorithm.violation(self, 0));
assertNull(algorithm.violation(self, 1));
assertNull(algorithm.violation(self, 2));
assertNull(algorithm.violation(self, 3));
assertNull(algorithm.violation(self, 4));
assertNotNull(algorithm.violation(self, 5));
assertNotNull(algorithm.violation(self, 6));
}
public void testG() {
setUp(4, 2, 13, 15, 19, 24, 33);
assertNotNull(algorithm.violation(self, 5));
assertNotNull(algorithm.violation(self, 6));
assertNotNull(algorithm.violation(self, 7));
}
public void testH() {
setUp((a,b)->0, 1, 3, 6, 10, 15, 10, 6, 3, 1);
assertNull(algorithm.violation(self, 5));
assertNull(algorithm.violation(self, 6));
assertNull(algorithm.violation(self, 7));
assertNull(algorithm.violation(self, 8));
assertNull(algorithm.violation(self, 9));
}
public void testI() {
setUp(1, 3, 9, 27, 81, 343, 1029, 3087, 9261);
assertNull(algorithm.violation(self, 5));
assertNull(algorithm.violation(self, 6));
assertNull(algorithm.violation(self, 7));
assertNull(algorithm.violation(self, 8));
assertNull(algorithm.violation(self, 9));
}
public void testJ() {
setUp(1, 4, 16, -64, 256, 1024, 4096, 16384, 65536, 262144);
assertNull(algorithm.violation(self, 0));
assertNull(algorithm.violation(self, 1));
assertNull(algorithm.violation(self, 2));
assertNull(algorithm.violation(self, 3));
assertNotNull(algorithm.violation(self, 8));
assertNotNull(algorithm.violation(self, 10));
}
}
TEST SELECTION SORT
import edu.uwm.cs351.SelectionSorter;
import edu.uwm.cs351.Sorter;
public class TestSelectionSort extends AbstractTestSort {
protected Sorter getAlgorithm() {
return new SelectionSorter<>();
}
@Override
protected int[] lo(int n, boolean isAdd) {
if (isAdd || n == 0) return s(0,0,0);
return s(n+1,0,n);
}
@Override
protected int[] hi(int n, boolean isAdd, int ni) {
if (isAdd) return s(0,0,0);
return s(n+1,2,n);
}
public void testA() {
setUp(42);
assertNull(algorithm.violation(self, 0));
assertNull(algorithm.violation(self, 1));
}
public void testB() {
setUp(10,20);
assertNull(algorithm.violation(self, 0));
assertNull(algorithm.violation(self, 1));
assertNull(algorithm.violation(self, 2));
}
public void testC() {
setUp(3,2,1);
assertNull(algorithm.violation(self, 0));
assertNull(algorithm.violation(self, 1));
assertNull(algorithm.violation(self, 2));
assertNull(algorithm.violation(self, 3));
}
public void testD() {
setUp(1,6,3,-19);
assertNull(algorithm.violation(self, 0));
assertNull(algorithm.violation(self, 1));
assertNull(algorithm.violation(self, 2));
assertNull(algorithm.violation(self, 3));
assertNull(algorithm.violation(self, 4));
}
public void testE() {
setUp(1024,16,32,65536,512);
assertNull(algorithm.violation(self, 0));
assertNull(algorithm.violation(self, 1));
assertNull(algorithm.violation(self, 2));
assertNull(algorithm.violation(self, 3));
assertNull(algorithm.violation(self, 4));
assertNull(algorithm.violation(self, 5));
}
public void testF() {
setUp(42,42,42,42,42,42);
assertNull(algorithm.violation(self, 0));
assertNull(algorithm.violation(self, 1));
assertNull(algorithm.violation(self, 2));
assertNull(algorithm.violation(self, 3));
assertNull(algorithm.violation(self, 4));
assertNull(algorithm.violation(self, 5));
assertNull(algorithm.violation(self, 6));
}
public void testG() {
setUp((a,b) -> b-a, 1,2,3,4,3,2,1);
assertNull(algorithm.violation(self, 0));
assertNull(algorithm.violation(self, 1));
assertNull(algorithm.violation(self, 2));
assertNull(algorithm.violation(self, 3));
assertNull(algorithm.violation(self, 4));
assertNull(algorithm.violation(self, 5));
assertNull(algorithm.violation(self, 6));
assertNull(algorithm.violation(self, 7));
}
public void testH() {
setUp((a,b) -> 0, -587, 110, 1066, 1492, -185, 221, 33);
assertNull(algorithm.violation(self, 0));
assertNull(algorithm.violation(self, 1));
assertNull(algorithm.violation(self, 2));
assertNull(algorithm.violation(self, 3));
assertNull(algorithm.violation(self, 4));
assertNull(algorithm.violation(self, 5));
assertNull(algorithm.violation(self, 6));
assertNull(algorithm.violation(self, 7));
assertNull(algorithm.violation(self, 8));
}
public void testI() {
setUp(9, -8, 7, -6, 5, -4, 3, -2, 1);
assertNull(algorithm.violation(self, 0));
assertNull(algorithm.violation(self, 1));
assertNull(algorithm.violation(self, 2));
assertNull(algorithm.violation(self, 3));
assertNull(algorithm.violation(self, 4));
assertNull(algorithm.violation(self, 5));
assertNull(algorithm.violation(self, 6));
assertNull(algorithm.violation(self, 7));
assertNull(algorithm.violation(self, 8));
assertNull(algorithm.violation(self, 9));
}
public void testJ() {
setUp(100,80,90,60,70,85,75,50,40,65,55,77,82,68,54,42,48,30,35,61,58,51,57,72,63,62,74);
assertNull(algorithm.violation(self, 0));
assertNull(algorithm.violation(self, 1));
assertNull(algorithm.violation(self, 2));
assertNull(algorithm.violation(self, 3));
assertNull(algorithm.violation(self, 4));
assertNull(algorithm.violation(self, 5));
assertNull(algorithm.violation(self, 6));
assertNull(algorithm.violation(self, 7));
assertNull(algorithm.violation(self, 8));
assertNull(algorithm.violation(self, 9));
assertNull(algorithm.violation(self, 10));
assertNull(algorithm.violation(self, 11));
assertNull(algorithm.violation(self, 12));
assertNull(algorithm.violation(self, 13));
assertNull(algorithm.violation(self, 14));
assertNull(algorithm.violation(self, 15));
assertNull(algorithm.violation(self, 16));
assertNull(algorithm.violation(self, 17));
assertNull(algorithm.violation(self, 18));
assertNull(algorithm.violation(self, 19));
assertNull(algorithm.violation(self, 20));
assertNull(algorithm.violation(self, 21));
assertNull(algorithm.violation(self, 22));
assertNull(algorithm.violation(self, 23));
assertNull(algorithm.violation(self, 24));
assertNull(algorithm.violation(self, 25));
assertNull(algorithm.violation(self, 26));
assertNull(algorithm.violation(self, 27));
}
}