@Test
public void testItemsRemoveRange() {
int[] indices = new int[] {3, 5, 1};
indicesList.addIndices(indices);
// items we expect to appear in removed
List removedItems = new ArrayList();
removedItems.add(3);
removedItems.add(5);
report.clear();
// remove items at 3...5, inclusive
items.remove(3, 6);
assertEquals(1, indicesList.size());
// report.prettyPrint();
indices = new int[] {1};
for (int i = 0; i < indices.length; i++) {
assertEquals("expected value at " + i, indices[i], indicesList.get(i).intValue());
}
assertEquals(1, report.getEventCount());
assertTrue(
"expected single replaced but was" + report.getLastChange(),
wasSingleRemoved(report.getLastChange()));
Change c = report.getLastChange();
c.next();
assertEquals(2, c.getRemovedSize());
assertEquals(removedItems, c.getRemoved());
}
/**
* Test get if index off range. Changed implementation to throw IndexOOB (off range access is
* always a programming error)
*/
@Test(expected = IndexOutOfBoundsException.class)
public void testGetOffRange() {
int[] indices = new int[] {3, 5, 1};
indicesList.addIndices(indices);
assertEquals(indices.length, indicesList.size());
assertEquals(-1, indicesList.get(-1).intValue());
assertEquals(-1, indicesList.get(indices.length).intValue());
}
@Test
public void testAddSingle() {
int index = 3;
indicesList.addIndices(index);
assertEquals(1, indicesList.size());
assertEquals(index, indicesList.get(0).intValue());
assertEquals(1, report.getEventCount());
}
@Test
public void testItemSetAt() {
int index = 3;
indicesList.setIndices(index);
report.clear();
items.set(index, "replaced-element-at-3");
assertEquals(1, indicesList.size());
assertEquals(index, indicesList.get(0).intValue());
assertEquals(0, report.getEventCount());
}
/** Source index is same as get, kind of. */
@Test
public void testSourceIndexInRange() {
int[] indices = new int[] {3, 5, 1};
indicesList.addIndices(indices);
assertEquals(indices.length, indicesList.size());
Arrays.sort(indices);
for (int i = 0; i < indices.length; i++) {
assertEquals("sourceIndex " + i, indices[i], indicesList.getSourceIndex(i));
}
}
/**
* Test notification on setAll if there are already set indices. Changed implementation due to
* RT-39776, test assumption incorrect.
*/
@Test
public void testSetAllNotificationIfHasSet() {
int[] indices = new int[] {3, 5, 1};
indicesList.addIndices(indices);
report.clear();
indicesList.setAllIndices();
// report.prettyPrint();
assertEquals(items.size(), indicesList.size());
assertEquals(1, report.getEventCount());
Change c = report.getLastChange();
assertEquals(4, getChangeCount(c, ChangeType.ADDED));
}
@Test
public void testAddMultiple() {
int[] indices = new int[] {3, 5, 1};
indicesList.addIndices(indices);
assertEquals(indices.length, indicesList.size());
Arrays.sort(indices);
for (int i = 0; i < indices.length; i++) {
assertEquals("expected value at " + i, indices[i], indicesList.get(i).intValue());
}
assertEquals(1, report.getEventCount());
assertTrue("got a single added", wasSingleAdded(report.getLastChange()));
}
@Test
public void testItemsSetAll() {
int[] indices = new int[] {3, 5, 1};
indicesList.addIndices(indices);
report.clear();
items.setAll("one", "two", "three");
// LOG.info("setAll" + report.getLastChange());
assertEquals("all cleared", 0, indicesList.size());
assertEquals(1, report.getEventCount());
assertTrue(
"expected single removed, but was " + report.getLastChange(),
wasSingleRemoved(report.getLastChange()));
}
@Test
public void testClearSomeIndicesNotification() {
int[] indices = new int[] {3, 5, 1};
indicesList.addIndices(indices);
report.clear();
int[] clear = new int[] {5, 1};
// new PrintingListChangeListener("clearSomeNotification", indicesList);
indicesList.clearIndices(clear);
assertEquals(1, indicesList.size());
assertEquals(1, report.getEventCount());
assertEquals(
"must be 2 disjoint removes",
2,
getChangeCount(report.getLastChange(), ChangeType.REMOVED));
}
@Test
public void testItemsSetAllSmallerSize() {
int[] indices = new int[] {3, 5, 1};
indicesList.addIndices(indices);
report.clear();
ObservableList<String> other = createObservableList(true);
other.remove(1);
items.setAll(other);
assertEquals("all cleared", 0, indicesList.size());
assertEquals(1, report.getEventCount());
assertTrue(
"expected single removed, but was " + report.getLastChange(),
wasSingleRemoved(report.getLastChange()));
}
@Test
public void testItemsSetAllSameSize() {
int[] indices = new int[] {3, 5, 1};
indicesList.addIndices(indices);
report.clear();
// new PrintingListChangeListener("SetAll Same size", indicesList);
ObservableList<String> other = createObservableList(true);
// make it not equal
other.set(0, "otherItem");
items.setAll(other);
assertEquals("all cleared", 0, indicesList.size());
assertEquals(1, report.getEventCount());
assertTrue(
"expected single removed, but was " + report.getLastChange(),
wasSingleRemoved(report.getLastChange()));
}
@Test
public void testItemsRemovedAtAndBetween() {
int[] indices = new int[] {1, 3, 5, 7};
indicesList.addIndices(indices);
report.clear();
// new PrintingListChangeListener("Items removed at 2/4", indicesList);
items.removeAll(items.get(3), items.get(6));
indices = new int[] {1, 4, 5};
assertEquals(indices.length, indicesList.size());
for (int i = 0; i < indices.length; i++) {
assertEquals("expected value at " + i, indices[i], indicesList.get(i).intValue());
}
assertEquals(1, report.getEventCount());
assertTrue(
"expected single replaced but was" + report.getLastChange(),
wasSingleReplaced(report.getLastChange()));
}
@Test
public void testClearIndicesNotification() {
int[] indices = new int[] {3, 5, 1};
indicesList.addIndices(indices);
report.clear();
indicesList.clearIndices(indices);
assertEquals(0, indicesList.size());
assertEquals(1, report.getEventCount());
assertTrue("must be single remove", wasSingleRemoved(report.getLastChange()));
Change c = report.getLastChange();
c.reset();
c.next();
Arrays.sort(indices);
List base = new ArrayList();
for (int i = 0; i < indices.length; i++) {
base.add(indices[i]);
}
assertEquals(base, c.getRemoved());
}
@Test
public void testSetIndices() {
int[] indices = new int[] {3, 5, 1};
indicesList.addIndices(indices);
report.clear();
int[] setIndices = new int[] {2, 4, 6, 7};
indicesList.setIndices(setIndices);
assertEquals(setIndices.length, indicesList.size());
assertEquals(1, report.getEventCount());
assertTrue(wasSingleReplaced(report.getLastChange()));
Change c = report.getLastChange();
c.reset();
c.next();
Arrays.sort(indices);
List base = new ArrayList();
for (int i = 0; i < indices.length; i++) {
base.add(indices[i]);
}
assertEquals(base, c.getRemoved());
}
@Test
public void testItemsRemovedBeforeAndWithFirst() {
int[] indices = new int[] {3, 5, 1};
indicesList.addIndices(indices);
report.clear();
// new PrintingListChangeListener("Items removed at 0/1", indicesList);
items.removeAll(items.get(0), items.get(1));
assertEquals(indices.length - 1, indicesList.size());
Arrays.sort(indices);
indices = Arrays.copyOfRange(indices, 1, 3);
for (int i = 0; i < indices.length; i++) {
indices[i] = indices[i] - 2;
}
for (int i = 0; i < indices.length; i++) {
assertEquals("expected value at " + i, indices[i], indicesList.get(i).intValue());
}
assertEquals(1, report.getEventCount());
assertTrue(
"expected single replaced, but was " + report.getLastChange(),
wasSingleReplaced(report.getLastChange()));
}
/** Remove items in between selected. */
@Test
public void testItemsRemovedBetweenReally() {
int[] indices = new int[] {3, 5, 1};
indicesList.addIndices(indices);
report.clear();
items.removeAll(items.get(2), items.get(4));
assertEquals(indices.length, indicesList.size());
indices = new int[] {1, 2, 3};
for (int i = 0; i < indices.length; i++) {
assertEquals("expected value at " + i, indices[i], indicesList.get(i).intValue());
}
assertEquals(1, report.getEventCount());
assertTrue(
"expected single replaced but was" + report.getLastChange(),
wasSingleReplaced(report.getLastChange()));
Change c = report.getLastChange();
c.next();
assertEquals(2, c.getAddedSize());
assertEquals(c.getAddedSize(), c.getRemovedSize());
// report.prettyPrint();
}
@Test
public void testItemsRemovedAtFirst() {
int[] indices = new int[] {3, 5, 1};
indicesList.addIndices(indices);
report.clear();
items.remove(1);
assertEquals(indices.length - 1, indicesList.size());
Arrays.sort(indices);
indices = Arrays.copyOfRange(indices, 1, 3);
// note: since here, the indices are "shortend" at start!
for (int i = 0; i < indices.length; i++) {
indices[i] = indices[i] - 1;
}
for (int i = 0; i < indices.length; i++) {
assertEquals("expected value at " + i, indices[i], indicesList.get(i).intValue());
}
assertEquals(1, report.getEventCount());
assertTrue(
"expected single replaced but was" + report.getLastChange(),
wasSingleReplaced(report.getLastChange()));
}
/** Sanity: single remove at index removes indexed */
@Test
public void testItemRemovedAt() {
indicesList.setIndices(3);
items.remove(3);
assertEquals(0, indicesList.size());
}
@Test
public void testInitial() {
assertEquals(0, indicesList.size());
}
@Test
public void testSetAllIndices() {
indicesList.setAllIndices();
assertEquals(items.size(), indicesList.size());
assertEquals(1, report.getEventCount());
}