org.infinispan.container.versioning.NumericVersion.<init> java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 Charset c =String charsetName;Charset.forName(charsetName)
Charset.defaultCharset()
ContentType contentType;contentType.getCharset()
Smart code suggestions by Codota
}

@DataProvider(name = "sizeMatchData")
public Object[][] sizeMatchData() {
 return new Object[][] {
    { 10, 100, -1, -1, null },
    { 20, 313, -1, -1, null },
    { 10, 100, 4000, -1, null },
    { 20, 313, -1, 10000, null },
    { 10, 100, 4000, -1, new NumericVersion(1003)},
    { 20, 313, -1, 10000, new NumericVersion(81418) },
    { 10, 100, 4000, 738141, null},
    { 20, 313, 14141, 10000, new NumericVersion(8417) },
 };
}

@Override
public Void apply(ReadWriteEntryView<K, String> rw) {
  rw.set("one", new MetaEntryVersion(new NumericVersion(100)));
  return null;
}

@Test
public void testDuplicateParametersOnConstruction() {
 MetaEntryVersion versionParam1 = new MetaEntryVersion(new NumericVersion(100));
 MetaEntryVersion versionParam2 = new MetaEntryVersion(new NumericVersion(200));
 MetaParams metas = MetaParams.of(versionParam1, versionParam2);
 assertEquals(1, metas.size());
 assertEquals(Optional.of(new MetaEntryVersion(new NumericVersion(200))),
   metas.find(MetaEntryVersion.class));
}

@Override
public ReadWriteEntryView<K, String> apply(ReadWriteEntryView<K, String> rw) {
  Optional<MetaEntryVersion> metaParam = rw.findMetaParam(MetaEntryVersion.class);
  metaParam.ifPresent(metaVersion -> {
   if (metaVersion.get().compareTo(new NumericVersion(version)) == EQUAL)
     rw.set("uno", new MetaEntryVersion(new NumericVersion(200)));
  });
  return rw;
}

@Test
public void testDuplicateParametersOnAdd() {
 MetaEntryVersion versionParam1 = new MetaEntryVersion(new NumericVersion(100));
 MetaParams metas = MetaParams.of(versionParam1);
 assertEquals(1, metas.size());
 assertEquals(Optional.of(new MetaEntryVersion(new NumericVersion(100))),
   metas.find(MetaEntryVersion.class));
 MetaEntryVersion versionParam2 = new MetaEntryVersion(new NumericVersion(200));
 metas.add(versionParam2);
 assertEquals(1, metas.size());
 assertEquals(Optional.of(new MetaEntryVersion(new NumericVersion(200))),
   metas.find(MetaEntryVersion.class));
 MetaEntryVersion versionParam3 = new MetaEntryVersion(new NumericVersion(300));
 MetaEntryVersion versionParam4 = new MetaEntryVersion(new NumericVersion(400));
 metas.addMany(versionParam3, versionParam4);
 assertEquals(1, metas.size());
 assertEquals(Optional.of(new MetaEntryVersion(new NumericVersion(400))),
   metas.find(MetaEntryVersion.class));
}

public void testPrimaryOwnerChangingDuringReplaceBasedOnMeta() throws Exception {
 // TODO: Move initial set and replace with meta logic to TestWriteOperation
 WriteOnlyMap<String, String> wo0 = wo(0);
 wo0.eval("testkey", wo -> wo.set("v0", new MetaEntryVersion(new NumericVersion(1))));
 doTest(TestWriteOperation.REPLACE_META_FUNCTIONAL);
}

@Test
public void testAddFindMultipleMetaParams() {
 MetaParams metas = MetaParams.empty();
 metas.addMany(new MetaLifespan(1000), new MetaMaxIdle(1000), new MetaEntryVersion(new NumericVersion(12345)));
 assertFalse(metas.isEmpty());
 assertEquals(3, metas.size());
 Optional<MetaMaxIdle> maxIdle = metas.find(MetaMaxIdle.class);
 Optional<MetaEntryVersion> entryVersion = metas.find(MetaEntryVersion.class);
 assertEquals(Optional.of(new MetaMaxIdle(1000)), maxIdle);
 assertFalse(900 == maxIdle.get().get().longValue());
 assertEquals(new MetaEntryVersion(new NumericVersion(12345)), entryVersion.get());
 assertFalse(new MetaEntryVersion(new NumericVersion(23456)).equals(entryVersion.get()));
}

@Override
protected Object perform(TestWriteOperation op, AdvancedCache<Object, Object> cache0, String key) {
 try {
   return super.perform(op, cache0, key);
 } catch (IllegalArgumentException e) {
   switch (op) {
    case REPLACE_META_FUNCTIONAL:
      return FunctionalTestUtils.await(rw(cache0).eval(key, "v1", (v, rw) -> {
         return rw.findMetaParam(MetaEntryVersion.class)
          .filter(ver -> ver.get().compareTo(new NumericVersion(1)) == EQUAL)
          .map(ver -> {
            rw.set(v, new MetaEntryVersion(new NumericVersion(2)));
            return true;
          }).orElse(false);
       }));
    default:
      throw new AssertionError("Unknown operation: " + op);
   }
 }
}

public void testGenerateVersion() {
 NumericVersionGenerator vg = new NumericVersionGenerator().clustered(true);
 vg.resetCounter();
 TestAddress addr1 = new TestAddress(1);
 TestAddress addr2 = new TestAddress(2);
 TestAddress addr3 = new TestAddress(1);
 List<Address> members = Arrays.asList((Address)addr1, addr2, addr3);
 vg.calculateRank(addr2, members, 1);
 assertEquals(new NumericVersion(0x1000200000001L), vg.generateNew());
 assertEquals(new NumericVersion(0x1000200000002L), vg.generateNew());
 assertEquals(new NumericVersion(0x1000200000003L), vg.generateNew());
}

public void testConditionalReplaceWithVersion() {
 final Integer key = 2;
 NumericVersion version = new NumericVersion(1);
 advCache.put(key, "v1", withVersion(version));
 NumericVersion newVersion = new NumericVersion(2);
 advCache.replace(key, "v1", "v2", withVersion(newVersion));
 CacheEntry cacheEntry = advCache.getCacheEntry(key);
 assertEquals(EQUAL, newVersion.compareTo(cacheEntry.getMetadata().version()));
}

protected Object replaceIfUnmodified() {
 CacheEntry<byte[], byte[]> entry = cache.withFlags(Flag.SKIP_LISTENER_NOTIFICATION).getCacheEntry(key);
 if (entry != null) {
   byte[] prev = entry.getValue();
   NumericVersion streamVersion = new NumericVersion(params.streamVersion);
   if (entry.getMetadata().version().equals(streamVersion)) {
    byte[] v = createValue();
    // Generate new version only if key present and version has not changed, otherwise it's wasteful
    boolean replaced = cache.replace(key, prev, v, buildMetadata());
    if (replaced)
      return createSuccessResponse();
    else
      return createNotExecutedResponse();
   } else {
    return createNotExecutedResponse();
   }
 } else return createNotExistResponse();
}

public void testReplaceWithVersion() {
 final Integer key = 7;
 NumericVersion version = new NumericVersion(1);
 advCache.put(key, "v1", withVersion(version));
 NumericVersion newVersion = new NumericVersion(2);
 advCache.replace(key, "v2", withVersion(newVersion));
 CacheEntry cacheEntry = advCache.getCacheEntry(key);
 assertEquals(EQUAL, newVersion.compareTo(cacheEntry.getMetadata().version()));
}

@Test
public void testReplaceFindMultipleMetaParams() {
 MetaParams metas = MetaParams.empty();
 metas.addMany(new MetaLifespan(1000), new MetaMaxIdle(1000), new MetaEntryVersion(new NumericVersion(12345)));
 assertFalse(metas.isEmpty());
 assertEquals(3, metas.size());
 metas.addMany(new MetaLifespan(2000), new MetaMaxIdle(2000));
 assertFalse(metas.isEmpty());
 assertEquals(3, metas.size());
 assertEquals(Optional.of(new MetaMaxIdle(2000)), metas.find(MetaMaxIdle.class));
 assertEquals(Optional.of(new MetaLifespan(2000)), metas.find(MetaLifespan.class));
 assertEquals(Optional.of(new MetaEntryVersion(new NumericVersion(12345))),
   metas.find(MetaEntryVersion.class));
}

public void testPutForExternalReadWithVersion() {
 final Integer key = 11;
 NumericVersion version = new NumericVersion(1);
 advCache.putForExternalRead(key, "v1", withVersion(version));
 CacheEntry cacheEntry = advCache.getCacheEntry(key);
 assertEquals(version, cacheEntry.getMetadata().version());
}

public void testPutAsyncWithVersion() throws Exception {
 final Integer key = 4;
 NumericVersion version = new NumericVersion(1);
 Future<String> f = advCache.putAsync(key, "v1", withVersion(version));
 assertNotNull(f);
 assertFalse(f.isCancelled());
 assertNull(f.get());
 assertTrue(f.isDone());
 CacheEntry entry = advCache.getCacheEntry(key);
 assertEquals("v1", entry.getValue());
 assertEquals(EQUAL, version.compareTo(entry.getMetadata().version()));
}

public void testPutWithVersion() {
 final Integer key = 1;
 NumericVersion version = new NumericVersion(1);
 advCache.put(key, "v1", withVersion(version));
 CacheEntry cacheEntry = advCache.getCacheEntry(key);
 assertEquals(EQUAL, version.compareTo(cacheEntry.getMetadata().version()));
}

public void testPutForExternalReadInDecaratedCacheWithVersion() {
 final Integer key = 12;
 NumericVersion version = new NumericVersion(1);
 // Flag forces decorated cache, but doesn't affect processing
 AdvancedCache<Integer, String> decoratedCache = advCache.withFlags(Flag.SKIP_STATISTICS);
 decoratedCache.putForExternalRead(key, "v1", withVersion(version));
 CacheEntry cacheEntry = decoratedCache.getCacheEntry(key);
 assertEquals(version, cacheEntry.getMetadata().version());
}

public void testPutIfAbsentWithVersion() {
 final Integer key = 3;
 NumericVersion version = new NumericVersion(1);
 assertEquals(null, advCache.putIfAbsent(key, "v1", withVersion(version)));
 CacheEntry cacheEntry = advCache.getCacheEntry(key);
 assertEquals(EQUAL, version.compareTo(cacheEntry.getMetadata().version()));
}

public void testAllocatedAmountEqualWithVersionAndExpiration() {
 ConfigurationBuilder builder = new ConfigurationBuilder();
 builder.memory()
    .size(MemoryUnit.MEGABYTES.toBytes(20))
    .evictionType(EvictionType.MEMORY)
    .storageType(StorageType.OFF_HEAP);
 EmbeddedCacheManager manager = TestCacheManagerFactory.createCacheManager(builder);
 AdvancedCache<Object, Object> cache = manager.getCache().getAdvancedCache();
 cache.put("lifespan", 2, new EmbeddedMetadata.Builder()
    .lifespan(1, TimeUnit.MINUTES)
    .version(new NumericVersion(23)).build());
 cache.put("both", 2, new EmbeddedMetadata.Builder()
    .lifespan(1, TimeUnit.MINUTES)
    .maxIdle(1, TimeUnit.MINUTES)
    .version(new NumericVersion(23)).build());
 cache.put("maxidle", 2, new EmbeddedMetadata.Builder()
    .maxIdle(1, TimeUnit.MINUTES)
    .version(new NumericVersion(23)).build());
 OffHeapMemoryAllocator allocator = cache.getComponentRegistry().getComponent(
    OffHeapMemoryAllocator.class);
 BoundedOffHeapDataContainer container = (BoundedOffHeapDataContainer) getContainer(cache);
 assertEquals(allocator.getAllocatedAmount(), container.currentSize);
 cache.clear();
 assertEquals(allocator.getAllocatedAmount(), container.currentSize);
}

public void testAllocatedAmountEqualWithVersion() {
 ConfigurationBuilder builder = new ConfigurationBuilder();
 builder.memory()
    .size(MemoryUnit.MEGABYTES.toBytes(20))
    .evictionType(EvictionType.MEMORY)
    .storageType(StorageType.OFF_HEAP);
 EmbeddedCacheManager manager = TestCacheManagerFactory.createCacheManager(builder);
 AdvancedCache<Object, Object> cache = manager.getCache().getAdvancedCache();
 cache.put(1, 2, new EmbeddedMetadata.Builder().version(new NumericVersion(23)).build());
 OffHeapMemoryAllocator allocator = cache.getComponentRegistry().getComponent(
    OffHeapMemoryAllocator.class);
 BoundedOffHeapDataContainer container = (BoundedOffHeapDataContainer) getContainer(cache);
 assertEquals(allocator.getAllocatedAmount(), container.currentSize);
 cache.clear();
 assertEquals(allocator.getAllocatedAmount(), container.currentSize);
}

How to use org.infinispan.container.versioning.NumericVersionconstructor

Best Java code snippets using org.infinispan.container.versioning.NumericVersion.<init> (Showing top 20 results out of 315)

How to use
org.infinispan.container.versioning.NumericVersion
constructor