Refine search
public void testCreate_map() { Map<String, Long> in = ImmutableMap.of("1", 1L, "2", 2L, "3", 3L); AtomicLongMap<String> map = AtomicLongMap.create(in); assertFalse(map.isEmpty()); assertSame(3, map.size()); assertTrue(map.containsKey("1")); assertTrue(map.containsKey("2")); assertTrue(map.containsKey("3")); assertEquals(1L, map.get("1")); assertEquals(2L, map.get("2")); assertEquals(3L, map.get("3")); }
/** * Decrements by one the value currently associated with {@code key}, and returns the new value. */ @CanIgnoreReturnValue public long decrementAndGet(K key) { return addAndGet(key, -1); }
/** * Increments by one the value currently associated with {@code key}, and returns the old value. */ @CanIgnoreReturnValue public long getAndIncrement(K key) { return getAndAdd(key, 1); }
public void testPutIfAbsent_zero() { AtomicLongMap<String> map = AtomicLongMap.create(); String key = "key"; long value = random.nextInt(MAX_ADDEND); assertEquals(0L, map.get(key)); assertFalse(map.containsKey(key)); assertEquals(0L, map.putIfAbsent(key, value)); assertEquals(value, map.get(key)); assertEquals(value, map.put(key, 0L)); assertEquals(0L, map.get(key)); assertTrue(map.containsKey(key)); assertEquals(0L, map.putIfAbsent(key, value)); assertEquals(value, map.get(key)); }
@CanIgnoreReturnValue public long put(K key, long newValue) { outer: AtomicLong atomic = map.get(key); if (atomic == null) { atomic = map.putIfAbsent(key, new AtomicLong(newValue)); if (atomic == null) { return 0L;
switch (behavior) { case 0: map.incrementAndGet(key); threadSum++; break; case 1: map.decrementAndGet(key); threadSum--; break; case 2: map.addAndGet(key, delta); threadSum += delta; break; case 3: map.getAndIncrement(key); threadSum++; break; case 4: map.getAndDecrement(key); threadSum--; break; case 5: map.getAndAdd(key, delta); threadSum += delta; break; case 6: long oldValue = map.put(key, delta); threadSum += delta - oldValue; break;
public void testAddAndGet_zero() { AtomicLongMap<String> map = AtomicLongMap.create(); String key = "key"; long value = random.nextInt(MAX_ADDEND); assertEquals(0L, map.get(key)); assertFalse(map.containsKey(key)); assertEquals(value, map.addAndGet(key, value)); assertEquals(value, map.get(key)); assertEquals(0L, map.addAndGet(key, -1 * value)); assertEquals(0L, map.get(key)); assertTrue(map.containsKey(key)); assertEquals(value, map.addAndGet(key, value)); assertEquals(value, map.get(key)); }
public void testRemoveZeros() { AtomicLongMap<Object> map = AtomicLongMap.create(); Set<Object> nonZeroKeys = Sets.newHashSet(); for (int i = 0; i < ITERATIONS; i++) { Object key = new Object(); long value = i % 2; map.put(key, value); if (value != 0L) { nonZeroKeys.add(key); } } assertEquals(ITERATIONS, map.size()); assertTrue(map.asMap().containsValue(0L)); map.removeAllZeros(); assertFalse(map.asMap().containsValue(0L)); assertEquals(ITERATIONS / 2, map.size()); assertEquals(nonZeroKeys, map.asMap().keySet()); }
public void testGetAndAdd_zero() { AtomicLongMap<String> map = AtomicLongMap.create(); String key = "key"; long value = random.nextInt(MAX_ADDEND); assertEquals(0L, map.get(key)); assertFalse(map.containsKey(key)); assertEquals(0L, map.getAndAdd(key, value)); assertEquals(value, map.get(key)); assertEquals(value, map.getAndAdd(key, -1 * value)); assertEquals(0L, map.get(key)); assertTrue(map.containsKey(key)); assertEquals(0L, map.getAndAdd(key, value)); assertEquals(value, map.get(key)); }
public void testGetAndIncrement_zero() { AtomicLongMap<String> map = AtomicLongMap.create(); String key = "key"; assertEquals(0L, map.get(key)); assertFalse(map.containsKey(key)); assertEquals(0L, map.getAndIncrement(key)); assertEquals(1L, map.get(key)); assertEquals(1L, map.getAndDecrement(key)); assertEquals(0L, map.get(key)); assertTrue(map.containsKey(key)); assertEquals(0L, map.getAndIncrement(key)); assertEquals(1L, map.get(key)); }
public void testIncrementAndGet_zero() { AtomicLongMap<String> map = AtomicLongMap.create(); String key = "key"; assertEquals(0L, map.get(key)); assertFalse(map.containsKey(key)); assertEquals(1L, map.incrementAndGet(key)); assertEquals(1L, map.get(key)); assertEquals(0L, map.decrementAndGet(key)); assertEquals(0L, map.get(key)); assertTrue(map.containsKey(key)); assertEquals(1L, map.incrementAndGet(key)); assertEquals(1L, map.get(key)); }
public void testReplace_zero() { AtomicLongMap<String> map = AtomicLongMap.create(); String key = "key"; long value = random.nextInt(MAX_ADDEND); assertEquals(0L, map.get(key)); assertFalse(map.containsKey(key)); assertTrue(map.replace(key, 0L, value)); assertEquals(value, map.get(key)); assertTrue(map.replace(key, value, 0L)); assertEquals(0L, map.get(key)); assertTrue(map.containsKey(key)); assertTrue(map.replace(key, 0L, value)); assertEquals(value, map.get(key)); }
/** Returns a live, read-only view of the map backing this {@code AtomicLongMap}. */ public Map<K, Long> asMap() { Map<K, Long> result = asMap; return (result == null) ? asMap = createAsMap() : result; }
/** Creates an {@code AtomicLongMap}. */ public static <K> AtomicLongMap<K> create() { return new AtomicLongMap<K>(new ConcurrentHashMap<>()); }
public void testConsistentHash_probabilities() { AtomicLongMap<Integer> map = AtomicLongMap.create(); Random r = new Random(9); for (int i = 0; i < ITERS; i++) { countRemaps(r.nextLong(), map); } for (int shard = 2; shard <= MAX_SHARDS; shard++) { // Rough: don't exceed 1.2x the expected number of remaps by more than 20 assertTrue(map.get(shard) <= 1.2 * ITERS / shard + 20); } }