Refine search
public void testParse_accessExpirationHours() { CacheBuilderSpec spec = parse("expireAfterAccess=150h"); assertEquals(TimeUnit.HOURS, spec.accessExpirationTimeUnit); assertEquals(150L, spec.accessExpirationDuration); assertCacheBuilderEquivalence( CacheBuilder.newBuilder().expireAfterAccess(150L, TimeUnit.HOURS), CacheBuilder.from(spec)); }
@Override public void serialize(CacheBuilderSpec value, JsonGenerator gen, SerializerProvider serializers) throws IOException { gen.writeString(value.toParsableString()); } }
/** * Creates a CacheBuilderSpec from a string. * * @param cacheBuilderSpecification the string form */ public static CacheBuilderSpec parse(String cacheBuilderSpecification) { CacheBuilderSpec spec = new CacheBuilderSpec(cacheBuilderSpecification); if (!cacheBuilderSpecification.isEmpty()) { for (String keyValuePair : KEYS_SPLITTER.split(cacheBuilderSpecification)) { List<String> keyAndValue = ImmutableList.copyOf(KEY_VALUE_SPLITTER.split(keyValuePair)); checkArgument(!keyAndValue.isEmpty(), "blank key-value pair"); checkArgument( keyAndValue.size() <= 2, "key-value pair %s with more than one equals sign", keyValuePair); // Find the ValueParser for the current key. String key = keyAndValue.get(0); ValueParser valueParser = VALUE_PARSERS.get(key); checkArgument(valueParser != null, "unknown key %s", key); String value = keyAndValue.size() == 1 ? null : keyAndValue.get(1); valueParser.parse(spec, key, value); } } return spec; }
@Override public CacheBuilderSpec deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException { final String text = jp.getText(); if ("off".equalsIgnoreCase(text) || "disabled".equalsIgnoreCase(text)) { return CacheBuilderSpec.disableCaching(); } return CacheBuilderSpec.parse(text); } }
/** * Create a new schema loader with a given loading configuration * * @param cfg the configuration * @see LoadingConfiguration * @see LoadingConfigurationBuilder */ public SchemaLoader(final LoadingConfiguration cfg) { translator = new URITranslator(cfg.getTranslatorConfiguration()); dereferencing = cfg.getDereferencing(); manager = new URIManager(cfg); preloadedSchemas = ImmutableMap.copyOf(cfg.getPreloadedSchemas()); final CacheBuilder<Object, Object> cacheBuilder = cfg.getEnableCache() ? CacheBuilder.newBuilder() : CacheBuilder.from(CacheBuilderSpec.disableCaching()); cache = cacheBuilder.build(new CacheLoader<URI, JsonNode>() { @Nonnull @Override public JsonNode load(@Nonnull final URI key) throws ProcessingException { return manager.getContent(key); } }); }
public void testParse_maximumSize() { CacheBuilderSpec spec = parse("maximumSize=9000"); assertNull(spec.initialCapacity); assertEquals(9000, spec.maximumSize.longValue()); assertNull(spec.concurrencyLevel); assertNull(spec.keyStrength); assertNull(spec.valueStrength); assertNull(spec.writeExpirationTimeUnit); assertNull(spec.accessExpirationTimeUnit); assertCacheBuilderEquivalence( CacheBuilder.newBuilder().maximumSize(9000), CacheBuilder.from(spec)); }
public void testDisableCaching() { // Functional test: assert that CacheBuilderSpec.disableCaching() // disables caching. It's irrelevant how it does so. CacheBuilder<Object, Object> builder = CacheBuilder.from(CacheBuilderSpec.disableCaching()); Object key = new Object(); Object value = new Object(); LoadingCache<Object, Object> cache = builder.build(CacheLoader.from(Suppliers.ofInstance(value))); assertSame(value, cache.getUnchecked(key)); assertEquals(0, cache.size()); assertFalse(cache.asMap().containsKey(key)); }
public void testParse_recordStats() { CacheBuilderSpec spec = parse("recordStats"); assertTrue(spec.recordStats); assertCacheBuilderEquivalence(CacheBuilder.newBuilder().recordStats(), CacheBuilder.from(spec)); }
public void testParse_concurrencyLevel() { CacheBuilderSpec spec = parse("concurrencyLevel=32"); assertNull(spec.initialCapacity); assertNull(spec.maximumSize); assertNull(spec.maximumWeight); assertEquals(32, spec.concurrencyLevel.intValue()); assertNull(spec.keyStrength); assertNull(spec.valueStrength); assertNull(spec.writeExpirationTimeUnit); assertNull(spec.accessExpirationTimeUnit); assertCacheBuilderEquivalence( CacheBuilder.newBuilder().concurrencyLevel(32), CacheBuilder.from(spec)); }
public void testParse_initialCapacity() { CacheBuilderSpec spec = parse("initialCapacity=10"); assertEquals(10, spec.initialCapacity.intValue()); assertNull(spec.maximumSize); assertNull(spec.maximumWeight); assertNull(spec.concurrencyLevel); assertNull(spec.keyStrength); assertNull(spec.valueStrength); assertNull(spec.writeExpirationTimeUnit); assertNull(spec.accessExpirationTimeUnit); assertCacheBuilderEquivalence( CacheBuilder.newBuilder().initialCapacity(10), CacheBuilder.from(spec)); }
public void testParse_maximumWeight() { CacheBuilderSpec spec = parse("maximumWeight=9000"); assertNull(spec.initialCapacity); assertEquals(9000, spec.maximumWeight.longValue()); assertNull(spec.concurrencyLevel); assertNull(spec.keyStrength); assertNull(spec.valueStrength); assertNull(spec.writeExpirationTimeUnit); assertNull(spec.accessExpirationTimeUnit); assertCacheBuilderEquivalence( CacheBuilder.newBuilder().maximumWeight(9000), CacheBuilder.from(spec)); }
public void testParse_softValues() { CacheBuilderSpec spec = parse("softValues"); assertNull(spec.initialCapacity); assertNull(spec.maximumSize); assertNull(spec.maximumWeight); assertNull(spec.concurrencyLevel); assertNull(spec.keyStrength); assertEquals(Strength.SOFT, spec.valueStrength); assertNull(spec.writeExpirationTimeUnit); assertNull(spec.accessExpirationTimeUnit); assertCacheBuilderEquivalence(CacheBuilder.newBuilder().softValues(), CacheBuilder.from(spec)); }
public void testParse_weakKeys() { CacheBuilderSpec spec = parse("weakKeys"); assertNull(spec.initialCapacity); assertNull(spec.maximumSize); assertNull(spec.maximumWeight); assertNull(spec.concurrencyLevel); assertEquals(Strength.WEAK, spec.keyStrength); assertNull(spec.valueStrength); assertNull(spec.writeExpirationTimeUnit); assertNull(spec.accessExpirationTimeUnit); assertCacheBuilderEquivalence(CacheBuilder.newBuilder().weakKeys(), CacheBuilder.from(spec)); }
public void testParse_weakValues() { CacheBuilderSpec spec = parse("weakValues"); assertNull(spec.initialCapacity); assertNull(spec.maximumSize); assertNull(spec.maximumWeight); assertNull(spec.concurrencyLevel); assertNull(spec.keyStrength); assertEquals(Strength.WEAK, spec.valueStrength); assertNull(spec.writeExpirationTimeUnit); assertNull(spec.accessExpirationTimeUnit); assertCacheBuilderEquivalence(CacheBuilder.newBuilder().weakValues(), CacheBuilder.from(spec)); }
public void testParse_empty() { CacheBuilderSpec spec = parse(""); assertNull(spec.initialCapacity); assertNull(spec.maximumSize); assertNull(spec.maximumWeight); assertNull(spec.concurrencyLevel); assertNull(spec.keyStrength); assertNull(spec.valueStrength); assertNull(spec.writeExpirationTimeUnit); assertNull(spec.accessExpirationTimeUnit); assertCacheBuilderEquivalence(CacheBuilder.newBuilder(), CacheBuilder.from(spec)); }
/** * Constructs a new {@code CacheBuilder} instance with the settings specified in {@code spec}. * This is especially useful for command-line configuration of a {@code CacheBuilder}. * * @param spec a String in the format specified by {@link CacheBuilderSpec} * @since 12.0 */ @GwtIncompatible // To be supported public static CacheBuilder<Object, Object> from(String spec) { return from(CacheBuilderSpec.parse(spec)); }
/** * Constructs a new {@code CacheBuilder} instance with the settings specified in {@code spec}. * * @since 12.0 */ @GwtIncompatible // To be supported public static CacheBuilder<Object, Object> from(CacheBuilderSpec spec) { return spec.toCacheBuilder().lenientParsing(); }
public void testParse_maximumSizeRepeated() { try { parse("maximumSize=10, maximumSize=20"); fail("Expected exception"); } catch (IllegalArgumentException expected) { } }