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); }