http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/integration-test/testExpiration.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/testExpiration.cpp 
b/src/cppcache/integration-test/testExpiration.cpp
index 342b8bb..7fc5c00 100644
--- a/src/cppcache/integration-test/testExpiration.cpp
+++ b/src/cppcache/integration-test/testExpiration.cpp
@@ -19,7 +19,8 @@
 
 #include "fw_helper.hpp"
 #include <geode/GeodeCppCache.hpp>
-#include <CacheRegionHelper.hpp>
+#include "CacheRegionHelper.hpp"
+#include "CacheImpl.hpp"
 
 using namespace apache::geode::client;
 

http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/integration-test/testOverflowPutGetSqLite.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/testOverflowPutGetSqLite.cpp 
b/src/cppcache/integration-test/testOverflowPutGetSqLite.cpp
index ffac596..7467539 100644
--- a/src/cppcache/integration-test/testOverflowPutGetSqLite.cpp
+++ b/src/cppcache/integration-test/testOverflowPutGetSqLite.cpp
@@ -512,7 +512,7 @@ END_TEST(OverFlowTest_SqLiteFull)
 // BEGIN_TEST(OverFlowTest_LargeData)
 //{
 //  /** Connecting to a distributed system. */
-//  DistributedSystemPtr dsysPtr;
+//  DistributedSystem& dsysPtr;
 //
 //  /** Creating a cache to manage regions. */
 //  CachePtr cachePtr ;

http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/integration-test/testRegionTemplateArgs.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/testRegionTemplateArgs.cpp 
b/src/cppcache/integration-test/testRegionTemplateArgs.cpp
index 457825c..1418bea 100644
--- a/src/cppcache/integration-test/testRegionTemplateArgs.cpp
+++ b/src/cppcache/integration-test/testRegionTemplateArgs.cpp
@@ -18,7 +18,8 @@
 #define ROOT_NAME "testRegionTemplateArgs"
 
 #include <geode/GeodeCppCache.hpp>
-#include <CacheRegionHelper.hpp>
+#include "CacheRegionHelper.hpp"
+#include "CacheImpl.hpp"
 #include "fw_helper.hpp"
 
 using namespace apache::geode::client;
@@ -77,10 +78,12 @@ BEGIN_TEST(CheckTemplates)
     resValPtr = std::dynamic_pointer_cast<CacheableBytes>(regPtr->get(keyPtr));
     ASSERT(CheckBytesEqual(resValPtr, valPtr),
            "put/get:: incorrect valPtr value");
-    resValPtr = 
std::dynamic_pointer_cast<CacheableBytes>(regPtr->get(stringPtr));
+    resValPtr =
+        std::dynamic_pointer_cast<CacheableBytes>(regPtr->get(stringPtr));
     ASSERT(CheckBytesEqual(resValPtr, valPtr),
            "put/get:: incorrect valPtr value");
-    resValPtr = 
std::dynamic_pointer_cast<CacheableBytes>(regPtr->get(int32Ptr));
+    resValPtr =
+        std::dynamic_pointer_cast<CacheableBytes>(regPtr->get(int32Ptr));
     ASSERT(CheckBytesEqual(resValPtr, valPtr),
            "put/get:: incorrect valPtr value");
     resValPtr = std::dynamic_pointer_cast<CacheableBytes>(regPtr->get(intKey));
@@ -103,10 +106,12 @@ BEGIN_TEST(CheckTemplates)
     resValPtr = std::dynamic_pointer_cast<CacheableBytes>(regPtr->get(keyPtr));
     ASSERT(CheckBytesEqual(resValPtr, bytesPtr),
            "put/get:: incorrect bytesPtr value");
-    resValPtr = 
std::dynamic_pointer_cast<CacheableBytes>(regPtr->get(stringPtr));
+    resValPtr =
+        std::dynamic_pointer_cast<CacheableBytes>(regPtr->get(stringPtr));
     ASSERT(CheckBytesEqual(resValPtr, bytesPtr),
            "put/get:: incorrect bytesPtr value");
-    resValPtr = 
std::dynamic_pointer_cast<CacheableBytes>(regPtr->get(int32Ptr));
+    resValPtr =
+        std::dynamic_pointer_cast<CacheableBytes>(regPtr->get(int32Ptr));
     ASSERT(CheckBytesEqual(resValPtr, bytesPtr),
            "put/get:: incorrect bytesPtr value");
     resValPtr = std::dynamic_pointer_cast<CacheableBytes>(regPtr->get(intKey));
@@ -126,19 +131,24 @@ BEGIN_TEST(CheckTemplates)
     regPtr->put(charKey, stringPtr);
     regPtr->put(intKey, stringPtr);
 
-    resStringPtr = 
std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
+    resStringPtr =
+        std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
     ASSERT(resStringPtr.get() == stringPtr.get(),
            "put/get:: incorrect stringPtr value");
-    resStringPtr = 
std::dynamic_pointer_cast<CacheableString>(regPtr->get(stringPtr));
+    resStringPtr =
+        std::dynamic_pointer_cast<CacheableString>(regPtr->get(stringPtr));
     ASSERT(resStringPtr.get() == stringPtr.get(),
            "put/get:: incorrect stringPtr value");
-    resStringPtr = 
std::dynamic_pointer_cast<CacheableString>(regPtr->get(int32Ptr));
+    resStringPtr =
+        std::dynamic_pointer_cast<CacheableString>(regPtr->get(int32Ptr));
     ASSERT(resStringPtr.get() == stringPtr.get(),
            "put/get:: incorrect stringPtr value");
-    resStringPtr = 
std::dynamic_pointer_cast<CacheableString>(regPtr->get(intKey));
+    resStringPtr =
+        std::dynamic_pointer_cast<CacheableString>(regPtr->get(intKey));
     ASSERT(resStringPtr.get() == stringPtr.get(),
            "put/get:: incorrect stringPtr value");
-    resStringPtr = 
std::dynamic_pointer_cast<CacheableString>(regPtr->get(charKey));
+    resStringPtr =
+        std::dynamic_pointer_cast<CacheableString>(regPtr->get(charKey));
     ASSERT(resStringPtr.get() == stringPtr.get(),
            "put/get:: incorrect stringPtr value");
 
@@ -152,19 +162,24 @@ BEGIN_TEST(CheckTemplates)
     regPtr->put(charKey, int32Ptr);
     regPtr->put(intKey, int32Ptr);
 
-    resInt32Ptr = 
std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(keyPtr));
+    resInt32Ptr =
+        std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(keyPtr));
     ASSERT(resInt32Ptr.get() == int32Ptr.get(),
            "put/get:: incorrect int32Ptr value");
-    resInt32Ptr = 
std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(stringPtr));
+    resInt32Ptr =
+        std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(stringPtr));
     ASSERT(resInt32Ptr.get() == int32Ptr.get(),
            "put/get:: incorrect int32Ptr value");
-    resInt32Ptr = 
std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(int32Ptr));
+    resInt32Ptr =
+        std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(int32Ptr));
     ASSERT(resInt32Ptr.get() == int32Ptr.get(),
            "put/get:: incorrect int32Ptr value");
-    resInt32Ptr = 
std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(intKey));
+    resInt32Ptr =
+        std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(intKey));
     ASSERT(resInt32Ptr.get() == int32Ptr.get(),
            "put/get:: incorrect int32Ptr value");
-    resInt32Ptr = 
std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(charKey));
+    resInt32Ptr =
+        std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(charKey));
     ASSERT(resInt32Ptr.get() == int32Ptr.get(),
            "put/get:: incorrect int32Ptr value");
 
@@ -178,19 +193,24 @@ BEGIN_TEST(CheckTemplates)
     regPtr->put(charKey, charVal);
     regPtr->put(intKey, charVal);
 
-    resStringPtr = 
std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
+    resStringPtr =
+        std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
     ASSERT(strcmp(resStringPtr->asChar(), charVal) == 0,
            "put/get:: incorrect charVal value");
-    resStringPtr = 
std::dynamic_pointer_cast<CacheableString>(regPtr->get(stringPtr));
+    resStringPtr =
+        std::dynamic_pointer_cast<CacheableString>(regPtr->get(stringPtr));
     ASSERT(strcmp(resStringPtr->asChar(), charVal) == 0,
            "put/get:: incorrect charVal value");
-    resStringPtr = 
std::dynamic_pointer_cast<CacheableString>(regPtr->get(int32Ptr));
+    resStringPtr =
+        std::dynamic_pointer_cast<CacheableString>(regPtr->get(int32Ptr));
     ASSERT(strcmp(resStringPtr->asChar(), charVal) == 0,
            "put/get:: incorrect charVal value");
-    resStringPtr = 
std::dynamic_pointer_cast<CacheableString>(regPtr->get(intKey));
+    resStringPtr =
+        std::dynamic_pointer_cast<CacheableString>(regPtr->get(intKey));
     ASSERT(strcmp(resStringPtr->asChar(), charVal) == 0,
            "put/get:: incorrect charVal value");
-    resStringPtr = 
std::dynamic_pointer_cast<CacheableString>(regPtr->get(charKey));
+    resStringPtr =
+        std::dynamic_pointer_cast<CacheableString>(regPtr->get(charKey));
     ASSERT(strcmp(resStringPtr->asChar(), charVal) == 0,
            "put/get:: incorrect charVal value");
 
@@ -204,15 +224,20 @@ BEGIN_TEST(CheckTemplates)
     regPtr->put(charKey, intVal);
     regPtr->put(intKey, intVal);
 
-    resInt32Ptr = 
std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(keyPtr));
+    resInt32Ptr =
+        std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(keyPtr));
     ASSERT(resInt32Ptr->value() == intVal, "put/get:: incorrect intVal value");
-    resInt32Ptr = 
std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(stringPtr));
+    resInt32Ptr =
+        std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(stringPtr));
     ASSERT(resInt32Ptr->value() == intVal, "put/get:: incorrect intVal value");
-    resInt32Ptr = 
std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(int32Ptr));
+    resInt32Ptr =
+        std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(int32Ptr));
     ASSERT(resInt32Ptr->value() == intVal, "put/get:: incorrect intVal value");
-    resInt32Ptr = 
std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(intKey));
+    resInt32Ptr =
+        std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(intKey));
     ASSERT(resInt32Ptr->value() == intVal, "put/get:: incorrect intVal value");
-    resInt32Ptr = 
std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(charKey));
+    resInt32Ptr =
+        std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(charKey));
     ASSERT(resInt32Ptr->value() == intVal, "put/get:: incorrect intVal value");
 
     // End with intVal
@@ -239,10 +264,12 @@ BEGIN_TEST(CheckTemplates)
     resValPtr = std::dynamic_pointer_cast<CacheableBytes>(regPtr->get(keyPtr));
     ASSERT(CheckBytesEqual(resValPtr, valPtr),
            "create/get/localDestroy:: incorrect valPtr value");
-    resValPtr = 
std::dynamic_pointer_cast<CacheableBytes>(regPtr->get(stringPtr));
+    resValPtr =
+        std::dynamic_pointer_cast<CacheableBytes>(regPtr->get(stringPtr));
     ASSERT(CheckBytesEqual(resValPtr, valPtr),
            "create/get/localDestroy:: incorrect valPtr value");
-    resValPtr = 
std::dynamic_pointer_cast<CacheableBytes>(regPtr->get(int32Ptr));
+    resValPtr =
+        std::dynamic_pointer_cast<CacheableBytes>(regPtr->get(int32Ptr));
     ASSERT(CheckBytesEqual(resValPtr, valPtr),
            "create/get/localDestroy:: incorrect valPtr value");
     resValPtr = std::dynamic_pointer_cast<CacheableBytes>(regPtr->get(intKey));
@@ -306,10 +333,12 @@ BEGIN_TEST(CheckTemplates)
     resValPtr = std::dynamic_pointer_cast<CacheableBytes>(regPtr->get(keyPtr));
     ASSERT(CheckBytesEqual(resValPtr, bytesPtr),
            "create/get/localDestroy:: incorrect bytesPtr value");
-    resValPtr = 
std::dynamic_pointer_cast<CacheableBytes>(regPtr->get(stringPtr));
+    resValPtr =
+        std::dynamic_pointer_cast<CacheableBytes>(regPtr->get(stringPtr));
     ASSERT(CheckBytesEqual(resValPtr, bytesPtr),
            "create/get/localDestroy:: incorrect bytesPtr value");
-    resValPtr = 
std::dynamic_pointer_cast<CacheableBytes>(regPtr->get(int32Ptr));
+    resValPtr =
+        std::dynamic_pointer_cast<CacheableBytes>(regPtr->get(int32Ptr));
     ASSERT(CheckBytesEqual(resValPtr, bytesPtr),
            "create/get/localDestroy:: incorrect bytesPtr value");
     resValPtr = std::dynamic_pointer_cast<CacheableBytes>(regPtr->get(intKey));
@@ -370,19 +399,24 @@ BEGIN_TEST(CheckTemplates)
     regPtr->create(charKey, stringPtr);
     regPtr->create(intKey, stringPtr);
 
-    resStringPtr = 
std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
+    resStringPtr =
+        std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
     ASSERT(resStringPtr.get() == stringPtr.get(),
            "create/get/localDestroy:: incorrect stringPtr value");
-    resStringPtr = 
std::dynamic_pointer_cast<CacheableString>(regPtr->get(stringPtr));
+    resStringPtr =
+        std::dynamic_pointer_cast<CacheableString>(regPtr->get(stringPtr));
     ASSERT(resStringPtr.get() == stringPtr.get(),
            "create/get/localDestroy:: incorrect stringPtr value");
-    resStringPtr = 
std::dynamic_pointer_cast<CacheableString>(regPtr->get(int32Ptr));
+    resStringPtr =
+        std::dynamic_pointer_cast<CacheableString>(regPtr->get(int32Ptr));
     ASSERT(resStringPtr.get() == stringPtr.get(),
            "create/get/localDestroy:: incorrect stringPtr value");
-    resStringPtr = 
std::dynamic_pointer_cast<CacheableString>(regPtr->get(intKey));
+    resStringPtr =
+        std::dynamic_pointer_cast<CacheableString>(regPtr->get(intKey));
     ASSERT(resStringPtr.get() == stringPtr.get(),
            "create/get/localDestroy:: incorrect stringPtr value");
-    resStringPtr = 
std::dynamic_pointer_cast<CacheableString>(regPtr->get(charKey));
+    resStringPtr =
+        std::dynamic_pointer_cast<CacheableString>(regPtr->get(charKey));
     ASSERT(resStringPtr.get() == stringPtr.get(),
            "create/get/localDestroy:: incorrect stringPtr value");
 
@@ -437,19 +471,24 @@ BEGIN_TEST(CheckTemplates)
     regPtr->create(charKey, int32Ptr);
     regPtr->create(intKey, int32Ptr);
 
-    resInt32Ptr = 
std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(keyPtr));
+    resInt32Ptr =
+        std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(keyPtr));
     ASSERT(resInt32Ptr.get() == int32Ptr.get(),
            "create/get/localDestroy:: incorrect int32Ptr value");
-    resInt32Ptr = 
std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(stringPtr));
+    resInt32Ptr =
+        std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(stringPtr));
     ASSERT(resInt32Ptr.get() == int32Ptr.get(),
            "create/get/localDestroy:: incorrect int32Ptr value");
-    resInt32Ptr = 
std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(int32Ptr));
+    resInt32Ptr =
+        std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(int32Ptr));
     ASSERT(resInt32Ptr.get() == int32Ptr.get(),
            "create/get/localDestroy:: incorrect int32Ptr value");
-    resInt32Ptr = 
std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(intKey));
+    resInt32Ptr =
+        std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(intKey));
     ASSERT(resInt32Ptr.get() == int32Ptr.get(),
            "create/get/localDestroy:: incorrect int32Ptr value");
-    resInt32Ptr = 
std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(charKey));
+    resInt32Ptr =
+        std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(charKey));
     ASSERT(resInt32Ptr.get() == int32Ptr.get(),
            "create/get/localDestroy:: incorrect int32Ptr value");
 
@@ -504,19 +543,24 @@ BEGIN_TEST(CheckTemplates)
     regPtr->create(charKey, charVal);
     regPtr->create(intKey, charVal);
 
-    resStringPtr = 
std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
+    resStringPtr =
+        std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
     ASSERT(strcmp(resStringPtr->asChar(), charVal) == 0,
            "create/get/localDestroy:: incorrect charVal value");
-    resStringPtr = 
std::dynamic_pointer_cast<CacheableString>(regPtr->get(stringPtr));
+    resStringPtr =
+        std::dynamic_pointer_cast<CacheableString>(regPtr->get(stringPtr));
     ASSERT(strcmp(resStringPtr->asChar(), charVal) == 0,
            "create/get/localDestroy:: incorrect charVal value");
-    resStringPtr = 
std::dynamic_pointer_cast<CacheableString>(regPtr->get(int32Ptr));
+    resStringPtr =
+        std::dynamic_pointer_cast<CacheableString>(regPtr->get(int32Ptr));
     ASSERT(strcmp(resStringPtr->asChar(), charVal) == 0,
            "create/get/localDestroy:: incorrect charVal value");
-    resStringPtr = 
std::dynamic_pointer_cast<CacheableString>(regPtr->get(intKey));
+    resStringPtr =
+        std::dynamic_pointer_cast<CacheableString>(regPtr->get(intKey));
     ASSERT(strcmp(resStringPtr->asChar(), charVal) == 0,
            "create/get/localDestroy:: incorrect charVal value");
-    resStringPtr = 
std::dynamic_pointer_cast<CacheableString>(regPtr->get(charKey));
+    resStringPtr =
+        std::dynamic_pointer_cast<CacheableString>(regPtr->get(charKey));
     ASSERT(strcmp(resStringPtr->asChar(), charVal) == 0,
            "create/get/localDestroy:: incorrect charVal value");
 
@@ -571,19 +615,24 @@ BEGIN_TEST(CheckTemplates)
     regPtr->create(charKey, intVal);
     regPtr->create(intKey, intVal);
 
-    resInt32Ptr = 
std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(keyPtr));
+    resInt32Ptr =
+        std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(keyPtr));
     ASSERT(resInt32Ptr->value() == intVal,
            "create/get/localDestroy:: incorrect intVal value");
-    resInt32Ptr = 
std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(stringPtr));
+    resInt32Ptr =
+        std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(stringPtr));
     ASSERT(resInt32Ptr->value() == intVal,
            "create/get/localDestroy:: incorrect intVal value");
-    resInt32Ptr = 
std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(int32Ptr));
+    resInt32Ptr =
+        std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(int32Ptr));
     ASSERT(resInt32Ptr->value() == intVal,
            "create/get/localDestroy:: incorrect intVal value");
-    resInt32Ptr = 
std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(intKey));
+    resInt32Ptr =
+        std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(intKey));
     ASSERT(resInt32Ptr->value() == intVal,
            "create/get/localDestroy:: incorrect intVal value");
-    resInt32Ptr = 
std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(charKey));
+    resInt32Ptr =
+        std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(charKey));
     ASSERT(resInt32Ptr->value() == intVal,
            "create/get/localDestroy:: incorrect intVal value");
 
@@ -644,23 +693,28 @@ BEGIN_TEST(CheckTemplates)
     regPtr->create(intKey, valPtr);
 
     resEntryPtr = regPtr->getEntry(keyPtr);
-    resValPtr = 
std::dynamic_pointer_cast<CacheableBytes>(resEntryPtr->getValue());
+    resValPtr =
+        std::dynamic_pointer_cast<CacheableBytes>(resEntryPtr->getValue());
     ASSERT(CheckBytesEqual(resValPtr, valPtr),
            "create/getEntry/destroy:: incorrect valPtr value");
     resEntryPtr = regPtr->getEntry(stringPtr);
-    resValPtr = 
std::dynamic_pointer_cast<CacheableBytes>(resEntryPtr->getValue());
+    resValPtr =
+        std::dynamic_pointer_cast<CacheableBytes>(resEntryPtr->getValue());
     ASSERT(CheckBytesEqual(resValPtr, valPtr),
            "create/getEntry/destroy:: incorrect valPtr value");
     resEntryPtr = regPtr->getEntry(int32Ptr);
-    resValPtr = 
std::dynamic_pointer_cast<CacheableBytes>(resEntryPtr->getValue());
+    resValPtr =
+        std::dynamic_pointer_cast<CacheableBytes>(resEntryPtr->getValue());
     ASSERT(CheckBytesEqual(resValPtr, valPtr),
            "create/getEntry/destroy:: incorrect valPtr value");
     resEntryPtr = regPtr->getEntry(charKey);
-    resValPtr = 
std::dynamic_pointer_cast<CacheableBytes>(resEntryPtr->getValue());
+    resValPtr =
+        std::dynamic_pointer_cast<CacheableBytes>(resEntryPtr->getValue());
     ASSERT(CheckBytesEqual(resValPtr, valPtr),
            "create/getEntry/destroy:: incorrect valPtr value");
     resEntryPtr = regPtr->getEntry(intKey);
-    resValPtr = 
std::dynamic_pointer_cast<CacheableBytes>(resEntryPtr->getValue());
+    resValPtr =
+        std::dynamic_pointer_cast<CacheableBytes>(resEntryPtr->getValue());
     ASSERT(CheckBytesEqual(resValPtr, valPtr),
            "create/getEntry/destroy:: incorrect valPtr value");
 
@@ -716,23 +770,28 @@ BEGIN_TEST(CheckTemplates)
     regPtr->create(intKey, bytesPtr);
 
     resEntryPtr = regPtr->getEntry(keyPtr);
-    resValPtr = 
std::dynamic_pointer_cast<CacheableBytes>(resEntryPtr->getValue());
+    resValPtr =
+        std::dynamic_pointer_cast<CacheableBytes>(resEntryPtr->getValue());
     ASSERT(CheckBytesEqual(resValPtr, bytesPtr),
            "create/getEntry/destroy:: incorrect bytesPtr value");
     resEntryPtr = regPtr->getEntry(stringPtr);
-    resValPtr = 
std::dynamic_pointer_cast<CacheableBytes>(resEntryPtr->getValue());
+    resValPtr =
+        std::dynamic_pointer_cast<CacheableBytes>(resEntryPtr->getValue());
     ASSERT(CheckBytesEqual(resValPtr, bytesPtr),
            "create/getEntry/destroy:: incorrect bytesPtr value");
     resEntryPtr = regPtr->getEntry(int32Ptr);
-    resValPtr = 
std::dynamic_pointer_cast<CacheableBytes>(resEntryPtr->getValue());
+    resValPtr =
+        std::dynamic_pointer_cast<CacheableBytes>(resEntryPtr->getValue());
     ASSERT(CheckBytesEqual(resValPtr, bytesPtr),
            "create/getEntry/destroy:: incorrect bytesPtr value");
     resEntryPtr = regPtr->getEntry(charKey);
-    resValPtr = 
std::dynamic_pointer_cast<CacheableBytes>(resEntryPtr->getValue());
+    resValPtr =
+        std::dynamic_pointer_cast<CacheableBytes>(resEntryPtr->getValue());
     ASSERT(CheckBytesEqual(resValPtr, bytesPtr),
            "create/getEntry/destroy:: incorrect bytesPtr value");
     resEntryPtr = regPtr->getEntry(intKey);
-    resValPtr = 
std::dynamic_pointer_cast<CacheableBytes>(resEntryPtr->getValue());
+    resValPtr =
+        std::dynamic_pointer_cast<CacheableBytes>(resEntryPtr->getValue());
     ASSERT(CheckBytesEqual(resValPtr, bytesPtr),
            "create/getEntry/destroy:: incorrect bytesPtr value");
 
@@ -788,23 +847,28 @@ BEGIN_TEST(CheckTemplates)
     regPtr->create(intKey, stringPtr);
 
     resEntryPtr = regPtr->getEntry(keyPtr);
-    resStringPtr = 
std::dynamic_pointer_cast<CacheableString>(resEntryPtr->getValue());
+    resStringPtr =
+        std::dynamic_pointer_cast<CacheableString>(resEntryPtr->getValue());
     ASSERT(resStringPtr.get() == stringPtr.get(),
            "create/getEntry/destroy:: incorrect stringPtr value");
     resEntryPtr = regPtr->getEntry(stringPtr);
-    resStringPtr = 
std::dynamic_pointer_cast<CacheableString>(resEntryPtr->getValue());
+    resStringPtr =
+        std::dynamic_pointer_cast<CacheableString>(resEntryPtr->getValue());
     ASSERT(resStringPtr.get() == stringPtr.get(),
            "create/getEntry/destroy:: incorrect stringPtr value");
     resEntryPtr = regPtr->getEntry(int32Ptr);
-    resStringPtr = 
std::dynamic_pointer_cast<CacheableString>(resEntryPtr->getValue());
+    resStringPtr =
+        std::dynamic_pointer_cast<CacheableString>(resEntryPtr->getValue());
     ASSERT(resStringPtr.get() == stringPtr.get(),
            "create/getEntry/destroy:: incorrect stringPtr value");
     resEntryPtr = regPtr->getEntry(intKey);
-    resStringPtr = 
std::dynamic_pointer_cast<CacheableString>(resEntryPtr->getValue());
+    resStringPtr =
+        std::dynamic_pointer_cast<CacheableString>(resEntryPtr->getValue());
     ASSERT(resStringPtr.get() == stringPtr.get(),
            "create/getEntry/destroy:: incorrect stringPtr value");
     resEntryPtr = regPtr->getEntry(charKey);
-    resStringPtr = 
std::dynamic_pointer_cast<CacheableString>(resEntryPtr->getValue());
+    resStringPtr =
+        std::dynamic_pointer_cast<CacheableString>(resEntryPtr->getValue());
     ASSERT(resStringPtr.get() == stringPtr.get(),
            "create/getEntry/destroy:: incorrect stringPtr value");
 
@@ -860,23 +924,28 @@ BEGIN_TEST(CheckTemplates)
     regPtr->create(intKey, int32Ptr);
 
     resEntryPtr = regPtr->getEntry(keyPtr);
-    resInt32Ptr = 
std::dynamic_pointer_cast<CacheableInt32>(resEntryPtr->getValue());
+    resInt32Ptr =
+        std::dynamic_pointer_cast<CacheableInt32>(resEntryPtr->getValue());
     ASSERT(resInt32Ptr.get() == int32Ptr.get(),
            "create/getEntry/destroy:: incorrect int32Ptr value");
     resEntryPtr = regPtr->getEntry(stringPtr);
-    resInt32Ptr = 
std::dynamic_pointer_cast<CacheableInt32>(resEntryPtr->getValue());
+    resInt32Ptr =
+        std::dynamic_pointer_cast<CacheableInt32>(resEntryPtr->getValue());
     ASSERT(resInt32Ptr.get() == int32Ptr.get(),
            "create/getEntry/destroy:: incorrect int32Ptr value");
     resEntryPtr = regPtr->getEntry(int32Ptr);
-    resInt32Ptr = 
std::dynamic_pointer_cast<CacheableInt32>(resEntryPtr->getValue());
+    resInt32Ptr =
+        std::dynamic_pointer_cast<CacheableInt32>(resEntryPtr->getValue());
     ASSERT(resInt32Ptr.get() == int32Ptr.get(),
            "create/getEntry/destroy:: incorrect int32Ptr value");
     resEntryPtr = regPtr->getEntry(intKey);
-    resInt32Ptr = 
std::dynamic_pointer_cast<CacheableInt32>(resEntryPtr->getValue());
+    resInt32Ptr =
+        std::dynamic_pointer_cast<CacheableInt32>(resEntryPtr->getValue());
     ASSERT(resInt32Ptr.get() == int32Ptr.get(),
            "create/getEntry/destroy:: incorrect int32Ptr value");
     resEntryPtr = regPtr->getEntry(charKey);
-    resInt32Ptr = 
std::dynamic_pointer_cast<CacheableInt32>(resEntryPtr->getValue());
+    resInt32Ptr =
+        std::dynamic_pointer_cast<CacheableInt32>(resEntryPtr->getValue());
     ASSERT(resInt32Ptr.get() == int32Ptr.get(),
            "create/getEntry/destroy:: incorrect int32Ptr value");
 
@@ -932,23 +1001,28 @@ BEGIN_TEST(CheckTemplates)
     regPtr->create(intKey, charVal);
 
     resEntryPtr = regPtr->getEntry(keyPtr);
-    resStringPtr = 
std::dynamic_pointer_cast<CacheableString>(resEntryPtr->getValue());
+    resStringPtr =
+        std::dynamic_pointer_cast<CacheableString>(resEntryPtr->getValue());
     ASSERT(strcmp(resStringPtr->asChar(), charVal) == 0,
            "create/getEntry/destroy:: incorrect charVal value");
     resEntryPtr = regPtr->getEntry(stringPtr);
-    resStringPtr = 
std::dynamic_pointer_cast<CacheableString>(resEntryPtr->getValue());
+    resStringPtr =
+        std::dynamic_pointer_cast<CacheableString>(resEntryPtr->getValue());
     ASSERT(strcmp(resStringPtr->asChar(), charVal) == 0,
            "create/getEntry/destroy:: incorrect charVal value");
     resEntryPtr = regPtr->getEntry(int32Ptr);
-    resStringPtr = 
std::dynamic_pointer_cast<CacheableString>(resEntryPtr->getValue());
+    resStringPtr =
+        std::dynamic_pointer_cast<CacheableString>(resEntryPtr->getValue());
     ASSERT(strcmp(resStringPtr->asChar(), charVal) == 0,
            "create/getEntry/destroy:: incorrect charVal value");
     resEntryPtr = regPtr->getEntry(intKey);
-    resStringPtr = 
std::dynamic_pointer_cast<CacheableString>(resEntryPtr->getValue());
+    resStringPtr =
+        std::dynamic_pointer_cast<CacheableString>(resEntryPtr->getValue());
     ASSERT(strcmp(resStringPtr->asChar(), charVal) == 0,
            "create/getEntry/destroy:: incorrect charVal value");
     resEntryPtr = regPtr->getEntry(charKey);
-    resStringPtr = 
std::dynamic_pointer_cast<CacheableString>(resEntryPtr->getValue());
+    resStringPtr =
+        std::dynamic_pointer_cast<CacheableString>(resEntryPtr->getValue());
     ASSERT(strcmp(resStringPtr->asChar(), charVal) == 0,
            "create/getEntry/destroy:: incorrect charVal value");
 
@@ -1004,23 +1078,28 @@ BEGIN_TEST(CheckTemplates)
     regPtr->create(intKey, intVal);
 
     resEntryPtr = regPtr->getEntry(keyPtr);
-    resInt32Ptr = 
std::dynamic_pointer_cast<CacheableInt32>(resEntryPtr->getValue());
+    resInt32Ptr =
+        std::dynamic_pointer_cast<CacheableInt32>(resEntryPtr->getValue());
     ASSERT(resInt32Ptr->value() == intVal,
            "create/getEntry/destroy:: incorrect intVal value");
     resEntryPtr = regPtr->getEntry(stringPtr);
-    resInt32Ptr = 
std::dynamic_pointer_cast<CacheableInt32>(resEntryPtr->getValue());
+    resInt32Ptr =
+        std::dynamic_pointer_cast<CacheableInt32>(resEntryPtr->getValue());
     ASSERT(resInt32Ptr->value() == intVal,
            "create/getEntry/destroy:: incorrect intVal value");
     resEntryPtr = regPtr->getEntry(int32Ptr);
-    resInt32Ptr = 
std::dynamic_pointer_cast<CacheableInt32>(resEntryPtr->getValue());
+    resInt32Ptr =
+        std::dynamic_pointer_cast<CacheableInt32>(resEntryPtr->getValue());
     ASSERT(resInt32Ptr->value() == intVal,
            "create/getEntry/destroy:: incorrect intVal value");
     resEntryPtr = regPtr->getEntry(intKey);
-    resInt32Ptr = 
std::dynamic_pointer_cast<CacheableInt32>(resEntryPtr->getValue());
+    resInt32Ptr =
+        std::dynamic_pointer_cast<CacheableInt32>(resEntryPtr->getValue());
     ASSERT(resInt32Ptr->value() == intVal,
            "create/getEntry/destroy:: incorrect intVal value");
     resEntryPtr = regPtr->getEntry(charKey);
-    resInt32Ptr = 
std::dynamic_pointer_cast<CacheableInt32>(resEntryPtr->getValue());
+    resInt32Ptr =
+        std::dynamic_pointer_cast<CacheableInt32>(resEntryPtr->getValue());
     ASSERT(resInt32Ptr->value() == intVal,
            "create/getEntry/destroy:: incorrect intVal value");
 

http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/integration-test/testSerialization.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/testSerialization.cpp 
b/src/cppcache/integration-test/testSerialization.cpp
index 52ae925..8f9bf79 100644
--- a/src/cppcache/integration-test/testSerialization.cpp
+++ b/src/cppcache/integration-test/testSerialization.cpp
@@ -45,15 +45,13 @@ int32_t g_classIdToReturn4 = 0x123456;
 template <class T>
 std::shared_ptr<T> duplicate(const std::shared_ptr<T>& orig) {
   std::shared_ptr<T> result;
-  DataOutput dout;
-  SerializationRegistry::serialize(orig, dout);
-  // dout.writeObject(orig);
+  auto dout = getHelper()->getCache()->createDataOutput();
+  dout->writeObject(orig);
 
   uint32_t length = 0;
-  const uint8_t* buffer = dout.getBuffer(&length);
-  DataInput din(buffer, length);
-  result = 
std::static_pointer_cast<T>(SerializationRegistry::deserialize(din));
-  // din.readObject(result);
+  const uint8_t* buffer = dout->getBuffer(&length);
+  auto din = getHelper()->getCache()->createDataInput(buffer, length);
+  din->readObject(result);
 
   return result;
 }
@@ -150,81 +148,6 @@ class OtherType : public Serializable {
 #define Sender s1p1
 #define Receiver s1p2
 
-DUNIT_TASK(NoDist, SerializeInMemory)
-  {
-    CppCacheLibrary::initLib();
-
-    CacheableStringPtr str = CacheableString::create("hello");
-    ASSERT(str->length() == 5, "expected length 5.");
-
-    CacheableStringPtr copy = duplicate(str);
-
-    ASSERT(*str == *copy, "expected copy to be hello.");
-    ASSERT(str != copy, "expected copy to be different object.");
-
-    str = CacheableString::create("");
-    copy = duplicate(str);
-    ASSERT(copy != nullptr, "error null copy.");
-    ASSERT(copy->length() == 0, "expected 0 length.");
-
-    CacheableInt32Ptr intkey = CacheableInt32::create(1);
-    CacheableInt32Ptr intcopy = duplicate(intkey);
-    ASSERT(intcopy->value() == 1, "expected value 1.");
-
-    CacheableInt64Ptr longkey = CacheableInt64::create(0x1122334455667788LL);
-    CacheableInt64Ptr longcopy = duplicate(longkey);
-    ASSERT(longcopy->value() == 0x1122334455667788LL,
-           "expected value 0x1122334455667788.");
-
-    struct blob {
-      int m_a;
-      bool m_b;
-      char m_name[100];
-    };
-    struct blob borig;
-    borig.m_a = 1;
-    borig.m_b = true;
-    strcpy(borig.m_name, "Joe Cool Coder");
-
-    CacheableBytesPtr bytes = CacheableBytes::create(
-        reinterpret_cast<uint8_t*>(&borig), sizeof(blob));
-    CacheableBytesPtr bytesCopy = duplicate(bytes);
-    struct blob* bcopy = (struct blob*)bytesCopy->value();
-    ASSERT(0 == strcmp(bcopy->m_name, borig.m_name), "expected Joe Cool 
Coder");
-    ASSERT(1 == bcopy->m_a, "expected value 1");
-  }
-ENDTASK
-
-DUNIT_TASK(NoDist, OtherTypeInMemory)
-  {
-    Serializable::registerType(OtherType::createDeserializable);
-    std::shared_ptr<OtherType> ot(new OtherType());
-    ot->m_struct.a = 1;
-    ot->m_struct.b = true;
-    ot->m_struct.c = 2;
-    ot->m_struct.d = 3.0;
-
-    std::shared_ptr<OtherType> copy = duplicate(ot);
-
-    ASSERT(copy->classId() == g_classIdToReturn, "unexpected classId");
-    if (copy->classId() > 0xFFFF) {
-      ASSERT(copy->typeId() == GeodeTypeIdsImpl::CacheableUserData4,
-             "typeId should be equal to 
GeodeTypeIdsImpl::CacheableUserData4.");
-    } else if (copy->classId() > 0xFF) {
-      ASSERT(copy->typeId() == GeodeTypeIdsImpl::CacheableUserData2,
-             "typeId should be equal to 
GeodeTypeIdsImpl::CacheableUserData2.");
-    } else {
-      ASSERT(copy->typeId() == GeodeTypeIdsImpl::CacheableUserData,
-             "typeId should be equal to GeodeTypeIdsImpl::CacheableUserData.");
-    }
-    ASSERT(copy != ot, "expected different instance.");
-    ASSERT(copy->m_struct.a == 1, "a == 1");
-    ASSERT(copy->m_struct.b == true, "b == true");
-    ASSERT(copy->m_struct.c == 2, "c == 2");
-    ASSERT(copy->m_struct.d == 3.0, "d == 3.0");
-  }
-ENDTASK
-
 RegionPtr regionPtr;
 
 DUNIT_TASK(Receiver, SetupR)
@@ -238,11 +161,15 @@ ENDTASK
 
 DUNIT_TASK(Sender, SetupAndPutInts)
   {
-    Serializable::registerType(OtherType::createDeserializable);
-    Serializable::registerType(OtherType::createDeserializable2);
-    Serializable::registerType(OtherType::createDeserializable4);
-    initClientWithPool(true, "__TEST_POOL1__", locatorsG, "ServerGroup1",
-                       nullptr, 0, true);
+    initClientWithPool(true, "__TEST_POOL1__", locatorsG, nullptr, nullptr, 0,
+                       true);
+    SerializationRegistryPtr serializationRegistry =
+        CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
+            ->getSerializationRegistry();
+    serializationRegistry->addType(OtherType::createDeserializable);
+    serializationRegistry->addType(OtherType::createDeserializable2);
+    serializationRegistry->addType(OtherType::createDeserializable4);
+
     getHelper()->createPooledRegion("DistRegionAck", USE_ACK, locatorsG,
                                     "__TEST_POOL1__", true, true);
     LOG("SenderInit complete.");

http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/integration-test/testThinClientAfterRegionLive.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/testThinClientAfterRegionLive.cpp 
b/src/cppcache/integration-test/testThinClientAfterRegionLive.cpp
index 9dd5695..3bcdfe0 100644
--- a/src/cppcache/integration-test/testThinClientAfterRegionLive.cpp
+++ b/src/cppcache/integration-test/testThinClientAfterRegionLive.cpp
@@ -58,10 +58,11 @@ auto cptr4 = std::make_shared<DisconnectCacheListioner>(3);
 #include "LocatorHelper.hpp"
 
 void createPooledRegionMine(bool callReadyForEventsAPI = false) {
-  PoolFactoryPtr poolFacPtr = PoolManager::createFactory();
+  auto& poolManager = getHelper()->getCache()->getPoolManager();
+  PoolFactoryPtr poolFacPtr = poolManager.createFactory();
   poolFacPtr->setSubscriptionEnabled(true);
   getHelper()->addServerLocatorEPs(locatorsG, poolFacPtr);
-  if ((PoolManager::find("__TEST_POOL1__")) ==
+  if ((poolManager.find("__TEST_POOL1__")) ==
       nullptr) {  // Pool does not exist with the same name.
     PoolPtr pptr = poolFacPtr->create("__TEST_POOL1__");
   }

http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/integration-test/testThinClientBigValue.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/testThinClientBigValue.cpp 
b/src/cppcache/integration-test/testThinClientBigValue.cpp
index 7be59f5..361d594 100644
--- a/src/cppcache/integration-test/testThinClientBigValue.cpp
+++ b/src/cppcache/integration-test/testThinClientBigValue.cpp
@@ -108,8 +108,8 @@ END_TASK(StartServer)
 
 DUNIT_TASK(CLIENT1, SetupClient1)
   {
-    initClientWithPool(true, "__TEST_POOL1__", locHostPort, "ServerGroup1",
-                       nullptr, 0, true);
+    initClientWithPool(true, "__TEST_POOL1__", locHostPort, nullptr, nullptr, 
0,
+                       true);
     getHelper()->createPooledRegion(regionNames[0], false, locHostPort,
                                     "__TEST_POOL1__", true, true);
   }
@@ -117,8 +117,8 @@ END_TASK(SetupClient1)
 
 DUNIT_TASK(CLIENT2, SetupClient2)
   {
-    initClientWithPool(true, "__TEST_POOL1__", locHostPort, "ServerGroup1",
-                       nullptr, 0, true);
+    initClientWithPool(true, "__TEST_POOL1__", locHostPort, nullptr, nullptr, 
0,
+                       true);
     getHelper()->createPooledRegion(regionNames[0], false, locHostPort,
                                     "__TEST_POOL1__", true, true);
   }

http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/integration-test/testThinClientCacheableStringArray.cpp
----------------------------------------------------------------------
diff --git 
a/src/cppcache/integration-test/testThinClientCacheableStringArray.cpp 
b/src/cppcache/integration-test/testThinClientCacheableStringArray.cpp
index 5e621b3..b6f5696 100644
--- a/src/cppcache/integration-test/testThinClientCacheableStringArray.cpp
+++ b/src/cppcache/integration-test/testThinClientCacheableStringArray.cpp
@@ -33,6 +33,10 @@
 #include <geode/Query.hpp>
 #include <geode/QueryService.hpp>
 
+#include "SerializationRegistry.hpp"
+#include "CacheRegionHelper.hpp"
+#include "CacheImpl.hpp"
+
 using namespace apache::geode::client;
 using namespace test;
 using namespace testobject;
@@ -63,11 +67,15 @@ END_TASK(CreateServer1)
 
 DUNIT_TASK(CLIENT1, StepOne)
   {
-    Serializable::registerType(Position::createDeserializable);
-    Serializable::registerType(Portfolio::createDeserializable);
+    initClientWithPool(true, "__TEST_POOL1__", locHostPort, nullptr, nullptr, 
0,
+                       true);
+    SerializationRegistryPtr serializationRegistry =
+        CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
+            ->getSerializationRegistry();
+
+    serializationRegistry->addType(Position::createDeserializable);
+    serializationRegistry->addType(Portfolio::createDeserializable);
 
-    initClientWithPool(true, "__TEST_POOL1__", locHostPort, "ServerGroup1",
-                       nullptr, 0, true);
     RegionPtr regptr = getHelper()->createPooledRegion(
         _regionNames[0], USE_ACK, locHostPort, "__TEST_POOL1__", true, true);
     RegionAttributesPtr lattribPtr = regptr->getAttributes();

http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/integration-test/testThinClientCacheablesLimits.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/testThinClientCacheablesLimits.cpp 
b/src/cppcache/integration-test/testThinClientCacheablesLimits.cpp
index 4f2b44c..7f59aea 100644
--- a/src/cppcache/integration-test/testThinClientCacheablesLimits.cpp
+++ b/src/cppcache/integration-test/testThinClientCacheablesLimits.cpp
@@ -90,8 +90,8 @@ const char* _regionNames[] = {"DistRegionAck", 
"DistRegionNoAck"};
 
 DUNIT_TASK_DEFINITION(CLIENT1, StepOne)
   {
-    initClientWithPool(true, "__TEST_POOL1__", locatorsG, "ServerGroup1",
-                       nullptr, 0, true);
+    initClientWithPool(true, "__TEST_POOL1__", locatorsG, nullptr, nullptr, 0,
+                       true);
     getHelper()->createPooledRegion(_regionNames[1], NO_ACK, locatorsG,
                                     "__TEST_POOL1__", false, false);
     LOG("StepOne complete.");

http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/integration-test/testThinClientClearRegion.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/testThinClientClearRegion.cpp 
b/src/cppcache/integration-test/testThinClientClearRegion.cpp
index 480af07..17307d0 100644
--- a/src/cppcache/integration-test/testThinClientClearRegion.cpp
+++ b/src/cppcache/integration-test/testThinClientClearRegion.cpp
@@ -67,8 +67,8 @@ END_TASK(StartServer)
 
 DUNIT_TASK(CLIENT1, SetupClient1)
   {
-    initClientWithPool(true, "__TEST_POOL1__", locHostPort, "ServerGroup1",
-                       nullptr, 0, true);
+    initClientWithPool(true, "__TEST_POOL1__", locHostPort, nullptr, nullptr, 
0,
+                       true);
     getHelper()->createPooledRegion(regionNames[0], false, locHostPort,
                                     "__TEST_POOL1__", true, true);
     RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
@@ -83,8 +83,8 @@ END_TASK(SetupClient1)
 
 DUNIT_TASK(CLIENT2, SetupClient2)
   {
-    initClientWithPool(true, "__TEST_POOL1__", locHostPort, "ServerGroup1",
-                       nullptr, 0, true);
+    initClientWithPool(true, "__TEST_POOL1__", locHostPort, nullptr, nullptr, 
0,
+                       true);
     getHelper()->createPooledRegion(regionNames[0], false, locHostPort,
                                     "__TEST_POOL1__", true, true);
     RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);

http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/integration-test/testThinClientConflation.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/testThinClientConflation.cpp 
b/src/cppcache/integration-test/testThinClientConflation.cpp
index 5be6103..15932f5 100644
--- a/src/cppcache/integration-test/testThinClientConflation.cpp
+++ b/src/cppcache/integration-test/testThinClientConflation.cpp
@@ -164,8 +164,8 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(FEEDER, CreateRegionsAndFirstFeederUpdate)
   {
-    initClientWithPool(true, "__TEST_POOL1__", locatorsG, "ServerGroup1",
-                       nullptr, 0, true);
+    initClientWithPool(true, "__TEST_POOL1__", locatorsG, nullptr, nullptr, 0,
+                       true);
     getHelper()->createPooledRegion(regions[0], USE_ACK, locatorsG,
                                     "__TEST_POOL1__", true, true);
     getHelper()->createPooledRegion(regions[1], USE_ACK, locatorsG,

http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/integration-test/testThinClientContainsKeyOnServer.cpp
----------------------------------------------------------------------
diff --git 
a/src/cppcache/integration-test/testThinClientContainsKeyOnServer.cpp 
b/src/cppcache/integration-test/testThinClientContainsKeyOnServer.cpp
index a9ab4fb..b07bf1a 100644
--- a/src/cppcache/integration-test/testThinClientContainsKeyOnServer.cpp
+++ b/src/cppcache/integration-test/testThinClientContainsKeyOnServer.cpp
@@ -40,8 +40,8 @@ END_TASK(StartServer)
 
 DUNIT_TASK(CLIENT1, SetupClient1)
   {
-    initClientWithPool(true, "__TEST_POOL1__", locatorsG, "ServerGroup1",
-                       nullptr, 0, true);
+    initClientWithPool(true, "__TEST_POOL1__", locatorsG, nullptr, nullptr, 0,
+                       true);
     getHelper()->createPooledRegion(regionNames[0], false, locatorsG,
                                     "__TEST_POOL1__", true, true);
     RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
@@ -52,8 +52,8 @@ END_TASK(SetupClient1)
 
 DUNIT_TASK(CLIENT2, SetupClient2)
   {
-    initClientWithPool(true, "__TEST_POOL1__", locatorsG, "ServerGroup1",
-                       nullptr, 0, true);
+    initClientWithPool(true, "__TEST_POOL1__", locatorsG, nullptr, nullptr, 0,
+                       true);
     getHelper()->createPooledRegion(regionNames[0], false, locatorsG,
                                     "__TEST_POOL1__", true, true);
     RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);

http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/integration-test/testThinClientCq.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/testThinClientCq.cpp 
b/src/cppcache/integration-test/testThinClientCq.cpp
index 5317e4a..19db32e 100644
--- a/src/cppcache/integration-test/testThinClientCq.cpp
+++ b/src/cppcache/integration-test/testThinClientCq.cpp
@@ -77,21 +77,24 @@ const char* queryStrings[MAX_LISTNER] = {
     "select * from /Portfolios p where p.ID != 7"};
 
 void initClientCq(const bool isthinClient) {
+  if (cacheHelper == nullptr) {
+    cacheHelper = new CacheHelper(isthinClient);
+  }
+  ASSERT(cacheHelper, "Failed to create a CacheHelper client instance.");
+
   try {
-    Serializable::registerType(Position::createDeserializable);
-    Serializable::registerType(Portfolio::createDeserializable);
+    SerializationRegistryPtr serializationRegistry =
+        CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
+            ->getSerializationRegistry();
+    serializationRegistry->addType(Position::createDeserializable);
+    serializationRegistry->addType(Portfolio::createDeserializable);
 
-    Serializable::registerPdxType(PositionPdx::createDeserializable);
-    Serializable::registerPdxType(PortfolioPdx::createDeserializable);
+    serializationRegistry->addPdxType(PositionPdx::createDeserializable);
+    serializationRegistry->addPdxType(PortfolioPdx::createDeserializable);
 
   } catch (const IllegalStateException&) {
     // ignore exception
   }
-
-  if (cacheHelper == nullptr) {
-    cacheHelper = new CacheHelper(isthinClient);
-  }
-  ASSERT(cacheHelper, "Failed to create a CacheHelper client instance.");
 }
 
 const char* regionNamesCq[] = {"Portfolios", "Positions", "Portfolios2",
@@ -380,7 +383,8 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepThree)
     uint8_t i = 0;
     QueryHelper* qh ATTR_UNUSED = &QueryHelper::getHelper();
 
-    PoolPtr pool = PoolManager::find(regionNamesCq[0]);
+    PoolPtr pool =
+        getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
     QueryServicePtr qs;
     if (pool != nullptr) {
       // Using region name as pool name as in ThinClientCq.hpp
@@ -482,7 +486,8 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepFour)
   {
     QueryHelper* qh ATTR_UNUSED = &QueryHelper::getHelper();
 
-    PoolPtr pool = PoolManager::find(regionNamesCq[0]);
+    PoolPtr pool =
+        getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
     QueryServicePtr qs;
     if (pool != nullptr) {
       // Using region name as pool name as in ThinClientCq.hpp
@@ -792,7 +797,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, createCQ)
   {
     SLEEP(10000);
     // Create CqAttributes and Install Listener
-    PoolPtr pool = PoolManager::find(regionName);
+    PoolPtr pool = getHelper()->getCache()->getPoolManager().find(regionName);
     QueryServicePtr qs = pool->getQueryService();
     CqAttributesFactory cqFac;
     auto cqLstner = std::make_shared<MyCqStatusListener>(100);
@@ -818,7 +823,8 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, createCQ_Pool)
   {
-    PoolPtr pool = PoolManager::find("__TEST_POOL1__");
+    PoolPtr pool =
+        getHelper()->getCache()->getPoolManager().find("__TEST_POOL1__");
     QueryServicePtr qs = pool->getQueryService();
     CqAttributesFactory cqFac;
     auto cqLstner = std::make_shared<MyCqStatusListener>(100);
@@ -839,7 +845,8 @@ DUNIT_TASK_DEFINITION(CLIENT1, createCQ_Pool)
     ASSERT(myStatusCq->getCqsConnectedCount() == 1,
            "incorrect number of CqStatus Connected count.");
 
-    PoolPtr pool2 = PoolManager::find("__TEST_POOL2__");
+    PoolPtr pool2 =
+        getHelper()->getCache()->getPoolManager().find("__TEST_POOL2__");
     QueryServicePtr qs2 = pool2->getQueryService();
     CqAttributesFactory cqFac1;
     auto cqLstner1 = std::make_shared<MyCqStatusListener>(101);
@@ -889,7 +896,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, createCQ_Pool)
 END_TASK_DEFINITION
 
 void executeCq(const char* poolName, const char* name) {
-  PoolPtr pool = PoolManager::find(poolName);
+  PoolPtr pool = getHelper()->getCache()->getPoolManager().find(poolName);
   QueryServicePtr qs;
   if (pool != nullptr) {
     qs = pool->getQueryService();
@@ -909,7 +916,7 @@ END_TASK_DEFINITION
 
 void checkCQStatusOnConnect(const char* poolName, const char* name,
                             int connect) {
-  PoolPtr pool = PoolManager::find(poolName);
+  PoolPtr pool = getHelper()->getCache()->getPoolManager().find(poolName);
   QueryServicePtr qs;
   if (pool != nullptr) {
     qs = pool->getQueryService();
@@ -953,7 +960,7 @@ END_TASK_DEFINITION
 
 void checkCQStatusOnDisConnect(const char* poolName, const char* cqName,
                                int disconnect) {
-  PoolPtr pool = PoolManager::find(poolName);
+  PoolPtr pool = getHelper()->getCache()->getPoolManager().find(poolName);
   QueryServicePtr qs;
   if (pool != nullptr) {
     qs = pool->getQueryService();
@@ -1025,7 +1032,7 @@ END_TASK_DEFINITION
 
 void checkCQStatusOnPutEvent(const char* poolName, const char* cqName,
                              int count) {
-  PoolPtr pool = PoolManager::find(poolName);
+  PoolPtr pool = getHelper()->getCache()->getPoolManager().find(poolName);
   QueryServicePtr qs;
   if (pool != nullptr) {
     qs = pool->getQueryService();
@@ -1060,7 +1067,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, ProcessCQ)
   {
     SLEEP(10000);
     // Create CqAttributes and Install Listener
-    PoolPtr pool = PoolManager::find(regionName);
+    PoolPtr pool = getHelper()->getCache()->getPoolManager().find(regionName);
     QueryServicePtr qs = pool->getQueryService();
     CqAttributesFactory cqFac;
     auto cqLstner = std::make_shared<MyCqListener>(1);

http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/integration-test/testThinClientCqDelta.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/testThinClientCqDelta.cpp 
b/src/cppcache/integration-test/testThinClientCqDelta.cpp
index ab07d5a..8372c06 100644
--- a/src/cppcache/integration-test/testThinClientCqDelta.cpp
+++ b/src/cppcache/integration-test/testThinClientCqDelta.cpp
@@ -30,6 +30,11 @@
 #include <geode/CqListener.hpp>
 #include <geode/CqQuery.hpp>
 #include <geode/CqServiceStatistics.hpp>
+#include <geode/Cache.hpp>
+
+#include "SerializationRegistry.hpp"
+#include "CacheRegionHelper.hpp"
+#include "CacheImpl.hpp"
 
 using namespace apache::geode::client;
 using namespace test;
@@ -44,6 +49,11 @@ CacheHelper* cacheHelper = nullptr;
 #define SERVER1 s2p1
 #include "LocatorHelper.hpp"
 
+CacheHelper* getHelper() {
+  ASSERT(cacheHelper != nullptr, "No cacheHelper initialized.");
+  return cacheHelper;
+}
+
 class CqDeltaListener : public CqListener {
  public:
   CqDeltaListener() : m_deltaCount(0), m_valueCount(0) {}
@@ -51,8 +61,9 @@ class CqDeltaListener : public CqListener {
   virtual void onEvent(const CqEvent& aCqEvent) {
     CacheableBytesPtr deltaValue = aCqEvent.getDeltaValue();
     DeltaTestImpl newValue;
-    DataInput input(deltaValue->value(), deltaValue->length());
-    newValue.fromDelta(input);
+    auto input = getHelper()->getCache()->createDataInput(
+        deltaValue->value(), deltaValue->length());
+    newValue.fromDelta(*input);
     if (newValue.getIntVar() == 5) {
       m_deltaCount++;
     }
@@ -92,11 +103,6 @@ void cleanProc() {
   }
 }
 
-CacheHelper* getHelper() {
-  ASSERT(cacheHelper != nullptr, "No cacheHelper initialized.");
-  return cacheHelper;
-}
-
 void createPooledRegion(const char* name, bool ackMode, const char* locators,
                         const char* poolname,
                         bool clientNotificationEnabled = false,
@@ -146,7 +152,11 @@ DUNIT_TASK_DEFINITION(CLIENT1, CreateClient1)
     createPooledRegion(regionNames[0], USE_ACK, locatorsG, "__TESTPOOL1_",
                        true);
     try {
-      Serializable::registerType(DeltaTestImpl::create);
+      SerializationRegistryPtr serializationRegistry =
+          CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
+              ->getSerializationRegistry();
+
+      serializationRegistry->addType(DeltaTestImpl::create);
     } catch (IllegalStateException&) {
       //  ignore exception caused by type reregistration.
     }
@@ -159,13 +169,18 @@ DUNIT_TASK_DEFINITION(CLIENT2, CreateClient2)
     createPooledRegion(regionNames[0], USE_ACK, locatorsG, "__TESTPOOL1_",
                        true);
     try {
-      Serializable::registerType(DeltaTestImpl::create);
+      SerializationRegistryPtr serializationRegistry =
+          CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
+              ->getSerializationRegistry();
+
+      serializationRegistry->addType(DeltaTestImpl::create);
     } catch (IllegalStateException&) {
       //  ignore exception caused by type reregistration.
     }
     RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
 
-    PoolPtr pool = PoolManager::find("__TESTPOOL1_");
+    PoolPtr pool =
+        getHelper()->getCache()->getPoolManager().find("__TESTPOOL1_");
     QueryServicePtr qs;
     qs = pool->getQueryService();
     CqAttributesFactory cqFac;
@@ -185,7 +200,11 @@ DUNIT_TASK_DEFINITION(CLIENT1, CreateClient1_NoPools)
     initClientNoPools();
     createRegion(regionNames[0], USE_ACK, true);
     try {
-      Serializable::registerType(DeltaTestImpl::create);
+      SerializationRegistryPtr serializationRegistry =
+          CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
+              ->getSerializationRegistry();
+
+      serializationRegistry->addType(DeltaTestImpl::create);
     } catch (IllegalStateException&) {
       //  ignore exception caused by type reregistration.
     }
@@ -197,7 +216,11 @@ DUNIT_TASK_DEFINITION(CLIENT2, CreateClient2_NoPools)
     initClientNoPools();
     createRegion(regionNames[0], USE_ACK, true);
     try {
-      Serializable::registerType(DeltaTestImpl::create);
+      SerializationRegistryPtr serializationRegistry =
+          CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
+              ->getSerializationRegistry();
+
+      serializationRegistry->addType(DeltaTestImpl::create);
     } catch (IllegalStateException&) {
       //  ignore exception caused by type reregistration.
     }

http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/integration-test/testThinClientCqDurable.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/testThinClientCqDurable.cpp 
b/src/cppcache/integration-test/testThinClientCqDurable.cpp
index 1039d07..35c3892 100644
--- a/src/cppcache/integration-test/testThinClientCqDurable.cpp
+++ b/src/cppcache/integration-test/testThinClientCqDurable.cpp
@@ -61,23 +61,27 @@ const char* durableCQNamesClient2[] = {
 static bool m_isPdx = false;
 
 void initClientWithId(int ClientIdx, bool typeRegistered = false) {
-  if (typeRegistered == false) {
-    try {
-      Serializable::registerType(Position::createDeserializable);
-      Serializable::registerType(Portfolio::createDeserializable);
-
-      Serializable::registerPdxType(PositionPdx::createDeserializable);
-      Serializable::registerPdxType(PortfolioPdx::createDeserializable);
-    } catch (const IllegalStateException&) {
-      // ignore exception
-    }
-  }
   PropertiesPtr pp = Properties::create();
   pp->insert("durable-client-id", durableIds[ClientIdx]);
   pp->insert("durable-timeout", 60);
   pp->insert("notify-ack-interval", 1);
 
   initClient(true, pp);
+
+  if (typeRegistered == false) {
+    try {
+      SerializationRegistryPtr serializationRegistry =
+          CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
+              ->getSerializationRegistry();
+      serializationRegistry->addType(Position::createDeserializable);
+      serializationRegistry->addType(Portfolio::createDeserializable);
+
+      serializationRegistry->addPdxType(PositionPdx::createDeserializable);
+      serializationRegistry->addPdxType(PortfolioPdx::createDeserializable);
+    } catch (const IllegalStateException&) {
+      // ignore exception
+    }
+  }
 }
 
 class MyCqListener1 : public CqListener {
@@ -188,10 +192,12 @@ void RunDurableCqClient() {
 
   // Create a Geode Cache Programmatically.
   CacheFactoryPtr cacheFactory = CacheFactory::createCacheFactory(pp);
-  CachePtr cachePtr = cacheFactory->setSubscriptionEnabled(true)
-                          ->setSubscriptionAckInterval(5000)
-                          ->setSubscriptionMessageTrackingTimeout(50000)
-                          ->create();
+  CachePtr cachePtr = cacheFactory->create();
+  auto poolFactory = cachePtr->getPoolManager().createFactory();
+  poolFactory->setSubscriptionEnabled(true);
+  poolFactory->setSubscriptionAckInterval(5000);
+  poolFactory->setSubscriptionMessageTrackingTimeout(50000);
+  poolFactory->create("");
 
   LOGINFO("Created the Geode Cache Programmatically");
 
@@ -369,7 +375,8 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepThree)
   {
     QueryHelper* qh ATTR_UNUSED = &QueryHelper::getHelper();
 
-    PoolPtr pool = PoolManager::find(regionNamesCq[0]);
+    PoolPtr pool =
+        getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
     QueryServicePtr qs;
     if (pool != nullptr) {
       qs = pool->getQueryService();
@@ -459,7 +466,11 @@ void client1Up() {
 
   QueryServicePtr qs;
 
-  qs = PoolManager::find(regionNamesCq[0])->getQueryService();
+  qs = getHelper()
+           ->getCache()
+           ->getPoolManager()
+           .find(regionNamesCq[0])
+           ->getQueryService();
   CqAttributesFactory cqFac;
   auto cqLstner = std::make_shared<MyCqListener>();
   cqFac.addCqListener(cqLstner);
@@ -522,7 +533,8 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepFour)
   {
     QueryHelper* qh ATTR_UNUSED = &QueryHelper::getHelper();
 
-    PoolPtr pool = PoolManager::find(regionNamesCq[0]);
+    PoolPtr pool =
+        getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
     QueryServicePtr qs;
     if (pool != nullptr) {
       qs = pool->getQueryService();
@@ -669,7 +681,8 @@ void doThinClientCqDurable() {
 
 DUNIT_TASK_DEFINITION(CLIENT1, RegisterCqs1)
   {
-    PoolPtr pool = PoolManager::find(regionNamesCq[0]);
+    PoolPtr pool =
+        getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
     QueryServicePtr qs;
     if (pool != nullptr) {
       qs = pool->getQueryService();
@@ -696,7 +709,8 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, RegisterCqsAfterClientup1)
   {
-    PoolPtr pool = PoolManager::find(regionNamesCq[0]);
+    PoolPtr pool =
+        getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
     QueryServicePtr qs;
     if (pool != nullptr) {
       qs = pool->getQueryService();
@@ -723,7 +737,8 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT2, RegisterCqs2)
   {
-    PoolPtr pool = PoolManager::find(regionNamesCq[0]);
+    PoolPtr pool =
+        getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
     QueryServicePtr qs;
     if (pool != nullptr) {
       qs = pool->getQueryService();
@@ -750,7 +765,8 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT2, RegisterCqsAfterClientup2)
   {
-    PoolPtr pool = PoolManager::find(regionNamesCq[0]);
+    PoolPtr pool =
+        getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
     QueryServicePtr qs;
     if (pool != nullptr) {
       qs = pool->getQueryService();
@@ -777,7 +793,8 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, VerifyCqs1)
   {
-    PoolPtr pool = PoolManager::find(regionNamesCq[0]);
+    PoolPtr pool =
+        getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
     QueryServicePtr qs;
     if (pool != nullptr) {
       qs = pool->getQueryService();
@@ -800,7 +817,8 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, VerifyCqsAfterClientup1)
   {
-    PoolPtr pool = PoolManager::find(regionNamesCq[0]);
+    PoolPtr pool =
+        getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
     QueryServicePtr qs;
     if (pool != nullptr) {
       qs = pool->getQueryService();
@@ -828,7 +846,8 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT2, VerifyCqs2)
   {
-    PoolPtr pool = PoolManager::find(regionNamesCq[0]);
+    PoolPtr pool =
+        getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
     QueryServicePtr qs;
     if (pool != nullptr) {
       qs = pool->getQueryService();
@@ -855,7 +874,8 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT2, VerifyCqsAfterClientup2)
   {
-    PoolPtr pool = PoolManager::find(regionNamesCq[0]);
+    PoolPtr pool =
+        getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
     QueryServicePtr qs;
     if (pool != nullptr) {
       qs = pool->getQueryService();
@@ -893,7 +913,8 @@ DUNIT_TASK_DEFINITION(CLIENT2, VerifyCqsAfterClientup2)
 END_TASK_DEFINITION
 
 void verifyEmptyDurableCQList() {
-  PoolPtr pool = PoolManager::find(regionNamesCq[0]);
+  PoolPtr pool =
+      getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
   QueryServicePtr qs;
   if (pool != nullptr) {
     qs = pool->getQueryService();

http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/integration-test/testThinClientCqFailover.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/testThinClientCqFailover.cpp 
b/src/cppcache/integration-test/testThinClientCqFailover.cpp
index 51cb013..2c4f2da 100644
--- a/src/cppcache/integration-test/testThinClientCqFailover.cpp
+++ b/src/cppcache/integration-test/testThinClientCqFailover.cpp
@@ -38,6 +38,10 @@
 
 #include "ThinClientCQ.hpp"
 
+#include "SerializationRegistry.hpp"
+#include "CacheRegionHelper.hpp"
+#include "CacheImpl.hpp"
+
 using namespace apache::geode::client;
 using namespace test;
 using namespace testobject;
@@ -108,17 +112,20 @@ class KillServerThread : public ACE_Task_Base {
 };
 
 void initClientCq(const bool isthinClient) {
-  try {
-    Serializable::registerType(Position::createDeserializable);
-    Serializable::registerType(Portfolio::createDeserializable);
-  } catch (const IllegalStateException&) {
-    // ignore exception
-  }
-
   if (cacheHelper == nullptr) {
     cacheHelper = new CacheHelper(isthinClient);
   }
   ASSERT(cacheHelper, "Failed to create a CacheHelper client instance.");
+
+  try {
+    SerializationRegistryPtr serializationRegistry =
+        CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
+            ->getSerializationRegistry();
+    serializationRegistry->addType(Position::createDeserializable);
+    serializationRegistry->addType(Portfolio::createDeserializable);
+  } catch (const IllegalStateException&) {
+    // ignore exception
+  }
 }
 
 const char* regionNamesCq[] = {"Portfolios", "Positions"};
@@ -196,7 +203,8 @@ END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT1, StepThree)
   {
     try {
-      PoolPtr pool = PoolManager::find(regionNamesCq[0]);
+      PoolPtr pool =
+          getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
       QueryServicePtr qs;
       if (pool != nullptr) {
         // Using region name as pool name as in ThinClientCq.hpp
@@ -258,7 +266,8 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, StepThree3)
   {
-    auto pool = PoolManager::find(regionNamesCq[0]);
+    auto pool =
+        getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
     QueryServicePtr qs;
     if (pool != nullptr) {
       // Using region name as pool name as in ThinClientCq.hpp
@@ -345,7 +354,8 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, CloseCache1)
   {
-    auto pool = PoolManager::find(regionNamesCq[0]);
+    auto pool =
+        getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
     QueryServicePtr qs;
     if (pool != nullptr) {
       // Using region name as pool name as in ThinClientCq.hpp

http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/integration-test/testThinClientCqHAFailover.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/testThinClientCqHAFailover.cpp 
b/src/cppcache/integration-test/testThinClientCqHAFailover.cpp
index 6227991..dc7cdea 100644
--- a/src/cppcache/integration-test/testThinClientCqHAFailover.cpp
+++ b/src/cppcache/integration-test/testThinClientCqHAFailover.cpp
@@ -110,17 +110,21 @@ class KillServerThread : public ACE_Task_Base {
 };
 
 void initClientCq(int redundancyLevel) {
-  try {
-    Serializable::registerType(Position::createDeserializable);
-    Serializable::registerType(Portfolio::createDeserializable);
-  } catch (const IllegalStateException&) {
-    // ignore exception
-  }
-
   if (cacheHelper == nullptr) {
     cacheHelper = new CacheHelper(true);
   }
   ASSERT(cacheHelper, "Failed to create a CacheHelper client instance.");
+
+  try {
+    SerializationRegistryPtr serializationRegistry =
+        CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
+            ->getSerializationRegistry();
+
+    serializationRegistry->addType(Position::createDeserializable);
+    serializationRegistry->addType(Portfolio::createDeserializable);
+  } catch (const IllegalStateException&) {
+    // ignore exception
+  }
 }
 
 KillServerThread* kst = nullptr;
@@ -197,7 +201,8 @@ END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT1, StepThree)
   {
     try {
-      PoolPtr pool = PoolManager::find(regionNamesCq[0]);
+      PoolPtr pool =
+          getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
       QueryServicePtr qs;
       if (pool != nullptr) {
         qs = pool->getQueryService();
@@ -295,7 +300,8 @@ END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT1, StepThree3)
   {
     // using region name as pool name
-    PoolPtr pool = PoolManager::find(regionNamesCq[0]);
+    PoolPtr pool =
+        getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
     QueryServicePtr qs;
     if (pool != nullptr) {
       qs = pool->getQueryService();
@@ -382,7 +388,8 @@ END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT1, CloseCache1)
   {
     // using region name as pool name
-    PoolPtr pool = PoolManager::find(regionNamesCq[0]);
+    PoolPtr pool =
+        getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
     QueryServicePtr qs;
     if (pool != nullptr) {
       qs = pool->getQueryService();

http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/integration-test/testThinClientCqIR.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/testThinClientCqIR.cpp 
b/src/cppcache/integration-test/testThinClientCqIR.cpp
index 8f0db1f..c1dabf8 100644
--- a/src/cppcache/integration-test/testThinClientCqIR.cpp
+++ b/src/cppcache/integration-test/testThinClientCqIR.cpp
@@ -49,20 +49,23 @@ using namespace testData;
 const char* cqName = "MyCq";
 
 void initClientCq(const bool isthinClient) {
-  try {
-    Serializable::registerType(Position::createDeserializable);
-    Serializable::registerType(Portfolio::createDeserializable);
-
-    Serializable::registerPdxType(PositionPdx::createDeserializable);
-    Serializable::registerPdxType(PortfolioPdx::createDeserializable);
-  } catch (const IllegalStateException&) {
-    // ignore exception
-  }
-
   if (cacheHelper == nullptr) {
     cacheHelper = new CacheHelper(isthinClient);
   }
   ASSERT(cacheHelper, "Failed to create a CacheHelper client instance.");
+
+  try {
+    SerializationRegistryPtr serializationRegistry =
+        CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
+            ->getSerializationRegistry();
+    serializationRegistry->addType(Position::createDeserializable);
+    serializationRegistry->addType(Portfolio::createDeserializable);
+
+    serializationRegistry->addPdxType(PositionPdx::createDeserializable);
+    serializationRegistry->addPdxType(PortfolioPdx::createDeserializable);
+  } catch (const IllegalStateException&) {
+    // ignore exception
+  }
 }
 const char* regionNamesCq[] = {"Portfolios", "Positions", "Portfolios2",
                                "Portfolios3"};
@@ -157,7 +160,8 @@ DUNIT_TASK_DEFINITION(CLIENT1, QueryData)
     auto& qh ATTR_UNUSED = QueryHelper::getHelper();
 
     // using region name as pool name
-    auto pool = PoolManager::find(regionNamesCq[0]);
+    auto pool =
+        getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
     QueryServicePtr qs;
     if (pool != nullptr) {
       qs = pool->getQueryService();

http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/integration-test/testThinClientDeltaWithNotification.cpp
----------------------------------------------------------------------
diff --git 
a/src/cppcache/integration-test/testThinClientDeltaWithNotification.cpp 
b/src/cppcache/integration-test/testThinClientDeltaWithNotification.cpp
index 77e26c1..4d79837 100644
--- a/src/cppcache/integration-test/testThinClientDeltaWithNotification.cpp
+++ b/src/cppcache/integration-test/testThinClientDeltaWithNotification.cpp
@@ -26,6 +26,11 @@
 #include "DeltaEx.hpp"
 #include "fw_dunit.hpp"
 #include <string>
+
+#include "SerializationRegistry.hpp"
+#include "CacheRegionHelper.hpp"
+#include "CacheImpl.hpp"
+
 using namespace apache::geode::client;
 using namespace test;
 
@@ -190,7 +195,11 @@ END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT1, Client1_Init)
   {
     try {
-      Serializable::registerType(DeltaEx::create);
+      SerializationRegistryPtr serializationRegistry =
+          CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
+              ->getSerializationRegistry();
+
+      serializationRegistry->addType(DeltaEx::create);
     } catch (IllegalStateException&) {
       //  ignore type reregistration exception.
     }
@@ -200,7 +209,11 @@ END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT2, Client2_Init)
   {
     try {
-      Serializable::registerType(DeltaEx::create);
+      SerializationRegistryPtr serializationRegistry =
+          CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
+              ->getSerializationRegistry();
+
+      serializationRegistry->addType(DeltaEx::create);
     } catch (IllegalStateException&) {
       //  ignore type reregistration exception.
     }

http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/integration-test/testThinClientExecuteFunctionPrSHOP.cpp
----------------------------------------------------------------------
diff --git 
a/src/cppcache/integration-test/testThinClientExecuteFunctionPrSHOP.cpp 
b/src/cppcache/integration-test/testThinClientExecuteFunctionPrSHOP.cpp
index 3a11922..d08b440 100644
--- a/src/cppcache/integration-test/testThinClientExecuteFunctionPrSHOP.cpp
+++ b/src/cppcache/integration-test/testThinClientExecuteFunctionPrSHOP.cpp
@@ -178,8 +178,8 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, StartC1)
   {
-    initClientWithPool(true, nullptr, locHostPort, serverGroup, nullptr, 0,
-                       true, -1, -1, 60000, /*singlehop*/ true,
+    initClientWithPool(true, poolRegNames[0], locHostPort, serverGroup, 
nullptr,
+                       0, true, -1, -1, 60000, /*singlehop*/ true,
                        /*threadLocal*/ true);
 
     RegionPtr regPtr0 =
@@ -568,7 +568,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, Client1OpTest2)
       ExecutionPtr RexecutionPtr = FunctionService::onRegion(regPtr0);
       CacheableVectorPtr fe =
           RexecutionPtr->withArgs(CacheableInt32::create(5000 * 1000))
-              ->execute(FETimeOut, 5000)
+              ->execute(FETimeOut, 5000 * 1000)
               ->getResult();
       if (fe == nullptr) {
         ASSERT(false, "functionResult is nullptr");

http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/integration-test/testThinClientGetInterests.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/testThinClientGetInterests.cpp 
b/src/cppcache/integration-test/testThinClientGetInterests.cpp
index 4197f4c..3910b8c 100644
--- a/src/cppcache/integration-test/testThinClientGetInterests.cpp
+++ b/src/cppcache/integration-test/testThinClientGetInterests.cpp
@@ -47,8 +47,7 @@ DUNIT_TASK(CLIENT1, SetupClient1)
     pp->insert("durable-timeout", 300);
     pp->insert("notify-ack-interval", 1);
 
-    initClientWithPool(true, "__TEST_POOL1__", locatorsG, "ServerGroup1", pp, 
0,
-                       true);
+    initClientWithPool(true, "__TEST_POOL1__", locatorsG, nullptr, pp, 0, 
true);
     getHelper()->createPooledRegion(regionNames[0], false, locatorsG,
                                     "__TEST_POOL1__", true, true);
     CacheableKeyPtr keyPtr0 = CacheableString::create(keys[0]);

http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/integration-test/testThinClientHAQueryFailover.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/testThinClientHAQueryFailover.cpp 
b/src/cppcache/integration-test/testThinClientHAQueryFailover.cpp
index 9f71ab5..18299df 100644
--- a/src/cppcache/integration-test/testThinClientHAQueryFailover.cpp
+++ b/src/cppcache/integration-test/testThinClientHAQueryFailover.cpp
@@ -26,7 +26,9 @@
 
 #include "CacheHelper.hpp"
 
-//#include "QueryHelper.hpp"
+#include "SerializationRegistry.hpp"
+#include "CacheRegionHelper.hpp"
+#include "CacheImpl.hpp"
 
 #include <geode/Query.hpp>
 #include <geode/QueryService.hpp>
@@ -78,23 +80,27 @@ class KillServerThread : public ACE_Task_Base {
 };
 
 void initClient() {
-  try {
-    Serializable::registerType(Portfolio::createDeserializable);
-    Serializable::registerType(Position::createDeserializable);
-  } catch (const IllegalStateException&) {
-    // ignore reregistration exception
-  }
   if (cacheHelper == nullptr) {
     cacheHelper = new CacheHelper(true);
   }
   ASSERT(cacheHelper, "Failed to create a CacheHelper client instance.");
+  try {
+    SerializationRegistryPtr serializationRegistry =
+        CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
+            ->getSerializationRegistry();
+
+    serializationRegistry->addType(Portfolio::createDeserializable);
+    serializationRegistry->addType(Position::createDeserializable);
+  } catch (const IllegalStateException&) {
+    // ignore reregistration exception
+  }
 }
 
 /*
 void initClient( const bool isthinClient )
 {
-  Serializable::registerType( Portfolio::createDeserializable);
-  Serializable::registerType( Position::createDeserializable);
+  serializationRegistry->addType( Portfolio::createDeserializable);
+  serializationRegistry->addType( Position::createDeserializable);
 
   if ( cacheHelper == nullptr ) {
     cacheHelper = new CacheHelper(isthinClient);
@@ -195,7 +201,8 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepThree)
 
       QueryServicePtr qs = nullptr;
 
-      PoolPtr pool = PoolManager::find("__TESTPOOL1_");
+      PoolPtr pool =
+          getHelper()->getCache()->getPoolManager().find("__TESTPOOL1_");
       qs = pool->getQueryService();
       LOG("Got query service from pool");
 

http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/integration-test/testThinClientHeapLRU.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/testThinClientHeapLRU.cpp 
b/src/cppcache/integration-test/testThinClientHeapLRU.cpp
index d2f2343..e70b5c0 100644
--- a/src/cppcache/integration-test/testThinClientHeapLRU.cpp
+++ b/src/cppcache/integration-test/testThinClientHeapLRU.cpp
@@ -75,8 +75,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepOne)
     PropertiesPtr pp = Properties::create();
     pp->insert("heap-lru-limit", 1);
     pp->insert("heap-lru-delta", 10);
-    initClientWithPool(true, "__TEST_POOL1__", locatorsG, "ServerGroup1", pp, 
0,
-                       true);
+    initClientWithPool(true, "__TEST_POOL1__", locatorsG, nullptr, pp, 0, 
true);
     getHelper()->createPooledRegion(_regionNames[0], USE_ACK, locatorsG,
                                     "__TEST_POOL1__", true, true);
     LOG("StepOne complete.");
@@ -88,8 +87,7 @@ DUNIT_TASK_DEFINITION(CLIENT2, StepTwo)
     PropertiesPtr pp = Properties::create();
     pp->insert("heap-lru-limit", 1);
     pp->insert("heap-lru-delta", 10);
-    initClientWithPool(true, "__TEST_POOL1__", locatorsG, "ServerGroup1", pp, 
0,
-                       true);
+    initClientWithPool(true, "__TEST_POOL1__", locatorsG, nullptr, pp, 0, 
true);
     getHelper()->createPooledRegion(_regionNames[0], USE_ACK, locatorsG,
                                     "__TEST_POOL1__", true, true);
     LOG("StepTwo complete.");

http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/integration-test/testThinClientIntResPolKeysInv.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/testThinClientIntResPolKeysInv.cpp 
b/src/cppcache/integration-test/testThinClientIntResPolKeysInv.cpp
index f25c5c8..d629560 100644
--- a/src/cppcache/integration-test/testThinClientIntResPolKeysInv.cpp
+++ b/src/cppcache/integration-test/testThinClientIntResPolKeysInv.cpp
@@ -40,7 +40,7 @@ CacheHelper *cacheHelper = nullptr;
 void initClient(const bool isthinClient) {
   if (cacheHelper == nullptr) {
     cacheHelper = new CacheHelper(isthinClient, "__TEST_POOL1__", locatorsG,
-                                  "ServerGroup1", nullptr, 0, true);
+                                  nullptr, nullptr, 0, true);
   }
   ASSERT(cacheHelper, "Failed to create a CacheHelper client instance.");
 }

http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/integration-test/testThinClientInterest1Cacheless.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/testThinClientInterest1Cacheless.cpp 
b/src/cppcache/integration-test/testThinClientInterest1Cacheless.cpp
index 8e628b2..d390710 100644
--- a/src/cppcache/integration-test/testThinClientInterest1Cacheless.cpp
+++ b/src/cppcache/integration-test/testThinClientInterest1Cacheless.cpp
@@ -81,8 +81,8 @@ END_TASK(StartServer)
 
 DUNIT_TASK(CLIENT1, SetupClient1)
   {
-    initClientWithPool(true, "__TEST_POOL1__", locatorsG, "ServerGroup1",
-                       nullptr, 0, true);
+    initClientWithPool(true, "__TEST_POOL1__", locatorsG, nullptr, nullptr, 0,
+                       true);
     getHelper()->createPooledRegion(regionNames[0], false, locatorsG,
                                     "__TEST_POOL1__", true, true);
   }
@@ -90,8 +90,8 @@ END_TASK(SetupClient1)
 
 DUNIT_TASK(CLIENT2, setupClient2)
   {
-    initClientWithPool(true, "__TEST_POOL1__", locatorsG, "ServerGroup1",
-                       nullptr, 0, true);
+    initClientWithPool(true, "__TEST_POOL1__", locatorsG, nullptr, nullptr, 0,
+                       true);
     getHelper()->createPooledRegion(regionNames[0], false, locatorsG,
                                     "__TEST_POOL1__", true, true);
     mylistner = std::make_shared<MyListener>();

http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/integration-test/testThinClientInterest1_Bug1001.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/testThinClientInterest1_Bug1001.cpp 
b/src/cppcache/integration-test/testThinClientInterest1_Bug1001.cpp
index fe225e3..d1761e1 100644
--- a/src/cppcache/integration-test/testThinClientInterest1_Bug1001.cpp
+++ b/src/cppcache/integration-test/testThinClientInterest1_Bug1001.cpp
@@ -48,8 +48,8 @@ CacheableStringPtr getUAString(int index) {
 
 DUNIT_TASK_DEFINITION(CLIENT1, SetupClient1)
   {
-    initClientWithPool(true, "__TEST_POOL1__", locatorsG, "ServerGroup1",
-                       nullptr, 0, true);
+    initClientWithPool(true, "__TEST_POOL1__", locatorsG, nullptr, nullptr, 0,
+                       true);
     getHelper()->createPooledRegion(regionNames[0], false, locatorsG,
                                     "__TEST_POOL1__", true, true);
   }
@@ -68,8 +68,8 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT2, setupClient2)
   {
-    initClientWithPool(true, "__TEST_POOL1__", locatorsG, "ServerGroup1",
-                       nullptr, 0, true);
+    initClientWithPool(true, "__TEST_POOL1__", locatorsG, nullptr, nullptr, 0,
+                       true);
     getHelper()->createPooledRegion(regionNames[0], false, locatorsG,
                                     "__TEST_POOL1__", true, true);
     RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
@@ -108,7 +108,8 @@ DUNIT_TASK_DEFINITION(CLIENT2, verifyUpdates)
       char buf[1024];
       sprintf(buf, "key[%s] should have been found", keys[index]);
       ASSERT(regPtr->containsKey(keyPtr), buf);
-      auto val = 
std::dynamic_pointer_cast<CacheableString>(regPtr->getEntry(keyPtr)->getValue());
+      auto val = std::dynamic_pointer_cast<CacheableString>(
+          regPtr->getEntry(keyPtr)->getValue());
       ASSERT(strcmp(val->asChar(), nvals[index]) == 0,
              "Incorrect value for key");
     }
@@ -165,7 +166,8 @@ DUNIT_TASK_DEFINITION(CLIENT2, CheckUpdateUnicodeStrings)
     RegionPtr reg0 = getHelper()->getRegion(regionNames[0]);
     for (int index = 0; index < 5; ++index) {
       CacheableStringPtr key = getUString(index);
-      auto val = 
std::dynamic_pointer_cast<CacheableFloat>(reg0->getEntry(key)->getValue());
+      auto val = std::dynamic_pointer_cast<CacheableFloat>(
+          reg0->getEntry(key)->getValue());
       ASSERT(val != nullptr, "expected non-null value in get");
       ASSERT(val->value() == (index + 20.0F), "unexpected value in get");
     }

http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/integration-test/testThinClientInterestNotify.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/testThinClientInterestNotify.cpp 
b/src/cppcache/integration-test/testThinClientInterestNotify.cpp
index 222d979..4d44cc7 100644
--- a/src/cppcache/integration-test/testThinClientInterestNotify.cpp
+++ b/src/cppcache/integration-test/testThinClientInterestNotify.cpp
@@ -269,8 +269,8 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(SERVER_AND_FEEDER, FeederUpAndFeed)
   {
-    initClientWithPool(true, "__TEST_POOL1__", locatorsG, "ServerGroup1",
-                       nullptr, 0, true);
+    initClientWithPool(true, "__TEST_POOL1__", locatorsG, nullptr, nullptr, 0,
+                       true);
     getHelper()->createPooledRegion(regions[0], USE_ACK, locatorsG,
                                     "__TEST_POOL1__", true, true);
     getHelper()->createPooledRegion(regions[1], USE_ACK, locatorsG,

http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/integration-test/testThinClientListenerCallbackArgTest.cpp
----------------------------------------------------------------------
diff --git 
a/src/cppcache/integration-test/testThinClientListenerCallbackArgTest.cpp 
b/src/cppcache/integration-test/testThinClientListenerCallbackArgTest.cpp
index 69fcac2..03312e2 100644
--- a/src/cppcache/integration-test/testThinClientListenerCallbackArgTest.cpp
+++ b/src/cppcache/integration-test/testThinClientListenerCallbackArgTest.cpp
@@ -25,6 +25,11 @@
 #include "TallyWriter.hpp"
 #include "testobject/PdxType.hpp"
 #include "testobject/VariousPdxTypes.hpp"
+
+#include "SerializationRegistry.hpp"
+#include "CacheRegionHelper.hpp"
+#include "CacheImpl.hpp"
+
 #define CLIENT1 s1p1
 #define CLIENT2 s1p2
 #define SERVER1 s2p1
@@ -222,9 +227,9 @@ DUNIT_TASK_DEFINITION(CLIENT1, SetupClient1_Pool_Locator)
 
     createPooledRegion(regionNames[0], false /*ack mode*/, locatorsG,
                        "__TEST_POOL1__", true /*client notification*/);
-
-    Serializable::registerType(Portfolio::createDeserializable);
-    Serializable::registerType(Position::createDeserializable);
+    SerializationRegistryPtr serializationRegistry = 
CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())->getSerializationRegistry();
+    serializationRegistry->addType(Portfolio::createDeserializable);
+    serializationRegistry->addType(Position::createDeserializable);
     reg1Listener1 = std::make_shared<CallbackListener>();
     callBackPortFolioPtr = std::make_shared<Portfolio>(1, 0, nullptr);
 

http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/integration-test/testThinClientListenerEvents.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/testThinClientListenerEvents.cpp 
b/src/cppcache/integration-test/testThinClientListenerEvents.cpp
index 1db1bda..136a830 100644
--- a/src/cppcache/integration-test/testThinClientListenerEvents.cpp
+++ b/src/cppcache/integration-test/testThinClientListenerEvents.cpp
@@ -79,8 +79,8 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, SetupClient1)
   {
-    initClientWithPool(true, "__TEST_POOL1__", locatorsG, "ServerGroup1",
-                       nullptr, 0, true);
+    initClientWithPool(true, "__TEST_POOL1__", locatorsG, nullptr, nullptr, 0,
+                       true);
     getHelper()->createPooledRegion(regionNames[0], false, locatorsG,
                                     "__TEST_POOL1__", true, true);
   }

http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/integration-test/testThinClientLocator.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/testThinClientLocator.cpp 
b/src/cppcache/integration-test/testThinClientLocator.cpp
index 4e73d3f..f5d6e4f 100644
--- a/src/cppcache/integration-test/testThinClientLocator.cpp
+++ b/src/cppcache/integration-test/testThinClientLocator.cpp
@@ -45,8 +45,8 @@ END_TASK(CreateServer12)
 DUNIT_TASK(CLIENT1, StepOne)
   {
     // starting client 1
-    initClientWithPool(true, "__TEST_POOL1__", locHostPort, "ServerGroup1",
-                       nullptr, 0, true);
+    initClientWithPool(true, "__TEST_POOL1__", locHostPort, nullptr, nullptr, 
0,
+                       true);
     getHelper()->createPooledRegion(regionNames[0], USE_ACK, locHostPort,
                                     "__TEST_POOL1__", true, true);
     getHelper()->createPooledRegion(regionNames[1], NO_ACK, locHostPort,
@@ -56,8 +56,8 @@ DUNIT_TASK(CLIENT1, StepOne)
 END_TASK(StepOne)
 DUNIT_TASK(CLIENT2, StepTwo)
   {
-    initClientWithPool(true, "__TEST_POOL1__", locHostPort, "ServerGroup1",
-                       nullptr, 0, true);
+    initClientWithPool(true, "__TEST_POOL1__", locHostPort, nullptr, nullptr, 
0,
+                       true);
     getHelper()->createPooledRegion(regionNames[0], USE_ACK, locHostPort,
                                     "__TEST_POOL1__", true, true);
     getHelper()->createPooledRegion(regionNames[1], NO_ACK, locHostPort,

http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/integration-test/testThinClientMultipleCaches.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/testThinClientMultipleCaches.cpp 
b/src/cppcache/integration-test/testThinClientMultipleCaches.cpp
new file mode 100644
index 0000000..1dfc42d
--- /dev/null
+++ b/src/cppcache/integration-test/testThinClientMultipleCaches.cpp
@@ -0,0 +1,21 @@
+/*
+ * 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.
+ */
+
+#include "ThinClientMultipleCaches.hpp"
+DUNIT_MAIN
+  { run(); }
+END_MAIN

Reply via email to