Examples with Entry org.apache.geode.cache.Region.Entry used on opensource projects

Example 21 with Entry

use of org.apache.geode.cache.Region.Entry in project geode by apache.

the class RegionTestCase method testInvalidateRegion.

/**
   * Tests invalidating an entire region
   */
@Test
public void testInvalidateRegion() throws CacheException {
    String name = this.getUniqueName();
    Region region = createRegion(name);
    region.put("A", "a");
    region.put("B", "b");
    region.put("C", "c");
    for (int i = 0; i < 50; i++) {
        region.put("Key=" + i, "Value-" + i);
    }
    region.invalidateRegion();
    Region.Entry entry;
    entry = region.getEntry("A");
    assertNotNull(entry);
    assertNull(entry.getValue());
    entry = region.getEntry("B");
    assertNotNull(entry);
    assertNull(entry.getValue());
    entry = region.getEntry("C");
    assertNotNull(entry);
    assertNull(entry.getValue());
    for (int i = 0; i < 50; i++) {
        String key = "Key=" + i;
        assertFalse("containsValueForKey returned true for key " + key, region.containsValueForKey(key));
        assertTrue("containsKey returned false for key " + key, region.containsKey(key));
    }
}

Example 22 with Entry

use of org.apache.geode.cache.Region.Entry in project geode by apache.

the class RegionTestCase method testEntriesRecursive.

/**
   * Tests the {@link Region#entrySet} method with recursion
   */
@Test
public void testEntriesRecursive() throws CacheException {
    if (!supportsSubregions()) {
        return;
    }
    String name = this.getUniqueName();
    Region region = createRegion(name);
    region.put("A", "a");
    region.put("B", "b");
    region.put("C", "c");
    Region sub = region.createSubregion("SUB", region.getAttributes());
    sub.put("D", "d");
    sub.put("E", "e");
    sub.put("F", "f");
    {
        Set entries = region.entrySet(true);
        assertEquals(6, entries.size());
        Set keys = new HashSet(Arrays.asList(new String[] { "A", "B", "C", "D", "E", "F" }));
        Iterator iter = entries.iterator();
        for (int i = 0; i < 6; i++) {
            assertTrue("!hasNext, i=" + i, iter.hasNext());
            assertTrue("remove returned false, i=" + i, keys.remove(((Region.Entry) iter.next()).getKey()));
        }
        assertFalse(iter.hasNext());
    }
    {
        Set entries = getRootRegion().entrySet(true);
        assertEquals(6, entries.size());
        Set keys = new HashSet(Arrays.asList(new String[] { "A", "B", "C", "D", "E", "F" }));
        Iterator iter = entries.iterator();
        for (int i = 0; i < 6; i++) {
            assertTrue("!hasNext, i=" + i, iter.hasNext());
            assertTrue("remove returned false, i=" + i, keys.remove(((Region.Entry) iter.next()).getKey()));
        }
        assertFalse(iter.hasNext());
    }
    {
        Iterator iter = region.entrySet(true).iterator();
        Region.Entry entry = (Region.Entry) iter.next();
        Object ekey = entry.getKey();
        region.destroy(ekey);
        assertEquals(false, region.containsKey(ekey));
        assertTrue(entry.isDestroyed());
    }
}

Example 23 with Entry

use of org.apache.geode.cache.Region.Entry in project geode by apache.

the class PRTransactionDUnitTest method validatePRTXInCacheListener.

/**
   * verify that 10 orders are created for each customer
   * 
   * @throws ClassNotFoundException
   */
public static void validatePRTXInCacheListener() throws ClassNotFoundException {
    PartitionedRegion customerPartitionedregion = null;
    PartitionedRegion orderPartitionedregion = null;
    try {
        customerPartitionedregion = (PartitionedRegion) basicGetCache().getRegion(Region.SEPARATOR + CustomerPartitionedRegionName);
        orderPartitionedregion = (PartitionedRegion) basicGetCache().getRegion(Region.SEPARATOR + OrderPartitionedRegionName);
    } catch (Exception e) {
        Assert.fail("validateAfterPutPartitionedRegion : failed while getting the region", e);
    }
    assertNotNull(customerPartitionedregion);
    assertNotNull(orderPartitionedregion);
    customerPartitionedregion.getDataStore().dumpEntries(false);
    orderPartitionedregion.getDataStore().dumpEntries(false);
    Iterator custIterator = customerPartitionedregion.getDataStore().getEntries().iterator();
    LogWriterUtils.getLogWriter().info("Found " + customerPartitionedregion.getDataStore().getEntries().size() + " Customer entries in the partition");
    Region.Entry custEntry = null;
    while (custIterator.hasNext()) {
        custEntry = (Entry) custIterator.next();
        CustId custid = (CustId) custEntry.getKey();
        Customer cust = (Customer) custEntry.getValue();
        Iterator orderIterator = orderPartitionedregion.getDataStore().getEntries().iterator();
        LogWriterUtils.getLogWriter().info("Found " + orderPartitionedregion.getDataStore().getEntries().size() + " Order entries in the partition");
        int orderPerCustomer = 0;
        Region.Entry orderEntry = null;
        while (orderIterator.hasNext()) {
            orderEntry = (Entry) orderIterator.next();
            OrderId orderId = (OrderId) orderEntry.getKey();
            Order order = (Order) orderEntry.getValue();
            if (custid.equals(orderId.getCustId())) {
                orderPerCustomer++;
            }
        }
        assertEquals(10, orderPerCustomer);
    }
}

Example 24 with Entry

use of org.apache.geode.cache.Region.Entry in project geode by apache.

the class PutAllCSDUnitTest method testPRServer.

/**
   * Tests putAll to 2 PR servers.
   */
@Test
public void testPRServer() throws CacheException, InterruptedException {
    final String title = "testPRServer:";
    final Host host = Host.getHost(0);
    VM server1 = host.getVM(0);
    VM server2 = host.getVM(1);
    VM client1 = host.getVM(2);
    VM client2 = host.getVM(3);
    final String regionName = getUniqueName();
    final String serverHost = NetworkUtils.getServerHostName(server1.getHost());
    // set <true, false> means <PR=true, notifyBySubscription=false> to test local-invalidates
    final int serverPort1 = createBridgeServer(server1, regionName, 0, true, 1, null);
    final int serverPort2 = createBridgeServer(server2, regionName, 0, true, 1, null);
    createBridgeClient(client1, regionName, serverHost, new int[] { serverPort1 }, -1, 59000, false);
    createBridgeClient(client2, regionName, serverHost, new int[] { serverPort2 }, -1, 59000, false);
    client2.invoke(new CacheSerializableRunnable(title + "client2 add listener") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            region.getAttributesMutator().addCacheListener(new MyListener(false));
        }
    });
    client1.invoke(new CacheSerializableRunnable(title + "client1 add listener and putAll") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            region.getAttributesMutator().addCacheListener(new MyListener(false));
            doPutAll(regionName, "key-", numberOfEntries);
            assertEquals(numberOfEntries, region.size());
            for (int i = 0; i < numberOfEntries; i++) {
                TestObject obj = (TestObject) region.getEntry("key-" + i).getValue();
                assertEquals(i, obj.getPrice());
            }
        }
    });
    // verify bridge server 1, its data are from client
    server1.invoke(new CacheSerializableRunnable(title + "verify Bridge Server 1") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            region.getAttributesMutator().setCacheWriter(new MyWriter("key-"));
            assertEquals(numberOfEntries, region.size());
            for (int i = 0; i < numberOfEntries; i++) {
                TestObject obj = (TestObject) region.getEntry("key-" + i).getValue();
                assertEquals(i, obj.getPrice());
            }
        }
    });
    // verify bridge server 2, because its data are from distribution
    server2.invoke(new CacheSerializableRunnable(title + "verify Bridge Server 2") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            region.getAttributesMutator().setCacheWriter(new MyWriter("key-"));
            assertEquals(numberOfEntries, region.size());
            for (int i = 0; i < numberOfEntries; i++) {
                TestObject obj = (TestObject) region.getEntry("key-" + i).getValue();
                assertEquals(i, obj.getPrice());
            }
        }
    });
    client2.invoke(new CacheSerializableRunnable(title + "verify client2") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            checkRegionSize(region, numberOfEntries);
            for (int i = 0; i < numberOfEntries; i++) {
                Region.Entry re = region.getEntry("key-" + i);
                assertNotNull(re);
                assertEquals(null, re.getValue());
            }
        }
    });
    client1.invoke(new CacheSerializableRunnable(title + "client1 removeAll") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            doRemoveAll(regionName, "key-", numberOfEntries);
            assertEquals(0, region.size());
        }
    });
    // verify bridge server 1, its data are from client
    server1.invoke(new CacheSerializableRunnable(title + "verify removeAll Bridge Server 1") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            assertEquals(0, region.size());
            MyWriter mywriter = (MyWriter) region.getAttributes().getCacheWriter();
            LogWriterUtils.getLogWriter().info("server cachewriter triggered for destroy: " + mywriter.num_destroyed);
            // beforeDestroys are only triggered at primary buckets. server1 and server2 each holds half
            // of buckets
            assertEquals(numberOfEntries / 2, mywriter.num_destroyed);
        }
    });
    // verify bridge server 2, because its data are from distribution
    server2.invoke(new CacheSerializableRunnable(title + "verify removeAll Bridge Server 2") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            assertEquals(0, region.size());
            MyWriter mywriter = (MyWriter) region.getAttributes().getCacheWriter();
            LogWriterUtils.getLogWriter().info("server cachewriter triggered for destroy: " + mywriter.num_destroyed);
            // beforeDestroys are only triggered at primary buckets. server1 and server2 each holds half
            // of buckets
            assertEquals(numberOfEntries / 2, mywriter.num_destroyed);
        }
    });
    client2.invoke(new CacheSerializableRunnable(title + "client2 verify removeAll") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            checkRegionSize(region, 0);
        }
    });
    // Execute client putAll from multithread client
    {
        AsyncInvocation async1 = client1.invokeAsync(new CacheSerializableRunnable(title + "async putAll1 from client1") {

            @Override
            public void run2() throws CacheException {
                doPutAll(regionName, "async1key-", numberOfEntries);
            }
        });
        AsyncInvocation async2 = client1.invokeAsync(new CacheSerializableRunnable(title + "async putAll2 from client1") {

            @Override
            public void run2() throws CacheException {
                doPutAll(regionName, "async2key-", numberOfEntries);
            }
        });
        ThreadUtils.join(async1, 30 * 1000);
        ThreadUtils.join(async2, 30 * 1000);
    }
    client1.invoke(new CacheSerializableRunnable(title + "verify client 1 for async keys") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            assertEquals(numberOfEntries * 2, region.size());
            long ts1 = 0, ts2 = 0;
            for (int i = 0; i < numberOfEntries; i++) {
                TestObject obj = (TestObject) region.getEntry("async1key-" + i).getValue();
                assertEquals(i, obj.getPrice());
                assertTrue(obj.getTS() >= ts1);
                ts1 = obj.getTS();
                obj = (TestObject) region.getEntry("async2key-" + i).getValue();
                assertEquals(i, obj.getPrice());
                assertTrue(obj.getTS() >= ts2);
                ts2 = obj.getTS();
            }
        }
    });
    // verify bridge server 2 for asyn keys
    server2.invoke(new CacheSerializableRunnable(title + "verify Bridge Server 2 for async keys") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            long ts1 = 0, ts2 = 0;
            for (int i = 0; i < numberOfEntries; i++) {
                TestObject obj = (TestObject) region.getEntry("async1key-" + i).getValue();
                assertEquals(i, obj.getPrice());
                assertTrue(obj.getTS() >= ts1);
                ts1 = obj.getTS();
                obj = (TestObject) region.getEntry("async2key-" + i).getValue();
                assertEquals(i, obj.getPrice());
                assertTrue(obj.getTS() >= ts2);
                ts2 = obj.getTS();
            }
        }
    });
    client2.invoke(new CacheSerializableRunnable(title + "client2 verify async putAll") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            checkRegionSize(region, numberOfEntries * 2);
            for (int i = 0; i < numberOfEntries; i++) {
                Region.Entry re = region.getEntry("async1key-" + i);
                assertNotNull(re);
                assertEquals(null, re.getValue());
            }
            for (int i = 0; i < numberOfEntries; i++) {
                Region.Entry re = region.getEntry("async2key-" + i);
                assertNotNull(re);
                assertEquals(null, re.getValue());
            }
        }
    });
    {
        // Execute client removeAll from multithread client
        AsyncInvocation async1 = client1.invokeAsync(new CacheSerializableRunnable(title + "async putAll1 from client1") {

            @Override
            public void run2() throws CacheException {
                doRemoveAll(regionName, "async1key-", numberOfEntries);
            }
        });
        AsyncInvocation async2 = client1.invokeAsync(new CacheSerializableRunnable(title + "async putAll2 from client1") {

            @Override
            public void run2() throws CacheException {
                doRemoveAll(regionName, "async2key-", numberOfEntries);
            }
        });
        ThreadUtils.join(async1, 30 * 1000);
        ThreadUtils.join(async2, 30 * 1000);
    }
    client1.invoke(new CacheSerializableRunnable(title + "client1 removeAll") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            doRemoveAll(regionName, "key-", numberOfEntries);
            assertEquals(0, region.size());
        }
    });
    // verify bridge server 1, its data are from client
    server1.invoke(new CacheSerializableRunnable(title + "verify async removeAll Bridge Server 1") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            assertEquals(0, region.size());
        }
    });
    // verify bridge server 2, because its data are from distribution
    server2.invoke(new CacheSerializableRunnable(title + "verify async removeAll Bridge Server 2") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            assertEquals(0, region.size());
        }
    });
    client2.invoke(new CacheSerializableRunnable(title + "client2 verify async removeAll") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            checkRegionSize(region, 0);
        }
    });
    // Execute p2p putAll
    server1.invoke(new CacheSerializableRunnable(title + "server1 execute P2P putAll") {

        @Override
        public void run2() throws CacheException {
            doPutAll(regionName, "p2pkey-", numberOfEntries);
            Region region = getRootRegion().getSubregion(regionName);
            long ts1 = 0;
            for (int i = 0; i < numberOfEntries; i++) {
                TestObject obj = (TestObject) region.getEntry("p2pkey-" + i).getValue();
                assertEquals(i, obj.getPrice());
                assertTrue(obj.getTS() >= ts1);
                ts1 = obj.getTS();
            }
        }
    });
    // verify bridge server 2 for p2p keys
    server2.invoke(new CacheSerializableRunnable(title + "verify Bridge Server 2 for async keys") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            long ts1 = 0;
            for (int i = 0; i < numberOfEntries; i++) {
                TestObject obj = (TestObject) region.getEntry("p2pkey-" + i).getValue();
                assertEquals(i, obj.getPrice());
                assertTrue(obj.getTS() >= ts1);
                ts1 = obj.getTS();
            }
        }
    });
    client2.invoke(new CacheSerializableRunnable(title + "client2 verify p2p putAll") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            checkRegionSize(region, numberOfEntries);
            for (int i = 0; i < numberOfEntries; i++) {
                Region.Entry re = region.getEntry("p2pkey-" + i);
                assertNotNull(re);
                assertEquals(null, re.getValue());
            }
        }
    });
    client1.invoke(new CacheSerializableRunnable(title + "client1 verify p2p putAll") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            checkRegionSize(region, numberOfEntries);
            for (int i = 0; i < numberOfEntries; i++) {
                Region.Entry re = region.getEntry("p2pkey-" + i);
                assertNotNull(re);
                assertEquals(null, re.getValue());
            }
        }
    });
    // Execute p2p removeAll
    server1.invoke(new CacheSerializableRunnable(title + "server1 execute P2P removeAll") {

        @Override
        public void run2() throws CacheException {
            doRemoveAll(regionName, "p2pkey-", numberOfEntries);
            Region region = getRootRegion().getSubregion(regionName);
            assertEquals(0, region.size());
        }
    });
    // verify bridge server 2, because its data are from distribution
    server2.invoke(new CacheSerializableRunnable(title + "verify p2p removeAll Bridge Server 2") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            assertEquals(0, region.size());
        }
    });
    client2.invoke(new CacheSerializableRunnable(title + "client2 verify p2p removeAll") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            checkRegionSize(region, 0);
        }
    });
    client1.invoke(new CacheSerializableRunnable(title + "client1 verify p2p removeAll") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            checkRegionSize(region, 0);
        }
    });
    // putAll at client2 to trigger local-invalidates at client1
    client2.invoke(new CacheSerializableRunnable(title + "execute putAll on client2 for key 0-10") {

        @Override
        public void run2() throws CacheException {
            doPutAll(regionName, "key-", 10);
        }
    });
    // verify client 2 for key 0-10
    client1.invoke(new CacheSerializableRunnable(title + "verify client1 for local invalidate") {

        @Override
        public void run2() throws CacheException {
            final Region region = getRootRegion().getSubregion(regionName);
            for (int i = 0; i < 10; i++) {
                final int ii = i;
                WaitCriterion ev = new WaitCriterion() {

                    @Override
                    public boolean done() {
                        Entry entry = region.getEntry("key-" + ii);
                        return entry != null && entry.getValue() == null;
                    }

                    @Override
                    public String description() {
                        return null;
                    }
                };
                Wait.waitForCriterion(ev, 10 * 1000, 1000, true);
                // local invalidate will set the value to null
                TestObject obj = (TestObject) region.getEntry("key-" + i).getValue();
                assertEquals(null, obj);
            }
        }
    });
    // Stop server
    stopBridgeServers(getCache());
}

Example 25 with Entry

use of org.apache.geode.cache.Region.Entry in project geode by apache.

the class PutAllCSDUnitTest method test2Server.

/**
   * Tests putAll and removeAll to 2 servers. Use Case: 1) putAll from a single-threaded client to a
   * replicated region 2) putAll from a multi-threaded client to a replicated region 3)
   */
@Test
public void test2Server() throws CacheException, InterruptedException {
    final String title = "test2Server:";
    final Host host = Host.getHost(0);
    VM server1 = host.getVM(0);
    VM server2 = host.getVM(1);
    VM client1 = host.getVM(2);
    VM client2 = host.getVM(3);
    final String regionName = getUniqueName();
    final String serverHost = NetworkUtils.getServerHostName(server1.getHost());
    // set notifyBySubscription=false to test local-invalidates
    final int serverPort1 = createBridgeServer(server1, regionName, 0, false, 0, null);
    final int serverPort2 = createBridgeServer(server2, regionName, 0, false, 0, null);
    createBridgeClient(client1, regionName, serverHost, new int[] { serverPort1 }, -1, -1, true);
    createBridgeClient(client2, regionName, serverHost, new int[] { serverPort2 }, -1, -1, true);
    client2.invoke(new CacheSerializableRunnable(title + "client2 add listener") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            region.getAttributesMutator().addCacheListener(new MyListener(false));
        }
    });
    client1.invoke(new CacheSerializableRunnable(title + "client1 add listener and putAll") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            region.getAttributesMutator().addCacheListener(new MyListener(false));
            doPutAll(regionName, "key-", numberOfEntries);
            assertEquals(numberOfEntries, region.size());
            for (int i = 0; i < numberOfEntries; i++) {
                TestObject obj = (TestObject) region.getEntry("key-" + i).getValue();
                assertEquals(i, obj.getPrice());
            }
        }
    });
    // verify bridge server 1, its data are from client
    server1.invoke(new CacheSerializableRunnable(title + "verify Bridge Server 1") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            region.getAttributesMutator().setCacheWriter(new MyWriter("key-"));
            assertEquals(numberOfEntries, region.size());
            for (int i = 0; i < numberOfEntries; i++) {
                TestObject obj = (TestObject) region.getEntry("key-" + i).getValue();
                assertEquals(i, obj.getPrice());
            }
        }
    });
    // verify bridge server 2, because its data are from distribution
    server2.invoke(new CacheSerializableRunnable(title + "verify Bridge Server 2") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            region.getAttributesMutator().setCacheWriter(new MyWriter("key-"));
            assertEquals(numberOfEntries, region.size());
            for (int i = 0; i < numberOfEntries; i++) {
                TestObject obj = (TestObject) region.getEntry("key-" + i).getValue();
                assertEquals(i, obj.getPrice());
            }
        }
    });
    client2.invoke(new CacheSerializableRunnable(title + "client2 verify putAll") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            checkRegionSize(region, numberOfEntries);
            for (int i = 0; i < numberOfEntries; i++) {
                Region.Entry re = region.getEntry("key-" + i);
                assertNotNull(re);
                assertEquals(null, re.getValue());
            }
        }
    });
    client1.invoke(new CacheSerializableRunnable(title + "client1 removeAll") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            doRemoveAll(regionName, "key-", numberOfEntries);
            assertEquals(0, region.size());
        }
    });
    // verify bridge server 1, its data are from client
    server1.invoke(new CacheSerializableRunnable(title + "verify removeAll Bridge Server 1") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            assertEquals(0, region.size());
            MyWriter mywriter = (MyWriter) region.getAttributes().getCacheWriter();
            LogWriterUtils.getLogWriter().info("server cachewriter triggered for destroy: " + mywriter.num_destroyed);
            assertEquals(numberOfEntries, mywriter.num_destroyed);
        }
    });
    // verify bridge server 2, because its data are from distribution
    server2.invoke(new CacheSerializableRunnable(title + "verify removeAll Bridge Server 2") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            assertEquals(0, region.size());
            MyWriter mywriter = (MyWriter) region.getAttributes().getCacheWriter();
            LogWriterUtils.getLogWriter().info("server cachewriter triggered for destroy: " + mywriter.num_destroyed);
            // beforeDestroys are only triggered at server1 since the removeAll is submitted from
            // client1
            assertEquals(0, mywriter.num_destroyed);
        }
    });
    client2.invoke(new CacheSerializableRunnable(title + "client2 verify removeAll") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            checkRegionSize(region, 0);
        }
    });
    {
        // Execute client putAll from multithread client
        AsyncInvocation async1 = client1.invokeAsync(new CacheSerializableRunnable(title + "async putAll1 from client1") {

            @Override
            public void run2() throws CacheException {
                doPutAll(regionName, "async1key-", numberOfEntries);
            }
        });
        AsyncInvocation async2 = client1.invokeAsync(new CacheSerializableRunnable(title + "async putAll2 from client1") {

            @Override
            public void run2() throws CacheException {
                doPutAll(regionName, "async2key-", numberOfEntries);
            }
        });
        ThreadUtils.join(async1, 30 * 1000);
        ThreadUtils.join(async2, 30 * 1000);
    }
    client1.invoke(new CacheSerializableRunnable(title + "verify client 1 for async keys") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            assertEquals(numberOfEntries * 2, region.size());
            long ts1 = 0, ts2 = 0;
            for (int i = 0; i < numberOfEntries; i++) {
                TestObject obj = (TestObject) region.getEntry("async1key-" + i).getValue();
                assertEquals(i, obj.getPrice());
                assertTrue(obj.getTS() >= ts1);
                ts1 = obj.getTS();
                obj = (TestObject) region.getEntry("async2key-" + i).getValue();
                assertEquals(i, obj.getPrice());
                assertTrue(obj.getTS() >= ts2);
                ts2 = obj.getTS();
            }
        }
    });
    // verify bridge server 1 for asyn keys
    server1.invoke(new CacheSerializableRunnable(title + "verify Bridge Server 1 for async keys") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            assertEquals(numberOfEntries * 2, region.size());
            long ts1 = 0, ts2 = 0;
            for (int i = 0; i < numberOfEntries; i++) {
                TestObject obj = (TestObject) region.getEntry("async1key-" + i).getValue();
                assertEquals(i, obj.getPrice());
                assertTrue(obj.getTS() >= ts1);
                ts1 = obj.getTS();
                obj = (TestObject) region.getEntry("async2key-" + i).getValue();
                assertEquals(i, obj.getPrice());
                assertTrue(obj.getTS() >= ts2);
                ts2 = obj.getTS();
            }
        }
    });
    // verify bridge server 2 for asyn keys
    server2.invoke(new CacheSerializableRunnable(title + "verify Bridge Server 2 for async keys") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            assertEquals(numberOfEntries * 2, region.size());
            long ts1 = 0, ts2 = 0;
            for (int i = 0; i < numberOfEntries; i++) {
                TestObject obj = (TestObject) region.getEntry("async1key-" + i).getValue();
                assertEquals(i, obj.getPrice());
                assertTrue(obj.getTS() >= ts1);
                ts1 = obj.getTS();
                obj = (TestObject) region.getEntry("async2key-" + i).getValue();
                assertEquals(i, obj.getPrice());
                assertTrue(obj.getTS() >= ts2);
                ts2 = obj.getTS();
            }
        }
    });
    client2.invoke(new CacheSerializableRunnable(title + "client2 verify async putAll") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            checkRegionSize(region, numberOfEntries * 2);
            for (int i = 0; i < numberOfEntries; i++) {
                Region.Entry re = region.getEntry("async1key-" + i);
                assertNotNull(re);
                assertEquals(null, re.getValue());
            }
            for (int i = 0; i < numberOfEntries; i++) {
                Region.Entry re = region.getEntry("async2key-" + i);
                assertNotNull(re);
                assertEquals(null, re.getValue());
            }
        }
    });
    {
        // Execute client removeAll from multithread client
        AsyncInvocation async1 = client1.invokeAsync(new CacheSerializableRunnable(title + "async putAll1 from client1") {

            @Override
            public void run2() throws CacheException {
                doRemoveAll(regionName, "async1key-", numberOfEntries);
            }
        });
        AsyncInvocation async2 = client1.invokeAsync(new CacheSerializableRunnable(title + "async putAll2 from client1") {

            @Override
            public void run2() throws CacheException {
                doRemoveAll(regionName, "async2key-", numberOfEntries);
            }
        });
        ThreadUtils.join(async1, 30 * 1000);
        ThreadUtils.join(async2, 30 * 1000);
    }
    client1.invoke(new CacheSerializableRunnable(title + "client1 removeAll") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            doRemoveAll(regionName, "key-", numberOfEntries);
            assertEquals(0, region.size());
        }
    });
    // verify bridge server 1, its data are from client
    server1.invoke(new CacheSerializableRunnable(title + "verify async removeAll Bridge Server 1") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            assertEquals(0, region.size());
        }
    });
    // verify bridge server 2, because its data are from distribution
    server2.invoke(new CacheSerializableRunnable(title + "verify async removeAll Bridge Server 2") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            assertEquals(0, region.size());
        }
    });
    client2.invoke(new CacheSerializableRunnable(title + "client2 verify async removeAll") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            checkRegionSize(region, 0);
        }
    });
    // Execute p2p putAll
    server1.invoke(new CacheSerializableRunnable(title + "server1 execute P2P putAll") {

        @Override
        public void run2() throws CacheException {
            doPutAll(regionName, "p2pkey-", numberOfEntries);
            Region region = getRootRegion().getSubregion(regionName);
            long ts1 = 0;
            for (int i = 0; i < numberOfEntries; i++) {
                TestObject obj = (TestObject) region.getEntry("p2pkey-" + i).getValue();
                assertEquals(i, obj.getPrice());
                assertTrue(obj.getTS() >= ts1);
                ts1 = obj.getTS();
            }
        }
    });
    // verify bridge server 2 for p2p keys
    server2.invoke(new CacheSerializableRunnable(title + "verify Bridge Server 2 for p2p keys") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            long ts1 = 0;
            for (int i = 0; i < numberOfEntries; i++) {
                TestObject obj = (TestObject) region.getEntry("p2pkey-" + i).getValue();
                assertEquals(i, obj.getPrice());
                assertTrue(obj.getTS() >= ts1);
                ts1 = obj.getTS();
            }
        }
    });
    client2.invoke(new CacheSerializableRunnable(title + "client2 verify p2p putAll") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            checkRegionSize(region, numberOfEntries);
            for (int i = 0; i < numberOfEntries; i++) {
                Region.Entry re = region.getEntry("p2pkey-" + i);
                assertNotNull(re);
                assertEquals(null, re.getValue());
            }
        }
    });
    client1.invoke(new CacheSerializableRunnable(title + "client1 verify p2p putAll") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            checkRegionSize(region, numberOfEntries);
            for (int i = 0; i < numberOfEntries; i++) {
                Region.Entry re = region.getEntry("p2pkey-" + i);
                assertNotNull(re);
                assertEquals(null, re.getValue());
            }
        }
    });
    // Execute p2p removeAll
    server1.invoke(new CacheSerializableRunnable(title + "server1 execute P2P removeAll") {

        @Override
        public void run2() throws CacheException {
            doRemoveAll(regionName, "p2pkey-", numberOfEntries);
            Region region = getRootRegion().getSubregion(regionName);
            assertEquals(0, region.size());
        }
    });
    // verify bridge server 2, because its data are from distribution
    server2.invoke(new CacheSerializableRunnable(title + "verify p2p removeAll Bridge Server 2") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            assertEquals(0, region.size());
        }
    });
    client2.invoke(new CacheSerializableRunnable(title + "client2 verify p2p removeAll") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            checkRegionSize(region, 0);
        }
    });
    client1.invoke(new CacheSerializableRunnable(title + "client1 verify p2p removeAll") {

        @Override
        public void run2() throws CacheException {
            Region region = getRootRegion().getSubregion(regionName);
            checkRegionSize(region, 0);
        }
    });
    // putAll at client2 to trigger local-invalidates at client1
    client2.invoke(new CacheSerializableRunnable(title + "execute putAll on client2 for key 0-10") {

        @Override
        public void run2() throws CacheException {
            doPutAll(regionName, "key-", 10);
        }
    });
    // verify client 2 for key 0-10
    client1.invoke(new CacheSerializableRunnable(title + "verify client1 for local invalidate") {

        @Override
        public void run2() throws CacheException {
            final Region region = getRootRegion().getSubregion(regionName);
            for (int i = 0; i < 10; i++) {
                final int ii = i;
                WaitCriterion ev = new WaitCriterion() {

                    @Override
                    public boolean done() {
                        Entry entry = region.getEntry("key-" + ii);
                        return entry != null && entry.getValue() == null;
                    }

                    @Override
                    public String description() {
                        return null;
                    }
                };
                Wait.waitForCriterion(ev, 10 * 1000, 1000, true);
                // local invalidate will set the value to null
                TestObject obj = null;
                obj = (TestObject) region.getEntry("key-" + i).getValue();
                assertEquals(null, obj);
            }
        }
    });
    // clean up
    // Stop server
    stopBridgeServers(getCache());
}