FSIndex bagIndex = this.cas.getIndexRepository().getIndex(CASTestSetup.ANNOT_BAG_INDEX);
FSIndex setIndex = this.cas.getIndexRepository().getIndex(CASTestSetup.ANNOT_SET_INDEX);
FSIndex sortedIndex = this.cas.getIndexRepository().getIndex(CASTestSetup.ANNOT_SORT_INDEX);
FSIterator it = setIndex.iterator();
AnnotationFS a, b = null;
while (it.isValid()) {
a = (AnnotationFS) it.get();
if (b != null) {
assertTrue(setIndex.compare(b, a) <= 0);
}
b = a;
// System.out.println(
// a.getType().getName() + " - " + a.getStart() + " - " +
// a.getEnd());
v.add(it.get().hashCode());
it.moveToNext();
}
// System.out.println("Number of annotations: " + v.size());
assertTrue(v.size() == ((10 * 3) + (10 * 3)));
it = setIndex.iterator();
it.moveToLast();
int current = v.size() - 1;
while (it.isValid() && (current >= 0)) {
// System.out.println("Current: " + current);
a = (AnnotationFS) it.get();
// System.out.println(
// a.getType().getName() + " - " + a.getStart() + " - " +
// a.getEnd());
assertTrue(it.get().hashCode() == v.get(current));
it.moveToPrevious();
--current;
}
assertTrue(current == -1);
assertFalse(it.isValid());
// /////////////////////////////////////////////////////////////////////////
// Use an iterator to move forwards and backwards and make sure the
// sequence
// remains constant.
it = setIndex.iterator();
it.moveToFirst(); // This is redundant.
current = 1;
// System.out.println("Codes: " + v);
while (current < (v.size() - 1)) {
it.moveToNext();
assertTrue(it.isValid());
assertTrue(it.get().hashCode() == v.get(current));
it.moveToNext();
assertTrue(it.isValid());
assertTrue(it.get().hashCode() == v.get(current + 1));
it.moveToPrevious();
assertTrue(it.isValid());
assertTrue(it.get().hashCode() == v.get(current));
++current;
}
// also test Java-style iteration
Iterator javaIt = setIndex.iterator();
current = 0;
while (javaIt.hasNext()) {
assertEquals(javaIt.next().hashCode(), v.get(current++));
}
// /////////////////////////////////////////////////////////////////////////
// Test fast fail.
it = bagIndex.iterator(); // use bag index, remove add last one
// (preserves order for other tests).
it.moveToLast();
a = (AnnotationFS) it.get();
it = setIndex.iterator(); // back to set iterator to do testing
this.cas.getIndexRepository().removeFS(a);
this.cas.getIndexRepository().addFS(a);
boolean ok = false;
try {
it.next(); // should throw
} catch (ConcurrentModificationException e) {
ok = true;
}
assertTrue(ok);
ok = false;
try {
it.next(); // should throw
} catch (ConcurrentModificationException e) {
ok = true;
}
assertTrue(ok);
it.moveTo(a);
ok = false;
try {
it.next(); // should not throw
ok = true;
} catch (ConcurrentModificationException e) {
// checking this with the ok variable
}
assertTrue(ok);
// /////////////////////////////////////////////////////////////////////////
// Test sorted index.
// FSIndex sortedIndex = cas.getAnnotationIndex(); // using different
// typeOrder
// System.out.println("Number of annotations: " + sortedIndex.size());
// for (it = sortedIndex.iterator(); it.hasNext(); it.next()) {
// System.out.println(it.get());
// }
assertTrue(sortedIndex.size() == 100);
v = new IntVector();
it = sortedIndex.iterator();
it.moveToFirst();
b = null;
while (it.isValid()) {
a = (AnnotationFS) it.get();
// System.out.println(a);
assertTrue(a != null);
if (b != null) {
// System.out.println("b = " + b);
assertTrue(sortedIndex.compare(b, a) <= 0);
}
b = a;
v.add(a.hashCode());
it.moveToNext();
}
assertTrue(sortedIndex.size() == v.size());
// Test moveTo()
ArrayList list = new ArrayList();
it = this.cas.getAnnotationIndex().iterator();
for (it.moveToFirst(); it.isValid(); it.moveToNext()) {
list.add(it.get());
}
// AnnotationFS an;
for (int i = 0; i < list.size(); i++) {
// System.out.println("Iteration: " + i);
it.moveToFirst();
it.moveTo((FeatureStructure) list.get(i));
assertTrue(((AnnotationFS) it.get()).getBegin() == ((AnnotationFS) list.get(i)).getBegin());
assertTrue(((AnnotationFS) it.get()).getEnd() == ((AnnotationFS) list.get(i)).getEnd());
}
// Check that reverse iterator produces reverse sequence.
// Note: this test is not valid. It is by no means guaranteed that reverse iteration of a
// sorted index will produce the reverse result of forward iteration. I no two annotations
// are equal wrt the sort order, this works of course. However, if some FSs are equal wrt
// the sort order, those may be returned in any order.
// it.moveToLast();
// System.out.println(it.get());
// for (int i = v.size() - 1; i >= 0; i--) {
// assertTrue(it.isValid());
// assertTrue(it.get().hashCode() == v.get(i));
// it.moveToPrevious();
// }
// /////////////////////////////////////////////////////////////////////////
// Use an iterator to move forwards and backwards and make sure the
// sequence
// remains constant.
it = sortedIndex.iterator();
it.moveToFirst(); // This is redundant.
current = 1;
// System.out.println("Codes: " + v);
while (current < (v.size() - 1)) {
it.moveToNext();
assertTrue(it.isValid());
assertTrue(it.get().hashCode() == v.get(current));
it.moveToNext();
assertTrue(it.isValid());
assertTrue(it.get().hashCode() == v.get(current + 1));
it.moveToPrevious();
assertTrue(it.isValid());
assertTrue(it.get().hashCode() == v.get(current));
++current;
}
// also test Java-style iteration
javaIt = sortedIndex.iterator();
current = 0;
while (javaIt.hasNext()) {
assertEquals(javaIt.next().hashCode(), v.get(current++));
}
// /////////////////////////////////////////////////////////////////////////
// Test fast fail.
it = bagIndex.iterator(); // use bag index, remove add last one
// (preserves order for other tests).
it.moveToLast();
a = (AnnotationFS) it.get();
// for (it = sortedIndex.iterator(); it.hasNext(); it.next()) {
// System.out.println(it.get());
// }
it = sortedIndex.iterator();
it.next();
it.next();
this.cas.getIndexRepository().removeFS(a);
this.cas.getIndexRepository().addFS(a);
ok = false;
try {
it.get(); // should throw
} catch (ConcurrentModificationException e) {
ok = true;
}
assertTrue(ok);
ok = false;
try {
it.next(); // should throw
} catch (ConcurrentModificationException e) {
ok = true;
}
assertTrue(ok);
ok = false;
try {
it.moveToNext(); // should throw
} catch (ConcurrentModificationException e) {
ok = true;
}
assertTrue(ok);
it.moveTo(a);
ok = false;
try {
it.next(); // should not throw
ok = true;
} catch (ConcurrentModificationException e) {
// checking with boolean "ok"
}
assertTrue(ok);
sortedIndex = null;
// /////////////////////////////////////////////////////////////////////////
// Test bag index.
// System.out.println("Number of annotations: " + sortedIndex.size());
assertTrue(bagIndex.size() == 100);
v = new IntVector();
it = bagIndex.iterator();
b = null;
while (it.isValid()) {
a = (AnnotationFS) it.get();
assertTrue(a != null);
if (b != null) {
assertTrue(bagIndex.compare(b, a) <= 0);
}
b = a;
v.add(a.hashCode());
it.moveToNext();
}
assertTrue(bagIndex.size() == v.size());
// Check that reverse iterator produces reverse sequence.