private Type getOnlyParameterType() { assertThat(method.getGenericParameterTypes()).hasLength(1); return method.getGenericParameterTypes()[0]; }
public void testComputeIfPresent() { cache.put(key, "1"); // simultaneous update for same key, expect count successful updates doParallelCacheOp( count, n -> { cache.asMap().computeIfPresent(key, (k, v) -> v + delimiter + n); }); assertEquals(1, cache.size()); assertThat(cache.getIfPresent(key).split(delimiter)).hasLength(count + 1); }
public void testStaticMethod_typeParameters() throws Exception { Invokable<?, ?> delegate = Prepender.method("prepend", String.class, Iterable.class); TypeVariable<?>[] variables = delegate.getTypeParameters(); assertThat(variables).hasLength(1); assertEquals("T", variables[0].getName()); }
public void testNewArray_fromArray_OfArray() { String[][] array = ObjectArrays.newArray(new String[0][0], 1); assertEquals(String[][].class, array.getClass()); assertThat(array).hasLength(1); assertNull(array[0]); }
@GwtIncompatible // CacheTesting public void testSizingDefaults() { LoadingCache<?, ?> cache = CacheBuilder.newBuilder().build(identityLoader()); LocalCache<?, ?> map = CacheTesting.toLocalCache(cache); assertThat(map.segments).hasLength(4); // concurrency level assertEquals(4, map.segments[0].table.length()); // capacity / conc level }
public void testConstructor_typeParameters() throws Exception { TypeVariable<?>[] variables = Prepender.constructor().getTypeParameters(); assertThat(variables).hasLength(1); assertEquals("A", variables[0].getName()); }
public void testNewArray_fromArray_Nonempty() { String[] array = ObjectArrays.newArray(new String[0], 2); assertEquals(String[].class, array.getClass()); assertThat(array).hasLength(2); assertNull(array[0]); }
@GwtIncompatible // CacheTesting public void testConcurrencyLevel_small() { LoadingCache<?, ?> cache = CacheBuilder.newBuilder().concurrencyLevel(1).build(identityLoader()); LocalCache<?, ?> map = CacheTesting.toLocalCache(cache); assertThat(map.segments).hasLength(1); }
private static void checkConcurrencyLevel(int concurrencyLevel, int segmentCount) { LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder().concurrencyLevel(concurrencyLevel)); assertThat(map.segments).hasLength(segmentCount); }
private static void checkConcurrencyLevel(int concurrencyLevel, int segmentCount) { MapMakerInternalMap<Object, Object, ?, ?> map = makeMap(createMapMaker().concurrencyLevel(concurrencyLevel)); assertThat(map.segments).hasLength(segmentCount); }
@GwtIncompatible // ObjectArrays.newArray(Class, int) public void testNewArray_fromClass_OfArray() { String[][] array = ObjectArrays.newArray(String[].class, 1); assertEquals(String[][].class, array.getClass()); assertThat(array).hasLength(1); assertNull(array[0]); }
@GwtIncompatible // ObjectArrays.newArray(Class, int) public void testNewArray_fromClass_Nonempty() { String[] array = ObjectArrays.newArray(String.class, 2); assertEquals(String[].class, array.getClass()); assertThat(array).hasLength(2); assertNull(array[0]); }
public void testTrimToSize() { CompactHashMap<Integer, String> map = CompactHashMap.createWithExpectedSize(100); for (int i = 0; i < 10; i++) { map.put(i, Integer.toString(i)); } map.trimToSize(); assertThat(map.entries).hasLength(10); assertThat(map.keys).hasLength(10); assertThat(map.values).hasLength(10); assertEquals(10, map.size()); for (int i = 0; i < 10; i++) { assertEquals(Integer.toString(i), map.get(i)); } }
@GwtIncompatible // CacheTesting public void testInitialCapacity_small() { LoadingCache<?, ?> cache = CacheBuilder.newBuilder().initialCapacity(5).build(identityLoader()); LocalCache<?, ?> map = CacheTesting.toLocalCache(cache); assertThat(map.segments).hasLength(4); assertEquals(2, map.segments[0].table.length()); assertEquals(2, map.segments[1].table.length()); assertEquals(2, map.segments[2].table.length()); assertEquals(2, map.segments[3].table.length()); }
@GwtIncompatible // CacheTesting public void testInitialCapacity_smallest() { LoadingCache<?, ?> cache = CacheBuilder.newBuilder().initialCapacity(0).build(identityLoader()); LocalCache<?, ?> map = CacheTesting.toLocalCache(cache); assertThat(map.segments).hasLength(4); // 1 is as low as it goes, not 0. it feels dirty to know this/test this. assertEquals(1, map.segments[0].table.length()); assertEquals(1, map.segments[1].table.length()); assertEquals(1, map.segments[2].table.length()); assertEquals(1, map.segments[3].table.length()); }
public void testConstructor_returnType_hasTypeParameter() throws Exception { @SuppressWarnings("rawtypes") // Foo.class for Foo<T> is always raw type Class<WithConstructorAndTypeParameter> type = WithConstructorAndTypeParameter.class; @SuppressWarnings("rawtypes") // Foo.class Constructor<WithConstructorAndTypeParameter> constructor = type.getDeclaredConstructor(); Invokable<?, ?> factory = Invokable.from(constructor); assertThat(factory.getTypeParameters()).hasLength(2); assertEquals(type.getTypeParameters()[0], factory.getTypeParameters()[0]); assertEquals(constructor.getTypeParameters()[0], factory.getTypeParameters()[1]); ParameterizedType returnType = (ParameterizedType) factory.getReturnType().getType(); assertEquals(type, returnType.getRawType()); assertEquals( ImmutableList.copyOf(type.getTypeParameters()), ImmutableList.copyOf(returnType.getActualTypeArguments())); }
public void testTrimToSize() { CompactLinkedHashMap<Integer, String> map = CompactLinkedHashMap.createWithExpectedSize(100); map.put(1, "a"); map.put(4, "b"); map.put(3, "d"); map.put(2, "c"); map.trimToSize(); assertThat(map.entries).hasLength(4); assertThat(map.keys).hasLength(4); assertThat(map.values).hasLength(4); assertThat(map.links).hasLength(4); assertEquals(4, map.size()); testHasMapEntriesInOrder(map, 1, "a", 4, "b", 3, "d", 2, "c"); }
/** * This test will fail whenever someone updates/reorders the BloomFilterStrategies constants. Only * appending a new constant is allowed. */ public void testBloomFilterStrategies() { assertThat(BloomFilterStrategies.values()).hasLength(2); assertEquals(BloomFilterStrategies.MURMUR128_MITZ_32, BloomFilterStrategies.values()[0]); assertEquals(BloomFilterStrategies.MURMUR128_MITZ_64, BloomFilterStrategies.values()[1]); }
@GwtIncompatible // ArrayTable.toArray(Class) public void testToArray() { ArrayTable<String, Integer, Character> table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c'); Character[][] array = table.toArray(Character.class); assertThat(array).hasLength(3); assertThat(array[0]).asList().containsExactly('a', null, 'c').inOrder(); assertThat(array[1]).asList().containsExactly('b', null, null).inOrder(); assertThat(array[2]).asList().containsExactly(null, null, null).inOrder(); table.set(0, 2, 'd'); assertEquals((Character) 'c', array[0][2]); array[0][2] = 'e'; assertEquals((Character) 'd', table.at(0, 2)); }
public void testDefaults() { MapMakerInternalMap<Object, Object, ?, ?> map = makeMap(createMapMaker()); assertSame(Strength.STRONG, map.keyStrength()); assertSame(Strength.STRONG, map.valueStrength()); assertSame(map.keyStrength().defaultEquivalence(), map.keyEquivalence); assertSame(map.valueStrength().defaultEquivalence(), map.valueEquivalence()); assertThat(map.entryHelper) .isInstanceOf(MapMakerInternalMap.StrongKeyStrongValueEntry.Helper.class); assertEquals(4, map.concurrencyLevel); // concurrency level assertThat(map.segments).hasLength(4); // initial capacity / concurrency level assertEquals(16 / map.segments.length, map.segments[0].table.length()); }