Java Code Examples for org.redisson.api.RSetCache#destroy()

@Test
public void testContains() throws InterruptedException {
    RSetCache<TestObject> set = redisson.getSetCache("set");

    set.add(new TestObject("1", "2"));
    set.add(new TestObject("1", "2"));
    set.add(new TestObject("2", "3"), 1, TimeUnit.SECONDS);
    set.add(new TestObject("3", "4"));
    set.add(new TestObject("5", "6"));

    Thread.sleep(1000);

    Assert.assertFalse(set.contains(new TestObject("2", "3")));
    Assert.assertTrue(set.contains(new TestObject("1", "2")));
    Assert.assertFalse(set.contains(new TestObject("1", "9")));
    set.destroy();
}
 

@Test
public void testRemove() throws InterruptedException, ExecutionException {
    RSetCache<Integer> set = redisson.getSetCache("simple");
    set.add(1, 1, TimeUnit.SECONDS);
    set.add(3, 2, TimeUnit.SECONDS);
    set.add(7, 3, TimeUnit.SECONDS);

    Assert.assertTrue(set.remove(1));
    Assert.assertFalse(set.contains(1));
    assertThat(set).containsOnly(3, 7);

    Assert.assertFalse(set.remove(1));
    assertThat(set).containsOnly(3, 7);

    Assert.assertTrue(set.remove(3));
    Assert.assertFalse(set.contains(3));
    assertThat(set).containsOnly(7);
    Assert.assertEquals(1, set.size());
    set.destroy();
}
 

@Test
public void testAddExpireThenAdd() throws InterruptedException, ExecutionException {
    RSetCache<String> set = redisson.getSetCache("simple31");
    assertThat(set.add("123", 500, TimeUnit.MILLISECONDS)).isTrue();
    
    Thread.sleep(500);

    assertThat(set.size()).isEqualTo(1);
    assertThat(set.contains("123")).isFalse();

    assertThat(set.add("123")).isTrue();
    Thread.sleep(1000);

    assertThat(set.contains("123")).isTrue();
    set.destroy();
}
 

@Test
public void testReadAll() {
    RSetCache<Integer> set = redisson.getSetCache("set");
    set.add(1, 2, TimeUnit.MINUTES);
    set.add(2);
    set.add(3);
    set.add(4);
    set.add(5);

    assertThat(set.readAll()).containsOnly(1, 2, 3, 4, 5);
    set.destroy();
}
 

@Test
public void testDuplicates() {
    RSetCache<TestObject> set = redisson.getSetCache("set");

    set.add(new TestObject("1", "2"));
    set.add(new TestObject("1", "2"));
    set.add(new TestObject("2", "3"));
    set.add(new TestObject("3", "4"));
    set.add(new TestObject("5", "6"));

    Assert.assertEquals(4, set.size());
    set.destroy();
}
 

@Test
public void testExpiredIterator() throws InterruptedException {
    RSetCache<String> cache = redisson.getSetCache("simple");
    cache.add("0");
    cache.add("1", 1, TimeUnit.SECONDS);
    cache.add("2", 3, TimeUnit.SECONDS);
    cache.add("3", 4, TimeUnit.SECONDS);
    cache.add("4", 1, TimeUnit.SECONDS);

    Thread.sleep(1000);

    assertThat(cache).contains("0", "2", "3");
    cache.destroy();
}
 

@Test
public void testContainsAll() {
    RSetCache<Integer> set = redisson.getSetCache("set");
    for (int i = 0; i < 200; i++) {
        set.add(i);
    }

    Assert.assertTrue(set.containsAll(Collections.emptyList()));
    Assert.assertTrue(set.containsAll(Arrays.asList(30, 11)));
    Assert.assertFalse(set.containsAll(Arrays.asList(30, 711, 11)));
    set.destroy();
}
 

@Test
public void testReadAllExpired() throws InterruptedException {
    RSetCache<Integer> set = redisson.getSetCache("set");
    set.add(1, 1, TimeUnit.SECONDS);
    Thread.sleep(1005);
    assertThat(set.readAll()).isEmpty();
    set.destroy();
}
 

@Test
public void testIteratorSequence() {
    RSetCache<Long> set = redisson.getSetCache("set");
    for (int i = 0; i < 1000; i++) {
        set.add(Long.valueOf(i));
    }

    Set<Long> setCopy = new HashSet<Long>();
    for (int i = 0; i < 1000; i++) {
        setCopy.add(Long.valueOf(i));
    }

    checkIterator(set, setCopy);
    set.destroy();
}
 

@Test
public void testIteratorRemove() throws InterruptedException {
    RSetCache<String> set = redisson.getSetCache("list");
    set.add("1");
    set.add("4", 1, TimeUnit.SECONDS);
    set.add("2");
    set.add("5", 1, TimeUnit.SECONDS);
    set.add("3");

    Thread.sleep(1000);

    for (Iterator<String> iterator = set.iterator(); iterator.hasNext();) {
        String value = iterator.next();
        if (value.equals("2")) {
            iterator.remove();
        }
    }

    assertThat(set).contains("1", "3");

    int iteration = 0;
    for (Iterator<String> iterator = set.iterator(); iterator.hasNext();) {
        iterator.next();
        iterator.remove();
        iteration++;
    }

    Assert.assertEquals(2, iteration);

    Assert.assertFalse(set.contains("4"));
    Assert.assertFalse(set.contains("5"));
    set.destroy();
}
 

@Test
public void testDestroy() {
    RSetCache<String> cache = redisson.getSetCache("test");
    
    EvictionScheduler evictionScheduler = ((Redisson)redisson).getEvictionScheduler();
    Map<?, ?> map = Reflect.on(evictionScheduler).get("tasks");
    assertThat(map.isEmpty()).isFalse();
    cache.destroy();
    assertThat(map.isEmpty()).isTrue();
}
 

@Test
public void testClearExpire() throws InterruptedException {
    RSetCache<String> cache = redisson.getSetCache("simple");
    cache.add("8", 1, TimeUnit.SECONDS);

    cache.expireAt(System.currentTimeMillis() + 100);

    cache.clearExpire();

    Thread.sleep(500);

    Assert.assertEquals(1, cache.size());
    cache.destroy();
}
 

@Test
public void testSize() {
    RSetCache<Integer> set = redisson.getSetCache("set");
    set.add(1);
    set.add(2);
    set.add(3);
    set.add(3);
    set.add(4);
    set.add(5);
    set.add(5);

    Assert.assertEquals(5, set.size());
    set.destroy();
}
 

@Test
public void testAddExpire() throws InterruptedException, ExecutionException {
    RSetCache<String> set = redisson.getSetCache("simple3");
    assertThat(set.add("123", 500, TimeUnit.MILLISECONDS)).isTrue();
    assertThat(set).contains("123");

    Thread.sleep(500);
    
    assertThat(set.size()).isEqualTo(1);
    assertThat(set).doesNotContain("123");
    
    assertThat(set.add("123", 1, TimeUnit.SECONDS)).isTrue();
    set.destroy();

}
 

@Test
public void testAddBean() throws InterruptedException, ExecutionException {
    SimpleBean sb = new SimpleBean();
    sb.setLng(1L);
    RSetCache<SimpleBean> set = redisson.getSetCache("simple");
    assertThat(set.add(sb)).isTrue();
    Assert.assertEquals(sb.getLng(), set.iterator().next().getLng());
    set.destroy();
}
 

@Test
public void testRetainAllNoModify() {
    RSetCache<Integer> set = redisson.getSetCache("set");
    set.add(1);
    set.add(2);

    Assert.assertFalse(set.retainAll(Arrays.asList(1, 2))); // nothing changed
    assertThat(set).containsOnly(1, 2);
    set.destroy();
}
 

@Test
public void testDelete() {
    RSetCache<Integer> set = redisson.getSetCache("set");
    assertThat(set.delete()).isFalse();
    set.add(1, 1, TimeUnit.SECONDS);
    assertThat(set.delete()).isTrue();
    assertThat(set.delete()).isFalse();
    set.destroy();
}
 

@Test
public void testRemoveAll() {
    RSetCache<Integer> set = redisson.getSetCache("set");
    set.add(1);
    set.add(2, 10, TimeUnit.SECONDS);
    set.add(3);
    
    assertThat(set.removeAll(Arrays.asList(1, 3))).isTrue();
    assertThat(set.removeAll(Arrays.asList(1, 3))).isFalse();
    assertThat(set).containsOnly(2);
    set.destroy();
}
 

@Test
public void testEmptyReadAll() {
    RSetCache<Integer> set = redisson.getSetCache("set");
    assertThat(set.readAll()).isEmpty();
    set.destroy();
}
 

@Test
public void testScheduler() throws InterruptedException {
    RSetCache<String> cache = redisson.getSetCache("simple33");
    Assert.assertFalse(cache.contains("33"));

    Assert.assertTrue(cache.add("33", 5, TimeUnit.SECONDS));

    Thread.sleep(11000);

    Assert.assertEquals(0, cache.size());
    cache.destroy();

}