@Test // (timeout = 10000) public void testIteration() { HTreeMap m = new HTreeMap<Integer, Integer>(recman, true) { @Override protected int hash(Object key) { return (Integer) key; } }; final int max = 140; final int inc = 111111; for (Integer i = 0; i < max; i++) { m.put(i, i + inc); } Iterator<Integer> keys = m.keySet().iterator(); for (Integer i = 0; i < max; i++) { assertTrue(keys.hasNext()); assertEquals(i, keys.next()); } assertTrue(!keys.hasNext()); Iterator<Integer> vals = m.values().iterator(); for (Integer i = inc; i < max + inc; i++) { assertTrue(vals.hasNext()); assertEquals(i, vals.next()); } assertTrue(!vals.hasNext()); // great it worked, test stuff spread across segments m.clear(); assertTrue(m.isEmpty()); for (int i = 0; i < max; i++) { m.put((1 << 30) + i, i + inc); m.put((2 << 30) + i, i + inc); m.put((3 << 30) + i, i + inc); } assertEquals(max * 3, m.size()); int countSegments = 0; for (long segmentRecid : m.segmentRecids) { if (recman.recordGet(segmentRecid, HTreeMap.DIR_SERIALIZER) != null) countSegments++; } assertEquals(3, countSegments); keys = m.keySet().iterator(); for (int i = 1; i <= 3; i++) { for (int j = 0; j < max; j++) { assertTrue(keys.hasNext()); assertEquals(Integer.valueOf((i << 30) + j), keys.next()); } } assertTrue(!keys.hasNext()); }
@Test public void clear() { HTreeMap m = new HTreeMap(recman, true); for (Integer i = 0; i < 100; i++) { m.put(i, i); } m.clear(); assertTrue(m.isEmpty()); assertEquals(0, m.size()); }
/** * Creates new HashSet * * @param name of set to create * @param keepCounter if counter should be kept, without counter updates are faster, but entire * collection needs to be traversed to count items. * @param serializer used to convert keys into/from binary form. Use null for default value. * @param <K> item type * @throws IllegalArgumentException if name is already used */ public synchronized <K> Set<K> createHashSet( String name, boolean keepCounter, Serializer<K> serializer) { checkNameNotExists(name); Set<K> ret = new HTreeMap<K, Object>( engine, catPut(name + ".counterRecid", !keepCounter ? 0L : engine.put(0L, Serializer.LONG)), catPut(name + ".hashSalt", Utils.RANDOM.nextInt()), catPut(name + ".segmentRecids", HTreeMap.preallocateSegments(engine)), catPut(name + ".serializer", serializer, getDefaultSerializer()), null, 0L, 0L, 0L, 0L, null, null, null) .keySet(); catalog.put(name + ".type", "HashSet"); collections.put(name, new WeakReference<Object>(ret)); return ret; }
@Test public void test_delete() { HTreeMap m = new HTreeMap(recman, true) { @Override protected int hash(Object key) { return 0; } }; for (long i = 0; i < 20; i++) { m.put(i, i + 100); } for (long i = 0; i < 20; i++) { assertTrue(m.containsKey(i)); assertEquals(i + 100, m.get(i)); } for (long i = 0; i < 20; i++) { m.remove(i); } for (long i = 0; i < 20; i++) { assertTrue(!m.containsKey(i)); assertEquals(null, m.get(i)); } }
/** delete record/collection with given name */ public synchronized void delete(String name) { Object r = get(name); if (r instanceof Atomic.Boolean) { engine.delete(((Atomic.Boolean) r).recid, Serializer.BOOLEAN); } else if (r instanceof Atomic.Integer) { engine.delete(((Atomic.Integer) r).recid, Serializer.INTEGER); } else if (r instanceof Atomic.Long) { engine.delete(((Atomic.Long) r).recid, Serializer.LONG); } else if (r instanceof Atomic.String) { engine.delete(((Atomic.String) r).recid, Serializer.STRING_NOSIZE); } else if (r instanceof Atomic.Var) { engine.delete(((Atomic.Var) r).recid, ((Atomic.Var) r).serializer); } else if (r instanceof Queue) { // drain queue Queue q = (Queue) r; while (q.poll() != null) { // do nothing } } else if (r instanceof HTreeMap || r instanceof HTreeMap.KeySet) { HTreeMap m = (r instanceof HTreeMap) ? (HTreeMap) r : ((HTreeMap.KeySet) r).parent(); m.clear(); // delete segments for (long segmentRecid : m.segmentRecids) { engine.delete(segmentRecid, HTreeMap.DIR_SERIALIZER); } } else if (r instanceof BTreeMap || r instanceof BTreeMap.KeySet) { BTreeMap m = (r instanceof BTreeMap) ? (BTreeMap) r : (BTreeMap) ((BTreeMap.KeySet) r).m; // TODO on BTreeMap recursively delete all nodes m.clear(); if (m.counter != null) engine.delete(m.counter.recid, Serializer.LONG); } for (String n : catalog.keySet()) { if (!n.startsWith(name)) continue; catalog.remove(n); } namesInstanciated.remove(name); namesLookup.remove(r); }
@Test public void test_simple_put() { HTreeMap m = new HTreeMap(recman, true); m.put(111L, 222L); m.put(333L, 444L); assertTrue(m.containsKey(111L)); assertTrue(!m.containsKey(222L)); assertTrue(m.containsKey(333L)); assertTrue(!m.containsKey(444L)); assertEquals(222L, m.get(111L)); assertEquals(null, m.get(222L)); assertEquals(444l, m.get(333L)); }
/** * Creates new HashMap with more specific arguments * * @param <K> key type * @param <V> value type * @throws IllegalArgumentException if name is already used * @return newly created map */ protected synchronized <K, V> HTreeMap<K, V> createHashMap(HTreeMapMaker m) { String name = m.name; checkNameNotExists(name); long expireTimeStart = 0, expire = 0, expireAccess = 0, expireMaxSize = 0; long[] expireHeads = null, expireTails = null; if (m.expire != 0 || m.expireAccess != 0 || m.expireMaxSize != 0) { expireTimeStart = catPut(name + ".expireTimeStart", System.currentTimeMillis()); expire = catPut(name + ".expire", m.expire); expireAccess = catPut(name + ".expireAccess", m.expireAccess); expireMaxSize = catPut(name + ".expireMaxSize", m.expireMaxSize); expireHeads = new long[16]; expireTails = new long[16]; for (int i = 0; i < 16; i++) { expireHeads[i] = engine.put(0L, Serializer.LONG); expireTails[i] = engine.put(0L, Serializer.LONG); } catPut(name + ".expireHeads", expireHeads); catPut(name + ".expireTails", expireHeads); } HTreeMap<K, V> ret = new HTreeMap<K, V>( engine, catPut(name + ".counterRecid", !m.keepCounter ? 0L : engine.put(0L, Serializer.LONG)), catPut(name + ".hashSalt", Utils.RANDOM.nextInt()), catPut(name + ".segmentRecids", HTreeMap.preallocateSegments(engine)), catPut(name + ".keySerializer", m.keySerializer, getDefaultSerializer()), catPut(name + ".valueSerializer", m.valueSerializer, getDefaultSerializer()), expireTimeStart, expire, expireAccess, expireMaxSize, expireHeads, expireTails, m.valueCreator); catalog.put(name + ".type", "HashMap"); collections.put(name, new WeakReference<Object>(ret)); return ret; }
@Test public void test_hash_collision() { HTreeMap m = new HTreeMap(recman, true) { @Override protected int hash(Object key) { return 0; } }; for (long i = 0; i < 20; i++) { m.put(i, i + 100); } for (long i = 0; i < 20; i++) { assertTrue(m.containsKey(i)); assertEquals(i + 100, m.get(i)); } m.put(11L, 1111L); assertEquals(1111L, m.get(11L)); }
@Test public void test_hash_dir_expand() { HTreeMap m = new HTreeMap(recman, true) { @Override protected int hash(Object key) { return 0; } }; for (long i = 0; i < HTreeMap.BUCKET_OVERFLOW; i++) { m.put(i, i); } // segment should not be expanded long[][] l = recman.recordGet(m.segmentRecids[0], HTreeMap.DIR_SERIALIZER); assertNotNull(l[0]); assertEquals(1, l[0][0] & 1); // last bite indicates leaf for (int j = 1; j < 8; j++) { // all others should be null assertEquals(0, l[0][j]); } long recid = l[0][0] >>> 1; for (long i = HTreeMap.BUCKET_OVERFLOW - 1; i >= 0; i--) { assertTrue(recid != 0); HTreeMap.LinkedNode n = (HTreeMap.LinkedNode) recman.recordGet(recid, m.LN_SERIALIZER); assertEquals(i, n.key); assertEquals(i, n.value); recid = n.next; } // adding one more item should trigger dir expansion to next level m.put((long) HTreeMap.BUCKET_OVERFLOW, (long) HTreeMap.BUCKET_OVERFLOW); recid = m.segmentRecids[0]; l = recman.recordGet(recid, HTreeMap.DIR_SERIALIZER); assertNotNull(l[0]); for (int j = 1; j < 8; j++) { // all others should be null assertEquals(null, l[j]); } assertEquals(0, l[0][0] & 1); // last bite indicates leaf for (int j = 1; j < 8; j++) { // all others should be zero assertEquals(0, l[0][j]); } recid = l[0][0] >>> 1; l = recman.recordGet(recid, HTreeMap.DIR_SERIALIZER); assertNotNull(l[0]); for (int j = 1; j < 8; j++) { // all others should be null assertEquals(null, l[j]); } assertEquals(1, l[0][0] & 1); // last bite indicates leaf for (int j = 1; j < 8; j++) { // all others should be zero assertEquals(0, l[0][j]); } recid = l[0][0] >>> 1; for (long i = 0; i <= HTreeMap.BUCKET_OVERFLOW; i++) { assertTrue(recid != 0); HTreeMap.LinkedNode n = (HTreeMap.LinkedNode) recman.recordGet(recid, m.LN_SERIALIZER); assertNotNull(n); assertEquals(i, n.key); assertEquals(i, n.value); recid = n.next; } }