geode-core/src/distributedTest/java/org/apache/geode/cache30/DistAckMapMethodsDUnitTest.java - geode - Git at Google

 /*
  * 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.
  */

 /*
  * DistAckMapMethodsDUnitTest.java
  *
  * Created on August 4, 2005, 12:36 PM
  */
 package org.apache.geode.cache30;

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.fail;

 import java.util.HashSet;
 import java.util.Properties;
 import java.util.Set;

 import org.junit.Test;

 import org.apache.geode.cache.AttributesFactory;
 import org.apache.geode.cache.Cache;
 import org.apache.geode.cache.CacheException;
 import org.apache.geode.cache.CacheFactory;
 import org.apache.geode.cache.CacheListener;
 import org.apache.geode.cache.CacheWriter;
 import org.apache.geode.cache.DataPolicy;
 import org.apache.geode.cache.EntryEvent;
 import org.apache.geode.cache.Region;
 import org.apache.geode.cache.RegionAttributes;
 import org.apache.geode.cache.RegionDestroyedException;
 import org.apache.geode.cache.Scope;
 import org.apache.geode.cache.util.CacheListenerAdapter;
 import org.apache.geode.cache.util.CacheWriterAdapter;
 import org.apache.geode.distributed.DistributedSystem;
 import org.apache.geode.test.dunit.Host;
 import org.apache.geode.test.dunit.Invoke;
 import org.apache.geode.test.dunit.LogWriterUtils;
 import org.apache.geode.test.dunit.SerializableRunnable;
 import org.apache.geode.test.dunit.VM;
 import org.apache.geode.test.dunit.internal.JUnit4DistributedTestCase;


 public class DistAckMapMethodsDUnitTest extends JUnit4DistributedTestCase { // TODO: reformat

   static Cache cache;
   static Properties props = new Properties();
   static DistributedSystem ds = null;
   static Region region;
   static Region mirroredRegion;
   static Region remRegion;
   static boolean afterDestroy = false;


   // helper class referece objects
   static Object afterDestroyObj;

   @Override
   public final void postSetUp() throws Exception {
     Host host = Host.getHost(0);
     VM vm0 = host.getVM(0);
     VM vm1 = host.getVM(1);
     vm0.invoke(() -> DistAckMapMethodsDUnitTest.createCache());
     vm1.invoke(() -> DistAckMapMethodsDUnitTest.createCache());
   }

   @Override
   public final void preTearDown() throws Exception {
     Host host = Host.getHost(0);
     VM vm0 = host.getVM(0);
     VM vm1 = host.getVM(1);
     vm0.invoke(() -> DistAckMapMethodsDUnitTest.closeCache());
     vm1.invoke(() -> DistAckMapMethodsDUnitTest.closeCache());
     cache = null;
     Invoke.invokeInEveryVM(new SerializableRunnable() {
       @Override
       public void run() {
         cache = null;
       }
     });
   }

   public static void createCache() {
     try {
       // props.setProperty(DistributionConfig.SystemConfigurationProperties.MCAST_PORT, "1234");
       // ds = DistributedSystem.connect(props);
       ds = (new DistAckMapMethodsDUnitTest()).getSystem(props);
       cache = CacheFactory.create(ds);
       AttributesFactory factory = new AttributesFactory();
       factory.setScope(Scope.DISTRIBUTED_ACK);
       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 static void createMirroredRegion() {
     try {
       AttributesFactory factory1 = new AttributesFactory();
       factory1.setScope(Scope.DISTRIBUTED_ACK);
       factory1.setDataPolicy(DataPolicy.REPLICATE);
       RegionAttributes attr1 = factory1.create();
       mirroredRegion = cache.createRegion("mirrored", attr1);

     } catch (Exception ex) {
       ex.printStackTrace();
     }
   }

   public static void createRegionToTestRemove() {
     try {
       AttributesFactory factory2 = new AttributesFactory();
       factory2.setScope(Scope.DISTRIBUTED_ACK);
       CacheWriter cacheWriter = new RemoveCacheWriter();
       CacheListener cacheListener = new RemoveCacheListener();
       factory2.setCacheWriter(cacheWriter);
       factory2.setCacheListener(cacheListener);
       RegionAttributes attr2 = factory2.create();
       remRegion = cache.createRegion("remove", attr2);

     } catch (Exception ex) {
       ex.printStackTrace();
     }
   }

   // testMethods

   @Test
   public void testPutMethod() {
     Host host = Host.getHost(0);
     VM vm0 = host.getVM(0);
     VM vm1 = host.getVM(1);
     Object obj1;
     // put from one and get from other
     int i = 1;
     Object[] objArr = new Object[1];
     objArr[0] = "" + i;
     // Integer in = new Integer(i);
     // objArr[0] = (Object) in;
     vm0.invoke(DistAckMapMethodsDUnitTest.class, "putMethod", objArr);
     obj1 = vm1.invoke(DistAckMapMethodsDUnitTest.class, "getMethod", objArr);
     if (obj1 == null) {
       fail("region.put(key, value) from one vm does not match with region.get(key) from other vm");
     }

     // put from both vms for same key
     i = 2;
     objArr[0] = "" + i;
     // in = new Integer(i);
     // objArr[0] = (Object) in;
     vm0.invoke(DistAckMapMethodsDUnitTest.class, "putMethod", objArr);
     obj1 = vm1.invoke(DistAckMapMethodsDUnitTest.class, "putMethod", objArr);
     if (obj1 != null) {// here if some dummy object is returned on first time put then that should
                        // be checked
       fail("failed while region.put from both vms for same key");
     }
   }

   @Test
   public void testRemoveMethod() {
     Host host = Host.getHost(0);
     VM vm0 = host.getVM(0);
     VM vm1 = host.getVM(1);
     Object obj1, obj2;
     boolean ret;
     // put from one and get from other
     int i = 1;
     Object objArr[] = new Object[1];
     objArr[0] = "" + i;
     // Integer in = new Integer(i);
     // objArr[0] = (Object) in;
     vm0.invoke(DistAckMapMethodsDUnitTest.class, "putMethod", objArr);
     vm0.invoke(DistAckMapMethodsDUnitTest.class, "removeMethod", objArr);
     // validate if vm0 has that key value entry
     ret = vm0.invoke(() -> containsKeyMethod("" + i));
     if (ret) {// if returned true means that the key is still there
       fail("region.remove failed with distributed ack scope");
     }

     // test if the correct value is returned
     vm0.invoke(DistAckMapMethodsDUnitTest.class, "putMethod", objArr);
     obj1 = vm1.invoke(DistAckMapMethodsDUnitTest.class, "getMethod", objArr);// to make sure that
                                                                              // vm1 region has the
                                                                              // entry
     obj2 = vm1.invoke(DistAckMapMethodsDUnitTest.class, "removeMethod", objArr);
     LogWriterUtils.getLogWriter().fine("111111111" + obj1);
     LogWriterUtils.getLogWriter().fine("2222222222" + obj2);
     if (obj1 == null)
       fail("region1.getMethod returned null");
     if (!(obj1.equals(obj2))) {
       fail("region.remove failed with distributed ack scope");
     }
   }

   @Test
   public void testRemoveMethodDetails() {
     Host host = Host.getHost(0);
     VM vm0 = host.getVM(0);
     VM vm1 = host.getVM(1);

     vm0.invoke(() -> DistAckMapMethodsDUnitTest.createRegionToTestRemove());
     vm1.invoke(() -> DistAckMapMethodsDUnitTest.createRegionToTestRemove());

     vm0.invoke(() -> DistAckMapMethodsDUnitTest.removeMethodDetails());
     vm1.invoke(new CacheSerializableRunnable("testRemoveMethodDetails") {
       @Override
       public void run2() throws CacheException {
         Object ob1 = remRegion.get(new Integer(1));
         assertEquals("beforeDestroy", ob1.toString());
         // wait till listeber switches afterDestroy to true
         // while(!afterDestroy){
         // //wait
         // }
         assertEquals("afterDestroy", remRegion.get(new Integer(3)).toString());
       }
     });
   }// end of testRemoveMethodDetails

   @Test
   public void testIsEmptyMethod() {
     Host host = Host.getHost(0);
     VM vm0 = host.getVM(0);
     VM vm1 = host.getVM(1);
     // boolean ret;
     // put from one and get from other
     int i = 1;
     Object objArr[] = new Object[1];
     objArr[0] = "" + i;
     // Integer in = new Integer(i);
     // objArr[0] = (Object) in;
     vm0.invoke(DistAckMapMethodsDUnitTest.class, "putMethod", objArr);
     boolean val = vm1.invoke(() -> DistAckMapMethodsDUnitTest.isEmptyMethod());
     if (!val) {// val should be true
       fail("Failed in region.isEmpty");
     }

     vm1.invoke(DistAckMapMethodsDUnitTest.class, "getMethod", objArr);
     boolean val1 = vm1.invoke(() -> DistAckMapMethodsDUnitTest.isEmptyMethod());
     if (val1) {
       fail("Failed in region.isEmpty");
     }
   }

   @Test
   public void testContainsValueMethod() {
     Host host = Host.getHost(0);
     VM vm0 = host.getVM(0);
     VM vm1 = host.getVM(1);
     // boolean ret;
     // put from one and get from other
     int i = 1;
     Object objArr[] = new Object[1];
     objArr[0] = "" + i;
     // Integer in = new Integer(i);
     // objArr[0] = (Object) in;
     vm0.invoke(DistAckMapMethodsDUnitTest.class, "putMethod", objArr);
     boolean val = vm1.invoke(() -> containsValueMethod("first"));
     if (val) {// val should be false.
       fail("Failed in region.ContainsValue");
     }

     vm1.invoke(DistAckMapMethodsDUnitTest.class, "getMethod", objArr);
     boolean val1 = vm1.invoke(() -> containsValueMethod("first"));
     if (!val1) {// val1 should be true.
       fail("Failed in region.ContainsValue");
     }
   }

   @Test
   public void testKeySetMethod() {
     Host host = Host.getHost(0);
     VM vm0 = host.getVM(0);
     VM vm1 = host.getVM(1);

     int i = 1;
     Object objArr[] = new Object[1];
     objArr[0] = "" + i;
     // Integer in = new Integer(i);
     // objArr[0] = (Object) in;
     vm0.invoke(DistAckMapMethodsDUnitTest.class, "putMethod", objArr);
     int temp = vm1.invoke(() -> DistAckMapMethodsDUnitTest.keySetMethod());
     if (temp != 0) {
       fail("failed in keySetMethodtest method");
     }

     vm1.invoke(DistAckMapMethodsDUnitTest.class, "getMethod", objArr);// to make sure that vm1
                                                                       // region has the entry
     temp = vm1.invoke(() -> DistAckMapMethodsDUnitTest.keySetMethod());
     if (temp == 0) {
       fail("failed in keySetMethodtest method");
     }
     // in the above scenarion we can test this for mirrorred region scenarion as well
     temp = 0;
     vm0.invoke(() -> DistAckMapMethodsDUnitTest.createMirroredRegion());
     vm1.invoke(() -> DistAckMapMethodsDUnitTest.createMirroredRegion());
     vm0.invoke(DistAckMapMethodsDUnitTest.class, "putMethod", objArr);
     temp = vm1.invoke(() -> DistAckMapMethodsDUnitTest.keySetMethod());
     if (temp == 0) {
       fail("failed in keySetMethodtest method");
     }
   }


   @Test
   public void testEntrySetMethod() {
     Host host = Host.getHost(0);
     VM vm0 = host.getVM(0);
     VM vm1 = host.getVM(1);

     int i = 1;
     Object objArr[] = new Object[1];
     objArr[0] = "" + i;
     // Integer in = new Integer(i);
     // objArr[0] = (Object) in;
     vm0.invoke(DistAckMapMethodsDUnitTest.class, "putMethod", objArr);
     int temp = vm1.invoke(() -> DistAckMapMethodsDUnitTest.entrySetMethod());
     if (temp != 0) {
       fail("failed in entrySetMethodtest method");
     }

     vm1.invoke(DistAckMapMethodsDUnitTest.class, "getMethod", objArr);// to make sure that vm1
                                                                       // region has the entry
     temp = vm1.invoke(() -> DistAckMapMethodsDUnitTest.entrySetMethod());
     if (temp == 0) {
       fail("failed in entrySetMethodtest method");
     }
     // in the above scenarion we can test this for mirrorred region scenarion as well
     temp = 0;
     vm0.invoke(() -> DistAckMapMethodsDUnitTest.createMirroredRegion());
     vm1.invoke(() -> DistAckMapMethodsDUnitTest.createMirroredRegion());
     vm0.invoke(DistAckMapMethodsDUnitTest.class, "putOnMirroredRegion", objArr);
     temp = vm1.invoke(() -> DistAckMapMethodsDUnitTest.entrySetMethod());
     if (temp == 0) {
       fail("failed in entrySetMethodtest method");
     }
   }

   @Test
   public void testSizeMethod() {
     Host host = Host.getHost(0);
     VM vm0 = host.getVM(0);
     VM vm1 = host.getVM(1);

     int i = 1, j = 0;
     Object objArr[] = new Object[1];
     objArr[0] = "" + i;
     // Integer in = new Integer(i);
     // objArr[0] = (Object) in;
     vm0.invoke(DistAckMapMethodsDUnitTest.class, "putMethod", objArr);
     j = vm1.invoke(() -> DistAckMapMethodsDUnitTest.sizeMethod());
     if (j != 0) {
       fail("failed in region.size method");
     }

     vm1.invoke(DistAckMapMethodsDUnitTest.class, "getMethod", objArr);// to make sure that vm1
                                                                       // region has the entry
     j = vm1.invoke(() -> DistAckMapMethodsDUnitTest.sizeMethod());
     if (j == 0) {
       fail("failed in region.size method");
     }
   }

   @Test
   public void testallMethodsArgs() {
     Host host = Host.getHost(0);
     VM vm0 = host.getVM(0);
     vm0.invoke(() -> DistAckMapMethodsDUnitTest.allMethodsArgs());
   }


   // following is the implementation of the methods of Map to use in dunit test cases.
   public static Object putMethod(Object ob) {
     Object obj = null;
     try {
       if (ob != null) {
         String str = "first";
         obj = region.put(ob, str);
       }
     } catch (Exception ex) {
       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 Object removeMethod(Object ob) {
     Object obj = null;
     try {
       obj = region.remove(ob);
     } catch (Exception ex) {
       ex.printStackTrace();
       fail("Failed while region.remove");
     }
     return obj;
   }

   public static boolean containsKeyMethod(Object ob) {
     boolean flag = false;
     try {
       flag = region.containsKey(ob);
     } catch (Exception ex) {
       fail("Failed while region.containsKey");
     }
     return flag;
   }

   public static boolean isEmptyMethod() {
     boolean flag = false;
     try {
       flag = region.isEmpty();
     } catch (Exception ex) {
       fail("Failed while region.isEmpty");
     }
     return flag;
   }

   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 keySetMethod() {
     Set set = new HashSet();
     int i = 0;
     try {
       set = region.keySet();
       i = set.size();
     } catch (Exception ex) {
       ex.printStackTrace();
       fail("Failed while region.keySet");
     }
     return i;
   }

   public static int entrySetMethod() {
     Set set = new HashSet();
     int i = 0;
     try {
       set = region.entrySet();
       i = set.size();
     } catch (Exception ex) {
       ex.printStackTrace();
       fail("Failed while region.entrySet");
     }
     return i;
   }

   public static int sizeMethod() {
     int i = 0;
     try {
       i = region.size();
     } catch (Exception ex) {
       fail("Failed while region.size");
     }
     return i;
   }

   // following are methods for put on and get from mirrored regions

   public static Object putOnMirroredRegion(Object ob) {
     Object obj = null;
     try {
       String str = "mirror";
       obj = mirroredRegion.put(ob, str);
     } catch (Exception ex) {
       ex.printStackTrace();
       fail("Failed while mirroredRegion.put");
     }
     return obj;
   }

   public static Object getFromMirroredRegion(Object ob) {
     Object obj = null;
     try {
       obj = mirroredRegion.get(ob);

     } catch (Exception ex) {
       fail("Failed while mirroredRegion.get");
     }
     return obj;
   }

   public static void removeMethodDetails() {
     Object ob1;
     // Object ob2;
     Integer inOb1 = new Integer(1);
     try {
       region.put(inOb1, "first");
       ob1 = region.remove(inOb1);
       assertEquals("first", ob1.toString());
     } catch (Exception ex) {
       ex.printStackTrace();
     }

     // to test EntryNotFoundException
     try {
       region.remove(new Integer(2));
       // fail("Should have thrown EntryNotFoundException");
     } // catch (EntryNotFoundException e){
     catch (Exception e) {
       // pass
       // e.printStackTrace();
     }

     // to test NullPointerException
     try {
       Integer inOb2 = new Integer(2);
       region.put(inOb2, "second");
       inOb2 = null;
       region.remove(inOb2);
       fail("Should have thrown NullPointerException ");
     } catch (NullPointerException e) {
       // pass
     }

     // to test the cache writers and listeners
     try {
       // createRegionToTestRemove();
       Integer inOb2 = new Integer(2);
       remRegion.put(inOb2, "second");
       remRegion.remove(inOb2);

       // to test cacheWriter
       inOb2 = new Integer(1);
       assertEquals("beforeDestroy", remRegion.get(inOb2).toString());

       // wait till listeber switches afterDestroy to true
       while (!afterDestroy) {
       }
       // to test cacheListener
       inOb2 = new Integer(3);
       assertEquals("afterDestroy", remRegion.get(inOb2).toString());

       // verify that entryEventvalue is correct for listener
       assertNotNull(afterDestroyObj);

     } catch (Exception ex) {
       ex.printStackTrace();
     }


   }// end of removeMethodDetail

   public static void allMethodsArgs() {
     // testing args for put method
     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"));

       // test args for get method
       Object ob1 = region.get(new Integer(1));
       assertEquals("first", ob1.toString());

       // test args for containsKey method
       boolean val1 = region.containsKey(new Integer(2));
       assertEquals(true, val1);

       // test args for containsKey method
       boolean val2 = region.containsValue(new String("second"));
       // assertIndexDetailsEquals(true, val2);

       // test args for remove method
       try {
         region.remove(new Integer(3));
       } // catch (EntryNotFoundException ex){
       catch (Exception ex) {
         ex.printStackTrace();
         fail("failed while region.remove(new Object())");
       }

       // verifying the correct exceptions are thrown by the methods

       Object key = null, value = null;
       // testing put method
       try {
         region.put(key, value);
         fail("should have thrown NullPointerException");
       } catch (NullPointerException iex) {
         // pass
       }

       // testing containsValue method
       try {
         region.containsValue(value);
         fail("should have thrown NullPointerException");
       } catch (NullPointerException iex) {
         // pass
       }

       // RegionDestroyedException
       key = new Integer(5);
       value = new String("fifth");

       region.localDestroyRegion();
       // test put method
       try {
         region.put(key, value);
         fail("should have thrown RegionDestroyedException");
       } catch (RegionDestroyedException iex) {
         // pass
       }

       // test remove method
       try {
         region.remove(key);
         fail("should have thrown RegionDestroyedException");
       } catch (RegionDestroyedException iex) {
         // pass
       }

       // test containsValue method
       try {
         region.containsValue(value);
         fail("should have thrown RegionDestroyedException");
       } catch (RegionDestroyedException iex) {
         // pass
       }

       // test size method
       try {
         region.size();
         fail("should have thrown RegionDestroyedException");
       } catch (RegionDestroyedException iex) {
         // pass
       }

       // test keySet method
       try {
         region.keySet();
         fail("should have thrown RegionDestroyedException");
       } catch (RegionDestroyedException iex) {
         // pass
       }

       // test entrySet method
       try {
         region.entrySet();
         fail("should have thrown RegionDestroyedException");
       } catch (RegionDestroyedException iex) {
         // pass
       }


     } catch (Exception ex) {
       ex.printStackTrace();
     }

   }// end of allMethodsArgs

   // helper classes

   static class RemoveCacheWriter extends CacheWriterAdapter {

     @Override
     public void beforeDestroy(EntryEvent entryEvent)
         throws org.apache.geode.cache.CacheWriterException {
       Integer o1 = new Integer(1);
       remRegion.put(o1, "beforeDestroy");
     }

   }// end of RemoveCacheWriter


   static class RemoveCacheListener extends CacheListenerAdapter {

     @Override
     public void afterDestroy(EntryEvent entryEvent)
         throws org.apache.geode.cache.CacheWriterException {
       Integer o1 = new Integer(3);
       remRegion.put(o1, "afterDestroy");

       afterDestroyObj = entryEvent.getKey();

       // to continue main thread where region.remove has actually occurred
       afterDestroy = true;
     }

   }// end of RemoveCacheListener


 }// end of class
	/*
	* 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.
	*/

	/*
	* DistAckMapMethodsDUnitTest.java
	*
	* Created on August 4, 2005, 12:36 PM
	*/
	package org.apache.geode.cache30;

	import static org.junit.Assert.assertEquals;
	import static org.junit.Assert.assertNotNull;
	import static org.junit.Assert.fail;

	import java.util.HashSet;
	import java.util.Properties;
	import java.util.Set;

	import org.junit.Test;

	import org.apache.geode.cache.AttributesFactory;
	import org.apache.geode.cache.Cache;
	import org.apache.geode.cache.CacheException;
	import org.apache.geode.cache.CacheFactory;
	import org.apache.geode.cache.CacheListener;
	import org.apache.geode.cache.CacheWriter;
	import org.apache.geode.cache.DataPolicy;
	import org.apache.geode.cache.EntryEvent;
	import org.apache.geode.cache.Region;
	import org.apache.geode.cache.RegionAttributes;
	import org.apache.geode.cache.RegionDestroyedException;
	import org.apache.geode.cache.Scope;
	import org.apache.geode.cache.util.CacheListenerAdapter;
	import org.apache.geode.cache.util.CacheWriterAdapter;
	import org.apache.geode.distributed.DistributedSystem;
	import org.apache.geode.test.dunit.Host;
	import org.apache.geode.test.dunit.Invoke;
	import org.apache.geode.test.dunit.LogWriterUtils;
	import org.apache.geode.test.dunit.SerializableRunnable;
	import org.apache.geode.test.dunit.VM;
	import org.apache.geode.test.dunit.internal.JUnit4DistributedTestCase;


	public class DistAckMapMethodsDUnitTest extends JUnit4DistributedTestCase { // TODO: reformat

	static Cache cache;
	static Properties props = new Properties();
	static DistributedSystem ds = null;
	static Region region;
	static Region mirroredRegion;
	static Region remRegion;
	static boolean afterDestroy = false;


	// helper class referece objects
	static Object afterDestroyObj;

	@Override
	public final void postSetUp() throws Exception {
	Host host = Host.getHost(0);
	VM vm0 = host.getVM(0);
	VM vm1 = host.getVM(1);
	vm0.invoke(() -> DistAckMapMethodsDUnitTest.createCache());
	vm1.invoke(() -> DistAckMapMethodsDUnitTest.createCache());
	}

	@Override
	public final void preTearDown() throws Exception {
	Host host = Host.getHost(0);
	VM vm0 = host.getVM(0);
	VM vm1 = host.getVM(1);
	vm0.invoke(() -> DistAckMapMethodsDUnitTest.closeCache());
	vm1.invoke(() -> DistAckMapMethodsDUnitTest.closeCache());
	cache = null;
	Invoke.invokeInEveryVM(new SerializableRunnable() {
	@Override
	public void run() {
	cache = null;
	}
	});
	}

	public static void createCache() {
	try {
	// props.setProperty(DistributionConfig.SystemConfigurationProperties.MCAST_PORT, "1234");
	// ds = DistributedSystem.connect(props);
	ds = (new DistAckMapMethodsDUnitTest()).getSystem(props);
	cache = CacheFactory.create(ds);
	AttributesFactory factory = new AttributesFactory();
	factory.setScope(Scope.DISTRIBUTED_ACK);
	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 static void createMirroredRegion() {
	try {
	AttributesFactory factory1 = new AttributesFactory();
	factory1.setScope(Scope.DISTRIBUTED_ACK);
	factory1.setDataPolicy(DataPolicy.REPLICATE);
	RegionAttributes attr1 = factory1.create();
	mirroredRegion = cache.createRegion("mirrored", attr1);

	} catch (Exception ex) {
	ex.printStackTrace();
	}
	}

	public static void createRegionToTestRemove() {
	try {
	AttributesFactory factory2 = new AttributesFactory();
	factory2.setScope(Scope.DISTRIBUTED_ACK);
	CacheWriter cacheWriter = new RemoveCacheWriter();
	CacheListener cacheListener = new RemoveCacheListener();
	factory2.setCacheWriter(cacheWriter);
	factory2.setCacheListener(cacheListener);
	RegionAttributes attr2 = factory2.create();
	remRegion = cache.createRegion("remove", attr2);

	} catch (Exception ex) {
	ex.printStackTrace();
	}
	}

	// testMethods

	@Test
	public void testPutMethod() {
	Host host = Host.getHost(0);
	VM vm0 = host.getVM(0);
	VM vm1 = host.getVM(1);
	Object obj1;
	// put from one and get from other
	int i = 1;
	Object[] objArr = new Object[1];
	objArr[0] = "" + i;
	// Integer in = new Integer(i);
	// objArr[0] = (Object) in;
	vm0.invoke(DistAckMapMethodsDUnitTest.class, "putMethod", objArr);
	obj1 = vm1.invoke(DistAckMapMethodsDUnitTest.class, "getMethod", objArr);
	if (obj1 == null) {
	fail("region.put(key, value) from one vm does not match with region.get(key) from other vm");
	}

	// put from both vms for same key
	i = 2;
	objArr[0] = "" + i;
	// in = new Integer(i);
	// objArr[0] = (Object) in;
	vm0.invoke(DistAckMapMethodsDUnitTest.class, "putMethod", objArr);
	obj1 = vm1.invoke(DistAckMapMethodsDUnitTest.class, "putMethod", objArr);
	if (obj1 != null) {// here if some dummy object is returned on first time put then that should
	// be checked
	fail("failed while region.put from both vms for same key");
	}
	}

	@Test
	public void testRemoveMethod() {
	Host host = Host.getHost(0);
	VM vm0 = host.getVM(0);
	VM vm1 = host.getVM(1);
	Object obj1, obj2;
	boolean ret;
	// put from one and get from other
	int i = 1;
	Object objArr[] = new Object[1];
	objArr[0] = "" + i;
	// Integer in = new Integer(i);
	// objArr[0] = (Object) in;
	vm0.invoke(DistAckMapMethodsDUnitTest.class, "putMethod", objArr);
	vm0.invoke(DistAckMapMethodsDUnitTest.class, "removeMethod", objArr);
	// validate if vm0 has that key value entry
	ret = vm0.invoke(() -> containsKeyMethod("" + i));
	if (ret) {// if returned true means that the key is still there
	fail("region.remove failed with distributed ack scope");
	}

	// test if the correct value is returned
	vm0.invoke(DistAckMapMethodsDUnitTest.class, "putMethod", objArr);
	obj1 = vm1.invoke(DistAckMapMethodsDUnitTest.class, "getMethod", objArr);// to make sure that
	// vm1 region has the
	// entry
	obj2 = vm1.invoke(DistAckMapMethodsDUnitTest.class, "removeMethod", objArr);
	LogWriterUtils.getLogWriter().fine("111111111" + obj1);
	LogWriterUtils.getLogWriter().fine("2222222222" + obj2);
	if (obj1 == null)
	fail("region1.getMethod returned null");
	if (!(obj1.equals(obj2))) {
	fail("region.remove failed with distributed ack scope");
	}
	}

	@Test
	public void testRemoveMethodDetails() {
	Host host = Host.getHost(0);
	VM vm0 = host.getVM(0);
	VM vm1 = host.getVM(1);

	vm0.invoke(() -> DistAckMapMethodsDUnitTest.createRegionToTestRemove());
	vm1.invoke(() -> DistAckMapMethodsDUnitTest.createRegionToTestRemove());

	vm0.invoke(() -> DistAckMapMethodsDUnitTest.removeMethodDetails());
	vm1.invoke(new CacheSerializableRunnable("testRemoveMethodDetails") {
	@Override
	public void run2() throws CacheException {
	Object ob1 = remRegion.get(new Integer(1));
	assertEquals("beforeDestroy", ob1.toString());
	// wait till listeber switches afterDestroy to true
	// while(!afterDestroy){
	// //wait
	// }
	assertEquals("afterDestroy", remRegion.get(new Integer(3)).toString());
	}
	});
	}// end of testRemoveMethodDetails

	@Test
	public void testIsEmptyMethod() {
	Host host = Host.getHost(0);
	VM vm0 = host.getVM(0);
	VM vm1 = host.getVM(1);
	// boolean ret;
	// put from one and get from other
	int i = 1;
	Object objArr[] = new Object[1];
	objArr[0] = "" + i;
	// Integer in = new Integer(i);
	// objArr[0] = (Object) in;
	vm0.invoke(DistAckMapMethodsDUnitTest.class, "putMethod", objArr);
	boolean val = vm1.invoke(() -> DistAckMapMethodsDUnitTest.isEmptyMethod());
	if (!val) {// val should be true
	fail("Failed in region.isEmpty");
	}

	vm1.invoke(DistAckMapMethodsDUnitTest.class, "getMethod", objArr);
	boolean val1 = vm1.invoke(() -> DistAckMapMethodsDUnitTest.isEmptyMethod());
	if (val1) {
	fail("Failed in region.isEmpty");
	}
	}

	@Test
	public void testContainsValueMethod() {
	Host host = Host.getHost(0);
	VM vm0 = host.getVM(0);
	VM vm1 = host.getVM(1);
	// boolean ret;
	// put from one and get from other
	int i = 1;
	Object objArr[] = new Object[1];
	objArr[0] = "" + i;
	// Integer in = new Integer(i);
	// objArr[0] = (Object) in;
	vm0.invoke(DistAckMapMethodsDUnitTest.class, "putMethod", objArr);
	boolean val = vm1.invoke(() -> containsValueMethod("first"));
	if (val) {// val should be false.
	fail("Failed in region.ContainsValue");
	}

	vm1.invoke(DistAckMapMethodsDUnitTest.class, "getMethod", objArr);
	boolean val1 = vm1.invoke(() -> containsValueMethod("first"));
	if (!val1) {// val1 should be true.
	fail("Failed in region.ContainsValue");
	}
	}

	@Test
	public void testKeySetMethod() {
	Host host = Host.getHost(0);
	VM vm0 = host.getVM(0);
	VM vm1 = host.getVM(1);

	int i = 1;
	Object objArr[] = new Object[1];
	objArr[0] = "" + i;
	// Integer in = new Integer(i);
	// objArr[0] = (Object) in;
	vm0.invoke(DistAckMapMethodsDUnitTest.class, "putMethod", objArr);
	int temp = vm1.invoke(() -> DistAckMapMethodsDUnitTest.keySetMethod());
	if (temp != 0) {
	fail("failed in keySetMethodtest method");
	}

	vm1.invoke(DistAckMapMethodsDUnitTest.class, "getMethod", objArr);// to make sure that vm1
	// region has the entry
	temp = vm1.invoke(() -> DistAckMapMethodsDUnitTest.keySetMethod());
	if (temp == 0) {
	fail("failed in keySetMethodtest method");
	}
	// in the above scenarion we can test this for mirrorred region scenarion as well
	temp = 0;
	vm0.invoke(() -> DistAckMapMethodsDUnitTest.createMirroredRegion());
	vm1.invoke(() -> DistAckMapMethodsDUnitTest.createMirroredRegion());
	vm0.invoke(DistAckMapMethodsDUnitTest.class, "putMethod", objArr);
	temp = vm1.invoke(() -> DistAckMapMethodsDUnitTest.keySetMethod());
	if (temp == 0) {
	fail("failed in keySetMethodtest method");
	}
	}


	@Test
	public void testEntrySetMethod() {
	Host host = Host.getHost(0);
	VM vm0 = host.getVM(0);
	VM vm1 = host.getVM(1);

	int i = 1;
	Object objArr[] = new Object[1];
	objArr[0] = "" + i;
	// Integer in = new Integer(i);
	// objArr[0] = (Object) in;
	vm0.invoke(DistAckMapMethodsDUnitTest.class, "putMethod", objArr);
	int temp = vm1.invoke(() -> DistAckMapMethodsDUnitTest.entrySetMethod());
	if (temp != 0) {
	fail("failed in entrySetMethodtest method");
	}

	vm1.invoke(DistAckMapMethodsDUnitTest.class, "getMethod", objArr);// to make sure that vm1
	// region has the entry
	temp = vm1.invoke(() -> DistAckMapMethodsDUnitTest.entrySetMethod());
	if (temp == 0) {
	fail("failed in entrySetMethodtest method");
	}
	// in the above scenarion we can test this for mirrorred region scenarion as well
	temp = 0;
	vm0.invoke(() -> DistAckMapMethodsDUnitTest.createMirroredRegion());
	vm1.invoke(() -> DistAckMapMethodsDUnitTest.createMirroredRegion());
	vm0.invoke(DistAckMapMethodsDUnitTest.class, "putOnMirroredRegion", objArr);
	temp = vm1.invoke(() -> DistAckMapMethodsDUnitTest.entrySetMethod());
	if (temp == 0) {
	fail("failed in entrySetMethodtest method");
	}
	}

	@Test
	public void testSizeMethod() {
	Host host = Host.getHost(0);
	VM vm0 = host.getVM(0);
	VM vm1 = host.getVM(1);

	int i = 1, j = 0;
	Object objArr[] = new Object[1];
	objArr[0] = "" + i;
	// Integer in = new Integer(i);
	// objArr[0] = (Object) in;
	vm0.invoke(DistAckMapMethodsDUnitTest.class, "putMethod", objArr);
	j = vm1.invoke(() -> DistAckMapMethodsDUnitTest.sizeMethod());
	if (j != 0) {
	fail("failed in region.size method");
	}

	vm1.invoke(DistAckMapMethodsDUnitTest.class, "getMethod", objArr);// to make sure that vm1
	// region has the entry
	j = vm1.invoke(() -> DistAckMapMethodsDUnitTest.sizeMethod());
	if (j == 0) {
	fail("failed in region.size method");
	}
	}

	@Test
	public void testallMethodsArgs() {
	Host host = Host.getHost(0);
	VM vm0 = host.getVM(0);
	vm0.invoke(() -> DistAckMapMethodsDUnitTest.allMethodsArgs());
	}


	// following is the implementation of the methods of Map to use in dunit test cases.
	public static Object putMethod(Object ob) {
	Object obj = null;
	try {
	if (ob != null) {
	String str = "first";
	obj = region.put(ob, str);
	}
	} catch (Exception ex) {
	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 Object removeMethod(Object ob) {
	Object obj = null;
	try {
	obj = region.remove(ob);
	} catch (Exception ex) {
	ex.printStackTrace();
	fail("Failed while region.remove");
	}
	return obj;
	}

	public static boolean containsKeyMethod(Object ob) {
	boolean flag = false;
	try {
	flag = region.containsKey(ob);
	} catch (Exception ex) {
	fail("Failed while region.containsKey");
	}
	return flag;
	}

	public static boolean isEmptyMethod() {
	boolean flag = false;
	try {
	flag = region.isEmpty();
	} catch (Exception ex) {
	fail("Failed while region.isEmpty");
	}
	return flag;
	}

	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 keySetMethod() {
	Set set = new HashSet();
	int i = 0;
	try {
	set = region.keySet();
	i = set.size();
	} catch (Exception ex) {
	ex.printStackTrace();
	fail("Failed while region.keySet");
	}
	return i;
	}

	public static int entrySetMethod() {
	Set set = new HashSet();
	int i = 0;
	try {
	set = region.entrySet();
	i = set.size();
	} catch (Exception ex) {
	ex.printStackTrace();
	fail("Failed while region.entrySet");
	}
	return i;
	}

	public static int sizeMethod() {
	int i = 0;
	try {
	i = region.size();
	} catch (Exception ex) {
	fail("Failed while region.size");
	}
	return i;
	}

	// following are methods for put on and get from mirrored regions

	public static Object putOnMirroredRegion(Object ob) {
	Object obj = null;
	try {
	String str = "mirror";
	obj = mirroredRegion.put(ob, str);
	} catch (Exception ex) {
	ex.printStackTrace();
	fail("Failed while mirroredRegion.put");
	}
	return obj;
	}

	public static Object getFromMirroredRegion(Object ob) {
	Object obj = null;
	try {
	obj = mirroredRegion.get(ob);

	} catch (Exception ex) {
	fail("Failed while mirroredRegion.get");
	}
	return obj;
	}

	public static void removeMethodDetails() {
	Object ob1;
	// Object ob2;
	Integer inOb1 = new Integer(1);
	try {
	region.put(inOb1, "first");
	ob1 = region.remove(inOb1);
	assertEquals("first", ob1.toString());
	} catch (Exception ex) {
	ex.printStackTrace();
	}

	// to test EntryNotFoundException
	try {
	region.remove(new Integer(2));
	// fail("Should have thrown EntryNotFoundException");
	} // catch (EntryNotFoundException e){
	catch (Exception e) {
	// pass
	// e.printStackTrace();
	}

	// to test NullPointerException
	try {
	Integer inOb2 = new Integer(2);
	region.put(inOb2, "second");
	inOb2 = null;
	region.remove(inOb2);
	fail("Should have thrown NullPointerException ");
	} catch (NullPointerException e) {
	// pass
	}

	// to test the cache writers and listeners
	try {
	// createRegionToTestRemove();
	Integer inOb2 = new Integer(2);
	remRegion.put(inOb2, "second");
	remRegion.remove(inOb2);

	// to test cacheWriter
	inOb2 = new Integer(1);
	assertEquals("beforeDestroy", remRegion.get(inOb2).toString());

	// wait till listeber switches afterDestroy to true
	while (!afterDestroy) {
	}
	// to test cacheListener
	inOb2 = new Integer(3);
	assertEquals("afterDestroy", remRegion.get(inOb2).toString());

	// verify that entryEventvalue is correct for listener
	assertNotNull(afterDestroyObj);

	} catch (Exception ex) {
	ex.printStackTrace();
	}


	}// end of removeMethodDetail

	public static void allMethodsArgs() {
	// testing args for put method
	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"));

	// test args for get method
	Object ob1 = region.get(new Integer(1));
	assertEquals("first", ob1.toString());

	// test args for containsKey method
	boolean val1 = region.containsKey(new Integer(2));
	assertEquals(true, val1);

	// test args for containsKey method
	boolean val2 = region.containsValue(new String("second"));
	// assertIndexDetailsEquals(true, val2);

	// test args for remove method
	try {
	region.remove(new Integer(3));
	} // catch (EntryNotFoundException ex){
	catch (Exception ex) {
	ex.printStackTrace();
	fail("failed while region.remove(new Object())");
	}

	// verifying the correct exceptions are thrown by the methods

	Object key = null, value = null;
	// testing put method
	try {
	region.put(key, value);
	fail("should have thrown NullPointerException");
	} catch (NullPointerException iex) {
	// pass
	}

	// testing containsValue method
	try {
	region.containsValue(value);
	fail("should have thrown NullPointerException");
	} catch (NullPointerException iex) {
	// pass
	}

	// RegionDestroyedException
	key = new Integer(5);
	value = new String("fifth");

	region.localDestroyRegion();
	// test put method
	try {
	region.put(key, value);
	fail("should have thrown RegionDestroyedException");
	} catch (RegionDestroyedException iex) {
	// pass
	}

	// test remove method
	try {
	region.remove(key);
	fail("should have thrown RegionDestroyedException");
	} catch (RegionDestroyedException iex) {
	// pass
	}

	// test containsValue method
	try {
	region.containsValue(value);
	fail("should have thrown RegionDestroyedException");
	} catch (RegionDestroyedException iex) {
	// pass
	}

	// test size method
	try {
	region.size();
	fail("should have thrown RegionDestroyedException");
	} catch (RegionDestroyedException iex) {
	// pass
	}

	// test keySet method
	try {
	region.keySet();
	fail("should have thrown RegionDestroyedException");
	} catch (RegionDestroyedException iex) {
	// pass
	}

	// test entrySet method
	try {
	region.entrySet();
	fail("should have thrown RegionDestroyedException");
	} catch (RegionDestroyedException iex) {
	// pass
	}


	} catch (Exception ex) {
	ex.printStackTrace();
	}

	}// end of allMethodsArgs

	// helper classes

	static class RemoveCacheWriter extends CacheWriterAdapter {

	@Override
	public void beforeDestroy(EntryEvent entryEvent)
	throws org.apache.geode.cache.CacheWriterException {
	Integer o1 = new Integer(1);
	remRegion.put(o1, "beforeDestroy");
	}

	}// end of RemoveCacheWriter


	static class RemoveCacheListener extends CacheListenerAdapter {

	@Override
	public void afterDestroy(EntryEvent entryEvent)
	throws org.apache.geode.cache.CacheWriterException {
	Integer o1 = new Integer(3);
	remRegion.put(o1, "afterDestroy");

	afterDestroyObj = entryEvent.getKey();

	// to continue main thread where region.remove has actually occurred
	afterDestroy = true;
	}

	}// end of RemoveCacheListener


	}// end of class