geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From upthewatersp...@apache.org
Subject [10/51] [abbrv] [partial] incubator-geode git commit: Merge remote-tracking branch 'origin/develop' into feature/GEODE-917
Date Fri, 19 Feb 2016 23:59:28 GMT
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/5beaaedc/geode-core/src/test/java/com/gemstone/gemfire/cache/query/internal/index/PutAllWithIndexPerfDUnitTest.java
----------------------------------------------------------------------
diff --cc geode-core/src/test/java/com/gemstone/gemfire/cache/query/internal/index/PutAllWithIndexPerfDUnitTest.java
index fd50e63,0000000..960bd4e
mode 100644,000000..100644
--- a/geode-core/src/test/java/com/gemstone/gemfire/cache/query/internal/index/PutAllWithIndexPerfDUnitTest.java
+++ b/geode-core/src/test/java/com/gemstone/gemfire/cache/query/internal/index/PutAllWithIndexPerfDUnitTest.java
@@@ -1,216 -1,0 +1,216 @@@
 +/*
 + * Licensed to the Apache Software Foundation (ASF) under one or more
 + * contributor license agreements.  See the NOTICE file distributed with
 + * this work for additional information regarding copyright ownership.
 + * The ASF licenses this file to You under the Apache License, Version 2.0
 + * (the "License"); you may not use this file except in compliance with
 + * the License.  You may obtain a copy of the License at
 + *
 + *      http://www.apache.org/licenses/LICENSE-2.0
 + *
 + * Unless required by applicable law or agreed to in writing, software
 + * distributed under the License is distributed on an "AS IS" BASIS,
 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 + * See the License for the specific language governing permissions and
 + * limitations under the License.
 + */
 +package com.gemstone.gemfire.cache.query.internal.index;
 +
 +import java.io.IOException;
 +import java.util.HashMap;
 +import java.util.Map;
 +import java.util.Properties;
 +
 +import org.junit.Ignore;
 +import org.junit.experimental.categories.Category;
 +
 +import com.gemstone.gemfire.cache.AttributesFactory;
 +import com.gemstone.gemfire.cache.Cache;
 +import com.gemstone.gemfire.cache.CacheException;
 +import com.gemstone.gemfire.cache.CacheFactory;
 +import com.gemstone.gemfire.cache.Region;
 +import com.gemstone.gemfire.cache.Scope;
 +import com.gemstone.gemfire.cache.client.ClientCache;
 +import com.gemstone.gemfire.cache.client.ClientCacheFactory;
 +import com.gemstone.gemfire.cache.client.ClientRegionShortcut;
 +import com.gemstone.gemfire.cache.query.data.PortfolioPdx;
 +import com.gemstone.gemfire.cache.query.dunit.RemoteQueryDUnitTest;
 +import com.gemstone.gemfire.cache.server.CacheServer;
 +import com.gemstone.gemfire.cache30.CacheSerializableRunnable;
 +import com.gemstone.gemfire.cache30.CacheTestCase;
 +import com.gemstone.gemfire.internal.AvailablePort;
 +import com.gemstone.gemfire.test.dunit.Assert;
 +import com.gemstone.gemfire.test.dunit.DistributedTestUtils;
 +import com.gemstone.gemfire.test.dunit.Host;
 +import com.gemstone.gemfire.test.dunit.NetworkUtils;
 +import com.gemstone.gemfire.test.dunit.VM;
 +import com.gemstone.gemfire.test.junit.categories.DistributedTest;
 +
 +/**
 + * @author shobhit
 + *
 + */
 +@Category(DistributedTest.class)
 +@Ignore("Test was disabled by renaming to DisabledTest")
 +public class PutAllWithIndexPerfDUnitTest extends CacheTestCase {
 +
 +  /** The port on which the bridge server was started in this VM */
 +  private static int bridgeServerPort;
 +  static long timeWithoutStructTypeIndex = 0;
 +  static long timeWithStructTypeIndex = 0;
 +  
 +  public PutAllWithIndexPerfDUnitTest(String name) {
 +    super(name);
 +  }
 +
 +  public void setUp() throws Exception {
 +    super.setUp();
 +    disconnectAllFromDS();
 +  }
 +
 +  @Override
 +  protected final void postTearDownCacheTestCase() throws Exception {
 +    disconnectAllFromDS();
 +  }
 +
 +  public void testPutAllWithIndexes() {
 +    final String name = "testRegion";
 +    final Host host = Host.getHost(0);
 +    VM vm0 = host.getVM(0);
 +    VM vm1 = host.getVM(1);
 +    final int numberOfEntries = 10000;
 +
 +    // Start server
 +    vm0.invoke(new CacheSerializableRunnable("Create Bridge Server") {
 +        public void run2() throws CacheException {
 +          Properties config = new Properties();
 +          config.put("locators", "localhost["+DistributedTestUtils.getDUnitLocatorPort()+"]");
 +          Cache cache = new CacheFactory(config).create();
 +          AttributesFactory factory = new AttributesFactory();
 +          factory.setScope(Scope.LOCAL);
 +          cache.createRegionFactory(factory.create()).create(name);
 +          try {
 +            startBridgeServer(0, false);
 +          } catch (Exception ex) {
 +            Assert.fail("While starting CacheServer", ex);
 +          }
 +          //Create Index on empty region
 +          try {
 +            cache.getQueryService().createIndex("idIndex", "ID", "/"+name);
 +          } catch (Exception e) {
 +            Assert.fail("index creation failed", e);
 +          }
 +        }
 +      });
 +
 +    // Create client region
-     final int port = vm0.invokeInt(PutAllWithIndexPerfDUnitTest.class, "getCacheServerPort");
++    final int port = vm0.invoke(() -> PutAllWithIndexPerfDUnitTest.getCacheServerPort());
 +    final String host0 = NetworkUtils.getServerHostName(vm0.getHost());
 +    vm1.invoke(new CacheSerializableRunnable("Create region") {
 +        public void run2() throws CacheException {
 +          Properties config = new Properties();
 +          config.setProperty("mcast-port", "0");
 +          ClientCache cache = new ClientCacheFactory().addPoolServer(host0, port).create();
 +          AttributesFactory factory = new AttributesFactory();
 +          factory.setScope(Scope.LOCAL);
 +          cache.createClientRegionFactory(ClientRegionShortcut.PROXY).create(name);
 +        }
 +      });
 +
 +    vm1.invoke(new CacheSerializableRunnable("putAll() test") {
 +      
 +      @Override
 +      public void run2() throws CacheException {
 +        Region exampleRegion = ClientCacheFactory.getAnyInstance().getRegion(name);
 +
 +        Map warmupMap = new HashMap();
 +        Map data =  new HashMap();
 +        for(int i=0; i<10000; i++){
 +          Object p = new PortfolioPdx(i);
 +          if (i < 1000) warmupMap.put(i, p);
 +          data.put(i, p);
 +        }
 +        
 +        for (int i=0; i<10; i++) {
 +          exampleRegion.putAll(warmupMap);
 +        }
 +        
 +        long start = System.currentTimeMillis();
 +        for (int i=0; i<10; i++) {
 +          exampleRegion.putAll(data);
 +        }
 +        long end = System.currentTimeMillis();
 +        timeWithoutStructTypeIndex = ((end-start)/10);
 +        System.out.println("Total putall time for 10000 objects is: "+ ((end-start)/10) + "ms");
 + 
 +      }
 +    });
 +    
 +    vm0.invoke(new CacheSerializableRunnable("Remove Index and create new one") {
 +      
 +      @Override
 +      public void run2() throws CacheException {
 +        try {
 +          Cache cache = CacheFactory.getAnyInstance();
 +          cache.getQueryService().removeIndexes();
 +          cache.getRegion(name).clear();
 +          cache.getQueryService().createIndex("idIndex", "p.ID", "/"+name+" p");
 +        } catch (Exception e) {
 +          Assert.fail("index creation failed", e);
 +        }
 +      }
 +    });
 +
 +    vm1.invoke(new CacheSerializableRunnable("putAll() test") {
 +      
 +      @Override
 +      public void run2() throws CacheException {
 +        Region exampleRegion = ClientCacheFactory.getAnyInstance().getRegion(name);
 +        exampleRegion.clear();
 +        Map warmupMap = new HashMap();
 +        Map data =  new HashMap();
 +        for(int i=0; i<10000; i++){
 +          Object p = new PortfolioPdx(i);
 +          if (i < 1000) warmupMap.put(i, p);
 +          data.put(i, p);
 +        }
 +        
 +        for (int i=0; i<10; i++) {
 +          exampleRegion.putAll(warmupMap);
 +        }
 +        
 +        long start = System.currentTimeMillis();
 +        for (int i=0; i<10; i++) {
 +          exampleRegion.putAll(data);
 +        }
 +        long end = System.currentTimeMillis();
 +        timeWithStructTypeIndex  = ((end-start)/10);
 +        System.out.println("Total putall time for 10000 objects is: "+ ((end-start)/10) + "ms");
 + 
 +      }
 +    });
 +    
 +    if (timeWithoutStructTypeIndex > timeWithStructTypeIndex) {
 +      fail("putAll took more time without struct type index than simple index");
 +    }
 +  }
 +
 +  /**
 +   * Starts a bridge server on the given port, using the given
 +   * deserializeValues and notifyBySubscription to serve up the
 +   * given region.
 +   */
 +  protected void startBridgeServer(int port, boolean notifyBySubscription)
 +    throws IOException {
 +
 +    Cache cache = CacheFactory.getAnyInstance();
 +    CacheServer bridge = cache.addCacheServer();
 +    bridge.setPort(port);
 +    bridge.start();
 +    bridgeServerPort = bridge.getPort();
 +  }
 +
 +  private static int getCacheServerPort() {
 +    return bridgeServerPort;
 +  }
 +}

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/5beaaedc/geode-core/src/test/java/com/gemstone/gemfire/cache30/Bug34387DUnitTest.java
----------------------------------------------------------------------
diff --cc geode-core/src/test/java/com/gemstone/gemfire/cache30/Bug34387DUnitTest.java
index 9c35b1b,0000000..879600d
mode 100644,000000..100644
--- a/geode-core/src/test/java/com/gemstone/gemfire/cache30/Bug34387DUnitTest.java
+++ b/geode-core/src/test/java/com/gemstone/gemfire/cache30/Bug34387DUnitTest.java
@@@ -1,174 -1,0 +1,174 @@@
 +/*
 + * Licensed to the Apache Software Foundation (ASF) under one or more
 + * contributor license agreements.  See the NOTICE file distributed with
 + * this work for additional information regarding copyright ownership.
 + * The ASF licenses this file to You under the Apache License, Version 2.0
 + * (the "License"); you may not use this file except in compliance with
 + * the License.  You may obtain a copy of the License at
 + *
 + *      http://www.apache.org/licenses/LICENSE-2.0
 + *
 + * Unless required by applicable law or agreed to in writing, software
 + * distributed under the License is distributed on an "AS IS" BASIS,
 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 + * See the License for the specific language governing permissions and
 + * limitations under the License.
 + */
 +package com.gemstone.gemfire.cache30;
 +
 +import com.gemstone.gemfire.cache.AttributesFactory;
 +import com.gemstone.gemfire.cache.CacheException;
 +import com.gemstone.gemfire.cache.CacheListener;
 +import com.gemstone.gemfire.cache.CacheTransactionManager;
 +import com.gemstone.gemfire.cache.DataPolicy;
 +import com.gemstone.gemfire.cache.EntryEvent;
 +import com.gemstone.gemfire.cache.Region;
 +import com.gemstone.gemfire.cache.Scope;
 +import com.gemstone.gemfire.cache.UnsupportedOperationInTransactionException;
 +import com.gemstone.gemfire.cache.util.CacheListenerAdapter;
 +import com.gemstone.gemfire.distributed.DistributedMember;
 +import com.gemstone.gemfire.distributed.internal.InternalDistributedSystem;
 +import com.gemstone.gemfire.internal.i18n.LocalizedStrings;
 +import com.gemstone.gemfire.test.dunit.Host;
 +import com.gemstone.gemfire.test.dunit.VM;
 +
 +/**
 + * Test create + localDestroy for bug 34387
 + *
 + * @author darrel
 + * @since 5.0
 + */
 +public class Bug34387DUnitTest extends CacheTestCase {
 +
 +//  private transient Region r;
 +//  private transient DistributedMember otherId;
 +  protected transient int invokeCount;
 +  
 +  static volatile boolean callbackFailure;
 +  
 +  public Bug34387DUnitTest(String name) {
 +    super(name);
 +  }
 +
 +  protected static void callbackAssertEquals(String message, Object expected, 
 +      Object actual) {
 +    if (expected == null && actual == null)
 +      return;
 +    if (expected != null && expected.equals(actual))
 +      return;
 +    callbackFailure = true;
 +    // Throws an error that is ignored, but...
 +    assertEquals(message, expected, actual);
 +  }
 +  
 +
 +  private VM getOtherVm() {
 +    Host host = Host.getHost(0);
 +    return host.getVM(0);
 +  }
 +    
 +  private void initOtherId() {
 +    VM vm = getOtherVm();
 +    vm.invoke(new CacheSerializableRunnable("Connect") {
 +        public void run2() throws CacheException {
 +          getCache();
 +        }
 +      });
-     vm.invoke(Bug34387DUnitTest.class, "getVMDistributedMember");
++    vm.invoke(() -> Bug34387DUnitTest.getVMDistributedMember());
 +  }
 +  private void doCommitOtherVm(final boolean doDestroy) {
 +    VM vm = getOtherVm();
 +    vm.invoke(new CacheSerializableRunnable("create root") {
 +        public void run2() throws CacheException {
 +          AttributesFactory af = new AttributesFactory();
 +          af.setScope(Scope.DISTRIBUTED_ACK);
 +          af.setConcurrencyChecksEnabled(true);
 +          Region r1 = createRootRegion("r1", af.create());
 +          CacheTransactionManager ctm =  getCache().getCacheTransactionManager();
 +          ctm.begin();
 +          r1.create("createKey", "createValue");
 +          if (doDestroy) {
 +            try {
 +              r1.localDestroy("createKey");
 +              fail("expected exception not thrown");
 +            } catch (UnsupportedOperationInTransactionException e) {
 +              assertEquals(e.getMessage(), LocalizedStrings.TXStateStub_LOCAL_DESTROY_NOT_ALLOWED_IN_TRANSACTION.toLocalizedString());
 +            }
 +          } else {
 +            try {
 +              r1.localInvalidate("createKey");
 +              fail("expected exception not thrown");
 +            } catch (UnsupportedOperationInTransactionException e) {
 +              assertEquals(e.getMessage(), LocalizedStrings.TXStateStub_LOCAL_INVALIDATE_NOT_ALLOWED_IN_TRANSACTION.toLocalizedString());
 +            }
 +          }
 +          ctm.commit();
 +        }
 +      });
 +  }
 +
 +  public static DistributedMember getVMDistributedMember() {
 +    return InternalDistributedSystem.getAnyInstance().getDistributedMember();
 +  }
 +  
 +  //////////////////////  Test Methods  //////////////////////
 +
 +  /**
 +   * test create followed by localDestroy
 +   */
 +  public void testCreateAndLD() throws CacheException {
 +    initOtherId();
 +    AttributesFactory af = new AttributesFactory();
 +    af.setDataPolicy(DataPolicy.REPLICATE);
 +    af.setScope(Scope.DISTRIBUTED_ACK);
 +    af.setConcurrencyChecksEnabled(true);
 +    callbackFailure = false;
 +    
 +    CacheListener cl1 = new CacheListenerAdapter() {
 +        public void afterCreate(EntryEvent e) {
 +          callbackAssertEquals("Keys not equal", "createKey", e.getKey());
 +          callbackAssertEquals("Values not equal", "createValue", e.getNewValue());
 +          Bug34387DUnitTest.this.invokeCount++;
 +        }
 +      };
 +    af.addCacheListener(cl1);
 +    Region r1 = createRootRegion("r1", af.create());
 +
 +    this.invokeCount = 0;
 +    assertNull(r1.getEntry("createKey"));
 +    doCommitOtherVm(true);
 +    assertNotNull(r1.getEntry("createKey"));
 +    assertEquals("createValue", r1.getEntry("createKey").getValue());
 +    assertEquals(1, this.invokeCount);
 +    assertFalse("Errors in callbacks; check logs for details", callbackFailure);
 +  }
 +  /**
 +   * test create followed by localInvalidate
 +   */
 +  public void testCreateAndLI() throws CacheException {
 +    initOtherId();
 +    AttributesFactory af = new AttributesFactory();
 +    af.setDataPolicy(DataPolicy.REPLICATE);
 +    af.setScope(Scope.DISTRIBUTED_ACK);
 +    af.setConcurrencyChecksEnabled(true);
 +    callbackFailure = false;
 +    
 +    CacheListener cl1 = new CacheListenerAdapter() {
 +        public void afterCreate(EntryEvent e) {
 +          callbackAssertEquals("key not equal", "createKey", e.getKey());
 +          callbackAssertEquals("value not equal", "createValue", e.getNewValue());
 +          Bug34387DUnitTest.this.invokeCount++;
 +        }
 +      };
 +    af.addCacheListener(cl1);
 +    Region r1 = createRootRegion("r1", af.create());
 +
 +    this.invokeCount = 0;
 +    assertNull(r1.getEntry("createKey"));
 +    doCommitOtherVm(false);
 +    assertNotNull(r1.getEntry("createKey"));
 +    assertEquals("createValue", r1.getEntry("createKey").getValue());
 +    assertEquals(1, this.invokeCount);
 +    assertFalse("Errors in callbacks; check logs for details", callbackFailure);
 +  }
 +}

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/5beaaedc/geode-core/src/test/java/com/gemstone/gemfire/cache30/CacheMapTxnDUnitTest.java
----------------------------------------------------------------------
diff --cc geode-core/src/test/java/com/gemstone/gemfire/cache30/CacheMapTxnDUnitTest.java
index b889bc7,0000000..f7e1739
mode 100644,000000..100644
--- a/geode-core/src/test/java/com/gemstone/gemfire/cache30/CacheMapTxnDUnitTest.java
+++ b/geode-core/src/test/java/com/gemstone/gemfire/cache30/CacheMapTxnDUnitTest.java
@@@ -1,534 -1,0 +1,534 @@@
 +/*
 + * Licensed to the Apache Software Foundation (ASF) under one or more
 + * contributor license agreements.  See the NOTICE file distributed with
 + * this work for additional information regarding copyright ownership.
 + * The ASF licenses this file to You under the Apache License, Version 2.0
 + * (the "License"); you may not use this file except in compliance with
 + * the License.  You may obtain a copy of the License at
 + *
 + *      http://www.apache.org/licenses/LICENSE-2.0
 + *
 + * Unless required by applicable law or agreed to in writing, software
 + * distributed under the License is distributed on an "AS IS" BASIS,
 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 + * See the License for the specific language governing permissions and
 + * limitations under the License.
 + */
 +
 +/*
 + * CacheMapTxnDUnitTest.java
 + *
 + * Created on August 9, 2005, 11:18 AM
 + */
 +package com.gemstone.gemfire.cache30;
 +
 +import java.util.Properties;
 +import java.util.Set;
 +
 +import com.gemstone.gemfire.cache.AttributesFactory;
 +import com.gemstone.gemfire.cache.Cache;
 +import com.gemstone.gemfire.cache.CacheFactory;
 +import com.gemstone.gemfire.cache.CacheTransactionManager;
 +import com.gemstone.gemfire.cache.DataPolicy;
 +import com.gemstone.gemfire.cache.Region;
 +import com.gemstone.gemfire.cache.RegionAttributes;
 +import com.gemstone.gemfire.cache.Scope;
 +import com.gemstone.gemfire.cache.UnsupportedOperationInTransactionException;
 +import com.gemstone.gemfire.distributed.DistributedSystem;
 +import com.gemstone.gemfire.test.dunit.Assert;
 +import com.gemstone.gemfire.test.dunit.AsyncInvocation;
 +import com.gemstone.gemfire.test.dunit.DistributedTestCase;
 +import com.gemstone.gemfire.test.dunit.Host;
 +import com.gemstone.gemfire.test.dunit.ThreadUtils;
 +import com.gemstone.gemfire.test.dunit.VM;
 +
 +public class CacheMapTxnDUnitTest extends DistributedTestCase{
 +    
 +    protected static Cache cache;
 +    protected static Properties props = new Properties();
 +    static DistributedSystem ds = null;
 +    static Region region;
 +    static Region mirroredRegion;
 +    protected static CacheTransactionManager cacheTxnMgr;
 +    
 +    /** Creates a new instance of CacheMapTxnDUnitTest */
 +    public CacheMapTxnDUnitTest(String name) {
 +        super(name);
 +    }
 +    
 +    @Override
 +    public void setUp() throws Exception {
 +      super.setUp();
 +      Host host = Host.getHost(0);
 +      VM vm0 = host.getVM(0);
 +      VM vm1 = host.getVM(1);
-       vm0.invoke(CacheMapTxnDUnitTest.class, "createCache");
-       vm1.invoke(CacheMapTxnDUnitTest.class, "createCache");
++      vm0.invoke(() -> CacheMapTxnDUnitTest.createCache());
++      vm1.invoke(() -> CacheMapTxnDUnitTest.createCache());
 +    }
 +    
 +    @Override
 +    protected final void preTearDown() throws Exception {
 +      Host host = Host.getHost(0);
 +      VM vm0 = host.getVM(0);
 +      VM vm1 = host.getVM(1);
-       vm0.invoke(CacheMapTxnDUnitTest.class, "closeCache");
-       vm1.invoke(CacheMapTxnDUnitTest.class, "closeCache");
++      vm0.invoke(() -> CacheMapTxnDUnitTest.closeCache());
++      vm1.invoke(() -> CacheMapTxnDUnitTest.closeCache());
 +    }
 +    
 +    public static void createCache(){
 +        try{
 +            //            props.setProperty("mcast-port", "1234");
 +            //            ds = DistributedSystem.connect(props);
 +            ds = (new CacheMapTxnDUnitTest("temp")).getSystem(props);
 +            cache = CacheFactory.create(ds);
 +            AttributesFactory factory  = new AttributesFactory();
 +            factory.setScope(Scope.DISTRIBUTED_ACK);
 +            factory.setDataPolicy(DataPolicy.REPLICATE);
 +            RegionAttributes attr = factory.create();
 +            region = cache.createRegion("map", attr);
 +            
 +        } catch (Exception ex){
 +            ex.printStackTrace();
 +        }
 +    }
 +    
 +    public static void closeCache(){
 +        try{            
 +            cache.close();
 +            ds.disconnect();            
 +        } catch (Exception ex){
 +            ex.printStackTrace();
 +        }
 +    }
 +    
 +    public void testCommitTxn() {
 +        //this is to test single VM region transactions
 +        Host host = Host.getHost(0);
 +        VM vm0 = host.getVM(0);
-         vm0.invoke(CacheMapTxnDUnitTest.class, "commitTxn");
++        vm0.invoke(() -> CacheMapTxnDUnitTest.commitTxn());
 +    }//end of testCommitTxn
 +    
 +    public void testRollbackTxn() {
 +        //this is to test single VM region transactions
 +        Host host = Host.getHost(0);
 +        VM vm0 = host.getVM(0);
-         vm0.invoke(CacheMapTxnDUnitTest.class, "rollbackTxn");
++        vm0.invoke(() -> CacheMapTxnDUnitTest.rollbackTxn());
 +    }//end of testRollbackTxn
 +    
 +    public void testRollbackTxnClear() {
 +        //this is to test single VM region transactions
 +        Host host = Host.getHost(0);
 +        VM vm0 = host.getVM(0);
 +        VM vm1 = host.getVM(1);
 +        int i=0;
 +        Object ob2;
 +        Object [] objArr = new Object[1];
 +        
 +        for (i=0;i<5; i++){
 +            objArr [0] = ""+i;
 +            vm1.invoke(CacheMapTxnDUnitTest.class, "putMethod", objArr);
 +        }
 +        
-         vm0.invoke(CacheMapTxnDUnitTest.class, "rollbackTxnClear");
++        vm0.invoke(() -> CacheMapTxnDUnitTest.rollbackTxnClear());
 +        
 +        i=3;
 +        objArr [0] = ""+i;
 +        ob2 = vm1.invoke(CacheMapTxnDUnitTest.class, "getMethod", objArr);
 +        
 +        if(ob2 != null){
 +            fail("failed in testRollbackTxnClear");
 +        }
 +    }//end of testRollbackTxnClear
 +    
 +    public void testMiscMethods() throws Throwable{
 +        Host host = Host.getHost(0);
 +        VM vm0 = host.getVM(0);
 +        VM vm1 = host.getVM(1);
-         vm0.invoke(CacheMapTxnDUnitTest.class, "miscMethodsOwner");
-         AsyncInvocation o2 = vm0.invokeAsync(CacheMapTxnDUnitTest.class, "miscMethodsNotOwner");//invoke in same vm but in seperate thread
-         AsyncInvocation o3 = vm1.invokeAsync(CacheMapTxnDUnitTest.class, "miscMethodsNotOwner");//invoke in another vm
++        vm0.invoke(() -> CacheMapTxnDUnitTest.miscMethodsOwner());
++        AsyncInvocation o2 = vm0.invokeAsync(() -> CacheMapTxnDUnitTest.miscMethodsNotOwner());//invoke in same vm but in seperate thread
++        AsyncInvocation o3 = vm1.invokeAsync(() -> CacheMapTxnDUnitTest.miscMethodsNotOwner());//invoke in another vm
 +        ThreadUtils.join(o2, 30 * 1000);
 +        ThreadUtils.join(o3, 30 * 1000);
 +        
 +        if(o2.exceptionOccurred()){
 +          Assert.fail("o2 failed", o2.getException());
 +        }
 +        
 +        if(o3.exceptionOccurred()){
 +          Assert.fail("o3 failed", o3.getException());
 +        }
 +        
 +    }//end of testMiscMethods
 +    
 +    
 +    //methods to be executed in remote vms...and called through vm.invoke
 +    
 +    public static void commitTxn(){
 +        try{
 +            cacheTxnMgr = cache.getCacheTransactionManager();
 +            int [] i = {0,1,2,3,4,5,6,7,8,9};
 +            Object o3;
 +            o3="init";
 +            region.put(""+i[0], "zero");
 +            region.create(""+i[5], "fifth");
 +            //begin transaction
 +            cacheTxnMgr.begin();
 +            region.put(""+i[1], "first");
 +            //test get
 +            o3 = region.get(""+i[1]);
 +            if( !(o3.toString().equals("first"))){
 +                fail("get inside transaction returns incorrect object");
 +            }
 +            
 +            //test remove
 +            region.put(""+i[2], "second");
 +            o3 = region.remove(""+i[2]);
 +            if( !(o3.toString().equals("second"))){
 +                fail("remove inside transaction returns incorrect object");
 +            }
 +            
 +            boolean flag = region.containsKey(""+i[2]);
 +            if (flag){
 +                fail("region.containsKey after region.remove inside txn returns incorrect value");
 +            }
 +            
 +            region.put(""+i[3], "third");
 +            region.put(""+i[0], "updatedZero");
 +
 +            // test putIfAbsent
 +            region.putIfAbsent(""+i[4], "fourth");
 +            if (!region.get(""+i[4]).toString().equals("fourth")) {
 +              fail("putIfAbsent inside transaction returns incorrect object");
 +            }
 +            
 +            // test replace
 +            region.replace(""+i[4], "fourth2");
 +            if (!region.get(""+i[4]).toString().equals("fourth2")) {
 +              fail("replace inside transaction returns incorrect object)");
 +            }
 +
 +            // test replace
 +            region.replace(""+i[4], "fourth2", "fourth3");
 +            if (!region.get(""+i[4]).toString().equals("fourth3")) {
 +              fail("replace inside transaction returns incorrect object)");
 +            }
 +            
 +            // test a failed removal
 +            boolean succeeded = region.remove(""+i[5], new Object());
 +            assertTrue(!succeeded);
 +            assertTrue(region.get(""+i[5]).equals("fifth"));
 +            
 +            // test remove
 +            region.remove(""+i[5]);
 +            
 +            //commit the transaction
 +            cacheTxnMgr.commit();
 +            
 +            //verify for persistent data now
 +            o3 = region.get(""+i[1]);
 +            if( !(o3.toString().equals("first"))){
 +                fail("get after committed transaction returns incorrect object");
 +            }
 +            
 +            o3 = region.get(""+i[2]);
 +            if(o3 != null){
 +                fail("get after committed transaction returns incorrect object");
 +            }
 +            
 +            o3 = region.get(""+i[3]);
 +            if( !(o3.toString().equals("third"))){
 +                fail("get after committed transaction returns incorrect object");
 +            }
 +            
 +            if (!region.get(""+i[4]).toString().equals("fourth3")) {
 +              fail("get after committed transaction returns incorrect object");
 +            }
 +            
 +            if (region.containsKey(""+i[5])) {
 +              fail("containsKey after committed transaction was true");
 +            }
 +            
 +            boolean val = region.containsValue("updatedZero");
 +            if(! val){
 +                fail("containsValue after committed transaction returns incorrect result");
 +            }
 +            
 +        }
 +        catch(Exception ex){
 +            ex.printStackTrace();
 +            fail("failed in commitTxn");
 +        }
 +        finally{
 +            if(cacheTxnMgr.exists()){
 +                try {cacheTxnMgr.commit();} catch (Exception cce){cce.printStackTrace();}
 +            }
 +        }
 +        
 +    }//end of commitTxn
 +    
 +    
 +    public static void rollbackTxn(){
 +        try{
 +            cacheTxnMgr = cache.getCacheTransactionManager();
 +            int [] i = {0,1,2,3,4,5,6,7,8,9};
 +            Object o3;
 +            o3="init";
 +            region.put(""+i[0], "zero");
 +            region.put(""+i[5], "fifth");
 +            cacheTxnMgr.begin();
 +            region.put(""+i[1], "first");
 +            //test get
 +            o3 = region.get(""+i[1]);
 +            if( !(o3.toString().equals("first"))){
 +                fail("get inside transaction returns incorrect object");
 +            }
 +            
 +            //test containsValue
 +            boolean flag = region.containsValue(new String("first"));
 +            //assertEquals(true, flag);
 +            
 +            //test remove
 +            region.put(""+i[2], "second");
 +            o3 = region.remove(""+i[2]);
 +            if( !(o3.toString().equals("second"))){
 +                fail("remove inside transaction returns incorrect object");
 +            }
 +            
 +            region.put(""+i[3], "third");
 +            region.put(""+i[0], "updatedZero");
 +
 +            
 +            // test putIfAbsent
 +            region.putIfAbsent(""+i[4], "fourth");
 +            if (!region.get(""+i[4]).toString().equals("fourth")) {
 +              fail("putIfAbsent inside transaction returns incorrect object");
 +            }
 +            
 +            // test replace
 +            region.replace(""+i[4], "fourth2");
 +            if (!region.get(""+i[4]).toString().equals("fourth2")) {
 +              fail("replace inside transaction returns incorrect object)");
 +            }
 +
 +            // test replace
 +            region.replace(""+i[4], "fourth2", "fourth3");
 +            if (!region.get(""+i[4]).toString().equals("fourth3")) {
 +              fail("replace inside transaction returns incorrect object)");
 +            }
 +            
 +            // test a failed removal
 +            boolean succeeded = region.remove(""+i[5], new Object());
 +            assertTrue(!succeeded);
 +            assertTrue(region.get(""+i[5]).equals("fifth"));
 +
 +            // test remove
 +            region.remove(""+i[5]);
 +            
 +            //rollback the transaction
 +            cacheTxnMgr.rollback();
 +            
 +            //verify for persistent data now
 +            o3 = region.get(""+i[1]);
 +            if( o3 != null){ //null?
 +                fail("get after rolled back transaction returns incorrect object");
 +            }
 +            
 +            o3 = region.get(""+i[2]);
 +            if( o3 != null){ //null?
 +                fail("get after rolled back transaction returns incorrect object");
 +            }
 +            
 +            o3 = region.get(""+i[3]);
 +            if( o3 != null){ //null?
 +                fail("get after rolled back transaction returns incorrect object");
 +            }
 +            
 +            o3 = region.get(""+i[4]);
 +            if( o3 != null){ //null?
 +                fail("get after rolled back transaction returns incorrect object");
 +            }
 +            
 +            o3 = region.get(""+i[5]);
 +            if (o3 == null) {
 +              fail("get after rolled back transaction returns incorrect object");
 +            }
 +            
 +            //            boolean val = region.containsValue("zero");
 +            //            if( !val){
 +            //                fail("containsValue after rolled back transaction returns incorrect result");
 +            //            }
 +            
 +        }
 +        catch(Exception ex){
 +            ex.printStackTrace();
 +            fail("failed in rollbackTxn");
 +        }
 +        finally{
 +            if(cacheTxnMgr.exists()){
 +                try {cacheTxnMgr.commit();} catch (Exception cce){cce.printStackTrace();}
 +            }
 +        }
 +        
 +    }//end of rollbackTxn
 +    
 +    public static void rollbackTxnClear(){
 +        try{
 +            cacheTxnMgr = cache.getCacheTransactionManager();
 +            int [] i = {0,1,2,3,4,5,6,7,8,9};
 +            region.put(""+i[0], "zero");
 +            //begin transaction
 +            cacheTxnMgr.begin();
 +            region.put(""+i[1], "first");
 +            region.put(""+i[0], "updatedZero");
 +            
 +            try {
 +              region.clear(); //clear is not transactional operation
 +              fail("excpected exception not thrown");
 +            } catch (UnsupportedOperationInTransactionException e) {
 +            }
 +            
 +            //rollback the transaction
 +            cacheTxnMgr.rollback();
 +            
 +            //verify for persistent data now
 +            
 +            boolean val = region.containsValue("updatedZero");
 +            if(val){
 +                fail("containsValue after region.clear & rolled back transaction returns incorrect result");
 +            }
 +            region.clear();
 +            val = region.containsValue("first");
 +            if(val){
 +                fail("containsValue after region.clear & rolled back transaction returns incorrect result");
 +            }
 +            
 +        }
 +        catch(Exception ex){
 +            cacheTxnMgr = null;
 +            ex.printStackTrace();
 +            fail("failed in rollbackTxnClear");
 +        }
 +        
 +    }//end of rollbackTxnClear
 +    
 +    public static void miscMethodsOwner(){
 +        try{
 +            cacheTxnMgr = cache.getCacheTransactionManager();
 +            int [] i = {0,1,2,3,4,5,6,7,8,9};
 +            region.clear();
 +            region.put(""+i[0], "zero");
 +            region.put(""+i[1], "first");
 +            region.put(""+i[2], "second");
 +            region.put(""+i[3], "third");
 +            
 +            cacheTxnMgr.begin();
 +            region.put(""+i[4], "forth");
 +            region.put(""+i[5], "fifth");
 +            
 +            //test size method
 +            int j = region.size();
 +            if(j != 6){
 +                fail("region.size inside transaction returns incorrect results");
 +            }
 +            
 +            //test entrySet method
 +            Set set = region.entrySet();
 +            int k = set.size();
 +            if(j != 6){
 +                fail("region.entrySet inside transaction returns incorrect results");
 +            }
 +            
 +            //test keySet method
 +            set = region.keySet();
 +            k = set.size();
 +            if(j != 6){
 +                fail("region.keySet inside transaction returns incorrect results");
 +            }
 +            
 +            boolean val = region.containsValue("forth");
 +            if( !val){
 +                fail("containsValue inside transaction returns incorrect result");
 +            }
 +            
 +            //commit the transaction
 +            cacheTxnMgr.rollback();
 +            
 +            //verify for persistent data now
 +            
 +        }
 +        catch(Exception ex){
 +            ex.printStackTrace();
 +            fail("failed in miscMethodsOwner");
 +        }
 +        finally{
 +            if(cacheTxnMgr.exists()){
 +                try {cacheTxnMgr.commit();} catch (Exception cce){cce.printStackTrace();}
 +            }
 +        }
 +        
 +    }//end of miscMethodsOwner
 +    
 +    public static void miscMethodsNotOwner(){
 +        try{
 +//            int [] i = {0,1,2,3,4,5,6,7,8,9};
 +            //it is assumed that there are already four committed entried inside region
 +            //test size method
 +            int j = region.size();
 +            if(j != 4){
 +                fail("region.size for not owner of transaction returns incorrect results, size is "+j+ " but expected 4");
 +            }
 +            
 +            //test entrySet method
 +            Set set = region.entrySet();
 +            int k = set.size();
 +            if(j != 4){
 +                fail("region.entrySet for not owner of transaction returns incorrect results");
 +            }
 +            
 +            //test keySet method
 +            set = region.keySet();
 +            k = set.size();
 +            if(j != 4){
 +                fail("region.keySet for not owner of transaction returns incorrect results");
 +            }
 +            boolean val = region.containsKey("forth");
 +            if(val){
 +                fail("containsValue for not owner of transaction returns incorrect result");
 +            }
 +            
 +        }
 +        catch(Exception ex){
 +            ex.printStackTrace();
 +            fail("failed in miscMethodsNotOwner");
 +        }
 +    }//end of miscMethodsNotOwner
 +    
 +    
 +    
 +    //helper methods
 +    public static Object putMethod(Object ob){
 +        Object obj=null;
 +        try{
 +            if(ob != null){
 +                String str = "first";
 +                obj = region.put(ob, str);
 +            }
 +        }catch(Exception ex){
 +            ex.printStackTrace();
 +            fail("Failed while region.put");
 +        }
 +        return obj;
 +    }
 +    
 +    public static Object getMethod(Object ob){
 +        Object obj=null;
 +        try{
 +            obj = region.get(ob);
 +        } catch(Exception ex){
 +            fail("Failed while region.get");
 +        }
 +        return obj;
 +    }
 +    
 +    
 +}//end of test class

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/5beaaedc/geode-core/src/test/java/com/gemstone/gemfire/cache30/CachedAllEventsDUnitTest.java
----------------------------------------------------------------------
diff --cc geode-core/src/test/java/com/gemstone/gemfire/cache30/CachedAllEventsDUnitTest.java
index c0a1fc4,0000000..c3f97f7
mode 100644,000000..100644
--- a/geode-core/src/test/java/com/gemstone/gemfire/cache30/CachedAllEventsDUnitTest.java
+++ b/geode-core/src/test/java/com/gemstone/gemfire/cache30/CachedAllEventsDUnitTest.java
@@@ -1,111 -1,0 +1,111 @@@
 +/*
 + * Licensed to the Apache Software Foundation (ASF) under one or more
 + * contributor license agreements.  See the NOTICE file distributed with
 + * this work for additional information regarding copyright ownership.
 + * The ASF licenses this file to You under the Apache License, Version 2.0
 + * (the "License"); you may not use this file except in compliance with
 + * the License.  You may obtain a copy of the License at
 + *
 + *      http://www.apache.org/licenses/LICENSE-2.0
 + *
 + * Unless required by applicable law or agreed to in writing, software
 + * distributed under the License is distributed on an "AS IS" BASIS,
 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 + * See the License for the specific language governing permissions and
 + * limitations under the License.
 + */
 +package com.gemstone.gemfire.cache30;
 +
 +import com.gemstone.gemfire.cache.AttributesFactory;
 +import com.gemstone.gemfire.cache.CacheException;
 +import com.gemstone.gemfire.cache.DataPolicy;
 +import com.gemstone.gemfire.cache.InterestPolicy;
 +import com.gemstone.gemfire.cache.Region;
 +import com.gemstone.gemfire.cache.Scope;
 +import com.gemstone.gemfire.cache.SubscriptionAttributes;
 +import com.gemstone.gemfire.distributed.DistributedMember;
 +import com.gemstone.gemfire.distributed.internal.InternalDistributedSystem;
 +import com.gemstone.gemfire.test.dunit.Host;
 +import com.gemstone.gemfire.test.dunit.VM;
 +
 +/**
 + * Make sure that create are distributed and done in
 + * remote regions that are CACHED_ALL_EVENTS*.
 + *
 + * @author darrel
 + * @since 5.0
 + */
 +public class CachedAllEventsDUnitTest extends CacheTestCase {
 +
 +//  private transient Region r;
 +//  private transient DistributedMember otherId;
 +//  private transient int invokeCount;
 +  
 +  public CachedAllEventsDUnitTest(String name) {
 +    super(name);
 +  }
 +
 +  private VM getOtherVm() {
 +    Host host = Host.getHost(0);
 +    return host.getVM(0);
 +  }
 +    
 +  private void initOtherId() {
 +    VM vm = getOtherVm();
 +    vm.invoke(new CacheSerializableRunnable("Connect") {
 +        public void run2() throws CacheException {
 +          getCache();
 +        }
 +      });
-     vm.invoke(CachedAllEventsDUnitTest.class, "getVMDistributedMember");
++    vm.invoke(() -> CachedAllEventsDUnitTest.getVMDistributedMember());
 +  }
 +  private void doCreateOtherVm() {
 +    VM vm = getOtherVm();
 +    vm.invoke(new CacheSerializableRunnable("create root") {
 +        public void run2() throws CacheException {
 +          AttributesFactory af = new AttributesFactory();
 +          af.setScope(Scope.DISTRIBUTED_ACK);
 +          Region r1 = createRootRegion("r1", af.create());
 +          r1.create("key", "value");
 +        }
 +      });
 +  }
 +
 +  public static DistributedMember getVMDistributedMember() {
 +    return InternalDistributedSystem.getAnyInstance().getDistributedMember();
 +  }
 +  
 +  //////////////////////  Test Methods  //////////////////////
 +
 +  /**
 +   * make sure a remote create will be done in a NORMAL+ALL region
 +   * @param rmtCreate is true if create should happen in remote region
 +   */
 +  private void remoteCreate(DataPolicy dp, InterestPolicy ip, boolean rmtCreate) throws CacheException {
 +    initOtherId();
 +    AttributesFactory af = new AttributesFactory();
 +    af.setDataPolicy(dp);
 +    af.setSubscriptionAttributes(new SubscriptionAttributes(ip));
 +    af.setScope(Scope.DISTRIBUTED_ACK);
 +    Region r1 = createRootRegion("r1", af.create());
 +
 +    assertEquals(false, r1.containsKey("key"));
 +    doCreateOtherVm();
 +    if (rmtCreate) {
 +      assertEquals(true, r1.containsKey("key"));
 +      assertEquals("value", r1.getEntry("key").getValue());
 +    } else {
 +      assertEquals(false, r1.containsKey("key"));
 +    }
 +  }
 +  // TODO these are never used
 +  public void testRemoteCreate_CAE() throws CacheException {
 +    remoteCreate(DataPolicy.NORMAL, InterestPolicy.ALL, true);
 +  }
 +  public void testRemoteCreate_CAER() throws CacheException {
 +    remoteCreate(DataPolicy.REPLICATE, InterestPolicy.CACHE_CONTENT, true);
 +  }
 +  public void testRemoteCreate_C() throws CacheException {
 +    remoteCreate(DataPolicy.NORMAL, InterestPolicy.CACHE_CONTENT, false);
 +  }
 +}

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/5beaaedc/geode-core/src/test/java/com/gemstone/gemfire/cache30/CallbackArgDUnitTest.java
----------------------------------------------------------------------
diff --cc geode-core/src/test/java/com/gemstone/gemfire/cache30/CallbackArgDUnitTest.java
index 49e38c0,0000000..f0bae93
mode 100644,000000..100644
--- a/geode-core/src/test/java/com/gemstone/gemfire/cache30/CallbackArgDUnitTest.java
+++ b/geode-core/src/test/java/com/gemstone/gemfire/cache30/CallbackArgDUnitTest.java
@@@ -1,185 -1,0 +1,185 @@@
 +/*
 + * Licensed to the Apache Software Foundation (ASF) under one or more
 + * contributor license agreements.  See the NOTICE file distributed with
 + * this work for additional information regarding copyright ownership.
 + * The ASF licenses this file to You under the Apache License, Version 2.0
 + * (the "License"); you may not use this file except in compliance with
 + * the License.  You may obtain a copy of the License at
 + *
 + *      http://www.apache.org/licenses/LICENSE-2.0
 + *
 + * Unless required by applicable law or agreed to in writing, software
 + * distributed under the License is distributed on an "AS IS" BASIS,
 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 + * See the License for the specific language governing permissions and
 + * limitations under the License.
 + */
 +package com.gemstone.gemfire.cache30;
 +
 +import java.util.ArrayList;
 +import java.util.Arrays;
 +import java.util.Iterator;
 +import java.util.List;
 +
 +import com.gemstone.gemfire.cache.AttributesFactory;
 +import com.gemstone.gemfire.cache.CacheException;
 +import com.gemstone.gemfire.cache.CacheListener;
 +import com.gemstone.gemfire.cache.CacheTransactionManager;
 +import com.gemstone.gemfire.cache.DataPolicy;
 +import com.gemstone.gemfire.cache.EntryEvent;
 +import com.gemstone.gemfire.cache.Region;
 +import com.gemstone.gemfire.cache.Scope;
 +import com.gemstone.gemfire.cache.TransactionEvent;
 +import com.gemstone.gemfire.cache.TransactionListener;
 +import com.gemstone.gemfire.cache.util.CacheListenerAdapter;
 +import com.gemstone.gemfire.cache.util.TransactionListenerAdapter;
 +import com.gemstone.gemfire.distributed.DistributedMember;
 +import com.gemstone.gemfire.distributed.internal.InternalDistributedSystem;
 +import com.gemstone.gemfire.test.dunit.Host;
 +import com.gemstone.gemfire.test.dunit.SerializableCallable;
 +import com.gemstone.gemfire.test.dunit.VM;
 +
 +/**
 + * Test the getCallbackArgument in light of bug 34075.
 + *
 + * @author darrel
 + * @since 5.0
 + */
 +public class CallbackArgDUnitTest extends CacheTestCase {
 +
 +//  private transient Region r;
 +//  private transient DistributedMember otherId;
 +  protected transient int invokeCount;
 +  protected static String callbackArg;
 +  
 +  public CallbackArgDUnitTest(String name) {
 +    super(name);
 +  }
 +
 +  private VM getOtherVm() {
 +    Host host = Host.getHost(0);
 +    return host.getVM(0);
 +  }
 +    
 +  private void initOtherId() {
 +    VM vm = getOtherVm();
 +    vm.invoke(new CacheSerializableRunnable("Connect") {
 +        public void run2() throws CacheException {
 +          getCache();
 +        }
 +      });
-     vm.invoke(CallbackArgDUnitTest.class, "getVMDistributedMember");
++    vm.invoke(() -> CallbackArgDUnitTest.getVMDistributedMember());
 +  }
 +  private void doCommitOtherVm() {
 +    VM vm = getOtherVm();
 +    vm.invoke(new CacheSerializableRunnable("create root") {
 +        public void run2() throws CacheException {
 +          AttributesFactory af = new AttributesFactory();
 +          CacheListener cl1 = new CacheListenerAdapter() {
 +              public void afterCreate(EntryEvent e) {
 +                assertEquals(callbackArg, e.getCallbackArgument());
 +              }
 +            };
 +          af.addCacheListener(cl1);
 +          af.setScope(Scope.DISTRIBUTED_ACK);
 +          Region r1 = createRootRegion("r1", af.create());
 +          Region r2 = r1.createSubregion("r2", af.create());
 +          Region r3 = r2.createSubregion("r3", af.create());
 +          CacheTransactionManager ctm =  getCache().getCacheTransactionManager();
 +          TransactionListener tl1 = new TransactionListenerAdapter() {
 +              public void afterCommit(TransactionEvent e) {
 +                assertEquals(6, e.getEvents().size());
 +                Iterator it = e.getEvents().iterator();
 +                while (it.hasNext()) {
 +                  EntryEvent ee = (EntryEvent)it.next();
 +                  assertEquals(callbackArg, ee.getCallbackArgument());
 +                  assertEquals(true, ee.isCallbackArgumentAvailable());
 +                }
 +              }
 +            };
 +          ctm.addListener(tl1);
 +          ctm.begin();
 +          r2.put("b", "value1", callbackArg);
 +          r3.put("c", "value2", callbackArg);
 +          r1.put("a", "value3", callbackArg);
 +          r1.put("a2", "value4", callbackArg);
 +          r3.put("c2", "value5", callbackArg);
 +          r2.put("b2", "value6", callbackArg);
 +          ctm.commit();
 +        }
 +      });
 +  }
 +
 +  public static DistributedMember getVMDistributedMember() {
 +    return InternalDistributedSystem.getAnyInstance().getDistributedMember();
 +  }
 +  
 +  //////////////////////  Test Methods  //////////////////////
 +
 +  List expectedKeys;
 +  int clCount = 0;
 +
 +  Object getCurrentExpectedKey() {
 +    Object result = this.expectedKeys.get(this.clCount);
 +    this.clCount += 1;
 +    return result;
 +  }
 +  /**
 +   * make sure callback arg is NOT_AVAILABLE in all the places it should be
 +   */
 +  public void testForNA_CA() throws CacheException {
 +    doTest();
 +  }
 +  public void testForCA() throws Exception {
 +    callbackArg = "cbArg";
 +    getOtherVm().invoke(new SerializableCallable() {
 +      public Object call() throws Exception {
 +        callbackArg = "cbArg";
 +        return null;
 +      }
 +    });
 +    doTest();
 +  }
 +  private void doTest() throws CacheException {
 +    initOtherId();
 +    AttributesFactory af = new AttributesFactory();
 +    af.setDataPolicy(DataPolicy.REPLICATE);
 +    af.setScope(Scope.DISTRIBUTED_ACK);
 +    CacheListener cl1 = new CacheListenerAdapter() {
 +        public void afterCreate(EntryEvent e) {
 +          assertEquals(getCurrentExpectedKey(), e.getKey());
 +          assertEquals(callbackArg, e.getCallbackArgument());
 +          assertEquals(true, e.isCallbackArgumentAvailable());
 +        }
 +      };
 +    af.addCacheListener(cl1);
 +    Region r1 = createRootRegion("r1", af.create());
 +    Region r2 = r1.createSubregion("r2", af.create());
 +    r2.createSubregion("r3", af.create());
 +
 +    TransactionListener tl1 = new TransactionListenerAdapter() {
 +        public void afterCommit(TransactionEvent e) {
 +          assertEquals(6, e.getEvents().size());
 +          ArrayList keys = new ArrayList();
 +          Iterator it = e.getEvents().iterator();
 +          while (it.hasNext()) {
 +            EntryEvent ee = (EntryEvent)it.next();
 +            keys.add(ee.getKey());
 +            assertEquals(callbackArg, ee.getCallbackArgument());
 +            assertEquals(true, ee.isCallbackArgumentAvailable());
 +          }
 +          assertEquals(CallbackArgDUnitTest.this.expectedKeys, keys);
 +          CallbackArgDUnitTest.this.invokeCount = 1;
 +        }
 +      };
 +    CacheTransactionManager ctm =  getCache().getCacheTransactionManager();
 +    ctm.addListener(tl1);
 +
 +    this.invokeCount = 0;
 +    this.clCount = 0;
 +    this.expectedKeys = Arrays.asList(new String[]{"b", "c", "a", "a2", "c2", "b2"});
 +    doCommitOtherVm();
 +    assertEquals(1, this.invokeCount);
 +    assertEquals(6, this.clCount);
 +  }
 +}

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/5beaaedc/geode-core/src/test/java/com/gemstone/gemfire/cache30/ClearMultiVmCallBkDUnitTest.java
----------------------------------------------------------------------
diff --cc geode-core/src/test/java/com/gemstone/gemfire/cache30/ClearMultiVmCallBkDUnitTest.java
index 1d5b621,0000000..e748a42
mode 100644,000000..100644
--- a/geode-core/src/test/java/com/gemstone/gemfire/cache30/ClearMultiVmCallBkDUnitTest.java
+++ b/geode-core/src/test/java/com/gemstone/gemfire/cache30/ClearMultiVmCallBkDUnitTest.java
@@@ -1,249 -1,0 +1,249 @@@
 +/*
 + * Licensed to the Apache Software Foundation (ASF) under one or more
 + * contributor license agreements.  See the NOTICE file distributed with
 + * this work for additional information regarding copyright ownership.
 + * The ASF licenses this file to You under the Apache License, Version 2.0
 + * (the "License"); you may not use this file except in compliance with
 + * the License.  You may obtain a copy of the License at
 + *
 + *      http://www.apache.org/licenses/LICENSE-2.0
 + *
 + * Unless required by applicable law or agreed to in writing, software
 + * distributed under the License is distributed on an "AS IS" BASIS,
 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 + * See the License for the specific language governing permissions and
 + * limitations under the License.
 + */
 +
 +/*
 + * ClearMultiVmCallBkDUnitTest.java
 + *
 + * Created on August 11, 2005, 7:37 PM
 + */
 +package com.gemstone.gemfire.cache30;
 +
 +import java.util.Properties;
 +
 +import com.gemstone.gemfire.cache.AttributesFactory;
 +import com.gemstone.gemfire.cache.Cache;
 +import com.gemstone.gemfire.cache.CacheFactory;
 +import com.gemstone.gemfire.cache.CacheListener;
 +import com.gemstone.gemfire.cache.CacheTransactionManager;
 +import com.gemstone.gemfire.cache.Region;
 +import com.gemstone.gemfire.cache.RegionAttributes;
 +import com.gemstone.gemfire.cache.RegionEvent;
 +import com.gemstone.gemfire.cache.Scope;
 +import com.gemstone.gemfire.cache.util.CacheListenerAdapter;
 +import com.gemstone.gemfire.distributed.DistributedSystem;
 +import com.gemstone.gemfire.test.dunit.DistributedTestCase;
 +import com.gemstone.gemfire.test.dunit.Host;
 +import com.gemstone.gemfire.test.dunit.LogWriterUtils;
 +import com.gemstone.gemfire.test.dunit.VM;
 +
 +/**
 + *
 + * @author  prafulla/vjadhav
 + */
 +public class ClearMultiVmCallBkDUnitTest extends DistributedTestCase{
 +    
 +    /** Creates a new instance of ClearMultiVmCallBkDUnitTest */
 +    public ClearMultiVmCallBkDUnitTest(String name) {
 +        super(name);
 +    }
 +    
 +    static Cache cache;
 +    static Properties props = new Properties();
 +    static Properties propsWork = new Properties();
 +    static DistributedSystem ds = null;
 +    static Region region;
 +    static Region paperWork;
 +    static CacheTransactionManager cacheTxnMgr;
 +    static boolean afterClear=false;
 +    
 +    
 +    @Override
 +    public void setUp() throws Exception {
 +      super.setUp();
 +      Host host = Host.getHost(0);
 +      VM vm0 = host.getVM(0);
 +      VM vm1 = host.getVM(1);
-       vm0.invoke(ClearMultiVmCallBkDUnitTest.class, "createCache");
-       vm1.invoke(ClearMultiVmCallBkDUnitTest.class, "createCache");
++      vm0.invoke(() -> ClearMultiVmCallBkDUnitTest.createCache());
++      vm1.invoke(() -> ClearMultiVmCallBkDUnitTest.createCache());
 +      LogWriterUtils.getLogWriter().fine("Cache created in successfully");
 +    }
 +    
 +    @Override
 +    protected final void preTearDown() throws Exception {
 +      Host host = Host.getHost(0);
 +      VM vm0 = host.getVM(0);
 +      VM vm1 = host.getVM(1);
-       vm0.invoke(ClearMultiVmCallBkDUnitTest.class, "closeCache");
-       vm1.invoke(ClearMultiVmCallBkDUnitTest.class, "closeCache");
++      vm0.invoke(() -> ClearMultiVmCallBkDUnitTest.closeCache());
++      vm1.invoke(() -> ClearMultiVmCallBkDUnitTest.closeCache());
 +    }
 +    
 +    public static void createCache(){
 +        try{
 +            CacheListener aListener = new ListenerCallBk();
 +//            props.setProperty("mcast-port", "1234");
 +//            ds = DistributedSystem.connect(props);
 +            ds = (new ClearMultiVmCallBkDUnitTest("temp")).getSystem(props);            
 +            
 +            cache = CacheFactory.create(ds);
 +            AttributesFactory factory  = new AttributesFactory();
 +            factory.setScope(Scope.DISTRIBUTED_ACK);
 +            
 +            // Set Cachelisterner : aListener
 +            
 +            factory.setCacheListener(aListener);
 +            RegionAttributes attr = factory.create();
 +            
 +            region = cache.createRegion("map", attr);
 +            
 +            
 +        } catch (Exception ex){
 +            ex.printStackTrace();
 +        }
 +    }
 +    
 +    public static void closeCache(){
 +        try{
 +            
 +            cache.close();
 +            ds.disconnect();
 +            
 +        } catch (Exception ex){
 +            ex.printStackTrace();
 +        }
 +    }
 +    
 +    //test methods
 +    
 +    public void testClearSingleVM(){
 +        
 +        Host host = Host.getHost(0);
 +        VM vm0 = host.getVM(0);
 +        //VM vm1 = host.getVM(1);
 +        
 +//        Object obj0;
 +//        Object obj1;
 +        Object[] objArr = new Object[1];
 +        for (int i=1; i<4; i++){
 +            objArr[0] = ""+i;
 +            vm0.invoke(ClearMultiVmCallBkDUnitTest.class, "putMethod", objArr);
 +            
 +        }
 +        LogWriterUtils.getLogWriter().fine("Did all puts successfully");
 +        
-         vm0.invoke(ClearMultiVmCallBkDUnitTest.class,"clearMethod");
++        vm0.invoke(() -> ClearMultiVmCallBkDUnitTest.clearMethod());
 +        LogWriterUtils.getLogWriter().fine("Did clear successfully");
 +        
 +        while(afterClear){
 +        }       
 +        
-         int Regsize = vm0.invokeInt(ClearMultiVmCallBkDUnitTest.class, "sizeMethod");
++        int Regsize = vm0.invoke(() -> ClearMultiVmCallBkDUnitTest.sizeMethod());
 +        assertEquals(1, Regsize);
 +        
 +        
 +    }//end of test case1
 +    
 +     public void testClearMultiVM(){
 +        
 +        Host host = Host.getHost(0);
 +        VM vm0 = host.getVM(0);
 +        VM vm1 = host.getVM(1);
 +        
 +        Object[] objArr = new Object[1];
 +        for (int i=1; i<4; i++){
 +            objArr[0] = ""+i;
 +            vm0.invoke(ClearMultiVmCallBkDUnitTest.class, "putMethod", objArr);
 +            vm1.invoke(ClearMultiVmCallBkDUnitTest.class, "getMethod", objArr);
 +        }
 +        LogWriterUtils.getLogWriter().fine("Did all puts successfully");
-         //vm0.invoke(ClearMultiVmCallBkDUnitTest.class,"putMethod");
-         vm1.invoke(ClearMultiVmCallBkDUnitTest.class,"clearMethod");
++        //vm0.invoke(() -> ClearMultiVmCallBkDUnitTest.putMethod());
++        vm1.invoke(() -> ClearMultiVmCallBkDUnitTest.clearMethod());
 +        LogWriterUtils.getLogWriter().fine("Did clear successfully");
 +        
 +        while(afterClear){
 +        }       
 +        
-         int Regsize = vm0.invokeInt(ClearMultiVmCallBkDUnitTest.class, "sizeMethod");
++        int Regsize = vm0.invoke(() -> ClearMultiVmCallBkDUnitTest.sizeMethod());
 +        assertEquals(1, Regsize);
 +        
 +        
 +    }//end of test case2
 +    
 +    public static Object putMethod(Object ob){
 +        Object obj=null;
 +        try{
 +            if(ob != null){
 +                String str = "first";
 +                obj = region.put(ob, str);
 +            }
 +        }catch(Exception ex){
 +            ex.printStackTrace();
 +            fail("Failed while region.put");
 +        }
 +        return obj;
 +    }
 +    
 +    public static Object getMethod(Object ob){
 +        Object obj=null;
 +        try{
 +            obj = region.get(ob);
 +        } catch(Exception ex){
 +            fail("Failed while region.get");
 +        }
 +        return obj;
 +    }
 +    
 +    public static boolean containsValueMethod(Object ob){
 +        boolean flag = false;
 +        try{
 +            flag = region.containsValue(ob);
 +        }catch(Exception ex){
 +            fail("Failed while region.containsValueMethod");
 +        }
 +        return flag;
 +    }
 +    
 +    public static int sizeMethod(){
 +        int i=0;
 +        try{
 +            i = region.size();
 +        }catch(Exception ex){
 +            fail("Failed while region.size");
 +        }
 +        return i;
 +    }
 +    
 +    public static void clearMethod(){
 +        try{
 +            region.clear();
 +        } catch(Exception ex){
 +            ex.printStackTrace();
 +        }
 +    }
 +    
 +    public static boolean getBoolean(){
 +        return afterClear;
 +    }
 +    
 +    static class ListenerCallBk extends CacheListenerAdapter {
 +  
 +        public void afterRegionClear(RegionEvent event){
 +            LogWriterUtils.getLogWriter().fine("In afterClear:: CacheListener Callback");
 +            try {
 +                int i = 7;
 +                region.put(""+i, "inAfterClear");
 +                afterClear = true;
 +            }catch (Exception e){
 +                //
 +            }
 +            
 +        }
 +        
 +    }
 +    
 +    
 +    
 +}//end of class

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/5beaaedc/geode-core/src/test/java/com/gemstone/gemfire/cache30/ClearMultiVmDUnitTest.java
----------------------------------------------------------------------
diff --cc geode-core/src/test/java/com/gemstone/gemfire/cache30/ClearMultiVmDUnitTest.java
index 8553fe6,0000000..5f9450b
mode 100644,000000..100644
--- a/geode-core/src/test/java/com/gemstone/gemfire/cache30/ClearMultiVmDUnitTest.java
+++ b/geode-core/src/test/java/com/gemstone/gemfire/cache30/ClearMultiVmDUnitTest.java
@@@ -1,469 -1,0 +1,467 @@@
 +/*
 + * Licensed to the Apache Software Foundation (ASF) under one or more
 + * contributor license agreements.  See the NOTICE file distributed with
 + * this work for additional information regarding copyright ownership.
 + * The ASF licenses this file to You under the Apache License, Version 2.0
 + * (the "License"); you may not use this file except in compliance with
 + * the License.  You may obtain a copy of the License at
 + *
 + *      http://www.apache.org/licenses/LICENSE-2.0
 + *
 + * Unless required by applicable law or agreed to in writing, software
 + * distributed under the License is distributed on an "AS IS" BASIS,
 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 + * See the License for the specific language governing permissions and
 + * limitations under the License.
 + */
 +
 +/*
 + * ClearMultiVmDUnitTest.java
 + *
 + * Created on August 11, 2005, 7:37 PM
 + */
 +package com.gemstone.gemfire.cache30;
 +
 +import java.util.Properties;
 +
 +import com.gemstone.gemfire.cache.AttributesFactory;
 +import com.gemstone.gemfire.cache.Cache;
 +import com.gemstone.gemfire.cache.CacheException;
 +import com.gemstone.gemfire.cache.CacheFactory;
 +import com.gemstone.gemfire.cache.CacheTransactionManager;
 +import com.gemstone.gemfire.cache.DataPolicy;
 +import com.gemstone.gemfire.cache.Region;
 +import com.gemstone.gemfire.cache.RegionAttributes;
 +import com.gemstone.gemfire.cache.RegionDestroyedException;
 +import com.gemstone.gemfire.cache.Scope;
 +import com.gemstone.gemfire.cache.UnsupportedOperationInTransactionException;
 +import com.gemstone.gemfire.distributed.DistributedSystem;
 +import com.gemstone.gemfire.test.dunit.Assert;
 +import com.gemstone.gemfire.test.dunit.AsyncInvocation;
 +import com.gemstone.gemfire.test.dunit.DistributedTestCase;
 +import com.gemstone.gemfire.test.dunit.Host;
 +import com.gemstone.gemfire.test.dunit.Invoke;
 +import com.gemstone.gemfire.test.dunit.SerializableRunnable;
 +import com.gemstone.gemfire.test.dunit.ThreadUtils;
 +import com.gemstone.gemfire.test.dunit.VM;
 +
 +/**
 + *
 + * @author  prafulla
 + */
 +public class ClearMultiVmDUnitTest extends DistributedTestCase{
 +    
 +    /** Creates a new instance of ClearMultiVmDUnitTest */
 +    public ClearMultiVmDUnitTest(String name) {
 +        super(name);
 +    }
 +    
 +    static Cache cache;
 +    static Properties props = new Properties();
 +    static Properties propsWork = new Properties();
 +    static DistributedSystem ds = null;
 +    static Region region;
 +    static Region paperWork;
 +    static Region mirroredRegion;
 +    static CacheTransactionManager cacheTxnMgr;
 +    
 +    @Override
 +    public void setUp() throws Exception {
 +      super.setUp();
 +      Host host = Host.getHost(0);
 +      VM vm0 = host.getVM(0);
 +      VM vm1 = host.getVM(1);
-       vm0.invoke(ClearMultiVmDUnitTest.class, "createCache");
-       vm1.invoke(ClearMultiVmDUnitTest.class, "createCache");
++      vm0.invoke(() -> ClearMultiVmDUnitTest.createCache());
++      vm1.invoke(() -> ClearMultiVmDUnitTest.createCache());
 +    }
 +    
 +    @Override
 +    protected final void preTearDown() throws Exception {
 +      Host host = Host.getHost(0);
 +      VM vm0 = host.getVM(0);
 +      VM vm1 = host.getVM(1);
-       vm0.invoke(ClearMultiVmDUnitTest.class, "closeCache");
-       vm1.invoke(ClearMultiVmDUnitTest.class, "closeCache");
++      vm0.invoke(() -> ClearMultiVmDUnitTest.closeCache());
++      vm1.invoke(() -> ClearMultiVmDUnitTest.closeCache());
 +      cache = null;
 +      Invoke.invokeInEveryVM(new SerializableRunnable() { public void run() { cache = null; } });
 +    }
 +    
 +    public static void createCache(){
 +        try{            
 +            ds = (new ClearMultiVmDUnitTest("temp")).getSystem(props);
 +            cache = CacheFactory.create(ds);
 +            AttributesFactory factory  = new AttributesFactory();
 +            factory.setScope(Scope.DISTRIBUTED_ACK);
 +            factory.setConcurrencyChecksEnabled(true);
 +            RegionAttributes attr = factory.create();
 +            region = cache.createRegion("map", attr);
 +            
 +            AttributesFactory factory1  = new AttributesFactory();
 +            factory1.setScope(Scope.DISTRIBUTED_ACK);
 +            factory.setConcurrencyChecksEnabled(true);
 +            factory1.setDataPolicy(DataPolicy.REPLICATE);
 +            paperWork = cache.createRegion("paperWork", factory1.create());
 +            
 +        } catch (Exception ex){
 +            ex.printStackTrace();
 +        }
 +    }
 +    
 +    public static void closeCache(){
 +        try{
 +            cache.close();
 +            ds.disconnect();
 +        } catch (Exception ex){
 +            ex.printStackTrace();
 +        }
 +    }
 +    
 +    //test methods
 +    
 +    public void testClearSimpleScenarios(){
 +        
 +        Host host = Host.getHost(0);
 +        VM vm0 = host.getVM(0);
 +        VM vm1 = host.getVM(1);
 +        
 +        //verifying Single VM clear functionalities
 +        vm0.invoke(new CacheSerializableRunnable("temp1"){
 +            public void run2()throws CacheException{
 +                region.put(new Integer(1), new String("first"));
 +                region.put(new Integer(2), new String("second"));
 +                region.put(new Integer(3), new String("third"));
 +                region.clear();
 +                assertEquals(0, region.size());
 +            }
 +        }
 +        );
 +        
 +        vm1.invoke(new CacheSerializableRunnable("temp1vm1"){
 +            public void run2()throws CacheException{
 +                assertEquals(0, region.size());
 +            }
 +        }
 +        );
 +        
 +        //verifying Single VM and single transaction clear functionalities
 +        vm1.invoke(new CacheSerializableRunnable("temp2"){
 +            public void run2() throws CacheException{
 +                try{
 +                    region.put(new Integer(1), new String("first"));
 +                    region.put(new Integer(2), new String("second"));
 +                    region.put(new Integer(3), new String("third"));
 +                    cacheTxnMgr = cache.getCacheTransactionManager();
 +                    cacheTxnMgr.begin();
 +                    region.put(new Integer(4), new String("forth"));
 +                    try {
 +                      region.clear();
 +                      fail("expected exception not thrown");
 +                    } catch (UnsupportedOperationInTransactionException e) {
 +                      // expected
 +                    }
 +                    region.put(new Integer(5), new String("fifth"));
 +                    cacheTxnMgr.commit();
 +                    assertEquals(5, region.size());
 +                    assertEquals("fifth", region.get(new Integer(5)).toString());
 +                }
 +                catch(CacheException ce){
 +                    ce.printStackTrace();
 +                }
 +                finally{
 +                    if(cacheTxnMgr.exists()){
 +                        try {cacheTxnMgr.commit();} catch (Exception cce){cce.printStackTrace();}
 +                    }
 +                }
 +                
 +            }
 +        }
 +        );
 +        
 +        //verifying that region.clear does not clear the entries from sub region
 +        vm0.invoke(new CacheSerializableRunnable("temp3"){
 +            public void run2()throws CacheException{
 +                region.put(new Integer(1), new String("first"));
 +                region.put(new Integer(2), new String("second"));
 +                AttributesFactory factory  = new AttributesFactory();
 +                factory.setScope(Scope.DISTRIBUTED_ACK);
 +                RegionAttributes attr = factory.create();
 +                Region subRegion = region.createSubregion("subr", attr);
 +                subRegion.put(new Integer(3), new String("third"));
 +                subRegion.put(new Integer(4), new String("forth"));
 +                region.clear();
 +                assertEquals(0, region.size());
 +                assertEquals(2, subRegion.size());
 +            }
 +        }
 +        );
 +        
 +    }//end of test case
 +    
 +    public void testClearMultiVM() throws Throwable{
 +        Host host = Host.getHost(0);
 +        VM vm0 = host.getVM(0);
 +        VM vm1 = host.getVM(1);
 +        
 +        //put 3 key/values in vm0 and get from vm1
 +        Object[] objArr = new Object[1];
 +        //Integer in = new Integer(i);
 +        //objArr[0] = (Object) in;
 +        for (int i=1; i<4; i++){
 +            objArr[0] = ""+i;
 +            vm0.invoke(ClearMultiVmDUnitTest.class, "putMethod", objArr);
 +            vm1.invoke(ClearMultiVmDUnitTest.class, "getMethod", objArr);
 +        }
 +        
-         AsyncInvocation as1 = vm0.invokeAsync(ClearMultiVmDUnitTest.class, "firstVM");
-         AsyncInvocation as2 = vm1.invokeAsync(ClearMultiVmDUnitTest.class, "secondVM");
++        AsyncInvocation as1 = vm0.invokeAsync(() -> ClearMultiVmDUnitTest.firstVM());
++        AsyncInvocation as2 = vm1.invokeAsync(() -> ClearMultiVmDUnitTest.secondVM());
 +        ThreadUtils.join(as1, 30 * 1000);
 +        ThreadUtils.join(as2, 30 * 1000);
 +        
 +        if(as1.exceptionOccurred()){
 +          Assert.fail("as1 failed", as1.getException());
 +        }
 +        
 +        if(as2.exceptionOccurred()){
 +          Assert.fail("as2 failed", as2.getException());
 +        }
 +        
-         int j = vm0.invokeInt(ClearMultiVmDUnitTest.class, "sizeMethod");
++        int j = vm0.invoke(() -> ClearMultiVmDUnitTest.sizeMethod());
 +        assertEquals(0, j);
 +        
-         j = vm1.invokeInt(ClearMultiVmDUnitTest.class, "sizeMethod");
++        j = vm1.invoke(() -> ClearMultiVmDUnitTest.sizeMethod());
 +        assertEquals(1, j);
 +        
 +        
 +        
 +        int i=6;
 +        objArr[0] = ""+i;
 +        vm1.invoke(ClearMultiVmDUnitTest.class, "getMethod", objArr);
 +        
-         Object ob[] = new Object[1];
-         ob[0] = "secondVM";
-         boolean val = vm1.invokeBoolean(ClearMultiVmDUnitTest.class, "containsValueMethod", ob);
++        boolean val = vm1.invoke(() -> containsValueMethod("secondVM"));
 +        assertEquals(true, val);
 +        
 +    }//end of testClearMultiVM
 +    
 +    public void testClearExceptions(){
 +        Host host = Host.getHost(0);
 +        VM vm0 = host.getVM(0);
 +        VM vm1 = host.getVM(1);
 +        
-         vm1.invoke(ClearMultiVmDUnitTest.class, "localDestroyRegionMethod");
++        vm1.invoke(() -> ClearMultiVmDUnitTest.localDestroyRegionMethod());
 +        vm0.invoke(new CacheSerializableRunnable ("exception in vm0"){
 +            public void run2() throws CacheException {
 +               try{
 +                    region.clear();                    
 +                } catch(RegionDestroyedException rdex){
 +                    fail("Should NOT have thrown RegionDestroyedException");
 +                } 
 +            }
 +        }        
 +        );
 +        
 +        vm1.invoke(new CacheSerializableRunnable ("exception in vm1"){
 +            public void run2() throws CacheException {
 +               try{
 +                    region.clear();
 +                    fail("Should have thrown RegionDestroyedException");
 +                } catch(RegionDestroyedException rdex){
 +                    //pass
 +                } 
 +            }
 +        }        
 +        );
 +        
 +    }//end of testClearExceptions
 +
 +    public void testGiiandClear() throws Throwable{
 +      if (false) {
 +        getSystem().getLogWriter().severe("testGiiandClear skipped because of bug 34963");
 +      } else {
 +        Host host = Host.getHost(0);
 +        VM vm0 = host.getVM(0);
 +        VM vm1 = host.getVM(1);
 +        
 +        SerializableRunnable create = new
 +        CacheSerializableRunnable("create mirrored region") {
 +            public void run2() throws CacheException {
 +                AttributesFactory factory1  = new AttributesFactory();
 +                factory1.setScope(Scope.DISTRIBUTED_ACK);
 +                factory1.setDataPolicy(DataPolicy.REPLICATE);
 +                RegionAttributes attr1 = factory1.create();
 +                mirroredRegion = cache.createRegion("mirrored", attr1);
 +                // reset slow
 +                com.gemstone.gemfire.internal.cache.InitialImageOperation.slowImageProcessing = 0;
 +            }
 +        };
 +        
 +        
 +        vm0.invoke(create);
 +        
 +        vm0.invoke(new CacheSerializableRunnable("put initial data"){
 +            public void run2() throws CacheException {
 +                for(int i=0; i<1000; i++){
 +                    mirroredRegion.put(new Integer(i), (new Integer(i)).toString());
 +                }
 +            }
 +        }
 +        );
 +        
 +        // slow down image processing to make it more likely to get async updates
 +        vm1.invoke(new SerializableRunnable("set slow image processing") {
 +            public void run() {
 +                // if this is a no_ack test, then we need to slow down more because of the
 +                // pauses in the nonblocking operations
 +                int pause = 50;
 +                com.gemstone.gemfire.internal.cache.InitialImageOperation.slowImageProcessing = pause;
 +            }
 +        });
 +        
 +        // now do the get initial image in vm1
 +        AsyncInvocation async1 = vm1.invokeAsync(create);
 +
 +        // try to time a distributed clear to happen in the middle of gii
 +        vm0.invoke(new SerializableRunnable("call clear when gii") {
 +            public void run() {
 +                try{Thread.sleep(3*1000);}catch(InterruptedException ex){fail("interrupted");}
 +                mirroredRegion.clear();                
 +                assertEquals(0, mirroredRegion.size());
 +            }
 +        });
 +        
 +        ThreadUtils.join(async1, 30 * 1000);
 +        if(async1.exceptionOccurred()){
 +          Assert.fail("async1 failed", async1.getException());
 +        }
 +        
 +        SerializableRunnable validate = new
 +        CacheSerializableRunnable("validate for region size") {
 +            public void run2() throws CacheException {
 +                assertEquals(0, mirroredRegion.size());
 +            }
 +        };
 +        
 +        vm0.invoke(validate);
 +        vm1.invoke(validate);
 +      }
 +        
 +    }//end of testGiiandClear
 +    
 +    
 +    //remote vm methods
 +    
 +    public static void firstVM(){
 +          //put one entry
 +          int i=5;
 +          region.put(i, "firstVM");
 +            
 +          //test localClear
 +          region.localClear();
 +          assertFalse(region.containsKey(i));
 +          
 +          paperWork.put("localClear","true");
 +          
 +          // wait unit clear on 2nd VM
 +          boolean val=false;
 +          while (!val) {
 +            val = paperWork.containsKey("localClearVerified");
 +          }
 +          region.put("key10", "value");
 +          region.put("key11", "value");
 +          
 +          // test distributed clear
 +          region.clear();
 +          paperWork.put("clear", "value");
 +          
 +          val = false;
 +          while (!val) {
 +            val = paperWork.containsKey("clearVerified");
 +          }
 +          
 +    }//end of firstVM
 +    
 +    public static void secondVM(){
 +          // verify that localClear on the other VM does not affect size on this VM
 +          boolean val=false;
 +          while (!val) {
 +            val = paperWork.containsKey("localClear");
 +          }
 +          assertEquals(3, region.size());
 +          
 +          paperWork.put("localClearVerified", "value");
 +          
 +          // wait for clear
 +          val = false;
 +          while (!val) {
 +            val = paperWork.containsKey("clear");
 +          }
 +          assertEquals(0, region.size());
 +          
 +          paperWork.put("clearVerified", "value");
 +          region.put(""+6, "secondVM");
 +    }//end of secondVM
 +    
 +    //helper methods
 +    
 +    
 +    public static Object putMethod(Object ob){
 +        Object obj=null;
 +        try{
 +            if(ob != null){
 +                String str = "first";
 +                obj = region.put(ob, str);
 +            }
 +        }catch(Exception ex){
 +            ex.printStackTrace();
 +            fail("Failed while region.put");
 +        }
 +        return obj;
 +    }
 +    
 +    public static Object getMethod(Object ob){
 +        Object obj=null;
 +        try{
 +            obj = region.get(ob);
 +        } catch(Exception ex){
 +            fail("Failed while region.get");
 +        }
 +        return obj;
 +    }
 +    
 +    public static boolean containsValueMethod(Object ob){
 +        boolean flag = false;
 +        try{
 +            flag = region.containsValue(ob);
 +        }catch(Exception ex){
 +            fail("Failed while region.containsValueMethod");
 +        }
 +        return flag;
 +    }
 +    
 +    public static int sizeMethod(){
 +        int i=0;
 +        try{
 +            i = region.size();
 +        }catch(Exception ex){
 +            fail("Failed while region.size");
 +        }
 +        return i;
 +    }
 +    
 +    public static void localDestroyRegionMethod(){
 +        try{
 +            region.localDestroyRegion();
 +        } catch (Exception ex){
 +            ex.printStackTrace();
 +        }
 +    }//end of localDestroyRegionMethod
 +    
 +    public static void clearExceptions(){
 +        try{
 +            region.clear();
 +            //fail("Should have thrown RegionDestroyedException");
 +        } catch(RegionDestroyedException rdex){
 +            //pass
 +        }
 +    }//end of clearExceptions
 +    
 +}//end of class


Mime
View raw message