private <T> void checkCursor(
EntityCursor<T> cursor,
Collection<T> collection,
boolean collectionIsKeySet,
List<List<Integer>> expected,
Getter<T> getter)
throws DatabaseException {
boolean first;
boolean firstDup;
Iterator<T> iterator = collection.iterator();
for (List<Integer> dups : expected) {
for (int i : dups) {
T o = cursor.next();
assertNotNull(o);
assertEquals(i, getter.getKey(o));
/* Value iterator over duplicates. */
if (!collectionIsKeySet) {
assertTrue(iterator.hasNext());
o = iterator.next();
assertNotNull(o);
assertEquals(i, getter.getKey(o));
}
}
}
first = true;
for (List<Integer> dups : expected) {
firstDup = true;
for (int i : dups) {
T o = first ? cursor.first() : (firstDup ? cursor.next() : cursor.nextDup());
assertNotNull(o);
assertEquals(i, getter.getKey(o));
first = false;
firstDup = false;
}
}
first = true;
for (List<Integer> dups : expected) {
if (!dups.isEmpty()) {
int i = dups.get(0);
T o = first ? cursor.first() : cursor.nextNoDup();
assertNotNull(o);
assertEquals(i, getter.getKey(o));
/* Key iterator over non-duplicates. */
if (collectionIsKeySet) {
assertTrue(iterator.hasNext());
o = iterator.next();
assertNotNull(o);
assertEquals(i, getter.getKey(o));
}
first = false;
}
}
List<List<Integer>> reversed = new ArrayList<List<Integer>>();
for (List<Integer> dups : expected) {
ArrayList<Integer> reversedDups = new ArrayList<Integer>(dups);
Collections.reverse(reversedDups);
reversed.add(reversedDups);
}
Collections.reverse(reversed);
first = true;
for (List<Integer> dups : reversed) {
for (int i : dups) {
T o = first ? cursor.last() : cursor.prev();
assertNotNull(o);
assertEquals(i, getter.getKey(o));
first = false;
}
}
first = true;
for (List<Integer> dups : reversed) {
firstDup = true;
for (int i : dups) {
T o = first ? cursor.last() : (firstDup ? cursor.prev() : cursor.prevDup());
assertNotNull(o);
assertEquals(i, getter.getKey(o));
first = false;
firstDup = false;
}
}
first = true;
for (List<Integer> dups : reversed) {
if (!dups.isEmpty()) {
int i = dups.get(0);
T o = first ? cursor.last() : cursor.prevNoDup();
assertNotNull(o);
assertEquals(i, getter.getKey(o));
first = false;
}
}
cursor.close();
}
/**
* @param obj
* @return
* @throws MapperException
*/
@SuppressWarnings("unchecked")
public JSonNode create(final Object obj) throws MapperException {
try {
if (obj == null) {
return new JSonValue(null);
}
final Class<? extends Object> clazz = obj.getClass();
TypeMapper<?> mapper;
if (clazz.isPrimitive()) {
if (clazz == boolean.class) {
return new JSonValue((Boolean) obj);
} else if (clazz == char.class) {
return new JSonValue(0 + ((Character) obj).charValue());
} else if (clazz == byte.class) {
return new JSonValue(((Byte) obj).longValue());
} else if (clazz == short.class) {
return new JSonValue(((Short) obj).longValue());
} else if (clazz == int.class) {
return new JSonValue(((Integer) obj).longValue());
} else if (clazz == long.class) {
return new JSonValue(((Long) obj).longValue());
} else if (clazz == float.class) {
return new JSonValue(((Float) obj).doubleValue());
} else if (clazz == double.class) {
return new JSonValue(((Double) obj).doubleValue());
}
} else if (clazz.isEnum()) {
return new JSonValue(obj + "");
} else if (obj instanceof Boolean) {
return new JSonValue(((Boolean) obj).booleanValue());
} else if (obj instanceof Character) {
return new JSonValue(0 + ((Character) obj).charValue());
} else if (obj instanceof Byte) {
return new JSonValue(((Byte) obj).longValue());
} else if (obj instanceof Short) {
return new JSonValue(((Short) obj).longValue());
} else if (obj instanceof Integer) {
return new JSonValue(((Integer) obj).longValue());
} else if (obj instanceof Long) {
return new JSonValue(((Long) obj).longValue());
} else if (obj instanceof Float) {
return new JSonValue(((Float) obj).doubleValue());
} else if (obj instanceof Double) {
return new JSonValue(((Double) obj).doubleValue());
} else if (obj instanceof String) {
return new JSonValue((String) obj);
} else if (obj instanceof Map) {
final JSonObject ret = new JSonObject();
Entry<Object, Object> next;
for (final Iterator<Entry<Object, Object>> it =
((Map<Object, Object>) obj).entrySet().iterator();
it.hasNext(); ) {
next = it.next();
if (!(next.getKey() instanceof String)) {
throw new MapperException(
"Map keys have to be Strings: "
+ clazz
+ " Keyclass:"
+ (next.getKey() == null ? "<null>" : next.getKey().getClass()));
}
ret.put(next.getKey().toString(), create(next.getValue()));
}
return ret;
} else if (obj instanceof Collection) {
final JSonArray ret = new JSonArray();
for (final Object o : (Collection<?>) obj) {
ret.add(create(o));
}
return ret;
} else if (clazz.isArray()) {
final JSonArray ret = new JSonArray();
for (int i = 0; i < Array.getLength(obj); i++) {
ret.add(create(Array.get(obj, i)));
}
return ret;
} else if (obj instanceof Class) {
return new JSonValue(((Class<?>) obj).getName());
} else if ((mapper = typeMapper.get(clazz)) != null) {
return mapper.map(obj);
} else /* if (obj instanceof Storable) */ {
final ClassCache cc = ClassCache.getClassCache(clazz);
final JSonObject ret = new JSonObject();
for (final Getter g : cc.getGetter()) {
ret.put(g.getKey(), create(g.getValue(obj)));
}
return ret;
}
} catch (final IllegalArgumentException e) {
e.printStackTrace();
} catch (final IllegalAccessException e) {
e.printStackTrace();
} catch (final InvocationTargetException e) {
e.printStackTrace();
} catch (final SecurityException e) {
e.printStackTrace();
} catch (final NoSuchMethodException e) {
e.printStackTrace();
}
return null;
}
private <K, V> void checkIndex(
EntityIndex<K, V> index,
SortedMap<Integer, SortedSet<Integer>> expected,
Getter<K> kGetter,
Getter<V> vGetter)
throws DatabaseException {
SortedMap<K, V> map = index.sortedMap();
Transaction txn = txnBegin();
for (int i : expected.keySet()) {
K k = kGetter.fromInt(i);
SortedSet<Integer> dups = expected.get(i);
if (dups.isEmpty()) {
/* EntityIndex */
V v = index.get(txn, k, null);
assertNull(v);
assertTrue(!index.contains(txn, k, null));
/* Map/Collection */
v = map.get(i);
assertNull(v);
assertTrue(!map.containsKey(i));
} else {
int j = dups.first();
/* EntityIndex */
V v = index.get(txn, k, null);
assertNotNull(v);
assertEquals(j, vGetter.getKey(v));
assertTrue(index.contains(txn, k, null));
/* Map/Collection */
v = map.get(i);
assertNotNull(v);
assertEquals(j, vGetter.getKey(v));
assertTrue(map.containsKey(i));
assertTrue("" + i + ' ' + j + ' ' + v + ' ' + map, map.containsValue(v));
assertTrue(map.keySet().contains(i));
assertTrue(map.values().contains(v));
assertTrue(map.entrySet().contains(new MapEntryParameter(i, v)));
}
}
txnCommit(txn);
int keysSize = expandKeySize(expected);
int valuesSize = expandValueSize(expected);
/* EntityIndex.count */
assertEquals("keysSize=" + keysSize, valuesSize, index.count());
/* Map/Collection size */
assertEquals(valuesSize, map.size());
assertEquals(valuesSize, map.values().size());
assertEquals(valuesSize, map.entrySet().size());
assertEquals(keysSize, map.keySet().size());
/* Map/Collection isEmpty */
assertEquals(valuesSize == 0, map.isEmpty());
assertEquals(valuesSize == 0, map.values().isEmpty());
assertEquals(valuesSize == 0, map.entrySet().isEmpty());
assertEquals(keysSize == 0, map.keySet().isEmpty());
txn = txnBeginCursor();
/* Unconstrained cursors. */
checkCursor(index.keys(txn, null), map.keySet(), true, expandKeys(expected), kGetter);
checkCursor(index.entities(txn, null), map.values(), false, expandValues(expected), vGetter);
/* Range cursors. */
if (expected.isEmpty()) {
checkOpenRanges(txn, 0, index, expected, kGetter, vGetter);
checkClosedRanges(txn, 0, 1, index, expected, kGetter, vGetter);
} else {
int firstKey = expected.firstKey();
int lastKey = expected.lastKey();
for (int i = firstKey - 1; i <= lastKey + 1; i += 1) {
checkOpenRanges(txn, i, index, expected, kGetter, vGetter);
int j = i + 1;
if (j < lastKey + 1) {
checkClosedRanges(txn, i, j, index, expected, kGetter, vGetter);
}
}
}
txnCommit(txn);
}
