geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jbarr...@apache.org
Subject [22/46] geode-native git commit: GEODE-2741: Remove custom shared pointer from cppcache
Date Wed, 17 May 2017 17:50:04 GMT
http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/integration-test/testAttributesFactory.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/testAttributesFactory.cpp b/src/cppcache/integration-test/testAttributesFactory.cpp
index 9489f6f..2e4ffcf 100644
--- a/src/cppcache/integration-test/testAttributesFactory.cpp
+++ b/src/cppcache/integration-test/testAttributesFactory.cpp
@@ -23,22 +23,22 @@
 
 using namespace apache::geode::client;
 
-BEGIN_TEST(ATTRIBUTE_FACTORY)
-  {
-    AttributesFactory af;
-    RegionAttributesPtr ra;
-    RegionPtr region;
-
-    CacheFactoryPtr cacheFactoryPtr = CacheFactory::createCacheFactory();
-    CachePtr cache = cacheFactoryPtr->create();
-    ra = af.createRegionAttributes();
-
-    CacheImpl* cacheImpl = CacheRegionHelper::getCacheImpl(cache.ptr());
-    cacheImpl->createRegion("region1", ra, region);
-    LOG("local region created with HA cache specification.");
-    cache->close();
-  }
-END_TEST(ATTRIBUTE_FACTORY)
+// BEGIN_TEST(ATTRIBUTE_FACTORY)
+//  {
+//    AttributesFactory af;
+//    RegionAttributesPtr ra;
+//    RegionPtr region;
+//
+//    CacheFactoryPtr cacheFactoryPtr = CacheFactory::createCacheFactory();
+//    CachePtr cache = cacheFactoryPtr->create();
+//    ra = af.createRegionAttributes();
+//
+//    CacheImpl* cacheImpl = CacheRegionHelper::getCacheImpl(cache.get());
+//    cacheImpl->createRegion("region1", ra, region);
+//    LOG("local region created with HA cache specification.");
+//    cache->close();
+//  }
+// END_TEST(ATTRIBUTE_FACTORY)
 
 /* testing attributes with invalid value */
 /* testing with negative values */          /*see bug no #865 */
@@ -53,7 +53,7 @@ BEGIN_TEST(REGION_FACTORY)
     try {
       rf->setInitialCapacity(-1);
       FAIL("Should have got expected IllegalArgumentException");
-    } catch (IllegalArgumentException) {
+    } catch (IllegalArgumentException&) {
       LOG("Got expected IllegalArgumentException");
     }
 
@@ -64,13 +64,13 @@ BEGIN_TEST(REGION_FACTORY)
            "Incorrect InitialCapacity");
 
     m_region->put(1, 1);
-    CacheableInt32Ptr res = dynCast<CacheableInt32Ptr>(m_region->get(1));
+    auto res = std::dynamic_pointer_cast<CacheableInt32>(m_region->get(1));
     ASSERT(res->value() == 1, "Expected to find value 1.");
 
     m_region->destroyRegion();
     m_cache->close();
-    m_cache = NULLPTR;
-    m_region = NULLPTR;
+    m_cache = nullptr;
+    m_region = nullptr;
 
     CacheFactoryPtr cf1 = CacheFactory::createCacheFactory();
     CachePtr m_cache1 = cf1->create();
@@ -80,7 +80,7 @@ BEGIN_TEST(REGION_FACTORY)
     try {
       rf1->setInitialCapacity(2147483648U);
       FAIL("Should have got expected IllegalArgumentException");
-    } catch (IllegalArgumentException) {
+    } catch (IllegalArgumentException&) {
       LOG("Got expected IllegalArgumentException");
     }
     RegionPtr m_region1 = rf1->create("Local_ETTL_LI");
@@ -90,12 +90,12 @@ BEGIN_TEST(REGION_FACTORY)
            "Incorrect InitialCapacity");
 
     m_region1->put(1, 1);
-    CacheableInt32Ptr res1 = dynCast<CacheableInt32Ptr>(m_region1->get(1));
+    auto res1 = std::dynamic_pointer_cast<CacheableInt32>(m_region1->get(1));
     ASSERT(res1->value() == 1, "Expected to find value 1.");
 
     m_region1->destroyRegion();
     m_cache1->close();
-    m_cache1 = NULLPTR;
-    m_region1 = NULLPTR;
+    m_cache1 = nullptr;
+    m_region1 = nullptr;
   }
 END_TEST(REGION_FACTORY)

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/integration-test/testAttributesMutator.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/testAttributesMutator.cpp b/src/cppcache/integration-test/testAttributesMutator.cpp
index 662bb33..16f8dbe 100644
--- a/src/cppcache/integration-test/testAttributesMutator.cpp
+++ b/src/cppcache/integration-test/testAttributesMutator.cpp
@@ -44,7 +44,7 @@ DUNIT_TASK(A, Init)
     af.setEntryTimeToLive(ExpirationAction::LOCAL_INVALIDATE, 5);
     RegionAttributesPtr attrs = af.createRegionAttributes();
 
-    CacheImpl* cacheImpl = CacheRegionHelper::getCacheImpl(Test.m_cache.ptr());
+    CacheImpl* cacheImpl = CacheRegionHelper::getCacheImpl(Test.m_cache.get());
     cacheImpl->createRegion("Local_ETTL_LI", attrs, Test.m_region);
   }
 ENDTASK
@@ -58,13 +58,12 @@ DUNIT_TASK(A, CreateAndVerifyExpiry)
 
     // countdown begins... it is ttl so access should not play into it..
     SLEEP(3000);  // sleep for a second, expect value to still be there.
-    CacheableInt32Ptr res =
-        dynCast<CacheableInt32Ptr>(Test.m_region->get("one"));
+    auto res = std::dynamic_pointer_cast<CacheableInt32>(Test.m_region->get("one"));
     ASSERT(res->value() == 1, "Expected to find value 1.");
     fflush(stdout);
     SLEEP(5000);  // sleep for 5 more seconds, expect value to be invalid.
     fflush(stdout);
-    res = NULLPTR;
+    res = nullptr;
     ASSERT(Test.m_region->containsValueForKey("one") == false,
            "should not contain value.");
   }
@@ -75,7 +74,7 @@ DUNIT_TASK(A, Close)
   {
     Test.m_region->destroyRegion();
     Test.m_cache->close();
-    Test.m_cache = NULLPTR;
-    Test.m_region = NULLPTR;
+    Test.m_cache = nullptr;
+    Test.m_region = nullptr;
   }
 ENDTASK

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/integration-test/testCache.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/testCache.cpp b/src/cppcache/integration-test/testCache.cpp
index 2937c93..e87530e 100644
--- a/src/cppcache/integration-test/testCache.cpp
+++ b/src/cppcache/integration-test/testCache.cpp
@@ -33,7 +33,7 @@ BEGIN_TEST(CacheFunction)
   char* subRegionName2 = (char*)"TESTCACHE_SUB_REGION2";
   char* subRegionName21 = (char*)"TESTCACHE_SUB_REGION21";
   CachePtr cptr;
-  if (cptr != NULLPTR) {
+  if (cptr != nullptr) {
     cout << "cptr is not null" << endl;
   }
   cout << "create Cache with name=" << host_name << " and unitialized system"
@@ -49,16 +49,16 @@ BEGIN_TEST(CacheFunction)
     cout << ex.getMessage() << endl;
     ASSERT(false, "attribute create failed");
   }
-  if (rAttr == NULLPTR) {
+  if (rAttr == nullptr) {
     cout << "Warnning! : AttributesFactory returned NULL" << endl;
   }
   RegionPtr rptr;
-  if (rptr != NULLPTR) {
+  if (rptr != nullptr) {
     cout << "rptr is not null" << endl;
   }
   cout << "create Region with name=" << regionName << endl;
   try {
-    CacheImpl* cacheImpl = CacheRegionHelper::getCacheImpl(cptr.ptr());
+    CacheImpl* cacheImpl = CacheRegionHelper::getCacheImpl(cptr.get());
     cacheImpl->createRegion(regionName, rAttr, rptr);
   } catch (Exception& ex) {
     cout << ex.getMessage() << endl;
@@ -127,7 +127,7 @@ BEGIN_TEST(CacheFunction)
     cout << ex.getMessage() << endl;
     ASSERT(false, (char*)"getRegion");
   }
-  if (region == NULLPTR) {
+  if (region == nullptr) {
     ASSERT(false, (char*)"did not find it");
   } else {
     cout << "found :" << region->getName() << endl;
@@ -139,7 +139,7 @@ BEGIN_TEST(CacheFunction)
     cout << ex.getMessage() << endl;
     ASSERT(false, (char*)"getRegion");
   }
-  if (region == NULLPTR) {
+  if (region == nullptr) {
     ASSERT(false, (char*)"did not find it");
   } else {
     cout << "found :" << region->getName() << endl;
@@ -151,7 +151,7 @@ BEGIN_TEST(CacheFunction)
     cout << ex.getMessage() << endl;
     ASSERT(false, (char*)"getRegion");
   }
-  if (region == NULLPTR) {
+  if (region == nullptr) {
     ASSERT(false, (char*)"did not find it");
   } else {
     cout << "found :" << region->getName() << endl;
@@ -164,7 +164,7 @@ BEGIN_TEST(CacheFunction)
     cout << ex.getMessage() << endl;
     ASSERT(false, (char*)"getRegion");
   }
-  if (region == NULLPTR) {
+  if (region == nullptr) {
     ASSERT(false, (char*)"did not find it");
   } else {
     cout << "found :" << region->getName() << endl;
@@ -177,7 +177,7 @@ BEGIN_TEST(CacheFunction)
     cout << ex.getMessage() << endl;
     ASSERT(false, (char*)"getRegion");
   }
-  if (region == NULLPTR) {
+  if (region == nullptr) {
     cout << "not found !" << endl;
   } else {
     ASSERT(false, (char*)"found it");

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/integration-test/testCacheless.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/testCacheless.cpp b/src/cppcache/integration-test/testCacheless.cpp
index 491d05b..7bd1964 100644
--- a/src/cppcache/integration-test/testCacheless.cpp
+++ b/src/cppcache/integration-test/testCacheless.cpp
@@ -61,8 +61,8 @@ class RegionWrapper {
     int tries = 0;
     int val = 0;
     do {
-      valPtr = dynCast<CacheableStringPtr>(m_regionPtr->get(keyPtr));
-      ASSERT(valPtr != NULLPTR, "value should not be null.");
+      valPtr = std::dynamic_pointer_cast<CacheableString>(m_regionPtr->get(keyPtr));
+      ASSERT(valPtr != nullptr, "value should not be null.");
       val = atoi(valPtr->asChar());
       SLEEP(100);
       tries++;
@@ -122,7 +122,7 @@ END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(s1p1, CreateRegionNoCache)
   {
     initClientWithPool(true, "__TEST_POOL1__", locHostPort, "ServerGroup1",
-                       NULLPTR, 0, true);
+                       nullptr, 0, true);
     LOG("Creating region in s1p1-pusher, no-ack, no-cache, no-listener");
     getHelper()->createPooledRegion(REGIONNAME, false, locHostPort,
                                     "__TEST_POOL1__", true, true);
@@ -133,8 +133,8 @@ DUNIT_TASK_DEFINITION(s1p2, CreateNoCacheWListener)
   {
     LOG("Creating region in s1p2-listener, no-ack, no-cache, with-listener");
     initClientWithPool(true, "__TEST_POOL1__", locHostPort, "ServerGroup1",
-                       NULLPTR, 0, true);
-    listener = new TallyListener();
+                       nullptr, 0, true);
+    listener = std::make_shared<TallyListener>();
     getHelper()->createPooledRegion(REGIONNAME, false, locHostPort,
                                     "__TEST_POOL1__", true, true, 0, 0, 0, 0, 0,
                                     listener);
@@ -146,7 +146,7 @@ DUNIT_TASK_DEFINITION(s2p1, CreateRegionCacheMirror)
     LOG("Creating region in s2p1-storage, no-ack, cache, no-interestlist, "
         "no-listener");
     initClientWithPool(true, "__TEST_POOL1__", locHostPort, "ServerGroup1",
-                       NULLPTR, 0, true);
+                       nullptr, 0, true);
     getHelper()->createPooledRegion(REGIONNAME, false, locHostPort,
                                     "__TEST_POOL1__", true, true);
   }
@@ -157,8 +157,8 @@ DUNIT_TASK_DEFINITION(s2p2, CreateRegionCache)
     LOG("Creating region in s2p2-subset, no-ack, no-mirror, cache, "
         "no-interestlist, with-listener");
     initClientWithPool(true, "__TEST_POOL1__", locHostPort, "ServerGroup1",
-                       NULLPTR, 0, true);
-    listener = new TallyListener();
+                       nullptr, 0, true);
+    listener = std::make_shared<TallyListener>();
     getHelper()->createPooledRegion(REGIONNAME, false, locHostPort,
                                     "__TEST_POOL1__", true, true, 0, 0, 0, 0, 0,
                                     listener);
@@ -171,8 +171,8 @@ DUNIT_TASK_DEFINITION(s1p2, NoEvents)
     LOG("Verifying TallyListener has received nothing.");
     ASSERT(listener->getCreates() == 0, "Should be no creates");
     ASSERT(listener->getUpdates() == 0, "Should be no updates");
-    ASSERT(listener->getLastKey() == NULLPTR, "Should be no key");
-    ASSERT(listener->getLastValue() == NULLPTR, "Should be no value");
+    ASSERT(listener->getLastKey() == nullptr, "Should be no key");
+    ASSERT(listener->getLastValue() == nullptr, "Should be no value");
   }
 END_TASK_DEFINITION
 

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/integration-test/testEntriesMap.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/testEntriesMap.cpp b/src/cppcache/integration-test/testEntriesMap.cpp
index 4bc1a5b..68b71c6 100644
--- a/src/cppcache/integration-test/testEntriesMap.cpp
+++ b/src/cppcache/integration-test/testEntriesMap.cpp
@@ -33,6 +33,7 @@ END_TEST(NotOnWindows)
 #include <LRUMapEntry.hpp>
 #include <VersionTag.hpp>
 #include <cstdlib>
+#include <LocalRegion.hpp>
 
 using namespace apache::geode::client;
 using namespace std;
@@ -41,7 +42,7 @@ typedef std::vector<MapEntryImplPtr> VectorOfMapEntry;
 
 CacheableStringPtr createCacheable(const char* value) {
   CacheableStringPtr result = CacheableString::create(value);
-  ASSERT(result != NULLPTR, "expected result non-NULL");
+  ASSERT(result != nullptr, "expected result non-NULL");
   return result;
 }
 
@@ -50,18 +51,19 @@ BEGIN_TEST(PutAndGet)
     CacheableStringPtr ccstr = createCacheable("100");
     CacheablePtr ct = ccstr;
     EntryFactory* entryFactory = EntryFactory::singleton;
+    AttributesFactory af;
     EntriesMap* entries = new ConcurrentEntriesMap(entryFactory, false);
     entries->open();
     CacheableKeyPtr keyPtr = CacheableKey::create((char*)"foobar");
-    ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
+    ASSERT(keyPtr != nullptr, "expected keyPtr non-NULL");
     MapEntryImplPtr me;
     VersionTagPtr versionTag;
     CacheablePtr oldValue;
     entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag);
     CacheablePtr myValuePtr;
     entries->get(keyPtr, myValuePtr, me);
-    ASSERT(myValuePtr != NULLPTR, "expected non-NULL");
-    CacheableStringPtr strValue = dynCast<CacheableStringPtr>(myValuePtr);
+    ASSERT(myValuePtr != nullptr, "expected non-NULL");
+    auto strValue = std::dynamic_pointer_cast<CacheableString>(myValuePtr);
     ASSERT(ccstr->operator==(*strValue), "expected 100");
     delete entries;
   }
@@ -71,11 +73,11 @@ BEGIN_TEST(CheckMapEntryImplPtr)
   {
     char error[1000] ATTR_UNUSED;
     MapEntryImplPtr mePtr;
-    ASSERT(mePtr == NULLPTR, "expected mePtr to be NULL");
+    ASSERT(mePtr == nullptr, "expected mePtr to be NULL");
     CacheableKeyPtr keyPtr = CacheableKey::create(fwtest_Name);
-    ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
+    ASSERT(keyPtr != nullptr, "expected keyPtr non-NULL");
     EntryFactory::singleton->newMapEntry(keyPtr, mePtr);
-    ASSERT(mePtr != NULLPTR, "expected to not be null.");
+    ASSERT(mePtr != nullptr, "expected to not be null.");
   }
 END_TEST(CheckMapEntryImplPtr)
 
@@ -88,18 +90,18 @@ BEGIN_TEST(RemoveTest)
     entries->open();
     CacheableKeyPtr keyPtr = CacheableKey::create(fwtest_Name);
     MapEntryImplPtr me;
-    ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
+    ASSERT(keyPtr != nullptr, "expected keyPtr non-NULL");
     CacheablePtr oldValue;
     VersionTagPtr versionTag;
     entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag);
     CacheablePtr myValuePtr;
     (void)entries->remove(keyPtr, myValuePtr, me, -1, versionTag, false);
-    CacheableStringPtr resPtr = dynCast<CacheableStringPtr>(myValuePtr);
-    ASSERT(myValuePtr != NULLPTR, "expected to not be null.");
+    auto resPtr = std::dynamic_pointer_cast<CacheableString>(myValuePtr);
+    ASSERT(myValuePtr != nullptr, "expected to not be null.");
     ASSERT(resPtr->operator==(*createCacheable("200")),
            "CustomerType with m_foobar 200.");
     (void)entries->remove(keyPtr, myValuePtr, me, -1, versionTag, false);
-    ASSERT(myValuePtr == NULLPTR,
+    ASSERT(myValuePtr == nullptr,
            "expected already removed, and null result should clear ptr.");
   }
 END_TEST(RemoveTest)
@@ -114,15 +116,15 @@ BEGIN_TEST(GetEntryTest)
     CacheableKeyPtr keyPtr;
     MapEntryImplPtr me;
     keyPtr = CacheableKey::create(fwtest_Name);
-    ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
+    ASSERT(keyPtr != nullptr, "expected keyPtr non-NULL");
     CacheablePtr oldValue;
     VersionTagPtr versionTag;
     entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag);
     MapEntryImplPtr mePtr;
     CacheablePtr ctPtr;
     entries->getEntry(keyPtr, mePtr, ctPtr);
-    ASSERT(mePtr != NULLPTR, "should not be null.");
-    CacheableStringPtr valPtr = dynCast<CacheableStringPtr>(ctPtr);
+    ASSERT(mePtr != nullptr, "should not be null.");
+    auto valPtr = std::dynamic_pointer_cast<CacheableString>(ctPtr);
     ASSERT(valPtr->operator==(*cst),
            "Entry should have a CustomerType Value of 200");
     CacheableKeyPtr keyPtr1;
@@ -135,7 +137,7 @@ BEGIN_TEST(MapEntryImplPtrRCTest)
   {
     // Test Reference Counting and destruction for MapEntry.
     CacheableKeyPtr keyPtr = CacheableKey::create("foobar");
-    ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
+    ASSERT(keyPtr != nullptr, "expected keyPtr non-NULL");
     MapEntryImplPtr mePtr;
     EntryFactory ef;
     ef.newMapEntry(keyPtr, mePtr);
@@ -181,7 +183,7 @@ BEGIN_TEST(EntriesTest)
       sprintf(keyBuf, "key_%d", i);
       sprintf(valBuf, "%d", i);
       CacheableKeyPtr keyPtr = CacheableKey::create(keyBuf);
-      ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
+      ASSERT(keyPtr != nullptr, "expected keyPtr non-NULL");
       CacheablePtr v = createCacheable(valBuf);
       CacheablePtr oldValue;
       entries->put(keyPtr, v, me, oldValue, -1, 0, versionTag);
@@ -199,7 +201,7 @@ BEGIN_TEST(EntriesTest)
       CacheableStringPtr ctPtr;
       CacheablePtr ccPtr;
       ccPtr = rePtr->getValue();
-      ctPtr = dynCast<CacheableStringPtr>(ccPtr);
+      ctPtr = std::dynamic_pointer_cast<CacheableString>(ccPtr);
       test::cout << "value is " << ctPtr->asChar() << test::endl;
       int val = atoi(ctPtr->asChar());
       test::cout << "atoi returned " << val << test::endl;
@@ -228,7 +230,7 @@ BEGIN_TEST(ValuesTest)
       sprintf(keyBuf, "key_%d", i);
       sprintf(valBuf, "%d", i);
       CacheableKeyPtr keyPtr = CacheableKey::create(keyBuf);
-      ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
+      ASSERT(keyPtr != nullptr, "expected keyPtr non-NULL");
       CacheablePtr v = createCacheable(valBuf);
       CacheablePtr oldValue;
       entries->put(keyPtr, v, me, oldValue, -1, 0, versionTag);
@@ -242,8 +244,8 @@ BEGIN_TEST(ValuesTest)
     int expectedTotal = 0;
     for (int k = 0; k < 10; k++) {
       expectedTotal += k;
-      CacheableStringPtr valuePtr =
-          dynCast<CacheableStringPtr>(valuesVec->back());
+      auto valuePtr =
+          std::dynamic_pointer_cast<CacheableString>(valuesVec->back());
       total += atoi(valuePtr->asChar());
       valuesVec->pop_back();
     }
@@ -267,7 +269,7 @@ BEGIN_TEST(KeysTest)
       sprintf(keyBuf, "key_%d", i);
       sprintf(valBuf, "%d", i);
       CacheableKeyPtr keyPtr = CacheableKey::create(keyBuf);
-      ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
+      ASSERT(keyPtr != nullptr, "expected keyPtr non-NULL");
       CacheablePtr v = createCacheable(valBuf);
       CacheablePtr oldValue;
       entries->put(keyPtr, v, me, oldValue, -1, 0, versionTag);
@@ -284,7 +286,7 @@ BEGIN_TEST(KeysTest)
       CacheableKeyPtr keyPtr = keysVec.back();
       CacheablePtr cvPtr;
       entries->get(keyPtr, cvPtr, me);
-      CacheableStringPtr valuePtr = dynCast<CacheableStringPtr>(cvPtr);
+      auto valuePtr = std::dynamic_pointer_cast<CacheableString>(cvPtr);
       total += atoi(valuePtr->asChar());
       keysVec.pop_back();
     }
@@ -310,7 +312,7 @@ BEGIN_TEST(TestRehash)
       sprintf(keyBuf, "key_%d", i);
       sprintf(valBuf, "%d", i);
       CacheableKeyPtr keyPtr = CacheableKey::create(keyBuf);
-      ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
+      ASSERT(keyPtr != nullptr, "expected keyPtr non-NULL");
       CacheablePtr v = createCacheable(valBuf);
       CacheablePtr oldValue;
       VersionTagPtr versionTag;
@@ -327,11 +329,11 @@ BEGIN_TEST(TestRehash)
       sprintf(keyBuf, "key_%d", j);
       CacheableStringPtr valuePtr;
       CacheableKeyPtr keyPtr = CacheableKey::create(keyBuf);
-      ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
+      ASSERT(keyPtr != nullptr, "expected keyPtr non-NULL");
       CacheablePtr cvPtr;
       entries->get(keyPtr, cvPtr, me);
-      valuePtr = dynCast<CacheableStringPtr>(cvPtr);
-      if (valuePtr == NULLPTR) {
+      valuePtr = std::dynamic_pointer_cast<CacheableString>(cvPtr);
+      if (valuePtr == nullptr) {
         test::cout << "error finding key: " << keyBuf << test::endl;
         FAIL("should have found value for all keys after rehash.");
       }
@@ -348,7 +350,7 @@ BEGIN_TEST(LRUPutAndGet)
     MapEntryImplPtr me;
     EntryFactory* entryFactory = LRUEntryFactory::singleton;
     EntriesMap* entries = new LRUEntriesMap(
-        entryFactory, NULL, LRUAction::LOCAL_DESTROY, 20, false);
+        entryFactory, nullptr, LRUAction::LOCAL_DESTROY, 20, false);
     entries->open();
     ASSERT(entries->size() == 0, "expected size 0.");
     CacheableKeyPtr keyPtr = CacheableKey::create("foobar");
@@ -358,10 +360,10 @@ BEGIN_TEST(LRUPutAndGet)
     ASSERT(entries->size() == 1, "expected size 1.");
     CacheableStringPtr myValuePtr;
     CacheablePtr cvPtr;
-    ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
+    ASSERT(keyPtr != nullptr, "expected keyPtr non-NULL");
     entries->get(keyPtr, cvPtr, me);
-    myValuePtr = dynCast<CacheableStringPtr>(cvPtr);
-    ASSERT(myValuePtr != NULLPTR, "expected non-NULL");
+    myValuePtr = std::dynamic_pointer_cast<CacheableString>(cvPtr);
+    ASSERT(myValuePtr != nullptr, "expected non-NULL");
     ASSERT(cst->operator==(*myValuePtr), "expected 100");
     delete entries;
   }
@@ -371,13 +373,13 @@ BEGIN_TEST(CheckLRUMapEntryImplPtr)
   {
     char error[1000] ATTR_UNUSED;
     MapEntryImplPtr mePtr;
-    ASSERT(mePtr == NULLPTR, "expected mePtr to be NULL");
+    ASSERT(mePtr == nullptr, "expected mePtr to be NULL");
     CacheableKeyPtr keyPtr = CacheableKey::create(fwtest_Name);
-    ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
+    ASSERT(keyPtr != nullptr, "expected keyPtr non-NULL");
     LRUEntryFactory::singleton->newMapEntry(keyPtr, mePtr);
-    ASSERT(mePtr != NULLPTR, "expected to not be null.");
-    LRUMapEntryPtr lmePtr = dynCast<LRUMapEntryPtr>(mePtr);
-    ASSERT(lmePtr != NULLPTR, "expected to cast successfully to LRUMapEntry.");
+    ASSERT(mePtr != nullptr, "expected to not be null.");
+    auto lmePtr = std::dynamic_pointer_cast<LRUMapEntry>(mePtr);
+    ASSERT(lmePtr != nullptr, "expected to cast successfully to LRUMapEntry.");
   }
 END_TEST(LRUCheckMapEntryImplPtr)
 
@@ -400,14 +402,14 @@ BEGIN_TEST(LRURemoveTest)
     CacheableStringPtr myValuePtr;
     CacheablePtr cvPtr;
     (void)entries->remove(keyPtr, cvPtr, me, -1, versionTag, false);
-    myValuePtr = dynCast<CacheableStringPtr>(cvPtr);
+    myValuePtr = std::dynamic_pointer_cast<CacheableString>(cvPtr);
     ASSERT(entries->size() == 0, "expected size 0.");
-    ASSERT(cvPtr != NULLPTR, "expected to not be null.");
+    ASSERT(cvPtr != nullptr, "expected to not be null.");
     ASSERT(myValuePtr->operator==(*createCacheable("200")),
            "CustomerType with m_foobar 200.");
 
     (void)entries->remove(keyPtr, cvPtr, me, -1, versionTag, false);
-    ASSERT(cvPtr == NULLPTR,
+    ASSERT(cvPtr == nullptr,
            "expected already removed, and null result should clear ptr.");
   }
 END_TEST(LRURemoveTest)
@@ -423,7 +425,7 @@ BEGIN_TEST(LRUGetEntryTest)
     CacheableKeyPtr keyPtr;
     MapEntryImplPtr me;
     keyPtr = CacheableKey::create(fwtest_Name);
-    ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
+    ASSERT(keyPtr != nullptr, "expected keyPtr non-NULL");
     CacheablePtr oldValue;
     VersionTagPtr versionTag;
     entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag);
@@ -431,9 +433,9 @@ BEGIN_TEST(LRUGetEntryTest)
     MapEntryImplPtr mePtr;
     CacheablePtr cvPtr;
     entries->getEntry(keyPtr, mePtr, cvPtr);
-    ASSERT(mePtr != NULLPTR, "should not be null.");
+    ASSERT(mePtr != nullptr, "should not be null.");
     CacheableStringPtr ctPtr;
-    ctPtr = dynCast<CacheableStringPtr>(cvPtr);
+    ctPtr = std::dynamic_pointer_cast<CacheableString>(cvPtr);
     ASSERT(ctPtr->operator==(*cst),
            "Entry should have a CustomerType Value of 200");
     CacheableKeyPtr keyPtr1;
@@ -452,29 +454,29 @@ BEGIN_TEST(LRULimitEvictTest)
     CacheablePtr ct = createCacheable("somevalue");
     CacheablePtr oldValue;
     CacheableKeyPtr keyPtr = CacheableKey::create("1");
-    ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
+    ASSERT(keyPtr != nullptr, "expected keyPtr non-NULL");
     VersionTagPtr versionTag;
     entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag);
     ASSERT(entries->size() == 1, "expected size 1.");
     keyPtr = CacheableKey::create("2");
-    ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
+    ASSERT(keyPtr != nullptr, "expected keyPtr non-NULL");
     entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag);
     ASSERT(entries->size() == 2, "expected size 2.");
     keyPtr = CacheableKey::create("3");
-    ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
+    ASSERT(keyPtr != nullptr, "expected keyPtr non-NULL");
     entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag);
     ASSERT(entries->size() == 3, "expected size 3.");
     keyPtr = CacheableKey::create("4");
-    ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
+    ASSERT(keyPtr != nullptr, "expected keyPtr non-NULL");
     entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag);
     ASSERT(entries->size() == 4, "expected size 4.");
     keyPtr = CacheableKey::create("5");
-    ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
+    ASSERT(keyPtr != nullptr, "expected keyPtr non-NULL");
     entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag);
     ASSERT(entries->size() == 5, "expected size 5.");
     LOG("Map is now at the limit.");
     keyPtr = CacheableKey::create("6");
-    ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
+    ASSERT(keyPtr != nullptr, "expected keyPtr non-NULL");
     LOG("About to spill over.");
     entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag);
     LOG("Spilled over.");

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/integration-test/testEntriesMapForVersioning.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/testEntriesMapForVersioning.cpp b/src/cppcache/integration-test/testEntriesMapForVersioning.cpp
index b99fb9d..7e4e301 100644
--- a/src/cppcache/integration-test/testEntriesMapForVersioning.cpp
+++ b/src/cppcache/integration-test/testEntriesMapForVersioning.cpp
@@ -92,9 +92,9 @@ void createRegion(const char* name, bool ackMode,
   fflush(stdout);
   // ack, caching
   regPtr =
-      getHelper()->createRegion(name, ackMode, caching, NULLPTR,
+      getHelper()->createRegion(name, ackMode, caching, nullptr,
                                 clientNotificationEnabled, true, true, 5000);
-  ASSERT(regPtr != NULLPTR, "Failed to create region.");
+  ASSERT(regPtr != nullptr, "Failed to create region.");
   LOG("Region created.");
 }
 
@@ -102,7 +102,7 @@ typedef std::vector<MapEntryImplPtr> VectorOfMapEntry;
 
 CacheableStringPtr createCacheable(const char* value) {
   CacheableStringPtr result = CacheableString::create(value);
-  ASSERT(result != NULLPTR, "expected result non-NULL");
+  ASSERT(result != nullptr, "expected result non-NULL");
   return result;
 }
 
@@ -111,29 +111,29 @@ uint8_t addr2[6] = {0xff, 0xff, 0xff, 0xaa, 0xff, 0xbb};
 uint8_t addr3[6] = {0xff, 0xff, 0xaa, 0xaa, 0xff, 0xff};
 uint8_t addr4[6] = {0xff, 0xff, 0xff, 0xff, 0xaa, 0xff};
 
-ClientProxyMembershipIDPtr member_host1(
-    new ClientProxyMembershipID(addr1, 6, 80, "", "myuniquetag", 0));
-ClientProxyMembershipIDPtr member_host12(
-    new ClientProxyMembershipID(addr1, 6, 80, "", "myuniquetah", 0));
-ClientProxyMembershipIDPtr member_host13(
-    new ClientProxyMembershipID(addr1, 6, 81, "", "myuniquetag", 0));
-ClientProxyMembershipIDPtr member_host14(
-    new ClientProxyMembershipID(addr1, 6, 88, "", "myuniquetag", 0));
-ClientProxyMembershipIDPtr member_host15(
-    new ClientProxyMembershipID(addr2, 6, 88, "", "myuniquetag", 0));
-ClientProxyMembershipIDPtr member_host16(
-    new ClientProxyMembershipID(addr3, 6, 88, "", "myuniquetag", 0));
-ClientProxyMembershipIDPtr member_host17(
-    new ClientProxyMembershipID(addr4, 6, 88, "", "myuniquetag", 0));
-DiskStoreId* diskStore17 = new DiskStoreId(1, 7);
-DiskStoreId* diskStore18 = new DiskStoreId(1, 8);
-DiskStoreId* diskStore27 = new DiskStoreId(2, 7);
-ClientProxyMembershipIDPtr member_host_vmview5(
-    new ClientProxyMembershipID(addr4, 6, 88, "", "", 5));
-ClientProxyMembershipIDPtr member_host_vmview6(
-    new ClientProxyMembershipID(addr4, 6, 88, "", "", 6));
-ClientProxyMembershipIDPtr member_host_vmview7(
-    new ClientProxyMembershipID(addr4, 6, 88, "", "", 7));
+auto member_host1 = std::make_shared<ClientProxyMembershipID>(addr1, 6, 80, "",
+                                                              "myuniquetag", 0);
+auto member_host12 = std::make_shared<ClientProxyMembershipID>(
+    addr1, 6, 80, "", "myuniquetah", 0);
+auto member_host13 = std::make_shared<ClientProxyMembershipID>(
+    addr1, 6, 81, "", "myuniquetag", 0);
+auto member_host14 = std::make_shared<ClientProxyMembershipID>(
+    addr1, 6, 88, "", "myuniquetag", 0);
+auto member_host15 = std::make_shared<ClientProxyMembershipID>(
+    addr2, 6, 88, "", "myuniquetag", 0);
+auto member_host16 = std::make_shared<ClientProxyMembershipID>(
+    addr3, 6, 88, "", "myuniquetag", 0);
+auto member_host17 = std::make_shared<ClientProxyMembershipID>(
+    addr4, 6, 88, "", "myuniquetag", 0);
+auto diskStore17 = new DiskStoreId(1, 7);
+auto diskStore18 = new DiskStoreId(1, 8);
+auto diskStore27 = new DiskStoreId(2, 7);
+auto member_host_vmview5 =
+    std::make_shared<ClientProxyMembershipID>(addr4, 6, 88, "", "", 5);
+auto member_host_vmview6 =
+    std::make_shared<ClientProxyMembershipID>(addr4, 6, 88, "", "", 6);
+auto member_host_vmview7 =
+    std::make_shared<ClientProxyMembershipID>(addr4, 6, 88, "", "", 7);
 
 uint16_t host1;
 uint16_t host12;
@@ -155,6 +155,13 @@ int DeltaEx::fromDeltaCount = 0;
 int DeltaEx::fromDataCount = 0;
 int DeltaEx::cloneCount = 0;
 
+//#undef DUNIT_TASK_DEFINITION
+//#define DUNIT_TASK_DEFINITION(_X, _Y) void _Y()
+//#undef END_TASK_DEFINITION
+//#define END_TASK_DEFINITION
+//#undef CALL_TASK
+//#define CALL_TASK(_Y) _Y()
+
 DUNIT_TASK_DEFINITION(CLIENT1, CREATECLIENT)
   {
     initClient();
@@ -169,7 +176,7 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, StepOne_AddHosts)
   {
-    LocalRegion* lregPtr = (dynamic_cast<LocalRegion*>(regPtr.ptr()));
+    auto lregPtr = std::dynamic_pointer_cast<LocalRegion>(regPtr);
     host1 = lregPtr->getCacheImpl()->getMemberListForVersionStamp()->add(
         member_host1);
     host12 = lregPtr->getCacheImpl()->getMemberListForVersionStamp()->add(
@@ -201,65 +208,63 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, StepTwo_TestPut)
   {
-    LocalRegion* lregPtr = (dynamic_cast<LocalRegion*>(regPtr.ptr()));
-    CacheableStringPtr ccstr = createCacheable("100");
-    CacheablePtr ct = ccstr;
-    CacheableStringPtr ccstr1 = createCacheable("500");
-    CacheablePtr ct1 = ccstr1;
-    EntryFactory* entryFactory = EntryFactory::singleton;
+    auto lregPtr = std::dynamic_pointer_cast<LocalRegion>(regPtr);
+    auto ccstr = createCacheable("100");
+    auto ccstr1 = createCacheable("500");
+    auto entryFactory = EntryFactory::singleton;
     entryFactory->setConcurrencyChecksEnabled(true);
-    EntriesMap* entries = new ConcurrentEntriesMap(entryFactory, true, lregPtr);
+    EntriesMap* entries =
+        new ConcurrentEntriesMap(entryFactory, true, lregPtr.get());
     entries->open();
-    CacheableKeyPtr keyPtr = CacheableKey::create((char*)"key1");
-    ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
+    auto keyPtr = CacheableKey::create("key1");
+    ASSERT(keyPtr != nullptr, "expected keyPtr non-NULL");
     MapEntryImplPtr me;
-    VersionTagPtr versionTag1(new VersionTag(5, 6, 7, host1, 0));
+    auto versionTag1 = std::make_shared<VersionTag>(5, 6, 7, host1, 0);
 
-    VersionTagPtr versionTag12(new VersionTag(5, 6, 7, host12, 0));
+    auto versionTag12 = std::make_shared<VersionTag>(5, 6, 7, host12, 0);
 
-    VersionTagPtr versionTag13(new VersionTag(5, 6, 7, host13, 0));
-    VersionTagPtr versionTag14(new VersionTag(5, 6, 7, host14, 0));
-    VersionTagPtr versionTag15(new VersionTag(5, 6, 7, host15, 0));
-    VersionTagPtr versionTag16(new VersionTag(5, 6, 7, host16, 0));
-    VersionTagPtr versionTag17(new VersionTag(5, 6, 7, host17, 0));
+    auto versionTag13 = std::make_shared<VersionTag>(5, 6, 7, host13, 0);
+    auto versionTag14 = std::make_shared<VersionTag>(5, 6, 7, host14, 0);
+    auto versionTag15 = std::make_shared<VersionTag>(5, 6, 7, host15, 0);
+    auto versionTag16 = std::make_shared<VersionTag>(5, 6, 7, host16, 0);
+    auto versionTag17 = std::make_shared<VersionTag>(5, 6, 7, host17, 0);
 
     CacheablePtr oldValue;
-    entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag1);
+    entries->put(keyPtr, ccstr, me, oldValue, -1, 0, versionTag1);
     char log[256];
 
-    GfErrType err =
-        entries->put(keyPtr, ct1, me, oldValue, -1, 0, versionTag12);
+    auto err = entries->put(keyPtr, ccstr1, me, oldValue, -1, 0, versionTag12);
     ASSERT(err != GF_CACHE_CONCURRENT_MODIFICATION_EXCEPTION, "an exception");
 
-    err = entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag1);
+    err = entries->put(keyPtr, ccstr, me, oldValue, -1, 0, versionTag1);
     ASSERT(err == GF_CACHE_CONCURRENT_MODIFICATION_EXCEPTION, "an exception");
 
-    err = entries->put(keyPtr, ct1, me, oldValue, -1, 0, versionTag13);
+    err = entries->put(keyPtr, ccstr1, me, oldValue, -1, 0, versionTag13);
     ASSERT(err != GF_CACHE_CONCURRENT_MODIFICATION_EXCEPTION, "an exception");
 
-    err = entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag1);
+    err = entries->put(keyPtr, ccstr, me, oldValue, -1, 0, versionTag1);
     ASSERT(err == GF_CACHE_CONCURRENT_MODIFICATION_EXCEPTION, "an exception");
 
     uint32_t conflatedEvents =
         lregPtr->getCacheImpl()->m_cacheStats->getConflatedEvents();
     ASSERT(conflatedEvents == 2, "conflated events should be 2");
 
-    err = entries->put(keyPtr, ct1, me, oldValue, -1, 0, versionTag14);
+    err = entries->put(keyPtr, ccstr1, me, oldValue, -1, 0, versionTag14);
     ASSERT(err != GF_CACHE_CONCURRENT_MODIFICATION_EXCEPTION, "an exception");
 
-    err = entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag1);
+    err = entries->put(keyPtr, ccstr, me, oldValue, -1, 0, versionTag1);
     ASSERT(err == GF_CACHE_CONCURRENT_MODIFICATION_EXCEPTION, "an exception");
 
-    err = entries->put(keyPtr, ct1, me, oldValue, -1, 0, versionTag15);
+    err = entries->put(keyPtr, ccstr1, me, oldValue, -1, 0, versionTag15);
     ASSERT(err == GF_CACHE_CONCURRENT_MODIFICATION_EXCEPTION, "an exception");
 
-    err = entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag1);
+    err = entries->put(keyPtr, ccstr, me, oldValue, -1, 0, versionTag1);
     ASSERT(err == GF_CACHE_CONCURRENT_MODIFICATION_EXCEPTION, "an exception");
 
-    err = entries->put(keyPtr, ct1, me, oldValue, -1, 0, versionTag16);
+    err = entries->put(keyPtr, ccstr1, me, oldValue, -1, 0, versionTag16);
     ASSERT(err == GF_CACHE_CONCURRENT_MODIFICATION_EXCEPTION, "an exception");
 
-    err = entries->put(keyPtr, ct1, me, oldValue, -1, 0, versionTag17);
+    err = entries->put(keyPtr, ccstr1, me, oldValue, -1, 0, versionTag17);
     ASSERT(err != GF_CACHE_CONCURRENT_MODIFICATION_EXCEPTION, "an exception");
     MapEntryImplPtr result;
     CacheablePtr value;
@@ -267,24 +272,24 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepTwo_TestPut)
     ASSERT(atoi(value->toString()->asChar()) == 500, "an exception");
     ASSERT(me->getVersionStamp().getMemberId() == 7, "an exception");
 
-    VersionTagPtr versionTag18(new VersionTag(0xffffaa, 6, 7, host1, 0));
+    auto versionTag18 = std::make_shared<VersionTag>(0xffffaa, 6, 7, host1, 0);
 
     // version rollover, this will not be applied
-    err = entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag18);
+    err = entries->put(keyPtr, ccstr, me, oldValue, -1, 0, versionTag18);
     ASSERT(err == GF_CACHE_CONCURRENT_MODIFICATION_EXCEPTION, "an exception");
     entries->getEntry(keyPtr, result, value);
     ASSERT(atoi(value->toString()->asChar()) == 500, "an exception");
     ASSERT(me->getVersionStamp().getMemberId() == 7, "an exception");
 
-    CacheableKeyPtr keyPtr2 = CacheableKey::create((char*)"Key2");
-    err = entries->put(keyPtr2, ct, me, oldValue, -1, 0, versionTag18);
+    auto keyPtr2 = CacheableKey::create("Key2");
+    err = entries->put(keyPtr2, ccstr, me, oldValue, -1, 0, versionTag18);
     ASSERT(err != GF_CACHE_CONCURRENT_MODIFICATION_EXCEPTION, "an exception");
     entries->getEntry(keyPtr2, result, value);
     ASSERT(atoi(value->toString()->asChar()) == 100, "an exception");
     ASSERT(me->getVersionStamp().getMemberId() == 1, "an exception");
 
     // version rollover, this will be applied
-    err = entries->put(keyPtr2, ct1, me, oldValue, -1, 0, versionTag12);
+    err = entries->put(keyPtr2, ccstr1, me, oldValue, -1, 0, versionTag12);
     ASSERT(err != GF_CACHE_CONCURRENT_MODIFICATION_EXCEPTION, "an exception");
     entries->getEntry(keyPtr2, result, value);
     ASSERT(atoi(value->toString()->asChar()) == 500, "an exception");
@@ -292,7 +297,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepTwo_TestPut)
 
     // Null version tag, this will be applied
     VersionTagPtr versionTag19;
-    err = entries->put(keyPtr2, ct, me, oldValue, -1, 0, versionTag19);
+    err = entries->put(keyPtr2, ccstr, me, oldValue, -1, 0, versionTag19);
     ASSERT(err != GF_CACHE_CONCURRENT_MODIFICATION_EXCEPTION, "an exception");
     entries->getEntry(keyPtr2, result, value);
     ASSERT(atoi(value->toString()->asChar()) == 100, "an exception");
@@ -300,8 +305,8 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepTwo_TestPut)
     ASSERT(result->getVersionStamp().getEntryVersion() == 5, "an exception");
 
     // inserts a null tag
-    CacheableKeyPtr keyPtr3 = CacheableKey::create((char*)"Key3");
-    err = entries->put(keyPtr3, ct1, me, oldValue, -1, 0, versionTag19);
+    auto keyPtr3 = CacheableKey::create("Key3");
+    err = entries->put(keyPtr3, ccstr1, me, oldValue, -1, 0, versionTag19);
     ASSERT(err == GF_NOERR, "an exception");
     entries->getEntry(keyPtr3, result, value);
     ASSERT(atoi(value->toString()->asChar()) == 500, "an exception");
@@ -312,7 +317,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepTwo_TestPut)
     // version
     // stamp,
     // should be allowed.
-    err = entries->put(keyPtr3, ct1, me, oldValue, -1, 0, versionTag12);
+    err = entries->put(keyPtr3, ccstr1, me, oldValue, -1, 0, versionTag12);
     ASSERT(err == GF_NOERR, "an exception");
     entries->getEntry(keyPtr3, result, value);
     ASSERT(atoi(value->toString()->asChar()) == 500, "an exception");
@@ -329,9 +334,8 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepTwo_TestPut)
     sprintf(log, "Some delta tests...");
     LOG(log);
 
-    CacheableKeyPtr keyPtr4 = CacheableKey::create((char*)"Key4");
-    DeltaEx* ptr = new DeltaEx();
-    CacheablePtr valPtr(ptr);
+    auto keyPtr4 = CacheableKey::create("Key4");
+    auto valPtr = std::make_shared<DeltaEx>();
     err = entries->put(keyPtr4, valPtr, me, oldValue, -1, 0, versionTag12);
     ASSERT(err == GF_NOERR, "an exception");
     entries->getEntry(keyPtr4, result, value);
@@ -339,17 +343,17 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepTwo_TestPut)
     ASSERT(result->getVersionStamp().getEntryVersion() == 5, "an exception");
     ASSERT(DeltaEx::fromDeltaCount == 0, " Delta count should have been 0 ");
 
-    DeltaEx* ptr1 = new DeltaEx();
-    ptr1->setDelta(true);
-    CacheablePtr valPtr1(ptr1);
+    auto valPtr1 = std::make_shared<DeltaEx>();
+    valPtr1->setDelta(true);
     DataOutput doutput;
     doutput.writeInt(1);
-    const uint8_t* buffer = doutput.getBuffer();
+    const auto buffer = doutput.getBuffer();
 
     DataInput datainput(buffer, doutput.getBufferLength());
 
     bool isUpdate;
-    VersionTagPtr versionTag12plus(new VersionTag(6, 6, 7, host13, host12));
+    auto versionTag12plus =
+        std::make_shared<VersionTag>(6, 6, 7, host13, host12);
     err = entries->put(keyPtr4, valPtr1, me, oldValue, -1, 0, versionTag12plus,
                        isUpdate, &datainput);
 
@@ -370,7 +374,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepTwo_TestPut)
 
     // Delta update, Not allowed as delta based on a different host version
     // different
-    VersionTagPtr versionTag12pp(new VersionTag(7, 6, 7, host13, host12));
+    auto versionTag12pp = std::make_shared<VersionTag>(7, 6, 7, host13, host12);
     err = entries->put(keyPtr4, valPtr1, me, oldValue, -1, 0, versionTag12plus,
                        isUpdate, &datainput);
     ASSERT(err == GF_INVALID_DELTA, "an exception");
@@ -379,16 +383,16 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepTwo_TestPut)
     ASSERT(result->getVersionStamp().getEntryVersion() == 6, "an exception");
     ASSERT(DeltaEx::fromDeltaCount == 1, " Delta count should have been 1 ");
 
-    DeltaEx* ptr2 = new DeltaEx();
-    ptr2->setDelta(true);
-    CacheablePtr valPtr2(ptr2);
+    auto valPtr2 = std::make_shared<DeltaEx>();
+    valPtr2->setDelta(true);
     DataOutput doutput1;
     doutput1.writeInt(1);
-    const uint8_t* buffer1 = doutput1.getBuffer();
+    const auto buffer1 = doutput1.getBuffer();
     DataInput datainput1(buffer1, doutput1.getBufferLength());
     DeltaEx::fromDeltaCount = 0;
     // Delta update,  allowed as delta based on correct host version different
-    VersionTagPtr versionTag12pp1(new VersionTag(7, 6, 7, host14, host13));
+    auto versionTag12pp1 =
+        std::make_shared<VersionTag>(7, 6, 7, host14, host13);
     err = entries->put(keyPtr4, valPtr2, me, oldValue, -1, 0, versionTag12pp1,
                        isUpdate, &datainput1);
     ASSERT(err == GF_NOERR, "an exception");
@@ -398,19 +402,25 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepTwo_TestPut)
     ASSERT(DeltaEx::fromDeltaCount == 1, " Delta count should have been 1 ");
 
     /******* Test disk version tags*****************/
-    VersionTagPtr versiondiskTag17(new DiskVersionTag(5, 6, 7, disk17, 0));
-    VersionTagPtr versiondiskTag18(new DiskVersionTag(5, 6, 7, disk18, 0));
-    VersionTagPtr versiondiskTag27(new DiskVersionTag(5, 6, 7, disk27, 0));
-    CacheableKeyPtr keydiskPtr = CacheableKey::create((char*)"keydisk1");
-    err = entries->put(keydiskPtr, ct, me, oldValue, -1, 0, versiondiskTag17);
-    err = entries->put(keydiskPtr, ct1, me, oldValue, -1, 0, versiondiskTag27);
+    auto versiondiskTag17 =
+        std::make_shared<DiskVersionTag>(5, 6, 7, disk17, 0);
+    auto versiondiskTag18 =
+        std::make_shared<DiskVersionTag>(5, 6, 7, disk18, 0);
+    auto versiondiskTag27 =
+        std::make_shared<DiskVersionTag>(5, 6, 7, disk27, 0);
+    auto keydiskPtr = CacheableKey::create("keydisk1");
+    err =
+        entries->put(keydiskPtr, ccstr, me, oldValue, -1, 0, versiondiskTag17);
+    err =
+        entries->put(keydiskPtr, ccstr1, me, oldValue, -1, 0, versiondiskTag27);
     ASSERT(err == GF_NOERR, "an exception");
     entries->getEntry(keydiskPtr, result, value);
     ASSERT(atoi(value->toString()->asChar()) == 500, "an exception");
     ASSERT(result->getVersionStamp().getMemberId() == disk27, "an exception");
     ASSERT(result->getVersionStamp().getEntryVersion() == 5, "an exception");
 
-    err = entries->put(keydiskPtr, ct, me, oldValue, -1, 0, versiondiskTag18);
+    err =
+        entries->put(keydiskPtr, ccstr, me, oldValue, -1, 0, versiondiskTag18);
     ASSERT(err == GF_CACHE_CONCURRENT_MODIFICATION_EXCEPTION, "an exception");
     entries->getEntry(keydiskPtr, result, value);
     ASSERT(atoi(value->toString()->asChar()) == 500, "an exception");
@@ -418,15 +428,18 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepTwo_TestPut)
     ASSERT(result->getVersionStamp().getEntryVersion() == 5, "an exception");
 
     /********* Test with vm view ids ****************/
-    VersionTagPtr versionvmviewTag5(new VersionTag(5, 6, 7, hostVmview5, 0));
-    VersionTagPtr versionvmviewTag6(new VersionTag(5, 6, 7, hostVmview6, 0));
-    VersionTagPtr versionvmviewTag7(new VersionTag(5, 6, 7, hostVmview7, 0));
-    CacheableKeyPtr keyvmviewPtr = CacheableKey::create((char*)"keyvm1");
-    err =
-        entries->put(keyvmviewPtr, ct, me, oldValue, -1, 0, versionvmviewTag5);
-
-    err =
-        entries->put(keyvmviewPtr, ct1, me, oldValue, -1, 0, versionvmviewTag7);
+    auto versionvmviewTag5 =
+        std::make_shared<VersionTag>(5, 6, 7, hostVmview5, 0);
+    auto versionvmviewTag6 =
+        std::make_shared<VersionTag>(5, 6, 7, hostVmview6, 0);
+    auto versionvmviewTag7 =
+        std::make_shared<VersionTag>(5, 6, 7, hostVmview7, 0);
+    auto keyvmviewPtr = CacheableKey::create("keyvm1");
+    err = entries->put(keyvmviewPtr, ccstr, me, oldValue, -1, 0,
+                       versionvmviewTag5);
+
+    err = entries->put(keyvmviewPtr, ccstr1, me, oldValue, -1, 0,
+                       versionvmviewTag7);
     ASSERT(err == GF_NOERR, "an exception");
     entries->getEntry(keyvmviewPtr, result, value);
     ASSERT(atoi(value->toString()->asChar()) == 500, "an exception");
@@ -434,8 +447,8 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepTwo_TestPut)
            "an exception");
     ASSERT(result->getVersionStamp().getEntryVersion() == 5, "an exception");
 
-    err =
-        entries->put(keyvmviewPtr, ct, me, oldValue, -1, 0, versionvmviewTag6);
+    err = entries->put(keyvmviewPtr, ccstr, me, oldValue, -1, 0,
+                       versionvmviewTag6);
     ASSERT(err == GF_CACHE_CONCURRENT_MODIFICATION_EXCEPTION, "an exception");
     entries->getEntry(keyvmviewPtr, result, value);
     ASSERT(atoi(value->toString()->asChar()) == 500, "an exception");
@@ -451,17 +464,16 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepTwo_TestPut)
 END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT1, StepThree_TestCreate)
   {
-    LocalRegion* lregPtr = (dynamic_cast<LocalRegion*>(regPtr.ptr()));
-    CacheableStringPtr ccstr = createCacheable("100");
-    CacheablePtr ct = ccstr;
-    CacheableStringPtr ccstr1 = createCacheable("500");
-    CacheablePtr ct1 = ccstr1;
-    EntryFactory* entryFactory = EntryFactory::singleton;
+    auto lregPtr = std::dynamic_pointer_cast<LocalRegion>(regPtr);
+    auto ccstr = createCacheable("100");
+    auto ccstr1 = createCacheable("500");
+    auto entryFactory = EntryFactory::singleton;
     entryFactory->setConcurrencyChecksEnabled(true);
-    EntriesMap* entries = new ConcurrentEntriesMap(entryFactory, true, lregPtr);
+    EntriesMap* entries =
+        new ConcurrentEntriesMap(entryFactory, true, lregPtr.get());
     entries->open();
-    CacheableKeyPtr keyPtr4 = CacheableKey::create((char*)"key4");
-    ASSERT(keyPtr4 != NULLPTR, "expected keyPtr non-NULL");
+    auto keyPtr4 = CacheableKey::create("key4");
+    ASSERT(keyPtr4 != nullptr, "expected keyPtr non-NULL");
     MapEntryImplPtr me;
     MapEntryImplPtr result;
     CacheablePtr value;
@@ -469,87 +481,87 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepThree_TestCreate)
     /*new VersionTag(int32_t entryVersion,
         int16_t regionVersionHighBytes, int32_t regionVersionLowBytes,
         uint16_t internalMemId, uint16_t previousMemId) */
-    VersionTagPtr versionTag1(new VersionTag(5, 6, 7, host1, 0));
+    auto versionTag1 = std::make_shared<VersionTag>(5, 6, 7, host1, 0);
 
-    VersionTagPtr versionTag12(new VersionTag(5, 6, 7, host12, 0));
+    auto versionTag12 = std::make_shared<VersionTag>(5, 6, 7, host12, 0);
 
-    VersionTagPtr versionTag13(new VersionTag(5, 6, 7, host13, 0));
-    VersionTagPtr versionTag14(new VersionTag(5, 6, 7, host14, 0));
-    VersionTagPtr versionTag15(new VersionTag(5, 6, 7, host15, 0));
-    VersionTagPtr versionTag16(new VersionTag(5, 6, 7, host16, 0));
-    VersionTagPtr versionTag17(new VersionTag(5, 6, 7, host17, 0));
+    auto versionTag13 = std::make_shared<VersionTag>(5, 6, 7, host13, 0);
+    auto versionTag14 = std::make_shared<VersionTag>(5, 6, 7, host14, 0);
+    auto versionTag15 = std::make_shared<VersionTag>(5, 6, 7, host15, 0);
+    auto versionTag16 = std::make_shared<VersionTag>(5, 6, 7, host16, 0);
+    auto versionTag17 = std::make_shared<VersionTag>(5, 6, 7, host17, 0);
 
     CacheablePtr oldValue;
-    entries->create(keyPtr4, ct, me, oldValue, -1, 0, versionTag1);
+    entries->create(keyPtr4, ccstr, me, oldValue, -1, 0, versionTag1);
     entries->getEntry(keyPtr4, result, value);
     ASSERT(me->getVersionStamp().getEntryVersion() == 5, "an exception");
     ASSERT(me->getVersionStamp().getMemberId() == 1, "an exception");
 
     char log[256];
 
-    CacheableKeyPtr keyPtr = CacheableKey::create((char*)"Key");
-    GfErrType err =
-        entries->create(keyPtr, NULLPTR, me, oldValue, -1, 0, versionTag12);
+    auto keyPtr = CacheableKey::create("Key");
+    auto err =
+        entries->create(keyPtr, nullptr, me, oldValue, -1, 0, versionTag12);
     ASSERT(err == GF_NOERR, "an exception");
 
-    err = entries->create(keyPtr, NULLPTR, me, oldValue, -1, 0, versionTag1);
+    err = entries->create(keyPtr, nullptr, me, oldValue, -1, 0, versionTag1);
     ASSERT(err == GF_CACHE_CONCURRENT_MODIFICATION_EXCEPTION, "an exception");
 
-    err = entries->create(keyPtr, NULLPTR, me, oldValue, -1, 0, versionTag13);
+    err = entries->create(keyPtr, nullptr, me, oldValue, -1, 0, versionTag13);
     ASSERT(err == GF_NOERR, "an exception");
 
-    err = entries->create(keyPtr, NULLPTR, me, oldValue, -1, 0, versionTag1);
+    err = entries->create(keyPtr, nullptr, me, oldValue, -1, 0, versionTag1);
     ASSERT(err == GF_CACHE_CONCURRENT_MODIFICATION_EXCEPTION, "an exception");
 
-    err = entries->create(keyPtr, NULLPTR, me, oldValue, -1, 0, versionTag14);
+    err = entries->create(keyPtr, nullptr, me, oldValue, -1, 0, versionTag14);
     ASSERT(err == GF_NOERR, "an exception");
 
-    err = entries->create(keyPtr, NULLPTR, me, oldValue, -1, 0, versionTag1);
+    err = entries->create(keyPtr, nullptr, me, oldValue, -1, 0, versionTag1);
     ASSERT(err == GF_CACHE_CONCURRENT_MODIFICATION_EXCEPTION, "an exception");
 
-    err = entries->create(keyPtr, NULLPTR, me, oldValue, -1, 0, versionTag15);
+    err = entries->create(keyPtr, nullptr, me, oldValue, -1, 0, versionTag15);
     ASSERT(err == GF_CACHE_CONCURRENT_MODIFICATION_EXCEPTION, "an exception");
 
-    err = entries->create(keyPtr, NULLPTR, me, oldValue, -1, 0, versionTag1);
+    err = entries->create(keyPtr, nullptr, me, oldValue, -1, 0, versionTag1);
     ASSERT(err == GF_CACHE_CONCURRENT_MODIFICATION_EXCEPTION, "an exception");
 
-    err = entries->create(keyPtr, NULLPTR, me, oldValue, -1, 0, versionTag16);
+    err = entries->create(keyPtr, nullptr, me, oldValue, -1, 0, versionTag16);
     ASSERT(err == GF_CACHE_CONCURRENT_MODIFICATION_EXCEPTION, "an exception");
 
-    err = entries->create(keyPtr, ct1, me, oldValue, -1, 0, versionTag17);
+    err = entries->create(keyPtr, ccstr1, me, oldValue, -1, 0, versionTag17);
     ASSERT(err == GF_NOERR, "an exception");
     entries->getEntry(keyPtr, result, value);
     ASSERT(result->getVersionStamp().getMemberId() == 7, "an exception");
     ASSERT(result->getVersionStamp().getEntryVersion() == 5, "an exception");
 
-    VersionTagPtr versionTag18(new VersionTag(0xffffaa, 6, 7, host1, 0));
+    auto versionTag18 = std::make_shared<VersionTag>(0xffffaa, 6, 7, host1, 0);
 
-    CacheableKeyPtr keyPtr2 = CacheableKey::create((char*)"Key2");
-    err = entries->create(keyPtr2, NULLPTR, me, oldValue, -1, 0, versionTag18);
+    auto keyPtr2 = CacheableKey::create("Key2");
+    err = entries->create(keyPtr2, nullptr, me, oldValue, -1, 0, versionTag18);
     ASSERT(err == GF_NOERR, "an exception");
 
     // version rollover, this will be applied
-    err = entries->create(keyPtr2, NULLPTR, me, oldValue, -1, 0, versionTag12);
+    err = entries->create(keyPtr2, nullptr, me, oldValue, -1, 0, versionTag12);
     ASSERT(err == GF_NOERR, "an exception");
 
     // Null version tag, this will be applied
     VersionTagPtr versionTag19;
-    err = entries->create(keyPtr2, ct, me, oldValue, -1, 0, versionTag19);
+    err = entries->create(keyPtr2, ccstr, me, oldValue, -1, 0, versionTag19);
     ASSERT(err == GF_NOERR, "an exception");
     entries->getEntry(keyPtr2, result, value);
     ASSERT(result->getVersionStamp().getMemberId() == 2, "an exception");
     ASSERT(result->getVersionStamp().getEntryVersion() == 5, "an exception");
 
     // inserts a null tag
-    CacheableKeyPtr keyPtr3 = CacheableKey::create((char*)"Key3");
-    err = entries->create(keyPtr3, NULLPTR, me, oldValue, -1, 0, versionTag19);
+    auto keyPtr3 = CacheableKey::create("Key3");
+    err = entries->create(keyPtr3, nullptr, me, oldValue, -1, 0, versionTag19);
     ASSERT(err == GF_NOERR, "an exception");
 
     // inserts an entry with version stamp, the previous entry is without
     // version
     // stamp,
     // should be allowed.
-    err = entries->create(keyPtr3, ct1, me, oldValue, -1, 0, versionTag12);
+    err = entries->create(keyPtr3, ccstr1, me, oldValue, -1, 0, versionTag12);
     ASSERT(err == GF_NOERR, "an exception");
     entries->getEntry(keyPtr3, result, value);
     ASSERT(result->getVersionStamp().getMemberId() == 2, "an exception");
@@ -564,46 +576,43 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, StepEight_TestLRUEntries)
   {
-    LocalRegion* lregPtr = (dynamic_cast<LocalRegion*>(regPtr.ptr()));
-    CacheableStringPtr ccstr = createCacheable("100");
-    CacheablePtr ct = ccstr;
-    CacheableStringPtr ccstr1 = createCacheable("500");
-    CacheablePtr ct1 = ccstr1;
-    EntryFactory* entryFactory = LRUExpEntryFactory::singleton;
+    auto lregPtr = std::dynamic_pointer_cast<LocalRegion>(regPtr);
+    auto ccstr = createCacheable("100");
+    auto ccstr1 = createCacheable("500");
+    auto entryFactory = LRUExpEntryFactory::singleton;
     entryFactory->setConcurrencyChecksEnabled(true);
-    EntriesMap* entries = new LRUEntriesMap(entryFactory, lregPtr,
+    EntriesMap* entries = new LRUEntriesMap(entryFactory, lregPtr.get(),
                                             LRUAction::DESTROY, 50000, true);
     entries->open();
-    CacheableKeyPtr keyPtr4 = CacheableKey::create((char*)"key4");
-    CacheableKeyPtr keyPtr5 = CacheableKey::create((char*)"key5");
-    CacheableKeyPtr keyPtr6 = CacheableKey::create((char*)"key6");
+    auto keyPtr4 = CacheableKey::create("key4");
+    auto keyPtr5 = CacheableKey::create("key5");
+    auto keyPtr6 = CacheableKey::create("key6");
     MapEntryImplPtr me;
     MapEntryImplPtr result;
     CacheablePtr value;
     char log[256];
 
-    VersionTagPtr versionTag1(new VersionTag(5, 6, 7, host1, 0));
+    auto versionTag1 = std::make_shared<VersionTag>(5, 6, 7, host1, 0);
 
-    VersionTagPtr versionTag12(new VersionTag(5, 6, 7, host12, 0));
+    auto versionTag12 = std::make_shared<VersionTag>(5, 6, 7, host12, 0);
 
-    entries->put(keyPtr4, ct, me, value, -1, 0, versionTag1);
+    entries->put(keyPtr4, ccstr, me, value, -1, 0, versionTag1);
 
-    GfErrType err =
-        entries->remove(keyPtr4, value, me, -1, versionTag12, false);
+    auto err = entries->remove(keyPtr4, value, me, -1, versionTag12, false);
     ASSERT(err == GF_NOERR, "an exception");
     bool isTombstone;
     err = entries->isTombstone(keyPtr4, result, isTombstone);
     ASSERT(err == GF_NOERR, "an exception");
     ASSERT(isTombstone == true, "an exception");
 
-    entries->put(keyPtr5, ct, me, value, -1, 0, versionTag1);
+    entries->put(keyPtr5, ccstr, me, value, -1, 0, versionTag1);
 
     err = entries->invalidate(keyPtr5, me, value, versionTag12);
     ASSERT(err == GF_NOERR, "an exception");
     entries->getEntry(keyPtr5, result, value);
     ASSERT(CacheableToken::isInvalid(value) == true, "an exception");
 
-    entries->put(keyPtr6, ct, me, value, -1, 0, versionTag1);
+    entries->put(keyPtr6, ccstr, me, value, -1, 0, versionTag1);
 
     ASSERT(entries->get(keyPtr4, value, result) == false, "an exception");
     ASSERT(entries->get(keyPtr6, value, result) == true, "an exception");
@@ -617,38 +626,36 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, StepFive_TestTombstoneExpiry)
   {
-    LocalRegion* lregPtr = (dynamic_cast<LocalRegion*>(regPtr.ptr()));
-    CacheableStringPtr ccstr = createCacheable("100");
-    CacheablePtr ct = ccstr;
-    CacheableStringPtr ccstr1 = createCacheable("500");
-    CacheablePtr ct1 = ccstr1;
-    EntryFactory* entryFactory = EntryFactory::singleton;
+    auto lregPtr = std::dynamic_pointer_cast<LocalRegion>(regPtr);
+    auto ccstr = createCacheable("100");
+    auto ccstr1 = createCacheable("500");
+    auto entryFactory = EntryFactory::singleton;
     entryFactory->setConcurrencyChecksEnabled(true);
-    EntriesMap* entries = new ConcurrentEntriesMap(entryFactory, true, lregPtr);
+    EntriesMap* entries =
+        new ConcurrentEntriesMap(entryFactory, true, lregPtr.get());
     entries->open();
-    CacheableKeyPtr keyPtr4 = CacheableKey::create((char*)"key4");
-    CacheableKeyPtr keyPtr5 = CacheableKey::create((char*)"key5");
-    CacheableKeyPtr keyPtr6 = CacheableKey::create((char*)"key6");
+    auto keyPtr4 = CacheableKey::create("key4");
+    auto keyPtr5 = CacheableKey::create("key5");
+    auto keyPtr6 = CacheableKey::create("key6");
     MapEntryImplPtr me;
     MapEntryImplPtr result;
     CacheablePtr value;
     char log[256];
 
-    VersionTagPtr versionTag1(new VersionTag(5, 6, 7, host1, 0));
+    auto versionTag1 = std::make_shared<VersionTag>(5, 6, 7, host1, 0);
 
-    VersionTagPtr versionTag12(new VersionTag(5, 6, 7, host12, 0));
+    auto versionTag12 = std::make_shared<VersionTag>(5, 6, 7, host12, 0);
 
-    entries->put(keyPtr4, ct, me, value, -1, 0, versionTag1);
+    entries->put(keyPtr4, ccstr, me, value, -1, 0, versionTag1);
 
-    GfErrType err =
-        entries->remove(keyPtr4, value, me, -1, versionTag12, false);
+    auto err = entries->remove(keyPtr4, value, me, -1, versionTag12, false);
     ASSERT(err == GF_NOERR, "an exception");
     bool isTombstone;
     err = entries->isTombstone(keyPtr4, result, isTombstone);
     ASSERT(err == GF_NOERR, "an exception");
     ASSERT(isTombstone == true, "an exception");
 
-    entries->put(keyPtr5, ct, me, value, -1, 0, versionTag1);
+    entries->put(keyPtr5, ccstr, me, value, -1, 0, versionTag1);
 
     err = entries->remove(keyPtr5, value, me, -1, versionTag12, false);
     ASSERT(err == GF_NOERR, "an exception");
@@ -656,10 +663,10 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepFive_TestTombstoneExpiry)
     ASSERT(err == GF_NOERR, "an exception");
     ASSERT(isTombstone == true, "an exception");
 
-    entries->put(keyPtr6, ct, me, value, -1, 0, versionTag1);
-    uint32_t tombstone_count =
+    entries->put(keyPtr6, ccstr, me, value, -1, 0, versionTag1);
+    auto tombstone_count =
         lregPtr->getCacheImpl()->m_cacheStats->getTombstoneCount();
-    uint64_t tombstone_size =
+    auto tombstone_size =
         lregPtr->getCacheImpl()->m_cacheStats->getTombstoneSize();
 
     sprintf(log,
@@ -682,9 +689,9 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepFive_TestTombstoneExpiry)
     ASSERT(isTombstone == false, "an exception");
     ASSERT(entries->get(keyPtr4, value, result) == false, "an exception");
 
-    uint32_t tombstone_count_after =
+    auto tombstone_count_after =
         lregPtr->getCacheImpl()->m_cacheStats->getTombstoneCount();
-    uint64_t tombstone_size_after =
+    auto tombstone_size_after =
         lregPtr->getCacheImpl()->m_cacheStats->getTombstoneSize();
 
     sprintf(log,
@@ -706,48 +713,47 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, StepSix_TestInvalidate)
   {
-    LocalRegion* lregPtr = (dynamic_cast<LocalRegion*>(regPtr.ptr()));
-    CacheableStringPtr ccstr = createCacheable("100");
-    CacheablePtr ct = ccstr;
-    CacheableStringPtr ccstr1 = createCacheable("500");
-    CacheablePtr ct1 = ccstr1;
-    EntryFactory* entryFactory = EntryFactory::singleton;
+    auto lregPtr = std::dynamic_pointer_cast<LocalRegion>(regPtr);
+    auto ccstr = createCacheable("100");
+    auto ccstr1 = createCacheable("500");
+    auto entryFactory = EntryFactory::singleton;
     entryFactory->setConcurrencyChecksEnabled(true);
-    EntriesMap* entries = new ConcurrentEntriesMap(entryFactory, true, lregPtr);
+    EntriesMap* entries =
+        new ConcurrentEntriesMap(entryFactory, true, lregPtr.get());
     entries->open();
-    CacheableKeyPtr keyPtr = CacheableKey::create((char*)"key1");
-    ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
+    CacheableKeyPtr keyPtr = CacheableKey::create("key1");
+    ASSERT(keyPtr != nullptr, "expected keyPtr non-NULL");
     MapEntryImplPtr me;
     MapEntryImplPtr result;
     CacheablePtr value;
 
-    VersionTagPtr versionTag1(new VersionTag(5, 6, 7, host1, 0));
+    auto versionTag1 = std::make_shared<VersionTag>(5, 6, 7, host1, 0);
 
-    VersionTagPtr versionTag12(new VersionTag(5, 6, 7, host12, 0));
+    auto versionTag12 = std::make_shared<VersionTag>(5, 6, 7, host12, 0);
 
-    VersionTagPtr versionTag13(new VersionTag(5, 6, 7, host13, 0));
-    VersionTagPtr versionTag14(new VersionTag(5, 6, 7, host14, 0));
-    VersionTagPtr versionTag15(new VersionTag(5, 6, 7, host15, 0));
-    VersionTagPtr versionTag16(new VersionTag(5, 6, 7, host16, 0));
-    VersionTagPtr versionTag17(new VersionTag(5, 6, 7, host17, 0));
-    VersionTagPtr versionTag22(new VersionTag(9, 10, 10, host12, 0));
+    auto versionTag13 = std::make_shared<VersionTag>(5, 6, 7, host13, 0);
+    auto versionTag14 = std::make_shared<VersionTag>(5, 6, 7, host14, 0);
+    auto versionTag15 = std::make_shared<VersionTag>(5, 6, 7, host15, 0);
+    auto versionTag16 = std::make_shared<VersionTag>(5, 6, 7, host16, 0);
+    auto versionTag17 = std::make_shared<VersionTag>(5, 6, 7, host17, 0);
+    auto versionTag22 = std::make_shared<VersionTag>(9, 10, 10, host12, 0);
 
     CacheablePtr oldValue;
-    entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag1);
+    entries->put(keyPtr, ccstr, me, oldValue, -1, 0, versionTag1);
     char log[256];
 
-    GfErrType err = entries->invalidate(keyPtr, me, oldValue, versionTag12);
+    auto err = entries->invalidate(keyPtr, me, oldValue, versionTag12);
 
     ASSERT(err == GF_NOERR, "an exception");
     entries->getEntry(keyPtr, result, value);
     ASSERT(CacheableToken::isInvalid(value) == true, "an exception");
 
-    err = entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag1);
+    err = entries->put(keyPtr, ccstr, me, oldValue, -1, 0, versionTag1);
     ASSERT(err == GF_CACHE_CONCURRENT_MODIFICATION_EXCEPTION, "an exception");
     entries->getEntry(keyPtr, result, value);
     ASSERT(CacheableToken::isInvalid(value) == true, "an exception");
 
-    err = entries->put(keyPtr, ct1, me, oldValue, -1, 0, versionTag13);
+    err = entries->put(keyPtr, ccstr1, me, oldValue, -1, 0, versionTag13);
     ASSERT(err == GF_NOERR, "an exception");
     entries->getEntry(keyPtr, result, value);
     ASSERT(CacheableToken::isInvalid(value) != true, "an exception");
@@ -776,18 +782,18 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepSix_TestInvalidate)
     ASSERT(result->getVersionStamp().getMemberId() == 2, "an exception");
     ASSERT(result->getVersionStamp().getEntryVersion() == 9, "an exception");
 
-    VersionTagPtr versionTag18(new VersionTag(0xffffaa, 6, 7, host1, 0));
+    auto versionTag18 = std::make_shared<VersionTag>(0xffffaa, 6, 7, host1, 0);
 
     // version rollover, this will not be applied
-    err = entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag18);
+    err = entries->put(keyPtr, ccstr, me, oldValue, -1, 0, versionTag18);
     ASSERT(err == GF_CACHE_CONCURRENT_MODIFICATION_EXCEPTION, "an exception");
     entries->getEntry(keyPtr, result, value);
     ASSERT(CacheableToken::isInvalid(value) == true, "an exception");
     ASSERT(result->getVersionStamp().getMemberId() == 2, "an exception");
     ASSERT(result->getVersionStamp().getEntryVersion() == 9, "an exception");
 
-    CacheableKeyPtr keyPtr2 = CacheableKey::create((char*)"Key2");
-    err = entries->put(keyPtr2, ct, me, oldValue, -1, 0, versionTag18);
+    auto keyPtr2 = CacheableKey::create("Key2");
+    err = entries->put(keyPtr2, ccstr, me, oldValue, -1, 0, versionTag18);
     ASSERT(err == GF_NOERR, "an exception");
     entries->getEntry(keyPtr2, result, value);
     ASSERT(atoi(value->toString()->asChar()) == 100, "an exception");
@@ -803,7 +809,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepSix_TestInvalidate)
 
     // Null version tag, this will be applied
     VersionTagPtr versionTag19;
-    err = entries->put(keyPtr2, ct, me, oldValue, -1, 0, versionTag19);
+    err = entries->put(keyPtr2, ccstr, me, oldValue, -1, 0, versionTag19);
     entries->getEntry(keyPtr2, result, value);
     ASSERT(CacheableToken::isInvalid(value) != true, "an exception");
     ASSERT(atoi(value->toString()->asChar()) == 100, "an exception");
@@ -811,8 +817,8 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepSix_TestInvalidate)
     ASSERT(result->getVersionStamp().getEntryVersion() == 9, "an exception");
 
     // inserts a null tag
-    CacheableKeyPtr keyPtr3 = CacheableKey::create((char*)"Key3");
-    err = entries->put(keyPtr3, ct1, me, oldValue, -1, 0, versionTag19);
+    auto keyPtr3 = CacheableKey::create("Key3");
+    err = entries->put(keyPtr3, ccstr1, me, oldValue, -1, 0, versionTag19);
     ASSERT(err == GF_NOERR, "an exception");
     entries->getEntry(keyPtr3, result, value);
     ASSERT(atoi(value->toString()->asChar()) == 500, "an exception");
@@ -836,40 +842,38 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, StepSeven_TestGetsAfterRemove)
   {
-    LocalRegion* lregPtr = (dynamic_cast<LocalRegion*>(regPtr.ptr()));
-    CacheableStringPtr ccstr = createCacheable("100");
-    CacheablePtr ct = ccstr;
-    CacheableStringPtr ccstr1 = createCacheable("500");
-    CacheablePtr ct1 = ccstr1;
-    EntryFactory* entryFactory = EntryFactory::singleton;
+    auto lregPtr = std::dynamic_pointer_cast<LocalRegion>(regPtr);
+    auto ccstr = createCacheable("100");
+    auto ccstr1 = createCacheable("500");
+    auto entryFactory = EntryFactory::singleton;
     entryFactory->setConcurrencyChecksEnabled(true);
-    EntriesMap* entries = new ConcurrentEntriesMap(entryFactory, true, lregPtr);
+    EntriesMap* entries =
+        new ConcurrentEntriesMap(entryFactory, true, lregPtr.get());
     entries->open();
-    CacheableKeyPtr keyPtr4 = CacheableKey::create((char*)"key4");
-    CacheableKeyPtr keyPtr5 = CacheableKey::create((char*)"key5");
-    CacheableKeyPtr keyPtr6 = CacheableKey::create((char*)"key6");
+    auto keyPtr4 = CacheableKey::create("key4");
+    auto keyPtr5 = CacheableKey::create("key5");
+    auto keyPtr6 = CacheableKey::create("key6");
     MapEntryImplPtr me;
     MapEntryImplPtr result;
     CacheablePtr value;
     char log[256];
 
-    VersionTagPtr versionTag1(new VersionTag(5, 6, 7, host1, 0));
+    auto versionTag1 = std::make_shared<VersionTag>(5, 6, 7, host1, 0);
 
-    VersionTagPtr versionTag12(new VersionTag(5, 6, 7, host12, 0));
+    auto versionTag12 = std::make_shared<VersionTag>(5, 6, 7, host12, 0);
 
-    VersionTagPtr versionTag22(new VersionTag(6, 6, 7, host12, 0));
+    auto versionTag22 = std::make_shared<VersionTag>(6, 6, 7, host12, 0);
 
-    entries->put(keyPtr4, ct, me, value, -1, 0, versionTag1);
+    entries->put(keyPtr4, ccstr, me, value, -1, 0, versionTag1);
 
-    GfErrType err =
-        entries->remove(keyPtr4, value, me, -1, versionTag12, false);
+    auto err = entries->remove(keyPtr4, value, me, -1, versionTag12, false);
     ASSERT(err == GF_NOERR, "an exception");
     bool isTombstone;
     err = entries->isTombstone(keyPtr4, result, isTombstone);
     ASSERT(err == GF_NOERR, "an exception");
     ASSERT(isTombstone == true, "an exception");
 
-    entries->put(keyPtr5, ct, me, value, -1, 0, versionTag1);
+    entries->put(keyPtr5, ccstr, me, value, -1, 0, versionTag1);
 
     err = entries->remove(keyPtr5, value, me, -1, versionTag12, false);
     ASSERT(err == GF_NOERR, "an exception");
@@ -877,7 +881,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepSeven_TestGetsAfterRemove)
     ASSERT(err == GF_NOERR, "an exception");
     ASSERT(isTombstone == true, "an exception");
 
-    entries->put(keyPtr6, ct, me, value, -1, 0, versionTag1);
+    entries->put(keyPtr6, ccstr, me, value, -1, 0, versionTag1);
 
     ASSERT(entries->containsKey(keyPtr6) == true, "an exception");
     ASSERT(entries->containsKey(keyPtr5) == false, "an exception");
@@ -898,7 +902,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepSeven_TestGetsAfterRemove)
     entries->entries(regionEntries);
     ASSERT(regionEntries.length() == 1, "an exception");
 
-    entries->put(keyPtr5, ct, me, value, -1, 0, versionTag22);
+    entries->put(keyPtr5, ccstr, me, value, -1, 0, versionTag22);
 
     ASSERT(entries->containsKey(keyPtr6) == true, "an exception");
     ASSERT(entries->containsKey(keyPtr5) == true, "an exception");
@@ -924,38 +928,36 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepSeven_TestGetsAfterRemove)
 END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT1, StepFour_TestRemove)
   {
-    LocalRegion* lregPtr = (dynamic_cast<LocalRegion*>(regPtr.ptr()));
-    CacheableStringPtr ccstr = createCacheable("100");
-    CacheablePtr ct = ccstr;
-    CacheableStringPtr ccstr1 = createCacheable("500");
-    CacheablePtr ct1 = ccstr1;
-    EntryFactory* entryFactory = EntryFactory::singleton;
+    auto lregPtr = std::dynamic_pointer_cast<LocalRegion>(regPtr);
+    auto ccstr = createCacheable("100");
+    auto ccstr1 = createCacheable("500");
+    auto entryFactory = EntryFactory::singleton;
     entryFactory->setConcurrencyChecksEnabled(true);
-    EntriesMap* entries = new ConcurrentEntriesMap(entryFactory, true, lregPtr);
+    EntriesMap* entries =
+        new ConcurrentEntriesMap(entryFactory, true, lregPtr.get());
     entries->open();
-    CacheableKeyPtr keyPtr = CacheableKey::create((char*)"key1");
-    ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
+    auto keyPtr = CacheableKey::create("key1");
+    ASSERT(keyPtr != nullptr, "expected keyPtr non-NULL");
     MapEntryImplPtr me;
     MapEntryImplPtr result;
     CacheablePtr value;
 
-    VersionTagPtr versionTag1(new VersionTag(5, 6, 7, host1, 0));
+    auto versionTag1 = std::make_shared<VersionTag>(5, 6, 7, host1, 0);
 
-    VersionTagPtr versionTag12(new VersionTag(5, 6, 7, host12, 0));
+    auto versionTag12 = std::make_shared<VersionTag>(5, 6, 7, host12, 0);
 
-    VersionTagPtr versionTag13(new VersionTag(5, 6, 7, host13, 0));
-    VersionTagPtr versionTag14(new VersionTag(5, 6, 7, host14, 0));
-    VersionTagPtr versionTag15(new VersionTag(5, 6, 7, host15, 0));
-    VersionTagPtr versionTag16(new VersionTag(5, 6, 7, host16, 0));
-    VersionTagPtr versionTag17(new VersionTag(5, 6, 7, host17, 0));
-    VersionTagPtr versionTag22(new VersionTag(9, 10, 10, host12, 0));
+    auto versionTag13 = std::make_shared<VersionTag>(5, 6, 7, host13, 0);
+    auto versionTag14 = std::make_shared<VersionTag>(5, 6, 7, host14, 0);
+    auto versionTag15 = std::make_shared<VersionTag>(5, 6, 7, host15, 0);
+    auto versionTag16 = std::make_shared<VersionTag>(5, 6, 7, host16, 0);
+    auto versionTag17 = std::make_shared<VersionTag>(5, 6, 7, host17, 0);
+    auto versionTag22 = std::make_shared<VersionTag>(9, 10, 10, host12, 0);
 
     CacheablePtr oldValue;
-    entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag1);
+    entries->put(keyPtr, ccstr, me, oldValue, -1, 0, versionTag1);
     char log[256];
 
-    GfErrType err =
-        entries->remove(keyPtr, oldValue, me, -1, versionTag12, false);
+    auto err = entries->remove(keyPtr, oldValue, me, -1, versionTag12, false);
 
     ASSERT(err == GF_NOERR, "an exception");
     bool isTombstone;
@@ -964,15 +966,15 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepFour_TestRemove)
     entries->getEntry(keyPtr, result, value);
     ASSERT(isTombstone == true, "an exception");
 
-    err = entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag1);
+    err = entries->put(keyPtr, ccstr, me, oldValue, -1, 0, versionTag1);
     ASSERT(err == GF_CACHE_CONCURRENT_MODIFICATION_EXCEPTION, "an exception");
     err = entries->isTombstone(keyPtr, result, isTombstone);
     ASSERT(err == GF_NOERR, "an exception");
     ASSERT(isTombstone == true, "an exception");
 
-    uint32_t tombstone_count =
+    auto tombstone_count =
         lregPtr->getCacheImpl()->m_cacheStats->getTombstoneCount();
-    uint64_t tombstone_size =
+    auto tombstone_size =
         lregPtr->getCacheImpl()->m_cacheStats->getTombstoneSize();
 
     sprintf(log, "After tombstone creation, Tombstone size: %" PRId64
@@ -984,7 +986,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepFour_TestRemove)
            "Tombstone size should be greater than 70 bytes. 70 is an approx "
            "figure for tombstone overhead");
 
-    err = entries->put(keyPtr, ct1, me, oldValue, -1, 0, versionTag13);
+    err = entries->put(keyPtr, ccstr1, me, oldValue, -1, 0, versionTag13);
     ASSERT(err == GF_NOERR, "an exception");
     err = entries->isTombstone(keyPtr, result, isTombstone);
     ASSERT(err == GF_NOERR, "an exception");
@@ -1018,13 +1020,13 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepFour_TestRemove)
     ASSERT(result->getVersionStamp().getEntryVersion() == 5, "an exception");
     ASSERT(entries->get(keyPtr, value, result) == false, "an exception");
 
-    err = entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag1);
+    err = entries->put(keyPtr, ccstr, me, oldValue, -1, 0, versionTag1);
     ASSERT(err == GF_CACHE_CONCURRENT_MODIFICATION_EXCEPTION, "an exception");
 
-    err = entries->put(keyPtr, ct1, me, oldValue, -1, 0, versionTag15);
+    err = entries->put(keyPtr, ccstr1, me, oldValue, -1, 0, versionTag15);
     ASSERT(err == GF_CACHE_CONCURRENT_MODIFICATION_EXCEPTION, "an exception");
 
-    err = entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag1);
+    err = entries->put(keyPtr, ccstr, me, oldValue, -1, 0, versionTag1);
     ASSERT(err == GF_CACHE_CONCURRENT_MODIFICATION_EXCEPTION, "an exception");
 
     err = entries->remove(keyPtr, oldValue, me, -1, versionTag16, false);
@@ -1048,10 +1050,10 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepFour_TestRemove)
     ASSERT(result->getVersionStamp().getEntryVersion() == 9, "an exception");
     ASSERT(entries->get(keyPtr, value, result) == false, "an exception");
 
-    VersionTagPtr versionTag18(new VersionTag(0xffffaa, 6, 7, host1, 0));
+    auto versionTag18 = std::make_shared<VersionTag>(0xffffaa, 6, 7, host1, 0);
 
     // version rollover, this will not be applied
-    err = entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag18);
+    err = entries->put(keyPtr, ccstr, me, oldValue, -1, 0, versionTag18);
     ASSERT(err == GF_CACHE_CONCURRENT_MODIFICATION_EXCEPTION, "an exception");
     err = entries->isTombstone(keyPtr, result, isTombstone);
     ASSERT(err == GF_NOERR, "an exception");
@@ -1060,8 +1062,8 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepFour_TestRemove)
     ASSERT(result->getVersionStamp().getEntryVersion() == 9, "an exception");
     ASSERT(entries->get(keyPtr, value, result) == false, "an exception");
 
-    CacheableKeyPtr keyPtr2 = CacheableKey::create((char*)"Key2");
-    err = entries->put(keyPtr2, ct, me, oldValue, -1, 0, versionTag18);
+    auto keyPtr2 = CacheableKey::create("Key2");
+    err = entries->put(keyPtr2, ccstr, me, oldValue, -1, 0, versionTag18);
     ASSERT(err == GF_NOERR, "an exception");
     entries->getEntry(keyPtr2, result, value);
     ASSERT(atoi(value->toString()->asChar()) == 100, "an exception");
@@ -1079,7 +1081,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepFour_TestRemove)
 
     // Null version tag, this will be applied
     VersionTagPtr versionTag19;
-    err = entries->put(keyPtr2, ct, me, oldValue, -1, 0, versionTag19);
+    err = entries->put(keyPtr2, ccstr, me, oldValue, -1, 0, versionTag19);
     ASSERT(err == GF_NOERR, "an exception");
     entries->getEntry(keyPtr2, result, value);
     ASSERT(atoi(value->toString()->asChar()) == 100, "an exception");
@@ -1087,8 +1089,8 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepFour_TestRemove)
     ASSERT(result->getVersionStamp().getEntryVersion() == 9, "an exception");
 
     // inserts a null tag
-    CacheableKeyPtr keyPtr3 = CacheableKey::create((char*)"Key3");
-    err = entries->put(keyPtr3, ct1, me, oldValue, -1, 0, versionTag19);
+    auto keyPtr3 = CacheableKey::create("Key3");
+    err = entries->put(keyPtr3, ccstr1, me, oldValue, -1, 0, versionTag19);
     ASSERT(err == GF_NOERR, "an exception");
     entries->getEntry(keyPtr3, result, value);
     ASSERT(atoi(value->toString()->asChar()) == 500, "an exception");
@@ -1107,36 +1109,36 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepFour_TestRemove)
     ASSERT(result->getVersionStamp().getEntryVersion() == 5, "an exception");
     ASSERT(entries->get(keyPtr3, value, result) == false, "an exception");
 
-    CacheableKeyPtr keyPtrR2 = CacheableKey::create((char*)"keyPtrR2");
-    CacheableKeyPtr keyPtrR3 = CacheableKey::create((char*)"keyPtrR3");
-    CacheableKeyPtr keyPtrR4 = CacheableKey::create((char*)"keyPtrR4");
-    CacheableKeyPtr keyPtrR5 = CacheableKey::create((char*)"keyPtrR5");
-    CacheableKeyPtr keyPtrR6 = CacheableKey::create((char*)"keyPtrR6");
+    auto keyPtrR2 = CacheableKey::create("keyPtrR2");
+    auto keyPtrR3 = CacheableKey::create("keyPtrR3");
+    auto keyPtrR4 = CacheableKey::create("keyPtrR4");
+    auto keyPtrR5 = CacheableKey::create("keyPtrR5");
+    auto keyPtrR6 = CacheableKey::create("keyPtrR6");
 
-    CacheableKeyPtr keyPtrR21 = CacheableKey::create((char*)"keyPtrR21");
-    CacheableKeyPtr keyPtrR31 = CacheableKey::create((char*)"keyPtrR31");
-    CacheableKeyPtr keyPtrR41 = CacheableKey::create((char*)"keyPtrR41");
-    CacheableKeyPtr keyPtrR51 = CacheableKey::create((char*)"keyPtrR51");
-    CacheableKeyPtr keyPtrR61 = CacheableKey::create((char*)"keyPtrR61");
+    auto keyPtrR21 = CacheableKey::create("keyPtrR21");
+    auto keyPtrR31 = CacheableKey::create("keyPtrR31");
+    auto keyPtrR41 = CacheableKey::create("keyPtrR41");
+    auto keyPtrR51 = CacheableKey::create("keyPtrR51");
+    auto keyPtrR61 = CacheableKey::create("keyPtrR61");
 
-    VersionTagPtr versionTag23(new VersionTag(9, 10, 10, host13, 0));
-    VersionTagPtr versionTag24(new VersionTag(9, 10, 10, host14, 0));
-    VersionTagPtr versionTag25(new VersionTag(9, 10, 10, host15, 0));
-    VersionTagPtr versionTag26(new VersionTag(9, 10, 10, host16, 0));
+    auto versionTag23 = std::make_shared<VersionTag>(9, 10, 10, host13, 0);
+    auto versionTag24 = std::make_shared<VersionTag>(9, 10, 10, host14, 0);
+    auto versionTag25 = std::make_shared<VersionTag>(9, 10, 10, host15, 0);
+    auto versionTag26 = std::make_shared<VersionTag>(9, 10, 10, host16, 0);
 
     sprintf(log, "Test reaping of tombstones");
     LOG(log);
 
     // add few entries with null version tags
-    err = entries->put(keyPtrR2, ct1, me, oldValue, -1, 0, versionTag19);
-    err = entries->put(keyPtrR3, ct1, me, oldValue, -1, 0, versionTag19);
-    err = entries->put(keyPtrR4, ct1, me, oldValue, -1, 0, versionTag19);
-    err = entries->put(keyPtrR5, ct1, me, oldValue, -1, 0, versionTag19);
-    err = entries->put(keyPtrR21, ct1, me, oldValue, -1, 0, versionTag19);
-    err = entries->put(keyPtrR31, ct1, me, oldValue, -1, 0, versionTag19);
-    err = entries->put(keyPtrR41, ct1, me, oldValue, -1, 0, versionTag19);
-    err = entries->put(keyPtrR51, ct1, me, oldValue, -1, 0, versionTag19);
-    err = entries->put(keyPtrR61, ct1, me, oldValue, -1, 0, versionTag19);
+    err = entries->put(keyPtrR2, ccstr1, me, oldValue, -1, 0, versionTag19);
+    err = entries->put(keyPtrR3, ccstr1, me, oldValue, -1, 0, versionTag19);
+    err = entries->put(keyPtrR4, ccstr1, me, oldValue, -1, 0, versionTag19);
+    err = entries->put(keyPtrR5, ccstr1, me, oldValue, -1, 0, versionTag19);
+    err = entries->put(keyPtrR21, ccstr1, me, oldValue, -1, 0, versionTag19);
+    err = entries->put(keyPtrR31, ccstr1, me, oldValue, -1, 0, versionTag19);
+    err = entries->put(keyPtrR41, ccstr1, me, oldValue, -1, 0, versionTag19);
+    err = entries->put(keyPtrR51, ccstr1, me, oldValue, -1, 0, versionTag19);
+    err = entries->put(keyPtrR61, ccstr1, me, oldValue, -1, 0, versionTag19);
 
     // remove those entries using non null version tags
     err = entries->remove(keyPtrR2, oldValue, me, -1, versionTag12, false);
@@ -1236,8 +1238,8 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepFour_TestRemove)
     sprintf(log, "Remove test complete. %d", err);
     LOG(log);
     // reap using removedKeys API
-    CacheableKeyPtr keyPtrR71 = CacheableKey::create((char*)"keyPtrR71");
-    CacheableHashSetPtr removedKeys = CacheableHashSet::create();
+    auto keyPtrR71 = CacheableKey::create("keyPtrR71");
+    auto removedKeys = CacheableHashSet::create();
     removedKeys->insert(keyPtrR3);
     removedKeys->insert(keyPtrR71);
     removedKeys->insert(keyPtrR2);

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/integration-test/testExpiration.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/testExpiration.cpp b/src/cppcache/integration-test/testExpiration.cpp
index 5aa2f3f..b214744 100644
--- a/src/cppcache/integration-test/testExpiration.cpp
+++ b/src/cppcache/integration-test/testExpiration.cpp
@@ -38,7 +38,7 @@ void startDSandCreateCache(CachePtr& cache) {
   PropertiesPtr pp = Properties::create();
   CacheFactoryPtr cacheFactoryPtr = CacheFactory::createCacheFactory(pp);
   cache = cacheFactoryPtr->create();
-  ASSERT(cache != NULLPTR, "cache not equal to null expected");
+  ASSERT(cache != nullptr, "cache not equal to null expected");
 }
 
 void doNPuts(RegionPtr& rptr, int n) {
@@ -48,7 +48,7 @@ void doNPuts(RegionPtr& rptr, int n) {
   buf[15] = '\0';
   memcpy(buf, "Value - ", 8);
   value = CacheableString::create(buf);
-  ASSERT(value != NULLPTR, "Failed to create value.");
+  ASSERT(value != nullptr, "Failed to create value.");
 
   for (int i = 0; i < n; i++) {
     sprintf(buf, "KeyA - %d", i + 1);
@@ -66,7 +66,7 @@ CacheableKeyPtr do1Put(RegionPtr& rptr) {
   buf[15] = '\0';
   memcpy(buf, "Value - ", 8);
   value = CacheableString::create(buf);
-  ASSERT(value != NULLPTR, "Failed to create value.");
+  ASSERT(value != nullptr, "Failed to create value.");
 
   sprintf(buf, "KeyA - %d", 0 + 1);
   CacheableKeyPtr key = CacheableKey::create(buf);
@@ -94,22 +94,24 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     startDSandCreateCache(cache);
 
-    ASSERT(cache != NULLPTR, "Expected cache to be NON-NULL");
+    ASSERT(cache != nullptr, "Expected cache to be NON-NULL");
+
+    CacheImpl* cacheImpl = CacheRegionHelper::getCacheImpl(cache.get());
+
+    int n;
 
     RegionAttributesPtr attrs_1;
     // ettl = 0, eit = 0, rttl = 0, reit = 0
     setExpTimes(attrs_1);
-
     RegionPtr R1;
-    CacheImpl* cacheImpl = CacheRegionHelper::getCacheImpl(cache.ptr());
     cacheImpl->createRegion("R1", attrs_1, R1);
-    ASSERT(R1 != NULLPTR, "Expected R1 to be NON-NULL");
+    ASSERT(R1 != nullptr, "Expected R1 to be NON-NULL");
 
     doNPuts(R1, 100);
 
     ACE_OS::sleep(10);
 
-    int n = getNumOfEntries(R1);
+    n = getNumOfEntries(R1);
     ASSERT(n == 100, "Expected 100 entries");
 
     ASSERT(R1->isDestroyed() == false, "Expected R1 to be alive");
@@ -120,7 +122,7 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     RegionPtr R2;
     cacheImpl->createRegion("R2", attrs_2, R2);
-    ASSERT(R2 != NULLPTR, "Expected R2 to be NON-NULL");
+    ASSERT(R2 != nullptr, "Expected R2 to be NON-NULL");
     LOG("Region R2 created");
     doNPuts(R2, 1);
 
@@ -137,7 +139,7 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     RegionPtr R3;
     cacheImpl->createRegion("R3", attrs_3, R3);
-    ASSERT(R3 != NULLPTR, "Expected R3 to be NON-NULL");
+    ASSERT(R3 != nullptr, "Expected R3 to be NON-NULL");
 
     ACE_OS::sleep(5);
 
@@ -149,7 +151,7 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     RegionPtr R4;
     cacheImpl->createRegion("R4", attrs_4, R4);
-    ASSERT(R4 != NULLPTR, "Expected R4 to be NON-NULL");
+    ASSERT(R4 != nullptr, "Expected R4 to be NON-NULL");
 
     doNPuts(R4, 1);
     // This will be same as updating the object
@@ -167,7 +169,7 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     RegionPtr R5;
     cacheImpl->createRegion("R5", attrs_5, R5);
-    ASSERT(R5 != NULLPTR, "Expected R5 to be NON-NULL");
+    ASSERT(R5 != nullptr, "Expected R5 to be NON-NULL");
 
     CacheableKeyPtr key_0 = do1Put(R5);
 
@@ -194,7 +196,7 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     RegionPtr R6;
     cacheImpl->createRegion("R6", attrs_6, R6);
-    ASSERT(R6 != NULLPTR, "Expected R6 to be NON-NULL");
+    ASSERT(R6 != nullptr, "Expected R6 to be NON-NULL");
 
     doNPuts(R6, 1);
 
@@ -212,7 +214,7 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     RegionPtr R7;
     cacheImpl->createRegion("R7", attrs_7, R7);
-    ASSERT(R7 != NULLPTR, "Expected R7 to be NON-NULL");
+    ASSERT(R7 != nullptr, "Expected R7 to be NON-NULL");
 
     doNPuts(R7, 1);
 
@@ -230,7 +232,7 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     RegionPtr R8;
     cacheImpl->createRegion("R8", attrs_8, R8);
-    ASSERT(R8 != NULLPTR, "Expected R8 to be NON-NULL");
+    ASSERT(R8 != nullptr, "Expected R8 to be NON-NULL");
 
     CacheableKeyPtr key = do1Put(R8);
 
@@ -249,7 +251,7 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     RegionPtr R9;
     cacheImpl->createRegion("R9", attrs_9, R9);
-    ASSERT(R9 != NULLPTR, "Expected R9 to be NON-NULL");
+    ASSERT(R9 != nullptr, "Expected R9 to be NON-NULL");
 
     CacheableKeyPtr key_1 = do1Put(R9);
 
@@ -270,7 +272,7 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     RegionPtr R10;
     cacheImpl->createRegion("R10", attrs_10, R10);
-    ASSERT(R10 != NULLPTR, "Expected R10 to be NON-NULL");
+    ASSERT(R10 != nullptr, "Expected R10 to be NON-NULL");
 
     doNPuts(R10, 1);
 
@@ -290,7 +292,7 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     RegionPtr R11;
     cacheImpl->createRegion("R11", attrs_11, R11);
-    ASSERT(R11 != NULLPTR, "Expected R11 to be NON-NULL");
+    ASSERT(R11 != nullptr, "Expected R11 to be NON-NULL");
 
     CacheableKeyPtr k11 = do1Put(R11);
 
@@ -316,7 +318,7 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     RegionPtr R12;
     cacheImpl->createRegion("R12", attrs_12, R12);
-    ASSERT(R12 != NULLPTR, "Expected R12 to be NON-NULL");
+    ASSERT(R12 != nullptr, "Expected R12 to be NON-NULL");
 
     CacheableKeyPtr key_3 = do1Put(R12);
 
@@ -334,7 +336,7 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     RegionPtr R14;
     cacheImpl->createRegion("R14", attrs_14, R14);
-    ASSERT(R14 != NULLPTR, "Expected R14 to be NON-NULL");
+    ASSERT(R14 != nullptr, "Expected R14 to be NON-NULL");
 
     doNPuts(R14, 1);
 
@@ -348,7 +350,7 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     RegionPtr R15;
     cacheImpl->createRegion("R15", attrs_15, R15);
-    ASSERT(R15 != NULLPTR, "Expected R15 to be NON-NULL");
+    ASSERT(R15 != nullptr, "Expected R15 to be NON-NULL");
 
     CacheableKeyPtr key_4 = do1Put(R15);
 
@@ -367,7 +369,7 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     RegionPtr R18;
     cacheImpl->createRegion("R18", attrs_18, R18);
-    ASSERT(R18 != NULLPTR, "Expected R18 to be NON-NULL");
+    ASSERT(R18 != nullptr, "Expected R18 to be NON-NULL");
 
     doNPuts(R18, 1);
 
@@ -386,7 +388,7 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     RegionPtr R19;
     cacheImpl->createRegion("R19x", attrs_19, R19);
-    ASSERT(R19 != NULLPTR, "Expected R19 to be NON-NULL");
+    ASSERT(R19 != nullptr, "Expected R19 to be NON-NULL");
 
     ACE_OS::sleep(4);
 


Mime
View raw message