You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@geode.apache.org by bb...@apache.org on 2020/06/17 20:33:04 UTC

[geode-native] branch develop updated: GEODE-8246: Enforce No Shadow as error (#618)

This is an automated email from the ASF dual-hosted git repository.

bbender pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/geode-native.git


The following commit(s) were added to refs/heads/develop by this push:
     new fb3d8cc  GEODE-8246: Enforce No Shadow as error (#618)
fb3d8cc is described below

commit fb3d8cc572860b5e488446fb2c360db57f91aca4
Author: M. Oleske <mo...@users.noreply.github.com>
AuthorDate: Wed Jun 17 13:32:55 2020 -0700

    GEODE-8246: Enforce No Shadow as error (#618)
    
    - Correct scope of locks, use auto, don't make unnecessary copy
---
 CMakeLists.txt                                     |  2 --
 .../integration-test/ThinClientCallbackArg.hpp     |  8 ++---
 cppcache/integration-test/ThinClientDistOps.hpp    |  7 ++---
 cppcache/integration-test/ThinClientFailover.hpp   |  5 +---
 cppcache/integration-test/ThinClientFailover2.hpp  |  5 +---
 cppcache/integration-test/ThinClientFailover3.hpp  |  5 +---
 .../ThinClientFailoverInterest.hpp                 |  5 +---
 .../ThinClientFailoverInterest2.hpp                |  5 +---
 .../ThinClientFailoverInterestAllWithCache.hpp     |  5 +---
 .../integration-test/ThinClientFailoverRegex.hpp   |  5 +---
 cppcache/integration-test/ThinClientHelper.hpp     | 28 ++++++++----------
 cppcache/integration-test/ThinClientInterest3.hpp  |  8 ++---
 .../ThinClientInterest3Cacheless.hpp               |  8 ++---
 .../integration-test/ThinClientInterestList.hpp    |  9 ++----
 .../integration-test/ThinClientInterestList2.hpp   |  5 +---
 .../integration-test/ThinClientListenerInit.hpp    | 14 ++++-----
 .../integration-test/ThinClientListenerWriter.hpp  |  8 ++---
 .../integration-test/ThinClientNotification.hpp    |  5 +---
 cppcache/integration-test/ThinClientPutAll.hpp     | 19 +++++-------
 .../ThinClientPutAllWithCallBack.hpp               | 11 +++----
 cppcache/integration-test/ThinClientPutGetAll.hpp  | 10 +++----
 .../ThinClientRIwithlocalRegionDestroy.hpp         |  8 ++---
 cppcache/integration-test/ThinClientRegex.hpp      |  5 +---
 cppcache/integration-test/ThinClientRegex2.hpp     |  5 +---
 cppcache/integration-test/ThinClientRegex3.hpp     |  5 +---
 cppcache/integration-test/ThinClientTXFailover.hpp |  6 ++--
 .../integration-test/ThinClientTransactions.hpp    |  6 ++--
 .../integration-test/ThinClientTransactionsXA.hpp  |  6 ++--
 cppcache/integration-test/testThinClientCq.cpp     | 11 +++----
 .../integration-test/testThinClientCqDurable.cpp   | 11 +++----
 .../testThinClientFixedPartitionResolver.cpp       |  9 +++---
 .../integration-test/testThinClientHADistOps.cpp   |  6 ++--
 .../testThinClientHAEventIDMap.cpp                 | 12 +++-----
 .../integration-test/testThinClientHAFailover.cpp  |  6 ++--
 .../testThinClientHAFailoverRegex.cpp              |  6 ++--
 .../testThinClientHAMixedRedundancy.cpp            |  6 ++--
 .../testThinClientHAPeriodicAck.cpp                | 12 +++-----
 .../testThinClientIntResPolKeysInv.cpp             |  6 ++--
 .../testThinClientLRUExpiration.cpp                |  8 ++---
 .../testThinClientPRPutAllFailover.cpp             | 24 +++++++--------
 .../integration-test/testThinClientPRSingleHop.cpp | 30 +++++++++----------
 .../testThinClientPRSingleHopServerGroup.cpp       | 18 ++++++------
 .../testThinClientPoolAttrTest.cpp                 | 34 +++++++++++-----------
 .../testThinClientPutAllPRSingleHop.cpp            |  6 ++--
 .../testThinClientRemoteQuerySS.cpp                |  6 ++--
 .../integration-test/testThinClientRemoveOps.cpp   | 18 +++++-------
 .../testThinClientSecurityAuthorization.cpp        | 14 ++++-----
 .../testThinClientSecurityAuthorizationMU.cpp      | 12 ++++----
 .../testThinClientSecurityPostAuthorization.cpp    | 12 ++++----
 .../testThinClientWriterException.cpp              |  4 +--
 cppcache/integration/test/BasicIPv6Test.cpp        |  8 ++---
 cppcache/integration/test/StructTest.cpp           |  8 ++---
 cppcache/src/ClientMetadataService.cpp             |  6 ++--
 cppcache/src/ExceptionTypes.cpp                    |  2 +-
 cppcache/src/FunctionService.cpp                   |  4 +--
 cppcache/src/LRUList.cpp                           |  4 +--
 cppcache/src/LocalRegion.cpp                       |  1 -
 cppcache/src/Log.cpp                               | 12 ++++----
 cppcache/src/MapSegment.cpp                        |  7 ++---
 cppcache/src/PdxLocalReader.cpp                    |  2 +-
 cppcache/src/SerializationRegistry.hpp             |  5 +---
 cppcache/src/StructSetImpl.cpp                     |  2 +-
 cppcache/src/TcrEndpoint.cpp                       |  5 ++--
 cppcache/src/ThinClientRedundancyManager.cpp       |  6 ++--
 cppcache/src/ThinClientRegion.cpp                  |  8 ++---
 cppcache/src/TransactionalOperation.cpp            |  4 +--
 66 files changed, 244 insertions(+), 329 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 73c50e1..7711923 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -217,7 +217,6 @@ elseif (CMAKE_CXX_COMPILER_ID MATCHES "GNU")
     -Wall
     -Wno-unused-variable #TODO fix
     -Wpedantic
-    # -Wshadow TODO fix
     # -Weffc++ TODO fix
     )
 
@@ -258,7 +257,6 @@ elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
     -Wno-shorten-64-to-32 #TODO fix
     -Wno-conversion #TODO fix
     -Wno-shadow-field-in-constructor #TODO fix
-    -Wno-shadow #TODO fix
     -Wno-missing-variable-declarations #TODO fix
     -Wno-switch-enum #TODO fix
     -Wno-reserved-id-macro #TODO fix
diff --git a/cppcache/integration-test/ThinClientCallbackArg.hpp b/cppcache/integration-test/ThinClientCallbackArg.hpp
index ecf14c0..b298bcd 100644
--- a/cppcache/integration-test/ThinClientCallbackArg.hpp
+++ b/cppcache/integration-test/ThinClientCallbackArg.hpp
@@ -54,17 +54,17 @@ std::shared_ptr<TallyWriter> regWriter;
 #include "LocatorHelper.hpp"
 
 void setCacheListener(const char* regName,
-                      std::shared_ptr<TallyListener> regListener) {
+                      std::shared_ptr<TallyListener> regionTallyListener) {
   auto reg = getHelper()->getRegion(regName);
   auto attrMutator = reg->getAttributesMutator();
-  attrMutator->setCacheListener(regListener);
+  attrMutator->setCacheListener(regionTallyListener);
 }
 
 void setCacheWriter(const char* regName,
-                    std::shared_ptr<TallyWriter> regWriter) {
+                    std::shared_ptr<TallyWriter> regionTallyWriter) {
   auto reg = getHelper()->getRegion(regName);
   auto attrMutator = reg->getAttributesMutator();
-  attrMutator->setCacheWriter(regWriter);
+  attrMutator->setCacheWriter(regionTallyWriter);
 }
 
 void createClientPooledLocatorRegion() {
diff --git a/cppcache/integration-test/ThinClientDistOps.hpp b/cppcache/integration-test/ThinClientDistOps.hpp
index e640766..9b1218e 100644
--- a/cppcache/integration-test/ThinClientDistOps.hpp
+++ b/cppcache/integration-test/ThinClientDistOps.hpp
@@ -149,10 +149,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
           std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
 
       ASSERT(checkPtr != nullptr, "Value Ptr should not be null.");
-      char buf[1024];
-      sprintf(buf, "In verify loop, get returned %s for key %s",
-              checkPtr->value().c_str(), key);
-      LOG(buf);
+      LOG("In verify loop, get returned " + checkPtr->value() + " for key " + key);
       if (strcmp(checkPtr->value().c_str(), value) != 0) {
         testValueCnt++;
       } else {
@@ -255,7 +252,7 @@ void createAndVerifyEntry(const char* name) {
   int64_t int64Key1 = 9223372036854775807LL;
   try {
     regPtr->create(int64Key1, in64Value);
-    auto longRetValue =
+    longRetValue =
         std::dynamic_pointer_cast<CacheableInt64>(regPtr->get(int64Key));
     FAIL("Expected EntryExistException here");
   } catch (EntryExistsException&) {
diff --git a/cppcache/integration-test/ThinClientFailover.hpp b/cppcache/integration-test/ThinClientFailover.hpp
index 044e644..21d2770 100644
--- a/cppcache/integration-test/ThinClientFailover.hpp
+++ b/cppcache/integration-test/ThinClientFailover.hpp
@@ -127,10 +127,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
           std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
 
       ASSERT(checkPtr != nullptr, "Value Ptr should not be null.");
-      char buf[1024];
-      sprintf(buf, "In verify loop, get returned %s for key %s",
-              checkPtr->value().c_str(), key);
-      LOG(buf);
+      LOG("In verify loop, get returned " + checkPtr->value() + " for key " + key);
       if (strcmp(checkPtr->value().c_str(), value) != 0) {
         testValueCnt++;
       } else {
diff --git a/cppcache/integration-test/ThinClientFailover2.hpp b/cppcache/integration-test/ThinClientFailover2.hpp
index 2e7d6ae..094f6bf 100644
--- a/cppcache/integration-test/ThinClientFailover2.hpp
+++ b/cppcache/integration-test/ThinClientFailover2.hpp
@@ -129,10 +129,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
           std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
 
       ASSERT(checkPtr != nullptr, "Value Ptr should not be null.");
-      char buf[1024];
-      sprintf(buf, "In verify loop, get returned %s for key %s",
-              checkPtr->value().c_str(), key);
-      LOG(buf);
+      LOG("In verify loop, get returned " + checkPtr->value() + " for key " + key);
       if (strcmp(checkPtr->value().c_str(), value) != 0) {
         testValueCnt++;
       } else {
diff --git a/cppcache/integration-test/ThinClientFailover3.hpp b/cppcache/integration-test/ThinClientFailover3.hpp
index 6afd278..7de886f 100644
--- a/cppcache/integration-test/ThinClientFailover3.hpp
+++ b/cppcache/integration-test/ThinClientFailover3.hpp
@@ -126,10 +126,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
           std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
 
       ASSERT(checkPtr != nullptr, "Value Ptr should not be null.");
-      char buf[1024];
-      sprintf(buf, "In verify loop, get returned %s for key %s",
-              checkPtr->value().c_str(), key);
-      LOG(buf);
+      LOG("In verify loop, get returned " + checkPtr->value() + " for key " + key);
       if (strcmp(checkPtr->value().c_str(), value) != 0) {
         testValueCnt++;
       } else {
diff --git a/cppcache/integration-test/ThinClientFailoverInterest.hpp b/cppcache/integration-test/ThinClientFailoverInterest.hpp
index 7e13dad..e4c93b0 100644
--- a/cppcache/integration-test/ThinClientFailoverInterest.hpp
+++ b/cppcache/integration-test/ThinClientFailoverInterest.hpp
@@ -143,10 +143,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
             std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
 
         ASSERT(checkPtr != nullptr, "Value Ptr should not be null.");
-        char buf[1024];
-        sprintf(buf, "In verify loop, get returned %s for key %s",
-                checkPtr->value().c_str(), key);
-        LOG(buf);
+        LOG("In verify loop, get returned " + checkPtr->value() + " for key " + key);
         if (strcmp(checkPtr->value().c_str(), value) != 0) {
           testValueCnt++;
         } else {
diff --git a/cppcache/integration-test/ThinClientFailoverInterest2.hpp b/cppcache/integration-test/ThinClientFailoverInterest2.hpp
index 8e44071..f8e5593 100644
--- a/cppcache/integration-test/ThinClientFailoverInterest2.hpp
+++ b/cppcache/integration-test/ThinClientFailoverInterest2.hpp
@@ -142,10 +142,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
             std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
 
         ASSERT(checkPtr != nullptr, "Value Ptr should not be null.");
-        char buf[1024];
-        sprintf(buf, "In verify loop, get returned %s for key %s",
-                checkPtr->value().c_str(), key);
-        LOG(buf);
+        LOG("In verify loop, get returned " + checkPtr->value() + " for key " + key);
         if (strcmp(checkPtr->value().c_str(), value) != 0) {
           testValueCnt++;
         } else {
diff --git a/cppcache/integration-test/ThinClientFailoverInterestAllWithCache.hpp b/cppcache/integration-test/ThinClientFailoverInterestAllWithCache.hpp
index a7fb8ee..a0b6bbc 100644
--- a/cppcache/integration-test/ThinClientFailoverInterestAllWithCache.hpp
+++ b/cppcache/integration-test/ThinClientFailoverInterestAllWithCache.hpp
@@ -147,10 +147,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
             std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
 
         ASSERT(checkPtr != nullptr, "Value Ptr should not be null.");
-        char buf[1024];
-        sprintf(buf, "In verify loop, get returned %s for key %s",
-                checkPtr->value().c_str(), key);
-        LOG(buf);
+        LOG("In verify loop, get returned " + checkPtr->value() + " for key " + key);
         if (strcmp(checkPtr->value().c_str(), value) != 0) {
           testValueCnt++;
         } else {
diff --git a/cppcache/integration-test/ThinClientFailoverRegex.hpp b/cppcache/integration-test/ThinClientFailoverRegex.hpp
index 88cb005..b1ed8c7 100644
--- a/cppcache/integration-test/ThinClientFailoverRegex.hpp
+++ b/cppcache/integration-test/ThinClientFailoverRegex.hpp
@@ -143,10 +143,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
             std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
 
         ASSERT(checkPtr != nullptr, "Value Ptr should not be null.");
-        char buf[1024];
-        sprintf(buf, "In verify loop, get returned %s for key %s",
-                checkPtr->value().c_str(), key);
-        LOG(buf);
+        LOG("In verify loop, get returned " + checkPtr->value() + " for key " + key);
         if (strcmp(checkPtr->value().c_str(), value) != 0) {
           testValueCnt++;
         } else {
diff --git a/cppcache/integration-test/ThinClientHelper.hpp b/cppcache/integration-test/ThinClientHelper.hpp
index 74b5eb1..409e5d5 100644
--- a/cppcache/integration-test/ThinClientHelper.hpp
+++ b/cppcache/integration-test/ThinClientHelper.hpp
@@ -199,10 +199,8 @@ void _verifyEntry(const std::string& name, const char* key, const char* val,
           std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
 
       ASSERT(checkPtr != nullptr, "Value Ptr should not be null.");
-      char buf[1024];
-      sprintf(buf, "In verify loop, get returned %s for key %s",
-              checkPtr->value().c_str(), key);
-      LOG(buf);
+      LOG("In verify loop, get returned " + checkPtr->value() + " for key " + key);
+
       if (strcmp(checkPtr->value().c_str(), value) != 0) {
         testValueCnt++;
       } else {
@@ -319,10 +317,8 @@ void _verifyIntEntry(const char* name, const char* key, const int val,
             std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(keyPtr));
 
         ASSERT(checkPtr != nullptr, "Value Ptr should not be null.");
-        char buf[1024];
-        sprintf(buf, "In verify loop, get returned %d for key %s",
-                checkPtr->value(), key);
-        LOG(buf);
+        LOG("In verify loop, get returned " + std::to_string(checkPtr->value()) + " for key " + key);
+
         if (checkPtr->value() != value) {
           testValueCnt++;
         } else {
@@ -646,11 +642,11 @@ class RegionOperations {
   explicit RegionOperations(const char* name)
       : m_regionPtr(getHelper()->getRegion(name)) {}
 
-  void putOp(int keys = 1,
+  void putOp(int keysMax = 1,
              const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) {
     char keybuf[100];
     char valbuf[100];
-    for (int i = 1; i <= keys; i++) {
+    for (int i = 1; i <= keysMax; i++) {
       sprintf(keybuf, "key%d", i);
       sprintf(valbuf, "value%d", i);
       auto valPtr = CacheableString::create(valbuf);
@@ -658,33 +654,33 @@ class RegionOperations {
     }
   }
   void invalidateOp(
-      int keys = 1,
+      int keysMax = 1,
       const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) {
     char keybuf[100];
     char valbuf[100] = {0};
-    for (int i = 1; i <= keys; i++) {
+    for (int i = 1; i <= keysMax; i++) {
       sprintf(keybuf, "key%d", i);
       auto valPtr = CacheableString::create(valbuf);
       m_regionPtr->localInvalidate(keybuf, aCallbackArgument);
     }
   }
   void destroyOp(
-      int keys = 1,
+      int keysMax = 1,
       const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) {
     char keybuf[100];
     char valbuf[100] = {0};
-    for (int i = 1; i <= keys; i++) {
+    for (int i = 1; i <= keysMax; i++) {
       sprintf(keybuf, "key%d", i);
       auto valPtr = CacheableString::create(valbuf);
       m_regionPtr->destroy(keybuf, aCallbackArgument);
     }
   }
   void removeOp(
-      int keys = 1,
+      int keysMax = 1,
       const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) {
     char keybuf[100];
     char valbuf[100] = {0};
-    for (int i = 1; i <= keys; i++) {
+    for (int i = 1; i <= keysMax; i++) {
       sprintf(keybuf, "key%d", i);
       sprintf(valbuf, "value%d", i);
       auto valPtr = CacheableString::create(valbuf);
diff --git a/cppcache/integration-test/ThinClientInterest3.hpp b/cppcache/integration-test/ThinClientInterest3.hpp
index 5bea095..2be8310 100644
--- a/cppcache/integration-test/ThinClientInterest3.hpp
+++ b/cppcache/integration-test/ThinClientInterest3.hpp
@@ -111,10 +111,10 @@ DUNIT_TASK_DEFINITION(CLIENT1, testCreatesAndUpdates)
     auto regPtr = getHelper()->getRegion(regionNames[0]);
     auto keyPtr1 = CacheableKey::create(keys[1]);
     auto keyPtr2 = CacheableKey::create(keys[2]);
-    std::vector<std::shared_ptr<CacheableKey>> keys;
-    keys.push_back(keyPtr1);
-    keys.push_back(keyPtr2);
-    regPtr->registerKeys(keys);
+    std::vector<std::shared_ptr<CacheableKey>> keysVector;
+    keysVector.push_back(keyPtr1);
+    keysVector.push_back(keyPtr2);
+    regPtr->registerKeys(keysVector);
 
     // Do a create followed by a create on the same key
     /*NIL: Changed the asserion due to the change in invalidate.
diff --git a/cppcache/integration-test/ThinClientInterest3Cacheless.hpp b/cppcache/integration-test/ThinClientInterest3Cacheless.hpp
index cda7362..7c773cd 100644
--- a/cppcache/integration-test/ThinClientInterest3Cacheless.hpp
+++ b/cppcache/integration-test/ThinClientInterest3Cacheless.hpp
@@ -112,10 +112,10 @@ DUNIT_TASK_DEFINITION(CLIENT1, testCreatesAndUpdates)
     auto regPtr = getHelper()->getRegion(regionNames[0]);
     auto keyPtr1 = CacheableKey::create(keys[1]);
     auto keyPtr2 = CacheableKey::create(keys[2]);
-    std::vector<std::shared_ptr<CacheableKey>> keys;
-    keys.push_back(keyPtr1);
-    keys.push_back(keyPtr2);
-    regPtr->registerKeys(keys);
+    std::vector<std::shared_ptr<CacheableKey>> keysVector;
+    keysVector.push_back(keyPtr1);
+    keysVector.push_back(keyPtr2);
+    regPtr->registerKeys(keysVector);
 
     regPtr->create(keyPtr1, vals[1]);
     numCreates++;
diff --git a/cppcache/integration-test/ThinClientInterestList.hpp b/cppcache/integration-test/ThinClientInterestList.hpp
index 59a68f8..b29f77c 100644
--- a/cppcache/integration-test/ThinClientInterestList.hpp
+++ b/cppcache/integration-test/ThinClientInterestList.hpp
@@ -140,10 +140,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
             std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
 
         ASSERT(checkPtr != nullptr, "Value Ptr should not be null.");
-        char buf[1024];
-        sprintf(buf, "In verify loop, get returned %s for key %s",
-                checkPtr->value().c_str(), key);
-        LOG(buf);
+        LOG("In verify loop, get returned " + checkPtr->value() + " for key " + key);
         if (strcmp(checkPtr->value().c_str(), value) != 0) {
           testValueCnt++;
         } else {
@@ -187,7 +184,7 @@ void _verifyCreated(const char* name, const char* key, int line) {
   LOG("Entry created.");
 }
 
-void createPooledRegion(const char* name, bool ackMode, const char* locatorsG,
+void createPooledRegion(const char* name, bool ackMode, const char* locators,
                         const char* poolname,
                         bool clientNotificationEnabled = false,
                         bool cachingEnable = true) {
@@ -195,7 +192,7 @@ void createPooledRegion(const char* name, bool ackMode, const char* locatorsG,
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
   auto regPtr =
-      getHelper()->createPooledRegion(name, ackMode, locatorsG, poolname,
+      getHelper()->createPooledRegion(name, ackMode, locators, poolname,
                                       cachingEnable, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
   LOG("Pooled Region created.");
diff --git a/cppcache/integration-test/ThinClientInterestList2.hpp b/cppcache/integration-test/ThinClientInterestList2.hpp
index 5c665c6..4cfeb4d 100644
--- a/cppcache/integration-test/ThinClientInterestList2.hpp
+++ b/cppcache/integration-test/ThinClientInterestList2.hpp
@@ -141,10 +141,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
             std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
 
         ASSERT(checkPtr != nullptr, "Value Ptr should not be null.");
-        char buf[1024];
-        sprintf(buf, "In verify loop, get returned %s for key %s",
-                checkPtr->value().c_str(), key);
-        LOG(buf);
+        LOG("In verify loop, get returned " + checkPtr->value() + " for key " + key);
         if (strcmp(checkPtr->value().c_str(), value) != 0) {
           testValueCnt++;
         } else {
diff --git a/cppcache/integration-test/ThinClientListenerInit.hpp b/cppcache/integration-test/ThinClientListenerInit.hpp
index 02f53d1..9c27983 100644
--- a/cppcache/integration-test/ThinClientListenerInit.hpp
+++ b/cppcache/integration-test/ThinClientListenerInit.hpp
@@ -145,9 +145,9 @@ DUNIT_TASK_DEFINITION(CLIENT1, testLoaderAndWriter)
   {
     auto regPtr = getHelper()->getRegion(regionNames[0]);
     auto keyPtr = CacheableKey::create(keys[0]);
-    std::vector<std::shared_ptr<CacheableKey>> keys;
-    keys.push_back(keyPtr);
-    regPtr->registerKeys(keys);
+    std::vector<std::shared_ptr<CacheableKey>> keysVector;
+    keysVector.push_back(keyPtr);
+    regPtr->registerKeys(keysVector);
 
     /*NIL: Changed the asserion due to the change in invalidate.
       Now we create new entery for every invalidate event received or
@@ -174,10 +174,10 @@ DUNIT_TASK_DEFINITION(CLIENT1, testCreatesAndUpdates)
     auto regPtr = getHelper()->getRegion(regionNames[0]);
     auto keyPtr1 = CacheableKey::create(keys[1]);
     auto keyPtr2 = CacheableKey::create(keys[2]);
-    std::vector<std::shared_ptr<CacheableKey>> keys;
-    keys.push_back(keyPtr1);
-    keys.push_back(keyPtr2);
-    regPtr->registerKeys(keys);
+    std::vector<std::shared_ptr<CacheableKey>> keysVector;
+    keysVector.push_back(keyPtr1);
+    keysVector.push_back(keyPtr2);
+    regPtr->registerKeys(keysVector);
 
     // Do a create followed by a create on the same key
     /*NIL: Changed the asserion due to the change in invalidate.
diff --git a/cppcache/integration-test/ThinClientListenerWriter.hpp b/cppcache/integration-test/ThinClientListenerWriter.hpp
index 8f53c65..f96e43d 100644
--- a/cppcache/integration-test/ThinClientListenerWriter.hpp
+++ b/cppcache/integration-test/ThinClientListenerWriter.hpp
@@ -135,17 +135,17 @@ std::shared_ptr<TallyWriter> regWriter;
 const char* myRegNames[] = {"DistRegionAck", "DistRegionNoAck", "ExampleRegion",
                             "SubRegion1", "SubRegion2"};
 void setCacheListener(const char* regName,
-                      std::shared_ptr<TallyListener> regListener) {
+                      std::shared_ptr<TallyListener> regionTallyListener) {
   auto reg = getHelper()->getRegion(regName);
   auto attrMutator = reg->getAttributesMutator();
-  attrMutator->setCacheListener(regListener);
+  attrMutator->setCacheListener(regionTallyListener);
 }
 
 void setCacheWriter(const char* regName,
-                    std::shared_ptr<TallyWriter> regWriter) {
+                    std::shared_ptr<TallyWriter> regionTallyWriter) {
   auto reg = getHelper()->getRegion(regName);
   auto attrMutator = reg->getAttributesMutator();
-  attrMutator->setCacheWriter(regWriter);
+  attrMutator->setCacheWriter(regionTallyWriter);
 }
 
 void validateEvents() {
diff --git a/cppcache/integration-test/ThinClientNotification.hpp b/cppcache/integration-test/ThinClientNotification.hpp
index 8e66631..84a7b5e 100644
--- a/cppcache/integration-test/ThinClientNotification.hpp
+++ b/cppcache/integration-test/ThinClientNotification.hpp
@@ -124,10 +124,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
           std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
 
       ASSERT(checkPtr != nullptr, "Value Ptr should not be null.");
-      char buf[1024];
-      sprintf(buf, "In verify loop, get returned %s for key %s",
-              checkPtr->value().c_str(), key);
-      LOG(buf);
+      LOG("In verify loop, get returned " + checkPtr->value() + " for key " + key);
       if (strcmp(checkPtr->value().c_str(), value) != 0) {
         testValueCnt++;
       } else {
diff --git a/cppcache/integration-test/ThinClientPutAll.hpp b/cppcache/integration-test/ThinClientPutAll.hpp
index 505fd11..0724fd9 100644
--- a/cppcache/integration-test/ThinClientPutAll.hpp
+++ b/cppcache/integration-test/ThinClientPutAll.hpp
@@ -156,10 +156,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
             std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
 
         ASSERT(checkPtr != nullptr, "Value Ptr should not be null.");
-        char buf[1024];
-        sprintf(buf, "In verify loop, get returned %s for key %s",
-                checkPtr->value().c_str(), key);
-        LOG(buf);
+        LOG("In verify loop, get returned " + checkPtr->value() + " for key " + key);
         if (strcmp(checkPtr->value().c_str(), value) != 0) {
           testValueCnt++;
         } else {
@@ -650,17 +647,17 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepThirteen)
              "putAll entry with long key and long value Mismatch.");
     }
     map0.clear();
-    const char* vals[] = {"Value-100", "Value-200"};
+    const char* testValues[] = {"Value-100", "Value-200"};
 
     for (int i = 80; i < 82; i++) {
       map0.emplace(CacheableInt64::create(i),
-                   CacheableString::create(vals[i - 80]));
+                   CacheableString::create(testValues[i - 80]));
     }
     regPtr0->putAll(map0);
     for (int i = 80; i < 82; i++) {
       auto checkPtr = std::dynamic_pointer_cast<CacheableString>(
           regPtr0->get(CacheableInt64::create(i)));
-      ASSERT(strcmp(checkPtr->value().c_str(), vals[i - 80]) == 0,
+      ASSERT(strcmp(checkPtr->value().c_str(), testValues[i - 80]) == 0,
              "putAll entry with long key and string value  Mismatch");
     }
     map0.clear();
@@ -705,9 +702,9 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepThirteen)
       map0.emplace(CacheableInt64::create(345),
                    CacheableInt64::create(3465987));
       regPtr0->putAll(map0, std::chrono::seconds(-1));
-      auto checkPtr = std::dynamic_pointer_cast<CacheableInt64>(
+      auto check = std::dynamic_pointer_cast<CacheableInt64>(
           regPtr0->get(CacheableInt64::create(345)));
-      ASSERT(checkPtr->value() == 3465987,
+      ASSERT(check->value() == 3465987,
              "putAll entry with long key and long value Mismatch.");
     } catch (Exception& excp) {
       std::string logmsg = "";
@@ -723,9 +720,9 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepThirteen)
       map0.emplace(CacheableInt64::create(3451),
                    CacheableInt64::create(3465987));
       regPtr0->putAll(map0, std::chrono::seconds(2147500));
-      auto checkPtr = std::dynamic_pointer_cast<CacheableInt64>(
+      auto check = std::dynamic_pointer_cast<CacheableInt64>(
           regPtr0->get(CacheableInt64::create(3451)));
-      ASSERT(checkPtr->value() == 3465987,
+      ASSERT(check->value() == 3465987,
              "putAll entry with long key and long value Mismatch.");
     } catch (Exception& excp) {
       std::string logmsg = "";
diff --git a/cppcache/integration-test/ThinClientPutAllWithCallBack.hpp b/cppcache/integration-test/ThinClientPutAllWithCallBack.hpp
index e9fd8ae..005dd1d 100644
--- a/cppcache/integration-test/ThinClientPutAllWithCallBack.hpp
+++ b/cppcache/integration-test/ThinClientPutAllWithCallBack.hpp
@@ -154,10 +154,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
             std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
 
         ASSERT(checkPtr != nullptr, "Value Ptr should not be null.");
-        char buf[1024];
-        sprintf(buf, "In verify loop, get returned %s for key %s",
-                checkPtr->value().c_str(), key);
-        LOG(buf);
+        LOG("In verify loop, get returned " + checkPtr->value() + " for key " + key);
         if (strcmp(checkPtr->value().c_str(), value) != 0) {
           testValueCnt++;
         } else {
@@ -659,18 +656,18 @@ DUNIT_TASK_DEFINITION(CLIENT1, VerifyPutAllWithLongKeyAndStringValue)
              "putAll entry with long key and long value Mismatch.");
     }
     map0.clear();
-    const char* vals[] = {"Value-100", "Value-200"};
+    const char* customVals[] = {"Value-100", "Value-200"};
 
     for (int i = 80; i < 82; i++) {
       map0.emplace(CacheableInt64::create(i),
-                   CacheableString::create(vals[i - 80]));
+                   CacheableString::create(customVals[i - 80]));
     }
     regPtr0->putAll(map0, std::chrono::seconds(15),
                     CacheableInt32::create(1000));
     for (int i = 80; i < 82; i++) {
       auto checkPtr = std::dynamic_pointer_cast<CacheableString>(
           regPtr0->get(CacheableInt64::create(i)));
-      ASSERT(strcmp(checkPtr->value().c_str(), vals[i - 80]) == 0,
+      ASSERT(strcmp(checkPtr->value().c_str(), customVals[i - 80]) == 0,
              "putAll entry with long key and string value  Mismatch");
     }
 
diff --git a/cppcache/integration-test/ThinClientPutGetAll.hpp b/cppcache/integration-test/ThinClientPutGetAll.hpp
index 0cf950b..f1def7d 100644
--- a/cppcache/integration-test/ThinClientPutGetAll.hpp
+++ b/cppcache/integration-test/ThinClientPutGetAll.hpp
@@ -71,7 +71,7 @@ const char* _regionNames[] = {"DistRegionAck"};
 
 #include "LocatorHelper.hpp"
 
-void verifyGetAll(std::shared_ptr<Region> region, const char** _vals,
+void verifyGetAll(std::shared_ptr<Region> region, const char** _values,
                   int startIndex,
                   std::shared_ptr<Cacheable> callBack = nullptr) {
   auto keyPtr0 = CacheableKey::create(_keys[0]);
@@ -84,8 +84,8 @@ void verifyGetAll(std::shared_ptr<Region> region, const char** _vals,
   keys1.push_back(keyPtr2);
 
   std::unordered_map<std::string, std::string> expected;
-  expected[_keys[0]] = _vals[startIndex + 0];
-  expected[_keys[1]] = _vals[startIndex + 1];
+  expected[_keys[0]] = _values[startIndex + 0];
+  expected[_keys[1]] = _values[startIndex + 1];
 
   auto valuesMap = region->getAll(keys1, callBack);
   if (valuesMap.size() == keys1.size()) {
@@ -110,9 +110,9 @@ void verifyGetAll(std::shared_ptr<Region> region, const char** _vals,
 }
 
 void verifyGetAllWithCallBackArg(std::shared_ptr<Region> region,
-                                 const char** vals, int startIndex,
+                                 const char** values, int startIndex,
                                  std::shared_ptr<Cacheable> callBack) {
-  verifyGetAll(region, vals, startIndex, callBack);
+  verifyGetAll(region, values, startIndex, callBack);
 }
 
 void createPooledRegion(const char* name, bool ackMode, const char* locators,
diff --git a/cppcache/integration-test/ThinClientRIwithlocalRegionDestroy.hpp b/cppcache/integration-test/ThinClientRIwithlocalRegionDestroy.hpp
index 29d96d1..f3e8c0d 100644
--- a/cppcache/integration-test/ThinClientRIwithlocalRegionDestroy.hpp
+++ b/cppcache/integration-test/ThinClientRIwithlocalRegionDestroy.hpp
@@ -206,10 +206,10 @@ DUNIT_TASK_DEFINITION(CLIENT1, registerKeysOnRegion)
     regPtr1->registerRegex(testregex[1]);*/
 
     // NIL
-    std::vector<std::shared_ptr<CacheableKey>> keys;
-    keys.push_back(CacheableString::create("Key-1"));
-    keys.push_back(CacheableString::create("Key-2"));
-    regPtr0->registerKeys(keys, false);
+    std::vector<std::shared_ptr<CacheableKey>> keysVector;
+    keysVector.push_back(CacheableString::create("Key-1"));
+    keysVector.push_back(CacheableString::create("Key-2"));
+    regPtr0->registerKeys(keysVector, false);
     LOGINFO("NIL CLIENT-1 registerAllKeys() done ");
 
     regPtr0->localDestroyRegion();
diff --git a/cppcache/integration-test/ThinClientRegex.hpp b/cppcache/integration-test/ThinClientRegex.hpp
index 0b1818f..88aa0af 100644
--- a/cppcache/integration-test/ThinClientRegex.hpp
+++ b/cppcache/integration-test/ThinClientRegex.hpp
@@ -140,10 +140,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
             std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
 
         ASSERT(checkPtr != nullptr, "Value Ptr should not be null.");
-        char buf[1024];
-        sprintf(buf, "In verify loop, get returned %s for key %s",
-                checkPtr->value().c_str(), key);
-        LOG(buf);
+        LOG("In verify loop, get returned " + checkPtr->value() + " for key " + key);
         if (strcmp(checkPtr->value().c_str(), value) != 0) {
           testValueCnt++;
         } else {
diff --git a/cppcache/integration-test/ThinClientRegex2.hpp b/cppcache/integration-test/ThinClientRegex2.hpp
index 26ccb2e..14b6a6f 100644
--- a/cppcache/integration-test/ThinClientRegex2.hpp
+++ b/cppcache/integration-test/ThinClientRegex2.hpp
@@ -141,10 +141,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
             std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
 
         ASSERT(checkPtr != nullptr, "Value Ptr should not be null.");
-        char buf[1024];
-        sprintf(buf, "In verify loop, get returned %s for key %s",
-                checkPtr->value().c_str(), key);
-        LOG(buf);
+        LOG("In verify loop, get returned " + checkPtr->value() + " for key " + key);
         if (strcmp(checkPtr->value().c_str(), value) != 0) {
           testValueCnt++;
         } else {
diff --git a/cppcache/integration-test/ThinClientRegex3.hpp b/cppcache/integration-test/ThinClientRegex3.hpp
index 5f5f7ac..865c30d 100644
--- a/cppcache/integration-test/ThinClientRegex3.hpp
+++ b/cppcache/integration-test/ThinClientRegex3.hpp
@@ -149,10 +149,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
             std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
 
         ASSERT(checkPtr != nullptr, "Value Ptr should not be null.");
-        char buf[1024];
-        sprintf(buf, "In verify loop, get returned %s for key %s",
-                checkPtr->value().c_str(), key);
-        LOG(buf);
+        LOG("In verify loop, get returned " + checkPtr->value() + " for key " + key);
         if (strcmp(checkPtr->value().c_str(), value) != 0) {
           testValueCnt++;
         } else {
diff --git a/cppcache/integration-test/ThinClientTXFailover.hpp b/cppcache/integration-test/ThinClientTXFailover.hpp
index 52001a4..4233c72 100644
--- a/cppcache/integration-test/ThinClientTXFailover.hpp
+++ b/cppcache/integration-test/ThinClientTXFailover.hpp
@@ -128,10 +128,8 @@ void _verifyEntry(const char* name, const char* key, const char* val,
           std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
 
       ASSERT(checkPtr != nullptr, "Value Ptr should not be null.");
-      char buf[1024];
-      sprintf(buf, "In verify loop, get returned %s for key %s",
-              checkPtr->value().c_str(), key);
-      LOG(buf);
+      LOG("In verify loop, get returned " + checkPtr->value() + " for key " + key);
+
       if (strcmp(checkPtr->value().c_str(), value) != 0) {
         testValueCnt++;
       } else {
diff --git a/cppcache/integration-test/ThinClientTransactions.hpp b/cppcache/integration-test/ThinClientTransactions.hpp
index 76e13ac..2e4bec6 100644
--- a/cppcache/integration-test/ThinClientTransactions.hpp
+++ b/cppcache/integration-test/ThinClientTransactions.hpp
@@ -144,10 +144,8 @@ void _verifyEntry(const char* name, const char* key, const char* val,
           std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
 
       ASSERT(checkPtr != nullptr, "Value Ptr should not be null.");
-      char buf[1024];
-      sprintf(buf, "In verify loop, get returned %s for key %s",
-              checkPtr->value().c_str(), key);
-      LOG(buf);
+      LOG("In verify loop, get returned " + checkPtr->value() + " for key " + key);
+
       if (strcmp(checkPtr->value().c_str(), value) != 0) {
         testValueCnt++;
       } else {
diff --git a/cppcache/integration-test/ThinClientTransactionsXA.hpp b/cppcache/integration-test/ThinClientTransactionsXA.hpp
index 24e9522..84fa784 100644
--- a/cppcache/integration-test/ThinClientTransactionsXA.hpp
+++ b/cppcache/integration-test/ThinClientTransactionsXA.hpp
@@ -145,10 +145,8 @@ void _verifyEntry(const char* name, const char* key, const char* val,
           std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
 
       ASSERT(checkPtr != nullptr, "Value Ptr should not be null.");
-      char buf[1024];
-      sprintf(buf, "In verify loop, get returned %s for key %s",
-              checkPtr->value().c_str(), key);
-      LOG(buf);
+      LOG("In verify loop, get returned " + checkPtr->value() + " for key " + key);
+
       if (strcmp(checkPtr->value().c_str(), value) != 0) {
         testValueCnt++;
       } else {
diff --git a/cppcache/integration-test/testThinClientCq.cpp b/cppcache/integration-test/testThinClientCq.cpp
index 258d847..3060f13 100644
--- a/cppcache/integration-test/testThinClientCq.cpp
+++ b/cppcache/integration-test/testThinClientCq.cpp
@@ -968,14 +968,15 @@ DUNIT_TASK_DEFINITION(CLIENT1, checkCQStatusOnConnect_Pool)
   }
 END_TASK_DEFINITION
 
-void checkCQStatusOnDisConnect(const char *poolName, const char *cqName,
+void checkCQStatusOnDisConnect(const char *poolName,
+                               const char *continuousQueryName,
                                uint32_t disconnect) {
   auto pool = getHelper()->getCache()->getPoolManager().find(poolName);
   std::shared_ptr<QueryService> qs;
   if (pool != nullptr) {
     qs = pool->getQueryService();
   }
-  auto cq = qs->getCq(const_cast<char *>(cqName));
+  auto cq = qs->getCq(const_cast<char *>(continuousQueryName));
   auto cqAttr = cq->getCqAttributes();
   auto vl = cqAttr->getCqListeners();
   auto myStatusCq = std::dynamic_pointer_cast<MyCqStatusListener>(vl[0]);
@@ -1038,14 +1039,14 @@ DUNIT_TASK_DEFINITION(CLIENT1, putEntries)
   }
 END_TASK_DEFINITION
 
-void checkCQStatusOnPutEvent(const char *poolName, const char *cqName,
-                             uint32_t count) {
+void checkCQStatusOnPutEvent(const char *poolName,
+                             const char *continuousQueryName, uint32_t count) {
   auto pool = getHelper()->getCache()->getPoolManager().find(poolName);
   std::shared_ptr<QueryService> qs;
   if (pool != nullptr) {
     qs = pool->getQueryService();
   }
-  auto cq = qs->getCq(const_cast<char *>(cqName));
+  auto cq = qs->getCq(const_cast<char *>(continuousQueryName));
   auto cqAttr = cq->getCqAttributes();
   auto vl = cqAttr->getCqListeners();
   MyCqStatusListener *myStatusCq =
diff --git a/cppcache/integration-test/testThinClientCqDurable.cpp b/cppcache/integration-test/testThinClientCqDurable.cpp
index 66715ea..74038c9 100644
--- a/cppcache/integration-test/testThinClientCqDurable.cpp
+++ b/cppcache/integration-test/testThinClientCqDurable.cpp
@@ -641,30 +641,31 @@ DUNIT_TASK_DEFINITION(CLIENT1, UnsetPortfolioTypeToPdx)
   { m_isPdx = false; }
 END_TASK_DEFINITION
 
-bool isDurableCQName(const char *cqName, int clientID, bool isRecycled) {
+bool isDurableCQName(const char *continuousQueryName, int clientID,
+                     bool isRecycled) {
   bool bRetVal = false;
   int i = 0;
   if (clientID == 1) {
     if (!isRecycled) {
       for (i = 0; i < 4; i++) {
-        if (strcmp(cqName, durableCQNamesClient1[i]) == 0) break;
+        if (strcmp(continuousQueryName, durableCQNamesClient1[i]) == 0) break;
       }
       if (i < 4) bRetVal = true;
     } else {
       for (i = 0; i < 8; i++) {
-        if (strcmp(cqName, durableCQNamesClient1[i]) == 0) break;
+        if (strcmp(continuousQueryName, durableCQNamesClient1[i]) == 0) break;
       }
       if (i < 8) bRetVal = true;
     }
   } else if (clientID == 2) {
     if (!isRecycled) {
       for (i = 0; i < 4; i++) {
-        if (strcmp(cqName, durableCQNamesClient2[i]) == 0) break;
+        if (strcmp(continuousQueryName, durableCQNamesClient2[i]) == 0) break;
       }
       if (i < 4) bRetVal = true;
     } else {
       for (i = 0; i < 8; i++) {
-        if (strcmp(cqName, durableCQNamesClient2[i]) == 0) break;
+        if (strcmp(continuousQueryName, durableCQNamesClient2[i]) == 0) break;
       }
       if (i < 8) bRetVal = true;
     }
diff --git a/cppcache/integration-test/testThinClientFixedPartitionResolver.cpp b/cppcache/integration-test/testThinClientFixedPartitionResolver.cpp
index e870386..784022e 100644
--- a/cppcache/integration-test/testThinClientFixedPartitionResolver.cpp
+++ b/cppcache/integration-test/testThinClientFixedPartitionResolver.cpp
@@ -342,13 +342,13 @@ DUNIT_TASK_DEFINITION(CLIENT1, CheckPrSingleHopForIntKeysTask_REGION)
     LOG("CheckPrSingleHopForIntKeysTask_REGION get completed.");
 
     for (int i = 1000; i < 2000; i++) {
-      std::vector<std::shared_ptr<CacheableKey>> keys;
+      std::vector<std::shared_ptr<CacheableKey>> keysVector;
       for (int j = i; j < i + 5; j++) {
-        keys.push_back(CacheableInt32::create(j));
+        keysVector.push_back(CacheableInt32::create(j));
       }
 
       try {
-        const auto values = dataReg->getAll(keys);
+        const auto values = dataReg->getAll(keysVector);
         bool networkhop = TestUtils::getCacheImpl(getHelper()->cachePtr)
                               ->getAndResetNetworkHopFlag();
         ASSERT(values.size() == 5, "number of value size should be 5");
@@ -380,7 +380,8 @@ DUNIT_TASK_DEFINITION(CLIENT1, CheckPrSingleHopForIntKeysTask_REGION)
       }
 
       try {
-        const auto values = dataReg->getAll(keys, CacheableInt32::create(1000));
+        const auto values =
+            dataReg->getAll(keysVector, CacheableInt32::create(1000));
         bool networkhop = TestUtils::getCacheImpl(getHelper()->cachePtr)
                               ->getAndResetNetworkHopFlag();
         ASSERT(values.size() == 5, "number of value size should be 5");
diff --git a/cppcache/integration-test/testThinClientHADistOps.cpp b/cppcache/integration-test/testThinClientHADistOps.cpp
index 918a120..92f557b 100644
--- a/cppcache/integration-test/testThinClientHADistOps.cpp
+++ b/cppcache/integration-test/testThinClientHADistOps.cpp
@@ -149,10 +149,8 @@ void _verifyEntry(const char *name, const char *key, const char *val,
           std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
 
       ASSERT(checkPtr != nullptr, "Value Ptr should not be null.");
-      char buf[1024];
-      sprintf(buf, "In verify loop, get returned %s for key %s",
-              checkPtr->value().c_str(), key);
-      LOG(buf);
+      LOG("In verify loop, get returned " + checkPtr->value() + " for key " +
+          key);
       if (strcmp(checkPtr->value().c_str(), value) != 0) {
         testValueCnt++;
       } else {
diff --git a/cppcache/integration-test/testThinClientHAEventIDMap.cpp b/cppcache/integration-test/testThinClientHAEventIDMap.cpp
index 963ffe6..f294fec 100644
--- a/cppcache/integration-test/testThinClientHAEventIDMap.cpp
+++ b/cppcache/integration-test/testThinClientHAEventIDMap.cpp
@@ -196,10 +196,8 @@ void _verifyEntry(const char *name, const char *key, const char *val,
             std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
 
         ASSERT(checkPtr != nullptr, "Value Ptr should not be null.");
-        char buf[1024];
-        sprintf(buf, "In verify loop, get returned %s for key %s",
-                checkPtr->value().c_str(), key);
-        LOG(buf);
+        LOG("In verify loop, get returned " + checkPtr->value() + " for key " +
+            key);
         if (strcmp(checkPtr->value().c_str(), value) != 0) {
           testValueCnt++;
         } else {
@@ -287,10 +285,8 @@ void _verifyIntEntry(const char *name, const char *key, const int val,
             std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(keyPtr));
 
         ASSERT(checkPtr != nullptr, "Value Ptr should not be null.");
-        char buf[1024];
-        sprintf(buf, "In verify loop, get returned %d for key %s",
-                checkPtr->value(), key);
-        LOG(buf);
+        LOG("In verify loop, get returned " +
+            std::to_string(checkPtr->value()) + " for key " + key);
         // if ( strcmp( checkPtr->value().c_str(), value ) != 0 ){
         if (checkPtr->value() != value) {
           testValueCnt++;
diff --git a/cppcache/integration-test/testThinClientHAFailover.cpp b/cppcache/integration-test/testThinClientHAFailover.cpp
index de83d76..7435c9a 100644
--- a/cppcache/integration-test/testThinClientHAFailover.cpp
+++ b/cppcache/integration-test/testThinClientHAFailover.cpp
@@ -162,10 +162,8 @@ void _verifyEntry(const char *name, const char *key, const char *val,
             std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
 
         ASSERT(checkPtr != nullptr, "Value Ptr should not be null.");
-        char buf[1024];
-        sprintf(buf, "In verify loop, get returned %s for key %s",
-                checkPtr->value().c_str(), key);
-        LOG(buf);
+        LOG("In verify loop, get returned " + checkPtr->value() + " for key " +
+            key);
         if (strcmp(checkPtr->value().c_str(), value) != 0) {
           testValueCnt++;
         } else {
diff --git a/cppcache/integration-test/testThinClientHAFailoverRegex.cpp b/cppcache/integration-test/testThinClientHAFailoverRegex.cpp
index 2e66bc8..c0ea44f 100644
--- a/cppcache/integration-test/testThinClientHAFailoverRegex.cpp
+++ b/cppcache/integration-test/testThinClientHAFailoverRegex.cpp
@@ -140,10 +140,8 @@ void _verifyEntry(const char *name, const char *key, const char *val,
             std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
 
         ASSERT(checkPtr != nullptr, "Value Ptr should not be null.");
-        char buf[1024];
-        sprintf(buf, "In verify loop, get returned %s for key %s",
-                checkPtr->value().c_str(), key);
-        LOG(buf);
+        LOG("In verify loop, get returned " + checkPtr->value() + " for key " +
+            key);
         if (strcmp(checkPtr->value().c_str(), value) != 0) {
           testValueCnt++;
         } else {
diff --git a/cppcache/integration-test/testThinClientHAMixedRedundancy.cpp b/cppcache/integration-test/testThinClientHAMixedRedundancy.cpp
index 4970573..abd2b52 100644
--- a/cppcache/integration-test/testThinClientHAMixedRedundancy.cpp
+++ b/cppcache/integration-test/testThinClientHAMixedRedundancy.cpp
@@ -145,10 +145,8 @@ void _verifyEntry(const char *name, const char *key, const char *val,
             std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
 
         ASSERT(checkPtr != nullptr, "Value Ptr should not be null.");
-        char buf[1024];
-        sprintf(buf, "In verify loop, get returned %s for key %s",
-                checkPtr->value().c_str(), key);
-        LOG(buf);
+        LOG("In verify loop, get returned " + checkPtr->value() + " for key " +
+            key);
         if (strcmp(checkPtr->value().c_str(), value) != 0) {
           testValueCnt++;
         } else {
diff --git a/cppcache/integration-test/testThinClientHAPeriodicAck.cpp b/cppcache/integration-test/testThinClientHAPeriodicAck.cpp
index 25d77fd..0ffcde9 100644
--- a/cppcache/integration-test/testThinClientHAPeriodicAck.cpp
+++ b/cppcache/integration-test/testThinClientHAPeriodicAck.cpp
@@ -214,10 +214,8 @@ void _verifyEntry(const char *name, const char *key, const char *val,
             std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
 
         ASSERT(checkPtr != nullptr, "Value Ptr should not be null.");
-        char buf[1024];
-        sprintf(buf, "In verify loop, get returned %s for key %s",
-                checkPtr->value().c_str(), key);
-        LOG(buf);
+        LOG("In verify loop, get returned " + checkPtr->value() + " for key " +
+            key);
         if (strcmp(checkPtr->value().c_str(), value) != 0) {
           testValueCnt++;
         } else {
@@ -305,10 +303,8 @@ void _verifyIntEntry(const char *name, const char *key, const int val,
             std::dynamic_pointer_cast<CacheableInt32>(regPtr->get(keyPtr));
 
         ASSERT(checkPtr != nullptr, "Value Ptr should not be null.");
-        char buf[1024];
-        sprintf(buf, "In verify loop, get returned %d for key %s",
-                checkPtr->value(), key);
-        LOG(buf);
+        LOG("In verify loop, get returned " +
+            std::to_string(checkPtr->value()) + " for key " + key);
         // if ( strcmp( checkPtr->value().c_str(), value ) != 0 ){
         if (checkPtr->value() != value) {
           testValueCnt++;
diff --git a/cppcache/integration-test/testThinClientIntResPolKeysInv.cpp b/cppcache/integration-test/testThinClientIntResPolKeysInv.cpp
index 7d8d09f..fe869d5 100644
--- a/cppcache/integration-test/testThinClientIntResPolKeysInv.cpp
+++ b/cppcache/integration-test/testThinClientIntResPolKeysInv.cpp
@@ -131,10 +131,8 @@ void _verifyEntry(const char *name, const char *key, const char *val,
             std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
 
         ASSERT(checkPtr != nullptr, "Value Ptr should not be null.");
-        char buf[1024];
-        sprintf(buf, "In verify loop, get returned %s for key %s",
-                checkPtr->value().c_str(), key);
-        LOG(buf);
+        LOG("In verify loop, get returned " + checkPtr->value() + " for key " +
+            key);
         if (strcmp(checkPtr->value().c_str(), value) != 0) {
           testValueCnt++;
         } else {
diff --git a/cppcache/integration-test/testThinClientLRUExpiration.cpp b/cppcache/integration-test/testThinClientLRUExpiration.cpp
index d599486..8d06af5 100644
--- a/cppcache/integration-test/testThinClientLRUExpiration.cpp
+++ b/cppcache/integration-test/testThinClientLRUExpiration.cpp
@@ -111,17 +111,17 @@ void printAttribute(RegionAttributes attr) {
 }
 
 void setCacheListener(const char *regName,
-                      std::shared_ptr<TallyListener> regListener) {
+                      std::shared_ptr<TallyListener> regionTallyListener) {
   auto reg = getHelper()->getRegion(regName);
   auto attrMutator = reg->getAttributesMutator();
-  attrMutator->setCacheListener(regListener);
+  attrMutator->setCacheListener(regionTallyListener);
 }
 
 void setCacheWriter(const char *regName,
-                    std::shared_ptr<TallyWriter> regWriter) {
+                    std::shared_ptr<TallyWriter> regionTallyWriter) {
   auto reg = getHelper()->getRegion(regName);
   auto attrMutator = reg->getAttributesMutator();
-  attrMutator->setCacheWriter(regWriter);
+  attrMutator->setCacheWriter(regionTallyWriter);
 }
 
 void getRegionAttr(const char *name) {
diff --git a/cppcache/integration-test/testThinClientPRPutAllFailover.cpp b/cppcache/integration-test/testThinClientPRPutAllFailover.cpp
index 080d7f0..a40df90 100644
--- a/cppcache/integration-test/testThinClientPRPutAllFailover.cpp
+++ b/cppcache/integration-test/testThinClientPRPutAllFailover.cpp
@@ -284,7 +284,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, RemoveAllOneTask)
     LOG("RemoveAllOneTask started.");
     auto dataReg = getHelper()->getRegion(regionNames[0]);
     HashMapOfCacheable entryMap;
-    std::vector<std::shared_ptr<CacheableKey>> keys;
+    std::vector<std::shared_ptr<CacheableKey>> keysVector;
     entryMap.clear();
     char key[256];
     char value[256];
@@ -293,7 +293,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, RemoveAllOneTask)
       sprintf(value, "%d", item);
       entryMap.emplace(CacheableKey::create(key),
                        CacheableString::create(value));
-      keys.push_back(CacheableKey::create(key));
+      keysVector.push_back(CacheableKey::create(key));
       LOGDEBUG(
           "CPPTEST:RemoveAllOneTask Doing PutAll on key using key: = %s: & "
           "value: = %s",
@@ -301,7 +301,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, RemoveAllOneTask)
     }
     try {
       dataReg->putAll(entryMap);
-      dataReg->removeAll(keys);
+      dataReg->removeAll(keysVector);
     } catch (Exception &ex) {
       LOGERROR("CPPTEST: Unexpected %s: %s", ex.getName().c_str(), ex.what());
       FAIL(ex.what());
@@ -319,7 +319,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, RemoveAllTwoTask)
     LOG("RemoveAllTwoTask started.");
     auto dataReg = getHelper()->getRegion(regionNames[0]);
     HashMapOfCacheable entryMap;
-    std::vector<std::shared_ptr<CacheableKey>> keys;
+    std::vector<std::shared_ptr<CacheableKey>> keysVector;
     entryMap.clear();
     char key[256];
     char value[256];
@@ -328,7 +328,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, RemoveAllTwoTask)
       sprintf(value, "%d", item);
       entryMap.emplace(CacheableKey::create(key),
                        CacheableString::create(value));
-      keys.push_back(CacheableKey::create(key));
+      keysVector.push_back(CacheableKey::create(key));
       LOGDEBUG(
           "CPPTEST:RemoveAllTwoTask Doing RemoveAll on key using key: = %s: & "
           "value: = %s",
@@ -336,7 +336,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, RemoveAllTwoTask)
     }
     try {
       dataReg->putAll(entryMap);
-      dataReg->removeAll(keys);
+      dataReg->removeAll(keysVector);
     } catch (Exception &ex) {
       LOGERROR("CPPTEST: Unexpected %s: %s", ex.getName().c_str(), ex.what());
       FAIL(ex.what());
@@ -354,7 +354,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, RemoveAllThreeTask)
     LOG("RemoveAllThreeTask started.");
     auto dataReg = getHelper()->getRegion(regionNames[0]);
     HashMapOfCacheable entryMap;
-    std::vector<std::shared_ptr<CacheableKey>> keys;
+    std::vector<std::shared_ptr<CacheableKey>> keysVector;
     entryMap.clear();
     char key[256];
     char value[256];
@@ -363,7 +363,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, RemoveAllThreeTask)
       sprintf(value, "%d", item);
       entryMap.emplace(CacheableKey::create(key),
                        CacheableString::create(value));
-      keys.push_back(CacheableKey::create(key));
+      keysVector.push_back(CacheableKey::create(key));
       LOGDEBUG(
           "CPPTEST:RemoveAllThreeTask Doing RemoveAll on key using key: = %s: "
           "& "
@@ -372,7 +372,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, RemoveAllThreeTask)
     }
     try {
       dataReg->putAll(entryMap);
-      dataReg->removeAll(keys);
+      dataReg->removeAll(keysVector);
     } catch (Exception &ex) {
       LOGERROR("CPPTEST: Unexpected %s: %s", ex.getName().c_str(), ex.what());
       FAIL(ex.what());
@@ -391,7 +391,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, RemoveAllFourTask)
     LOG("RemoveAllFourTask started.");
     auto dataReg = getHelper()->getRegion(regionNames[0]);
     HashMapOfCacheable entryMap;
-    std::vector<std::shared_ptr<CacheableKey>> keys;
+    std::vector<std::shared_ptr<CacheableKey>> keysVector;
     entryMap.clear();
     char key[256];
     char value[256];
@@ -400,7 +400,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, RemoveAllFourTask)
       sprintf(value, "%d", item);
       entryMap.emplace(CacheableKey::create(key),
                        CacheableString::create(value));
-      keys.push_back(CacheableKey::create(key));
+      keysVector.push_back(CacheableKey::create(key));
       LOGDEBUG(
           "CPPTEST:RemoveAllFourTask Doing RemoveAll on key using key: = %s: & "
           "value: = %s",
@@ -408,7 +408,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, RemoveAllFourTask)
     }
     try {
       dataReg->putAll(entryMap);
-      dataReg->removeAll(keys);
+      dataReg->removeAll(keysVector);
     } catch (Exception &ex) {
       LOGERROR("CPPTEST: Unexpected %s: %s", ex.getName().c_str(), ex.what());
       FAIL(ex.what());
diff --git a/cppcache/integration-test/testThinClientPRSingleHop.cpp b/cppcache/integration-test/testThinClientPRSingleHop.cpp
index 0383daa..db00235 100644
--- a/cppcache/integration-test/testThinClientPRSingleHop.cpp
+++ b/cppcache/integration-test/testThinClientPRSingleHop.cpp
@@ -746,15 +746,15 @@ DUNIT_TASK_DEFINITION(CLIENT1, CheckPrSingleHopForIntKeysTask2)
     LOG("CheckPrSingleHopForIntKeysTask2 get completed.");
 
     for (int i = 1000; i < 2000; i++) {
-      std::vector<std::shared_ptr<CacheableKey>> keys;
+      std::vector<std::shared_ptr<CacheableKey>> keysVector;
       for (int j = i; j < i + 5; j++) {
-        keys.push_back(CacheableInt32::create(j));
+        keysVector.push_back(CacheableInt32::create(j));
       }
 
       try {
         // LOGINFO("CPPTEST: getting key %d with hashcode %d", i,
         // (int32_t)keyPtr->hashcode());
-        dataReg->getAll(keys);
+        dataReg->getAll(keysVector);
         bool networkhop = TestUtils::getCacheImpl(getHelper()->cachePtr)
                               ->getAndResetNetworkHopFlag();
         LOGINFO("CheckPrSingleHopForIntKeysTask2: networkhop %d ", networkhop);
@@ -799,18 +799,18 @@ END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT1, CheckPrSingleHopForGetAllTask)
   {
     auto dataReg = getHelper()->getRegion(regionNames[0]);
-    std::vector<std::shared_ptr<CacheableKey>> keys;
+    std::vector<std::shared_ptr<CacheableKey>> keysVector;
     for (int i = 0; i < 100; i++) {
       auto keyPtr =
           std::dynamic_pointer_cast<CacheableKey>(CacheableInt32::create(i));
       dataReg->put(keyPtr, keyPtr->hashcode());
-      keys.push_back(keyPtr);
+      keysVector.push_back(keyPtr);
     }
 
-    auto valuesMap = dataReg->getAll(keys);
+    auto valuesMap = dataReg->getAll(keysVector);
     ASSERT(valuesMap.size() == 100, "GetAll returns wrong number of values");
 
-    valuesMap = dataReg->getAll(keys, CacheableInt32::create(1000));
+    valuesMap = dataReg->getAll(keysVector, CacheableInt32::create(1000));
     ASSERT(valuesMap.size() == 100,
            "GetAllWithCallBack returns wrong number of values");
 
@@ -942,15 +942,15 @@ DUNIT_TASK_DEFINITION(CLIENT1, CheckPrSingleHopForIntKeysTask)
     LOG("CheckPrSingleHopForIntKeysTask get completed.");
 
     for (int i = 1000; i < 2000; i++) {
-      std::vector<std::shared_ptr<CacheableKey>> keys;
+      std::vector<std::shared_ptr<CacheableKey>> keysVector;
       for (int j = i; j < i + 5; j++) {
-        keys.push_back(CacheableInt32::create(j));
+        keysVector.push_back(CacheableInt32::create(j));
       }
 
       try {
         // LOGINFO("CPPTEST: getting key %d with hashcode %d", i,
         // (int32_t)keyPtr->hashcode());
-        dataReg->getAll(keys);
+        dataReg->getAll(keysVector);
         bool networkhop = TestUtils::getCacheImpl(getHelper()->cachePtr)
                               ->getAndResetNetworkHopFlag();
         LOGINFO("CheckPrSingleHopForIntKeysTask: networkhop %d ", networkhop);
@@ -990,7 +990,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, CheckPrSingleHopForIntKeysTask)
       try {
         // LOGINFO("CPPTEST: getting key %d with hashcode %d", i,
         // (int32_t)keyPtr->hashcode());
-        dataReg->getAll(keys, CacheableInt32::create(1000));
+        dataReg->getAll(keysVector, CacheableInt32::create(1000));
         bool networkhop = TestUtils::getCacheImpl(getHelper()->cachePtr)
                               ->getAndResetNetworkHopFlag();
         LOGINFO("CheckPrSingleHopForIntKeysTask: networkhop %d ", networkhop);
@@ -1122,22 +1122,22 @@ END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT1, CheckGetAllTask)
   {
     auto dataReg = getHelper()->getRegion(regionNames[0]);
-    std::vector<std::shared_ptr<CacheableKey>> keys;
+    std::vector<std::shared_ptr<CacheableKey>> keysVector;
     for (int i = 0; i < 100000; i++) {
       auto keyPtr =
           std::dynamic_pointer_cast<CacheableKey>(CacheableInt32::create(i));
       dataReg->put(keyPtr, keyPtr->hashcode());
-      keys.push_back(keyPtr);
+      keysVector.push_back(keyPtr);
     }
 
     ACE_Time_Value startTime = ACE_OS::gettimeofday();
-    auto valuesMap = dataReg->getAll(keys);
+    auto valuesMap = dataReg->getAll(keysVector);
     ACE_Time_Value interval = ACE_OS::gettimeofday() - startTime;
     LOGDEBUG("NILKANTH: Time taken to execute getALL sec = %d and MSec = %d ",
              interval.sec(), interval.usec());
     ASSERT(valuesMap.size() == 100000, "GetAll returns wrong number of values");
 
-    valuesMap = dataReg->getAll(keys, CacheableInt32::create(10000));
+    valuesMap = dataReg->getAll(keysVector, CacheableInt32::create(10000));
     ASSERT(valuesMap.size() == 100000,
            "GetAllWithCallBack returns wrong number of values");
 
diff --git a/cppcache/integration-test/testThinClientPRSingleHopServerGroup.cpp b/cppcache/integration-test/testThinClientPRSingleHopServerGroup.cpp
index 6d9b1ae..fba653d 100644
--- a/cppcache/integration-test/testThinClientPRSingleHopServerGroup.cpp
+++ b/cppcache/integration-test/testThinClientPRSingleHopServerGroup.cpp
@@ -171,15 +171,15 @@ DUNIT_TASK_DEFINITION(CLIENT1, CheckPrSingleHopForIntKeysTask_CLIENT1)
     LOG("CheckPrSingleHopForIntKeysTask_CLIENT1 get completed.");
 
     for (int i = 1000; i < 2000; i++) {
-      std::vector<std::shared_ptr<CacheableKey>> keys;
+      std::vector<std::shared_ptr<CacheableKey>> keysVector;
       for (int j = i; j < i + 5; j++) {
-        keys.push_back(CacheableInt32::create(j));
+        keysVector.push_back(CacheableInt32::create(j));
       }
 
       auto exceptions = std::make_shared<HashMapOfException>();
 
       try {
-        auto values = dataReg->getAll(keys);
+        auto values = dataReg->getAll(keysVector);
         bool networkhop = TestUtils::getCacheImpl(getHelper()->cachePtr)
                               ->getAndResetNetworkHopFlag();
         ASSERT(!networkhop, "It is networkhop operation.");
@@ -313,13 +313,13 @@ DUNIT_TASK_DEFINITION(CLIENT2, CheckPrSingleHopForIntKeysTask_CLIENT2)
     LOG("CheckPrSingleHopForIntKeysTask_CLIENT2 get completed.");
 
     for (int i = 1000; i < 2000; i++) {
-      std::vector<std::shared_ptr<CacheableKey>> keys;
+      std::vector<std::shared_ptr<CacheableKey>> keysVector;
       for (int j = i; j < i + 5; j++) {
-        keys.push_back(CacheableInt32::create(j));
+        keysVector.push_back(CacheableInt32::create(j));
       }
 
       try {
-        const auto values = dataReg->getAll(keys);
+        const auto values = dataReg->getAll(keysVector);
         int8_t serverGroupFlag = TestUtils::getCacheImpl(getHelper()->cachePtr)
                                      ->getAndResetServerGroupFlag();
         ASSERT(values.size() == 5, "getall size should be 5 ");
@@ -448,13 +448,13 @@ DUNIT_TASK_DEFINITION(CLIENT3, CheckPrSingleHopForIntKeysTask_CLIENT3)
     LOG("CheckPrSingleHopForIntKeysTask_CLIENT3 get completed.");
 
     for (int i = 1000; i < 2000; i++) {
-      std::vector<std::shared_ptr<CacheableKey>> keys;
+      std::vector<std::shared_ptr<CacheableKey>> keysVector;
       for (int j = i; j < i + 5; j++) {
-        keys.push_back(CacheableInt32::create(j));
+        keysVector.push_back(CacheableInt32::create(j));
       }
 
       try {
-        dataReg->getAll(keys);
+        dataReg->getAll(keysVector);
         int8_t serverGroupFlag = TestUtils::getCacheImpl(getHelper()->cachePtr)
                                      ->getAndResetServerGroupFlag();
         ASSERT(serverGroupFlag != 2,
diff --git a/cppcache/integration-test/testThinClientPoolAttrTest.cpp b/cppcache/integration-test/testThinClientPoolAttrTest.cpp
index d3cb2a4..1ea7ead 100644
--- a/cppcache/integration-test/testThinClientPoolAttrTest.cpp
+++ b/cppcache/integration-test/testThinClientPoolAttrTest.cpp
@@ -71,7 +71,7 @@ class putThread : public ACE_Task_Base {
   void stop() { wait(); }
 };
 
-void doAttrTestingAndCreatePool(const char *poolName) {
+void doAttrTestingAndCreatePool(const char *poolNameToUse) {
   auto poolFac = getHelper()->getCache()->getPoolManager().createFactory();
   poolFac.setFreeConnectionTimeout(std::chrono::milliseconds(10000));
   poolFac.setLoadConditioningInterval(std::chrono::milliseconds(60000));
@@ -94,7 +94,7 @@ void doAttrTestingAndCreatePool(const char *poolName) {
   // poolFacPtr->setMultiuserSecurityMode(true);
   poolFac.setPRSingleHopEnabled(false);
 
-  auto pptr = poolFac.create(poolName);
+  auto pptr = poolFac.create(poolNameToUse);
 
   // Validate the attributes
   ASSERT(pptr->getFreeConnectionTimeout() == std::chrono::milliseconds(10000),
@@ -136,10 +136,10 @@ void doAttrTestingAndCreatePool(const char *poolName) {
          "PRSingleHopEnabled should have been false");
 }
 
-void doAttrTesting(const char *poolName1) {
+void doAttrTesting(const char *poolNameToUse) {
   // auto poolFacPtr = cachePtr->getPoolFactory();
-  auto pptr = getHelper()->getCache()->getPoolManager().find(poolName1);
-  // auto pptr = poolFacPtr->find(poolName1);
+  auto pptr = getHelper()->getCache()->getPoolManager().find(poolNameToUse);
+  // auto pptr = poolFacPtr->find(poolNameToUse);
 
   ASSERT(pptr->getName() == "clientPool",
          "Pool name should have been clientPool");
@@ -258,14 +258,14 @@ DUNIT_TASK(CLIENT1, ClientOp)
     // min.
     SLEEP(5000);
     // Check current # connections they should be == min
-    std::string poolName =
+    std::string poolNameString =
         getHelper()->getRegion(poolRegNames[0])->getAttributes().getPoolName();
-    int level =
-        TestUtils::getCacheImpl(getHelper()->cachePtr)->getPoolSize(poolName);
+    int level = TestUtils::getCacheImpl(getHelper()->cachePtr)
+                    ->getPoolSize(poolNameString);
     int min = getHelper()
                   ->getCache()
                   ->getPoolManager()
-                  .find(poolName.c_str())
+                  .find(poolNameString.c_str())
                   ->getMinConnections();
     char logmsg[100] = {0};
     sprintf(logmsg, "Pool level not equal to min level. Expected %d, actual %d",
@@ -281,12 +281,12 @@ DUNIT_TASK(CLIENT1, ClientOp)
     SLEEP(5000);  // wait for threads to become active
 
     // Check current # connections they should be == max
-    level =
-        TestUtils::getCacheImpl(getHelper()->cachePtr)->getPoolSize(poolName);
+    level = TestUtils::getCacheImpl(getHelper()->cachePtr)
+                ->getPoolSize(poolNameString);
     int max = getHelper()
                   ->getCache()
                   ->getPoolManager()
-                  .find(poolName.c_str())
+                  .find(poolNameString.c_str())
                   ->getMaxConnections();
     sprintf(logmsg, "Pool level not equal to max level. Expected %d, actual %d",
             max, level);
@@ -301,12 +301,12 @@ DUNIT_TASK(CLIENT1, ClientOp)
     LOG("Waiting 25 sec for idle timeout to kick in");
     SLEEP(25000);
 
-    level =
-        TestUtils::getCacheImpl(getHelper()->cachePtr)->getPoolSize(poolName);
+    level = TestUtils::getCacheImpl(getHelper()->cachePtr)
+                ->getPoolSize(poolNameString);
     min = getHelper()
               ->getCache()
               ->getPoolManager()
-              .find(poolName.c_str())
+              .find(poolNameString.c_str())
               ->getMinConnections();
     sprintf(logmsg,
             "Pool level not equal to min level after idle timeout. "
@@ -317,8 +317,8 @@ DUNIT_TASK(CLIENT1, ClientOp)
     LOG("Waiting 1 minute for load conditioning to kick in");
     SLEEP(60000);
 
-    level =
-        TestUtils::getCacheImpl(getHelper()->cachePtr)->getPoolSize(poolName);
+    level = TestUtils::getCacheImpl(getHelper()->cachePtr)
+                ->getPoolSize(poolNameString);
     sprintf(logmsg,
             "Pool level not equal to min level after load "
             "conditioning. Expected %d, actual %d",
diff --git a/cppcache/integration-test/testThinClientPutAllPRSingleHop.cpp b/cppcache/integration-test/testThinClientPutAllPRSingleHop.cpp
index e8d625a..541e211 100644
--- a/cppcache/integration-test/testThinClientPutAllPRSingleHop.cpp
+++ b/cppcache/integration-test/testThinClientPutAllPRSingleHop.cpp
@@ -240,14 +240,14 @@ DUNIT_TASK_DEFINITION(CLIENT1, CheckPrSingleHopRemoveAllForIntKeysTask)
       LOGINFO("Iteration removeAll Start ");
       try {
         HashMapOfCacheable valMap;
-        std::vector<std::shared_ptr<CacheableKey>> keys;
+        std::vector<std::shared_ptr<CacheableKey>> keysVector;
         for (int j = 1000; j < 25000; j++) {
           auto keyPtr = CacheableInt32::create(j);
           auto valPtr = CacheableInt32::create(keyPtr->hashcode());
           LOGINFO("CPPTEST: removeall CASE:: getting key %d with hashcode %d",
                   j, keyPtr->hashcode());
           valMap.emplace(keyPtr, valPtr);
-          keys.push_back(keyPtr);
+          keysVector.push_back(keyPtr);
         }
         LOGINFO("TEST-1");
         ACE_Time_Value startTime = ACE_OS::gettimeofday();
@@ -264,7 +264,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, CheckPrSingleHopRemoveAllForIntKeysTask)
 
         LOGINFO("RemoveALL test");
         startTime = ACE_OS::gettimeofday();
-        dataReg->removeAll(keys);
+        dataReg->removeAll(keysVector);
         interval = ACE_OS::gettimeofday() - startTime;
 
         LOGINFO("Time taken to execute removeAll SH sec = %d and MSec = %d ",
diff --git a/cppcache/integration-test/testThinClientRemoteQuerySS.cpp b/cppcache/integration-test/testThinClientRemoteQuerySS.cpp
index 5e70e48..c35fa9b 100644
--- a/cppcache/integration-test/testThinClientRemoteQuerySS.cpp
+++ b/cppcache/integration-test/testThinClientRemoteQuerySS.cpp
@@ -141,14 +141,14 @@ void _printFields(std::shared_ptr<Cacheable> field, Struct *ssptr,
           printf("   structImpl %s {\n", ssptr->getFieldName(fields).c_str());
           for (int32_t inner_fields = 0; inner_fields < structimpl->size();
                inner_fields++) {
-            auto field = (*structimpl)[inner_fields];
-            if (field == nullptr) {
+            auto innerField = (*structimpl)[inner_fields];
+            if (innerField == nullptr) {
               printf(
                   "we got null fields here, probably we have nullptr data\n");
               continue;
             }
 
-            _printFields(field, structimpl.get(), inner_fields);
+            _printFields(innerField, structimpl.get(), inner_fields);
 
           }  // end of field iterations
           printf("   } //end of %s\n", ssptr->getFieldName(fields).c_str());
diff --git a/cppcache/integration-test/testThinClientRemoveOps.cpp b/cppcache/integration-test/testThinClientRemoveOps.cpp
index e4d781a..277c3e2 100644
--- a/cppcache/integration-test/testThinClientRemoveOps.cpp
+++ b/cppcache/integration-test/testThinClientRemoveOps.cpp
@@ -136,10 +136,8 @@ void _verifyEntry(const char *name, const char *key, const char *val,
           std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
 
       ASSERT(checkPtr != nullptr, "Value Ptr should not be null.");
-      char buf[1024];
-      sprintf(buf, "In verify loop, get returned %s for key %s",
-              checkPtr->value().c_str(), key);
-      LOG(buf);
+      LOG("In verify loop, get returned " + checkPtr->value() + " for key " +
+          key);
       if (strcmp(checkPtr->value().c_str(), value) != 0) {
         testValueCnt++;
       } else {
@@ -1074,9 +1072,9 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepEight)
 
     ASSERT(reg->size() == 2, "region size should be equal to 2");
 
-    std::vector<std::shared_ptr<CacheableKey>> keys = reg->keys();
-    LOGINFO("Region keys = %d ", keys.size());
-    ASSERT(keys.size() == reg->size(),
+    std::vector<std::shared_ptr<CacheableKey>> keysVector = reg->keys();
+    LOGINFO("Region keys = %d ", keysVector.size());
+    ASSERT(keysVector.size() == reg->size(),
            "region size should be equal to keys size");
 
     auto values = reg->values();
@@ -1085,9 +1083,9 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepEight)
            "region size should be equal to values size");
 
     reg->destroy("Key100");
-    keys = reg->keys();
-    LOGINFO("Region keys = %d ", keys.size());
-    ASSERT(keys.size() == reg->size(),
+    keysVector = reg->keys();
+    LOGINFO("Region keys = %d ", keysVector.size());
+    ASSERT(keysVector.size() == reg->size(),
            "region size should be equal to keys size");
 
     values = reg->values();
diff --git a/cppcache/integration-test/testThinClientSecurityAuthorization.cpp b/cppcache/integration-test/testThinClientSecurityAuthorization.cpp
index cc1c8ea..401b0a7 100644
--- a/cppcache/integration-test/testThinClientSecurityAuthorization.cpp
+++ b/cppcache/integration-test/testThinClientSecurityAuthorization.cpp
@@ -464,14 +464,14 @@ DUNIT_TASK_DEFINITION(READER_CLIENT, StepThree)
     initClientAuth('R');
     std::shared_ptr<Region> rptr;
     char buf[100];
-    int i = 102;
+    int value = 102;
 
     createRegionForSecurity(regionNamesAuth[0], USE_ACK, true);
 
     rptr = getHelper()->getRegion(regionNamesAuth[0]);
-    sprintf(buf, "%s: %d", rptr->getName().c_str(), i);
+    sprintf(buf, "%s: %d", rptr->getName().c_str(), value);
     auto key = CacheableKey::create(buf);
-    sprintf(buf, "testUpdate::%s: value of %d", rptr->getName().c_str(), i);
+    sprintf(buf, "testUpdate::%s: value of %d", rptr->getName().c_str(), value);
     auto valuePtr = buf;
     try {
       LOG("Trying put Operation");
@@ -513,10 +513,8 @@ DUNIT_TASK_DEFINITION(READER_CLIENT, StepThree)
       auto checkPtr =
           std::dynamic_pointer_cast<CacheableString>(regPtr0->get(keyPtr));
       if (checkPtr != nullptr) {
-        char buf[1024];
-        sprintf(buf, "In net search, get returned %s for key %s",
-                checkPtr->value().c_str(), keys[2]);
-        LOG(buf);
+        LOG("In net search, get returned " + checkPtr->value() + " for key " +
+            keys[2]);
       } else {
         LOG("checkPtr is nullptr");
       }
@@ -635,7 +633,7 @@ DUNIT_TASK_DEFINITION(READER_CLIENT, StepThree)
 
     try {
       if (pool != nullptr) {
-        auto regPtr0 = getHelper()->getRegion(regionNamesAuth[0]);
+        regPtr0 = getHelper()->getRegion(regionNamesAuth[0]);
         FunctionService::onRegion(regPtr0).execute("securityTest")->getResult();
         FAIL("Function execution should not have completed successfully");
       } else {
diff --git a/cppcache/integration-test/testThinClientSecurityAuthorizationMU.cpp b/cppcache/integration-test/testThinClientSecurityAuthorizationMU.cpp
index 5d2d05c..9bbd819 100644
--- a/cppcache/integration-test/testThinClientSecurityAuthorizationMU.cpp
+++ b/cppcache/integration-test/testThinClientSecurityAuthorizationMU.cpp
@@ -797,7 +797,7 @@ DUNIT_TASK_DEFINITION(READER_CLIENT, StepThree)
     initCredentialGenerator();
     initClientAuth('R');
     char buf[100];
-    int i = 102;
+    int value = 102;
 
     createRegionForSecurity(regionNamesAuth[0], USE_ACK, false, nullptr, false,
                             -1, true, 0);
@@ -813,9 +813,9 @@ DUNIT_TASK_DEFINITION(READER_CLIENT, StepThree)
     rptr = virtualCache.getRegion(regionNamesAuth[0]);
     LOG("Operation allowed, something is wrong.");
 
-    sprintf(buf, "%s: %d", rptr->getName().c_str(), i);
+    sprintf(buf, "%s: %d", rptr->getName().c_str(), value);
     auto key = CacheableKey::create(buf);
-    sprintf(buf, "testUpdate::%s: value of %d", rptr->getName().c_str(), i);
+    sprintf(buf, "testUpdate::%s: value of %d", rptr->getName().c_str(), value);
     auto valuePtr = buf;
     try {
       LOG("Trying put Operation");
@@ -852,10 +852,8 @@ DUNIT_TASK_DEFINITION(READER_CLIENT, StepThree)
       auto checkPtr =
           std::dynamic_pointer_cast<CacheableString>(rptr->get(keyPtr));
       if (checkPtr != nullptr) {
-        char buf[1024];
-        sprintf(buf, "In net search, get returned %s for key %s",
-                checkPtr->value().c_str(), keys[2]);
-        LOG(buf);
+        LOG("In net search, get returned " + checkPtr->value() + " for key " +
+            keys[2]);
       } else {
         LOG("checkPtr is nullptr");
       }
diff --git a/cppcache/integration-test/testThinClientSecurityPostAuthorization.cpp b/cppcache/integration-test/testThinClientSecurityPostAuthorization.cpp
index 9c879f4..d151bdd 100644
--- a/cppcache/integration-test/testThinClientSecurityPostAuthorization.cpp
+++ b/cppcache/integration-test/testThinClientSecurityPostAuthorization.cpp
@@ -288,10 +288,10 @@ DUNIT_TASK_DEFINITION(READER_CLIENT, StepThree)
     initClientAuth('R', 2);
     createRegionForSecurity(regionNamesAuth[0], USE_ACK, true);
 
-    std::vector<std::shared_ptr<CacheableKey>> keys;
-    getKeysVector(keys, 6);
+    std::vector<std::shared_ptr<CacheableKey>> keysVector;
+    getKeysVector(keysVector, 6);
     auto rptr = getHelper()->getRegion(regionNamesAuth[0]);
-    auto values = rptr->getAll(keys);
+    auto values = rptr->getAll(keysVector);
 
     checkValuesMap(values, 2, 6);
 
@@ -304,10 +304,10 @@ DUNIT_TASK_DEFINITION(READER2_CLIENT, StepFour)
     initClientAuth('R', 3);
     createRegionForSecurity(regionNamesAuth[0], USE_ACK, true);
 
-    std::vector<std::shared_ptr<CacheableKey>> keys;
-    getKeysVector(keys, 6);
+    std::vector<std::shared_ptr<CacheableKey>> keysVector;
+    getKeysVector(keysVector, 6);
     auto rptr = getHelper()->getRegion(regionNamesAuth[0]);
-    auto values = rptr->getAll(keys);
+    auto values = rptr->getAll(keysVector);
 
     checkValuesMap(values, 3, 6);
 
diff --git a/cppcache/integration-test/testThinClientWriterException.cpp b/cppcache/integration-test/testThinClientWriterException.cpp
index ea54f5f..95277ed 100644
--- a/cppcache/integration-test/testThinClientWriterException.cpp
+++ b/cppcache/integration-test/testThinClientWriterException.cpp
@@ -129,10 +129,10 @@ void initClientAuth() {
 }
 
 void setCacheWriter(const char *regName,
-                    std::shared_ptr<TallyWriter> regWriter) {
+                    std::shared_ptr<TallyWriter> tallyWriter) {
   auto reg = getHelper()->getRegion(regName);
   auto attrMutator = reg->getAttributesMutator();
-  attrMutator->setCacheWriter(regWriter);
+  attrMutator->setCacheWriter(tallyWriter);
 }
 
 DUNIT_TASK_DEFINITION(ADMIN_CLIENT, StartServer1)
diff --git a/cppcache/integration/test/BasicIPv6Test.cpp b/cppcache/integration/test/BasicIPv6Test.cpp
index 913de96..856ba62 100644
--- a/cppcache/integration/test/BasicIPv6Test.cpp
+++ b/cppcache/integration/test/BasicIPv6Test.cpp
@@ -87,13 +87,13 @@ TEST(BasicIPv6Test, queryResultForRange) {
     auto key = -1;
     for (auto&& column : *rowStruct) {
       // Expect to read: key:int, value:string
-      if (auto columnValue =
+      if (auto cacheableInt32ColumnValue =
               std::dynamic_pointer_cast<CacheableInt32>(column)) {
-        key = columnValue->value();
+        key = cacheableInt32ColumnValue->value();
         EXPECT_NE(values.end(), values.find(key));
-      } else if (auto columnValue =
+      } else if (auto cacheableStringColumnValue =
                      std::dynamic_pointer_cast<CacheableString>(column)) {
-        auto value = columnValue->value();
+        auto value = cacheableStringColumnValue->value();
         EXPECT_EQ(values.find(key)->second, value);
       } else {
         FAIL() << "Column is not int or string.";
diff --git a/cppcache/integration/test/StructTest.cpp b/cppcache/integration/test/StructTest.cpp
index 2565c13..fda4132 100644
--- a/cppcache/integration/test/StructTest.cpp
+++ b/cppcache/integration/test/StructTest.cpp
@@ -89,13 +89,13 @@ TEST(StructTest, queryResultForRange) {
     auto key = -1;
     for (auto&& column : *rowStruct) {
       // Expect to read: key:int, value:string
-      if (auto columnValue =
+      if (auto cacheableInt32ColumnValue =
               std::dynamic_pointer_cast<CacheableInt32>(column)) {
-        key = columnValue->value();
+        key = cacheableInt32ColumnValue->value();
         EXPECT_NE(values.end(), values.find(key));
-      } else if (auto columnValue =
+      } else if (auto cacheableStringColumnValue =
                      std::dynamic_pointer_cast<CacheableString>(column)) {
-        auto value = columnValue->value();
+        auto value = cacheableStringColumnValue->value();
         EXPECT_EQ(values.find(key)->second, value);
       } else {
         FAIL() << "Column is not int or string.";
diff --git a/cppcache/src/ClientMetadataService.cpp b/cppcache/src/ClientMetadataService.cpp
index 7fca094..21ead03 100644
--- a/cppcache/src/ClientMetadataService.cpp
+++ b/cppcache/src/ClientMetadataService.cpp
@@ -751,7 +751,8 @@ void ClientMetadataService::markPrimaryBucketForTimeoutButLookSecondaryBucket(
     std::shared_ptr<BucketServerLocation>& serverLocation, int8_t& version) {
   if (m_bucketWaitTimeout == std::chrono::milliseconds::zero()) return;
 
-  boost::unique_lock<decltype(m_PRbucketStatusLock)> lock(m_PRbucketStatusLock);
+  boost::unique_lock<decltype(m_PRbucketStatusLock)> boostPRbucketStatusLock(
+      m_PRbucketStatusLock);
 
   PRbuckets* prBuckets = nullptr;
   const auto& bs = m_bucketStatus.find(region->getFullPath());
@@ -766,7 +767,7 @@ void ClientMetadataService::markPrimaryBucketForTimeoutButLookSecondaryBucket(
 
   std::shared_ptr<ClientMetadata> cptr = nullptr;
   {
-    boost::shared_lock<decltype(m_regionMetadataLock)> lock(
+    boost::shared_lock<decltype(m_regionMetadataLock)> boostRegionMetadataLock(
         m_regionMetadataLock);
 
     const auto& cptrIter = m_regionMetaDataMap.find(region->getFullPath());
@@ -778,7 +779,6 @@ void ClientMetadataService::markPrimaryBucketForTimeoutButLookSecondaryBucket(
       return;
     }
   }
-
   LOGFINE("Setting in markPrimaryBucketForTimeoutButLookSecondaryBucket");
 
   auto totalBuckets = cptr->getTotalNumBuckets();
diff --git a/cppcache/src/ExceptionTypes.cpp b/cppcache/src/ExceptionTypes.cpp
index 2a12e07..87afb9b 100644
--- a/cppcache/src/ExceptionTypes.cpp
+++ b/cppcache/src/ExceptionTypes.cpp
@@ -299,7 +299,7 @@ const std::string& getThreadLocalExceptionMessage();
     }
     default: {
       LOGINFO("error code: %d", err);
-      std::string message = func;
+      message = func;
       if (exMsg.empty()) {
         message.append("Unknown error code ").append(std::to_string(err));
       } else {
diff --git a/cppcache/src/FunctionService.cpp b/cppcache/src/FunctionService.cpp
index 304af08..a15b7c4 100644
--- a/cppcache/src/FunctionService.cpp
+++ b/cppcache/src/FunctionService.cpp
@@ -36,7 +36,7 @@ Execution FunctionService::onRegion(const std::shared_ptr<Region>& region) {
   }
 
   auto realRegion = region;
-  const auto& pool = realRegion->getPool();
+  auto pool = realRegion->getPool();
 
   if (pool == nullptr) {
     throw IllegalArgumentException("Pool attached with region is closed.");
@@ -51,7 +51,7 @@ Execution FunctionService::onRegion(const std::shared_ptr<Region>& region) {
       // it is in multiuser mode
       authenticatedView = pr->m_authenticatedView;
       auto userAttachedPool = authenticatedView->m_userAttributes->getPool();
-      auto pool = realRegion->getCache().getPoolManager().find(
+      pool = realRegion->getCache().getPoolManager().find(
           userAttachedPool->getName());
       if (!(pool != nullptr && pool.get() == userAttachedPool.get() &&
             !pool->isDestroyed())) {
diff --git a/cppcache/src/LRUList.cpp b/cppcache/src/LRUList.cpp
index 8d16753..28f155c 100644
--- a/cppcache/src/LRUList.cpp
+++ b/cppcache/src/LRUList.cpp
@@ -102,13 +102,13 @@ void LRUList<TEntry, TCreateEntry>::getLRUEntry(
 template <typename TEntry, typename TCreateEntry>
 typename LRUList<TEntry, TCreateEntry>::LRUListNode*
 LRUList<TEntry, TCreateEntry>::getHeadNode(bool& isLast) {
-  std::lock_guard<spinlock_mutex> lk(m_headLock);
+  std::lock_guard<spinlock_mutex> headSpinlock(m_headLock);
 
   LRUListNode* result = m_headNode;
   LRUListNode* nextNode;
 
   {
-    std::lock_guard<spinlock_mutex> lk(m_tailLock);
+    std::lock_guard<spinlock_mutex> tailSpinlock(m_tailLock);
 
     nextNode = m_headNode->getNextLRUListNode();
     if (nextNode == nullptr) {
diff --git a/cppcache/src/LocalRegion.cpp b/cppcache/src/LocalRegion.cpp
index 73ba5d7..a5707f2 100644
--- a/cppcache/src/LocalRegion.cpp
+++ b/cppcache/src/LocalRegion.cpp
@@ -1488,7 +1488,6 @@ class RemoveActions {
       std::shared_ptr<MapEntryImpl> entry;
       //  for notification invoke the listener even if the key does
       // not exist locally
-      GfErrType err;
       LOGDEBUG("Region::remove: region [%s] removing key [%s]",
                m_region.getFullPath().c_str(),
                Utils::nullSafeToString(key).c_str());
diff --git a/cppcache/src/Log.cpp b/cppcache/src/Log.cpp
index 1be79e8..1a8b89b 100644
--- a/cppcache/src/Log.cpp
+++ b/cppcache/src/Log.cpp
@@ -213,8 +213,8 @@ void Log::init(LogLevel level, const char* logFileName, int32_t logFileLimit,
     // Appending a ".log" at the end if it does not exist or file has some other
     // extension.
     std::string filebasename = ACE::basename(g_logFile->c_str());
-    int32_t len = static_cast<int32_t>(filebasename.length());
-    size_t fileExtPos = filebasename.find_last_of('.', len);
+    auto len = static_cast<int32_t>(filebasename.length());
+    auto fileExtPos = filebasename.find_last_of('.', len);
     // if no extension then add .log extension
     if (fileExtPos == std::string::npos) {
       g_logFileWithExt = new std::string(*g_logFile + ".log");
@@ -257,7 +257,7 @@ void Log::init(LogLevel level, const char* logFileName, int32_t logFileLimit,
     if (status != -1) {
       for (int index = 0; index < sds.length(); ++index) {
         std::string strname = ACE::basename(sds[index]->d_name);
-        size_t fileExtPos = strname.find_last_of('.', strname.length());
+        fileExtPos = strname.find_last_of('.', strname.length());
         if (fileExtPos != std::string::npos) {
           std::string tempname = strname.substr(0, fileExtPos);
           size_t fileHyphenPos = tempname.find_last_of('-', tempname.length());
@@ -280,7 +280,7 @@ void Log::init(LogLevel level, const char* logFileName, int32_t logFileLimit,
       std::string extName;
       std::string newfilestr;
 
-      int32_t len = static_cast<int32_t>(g_logFileWithExt->length());
+      len = static_cast<int32_t>(g_logFileWithExt->length());
       int32_t lastPosOfSep = static_cast<int32_t>(
           g_logFileWithExt->find_last_of(ACE_DIRECTORY_SEPARATOR_CHAR, len));
       if (lastPosOfSep == -1) {
@@ -567,7 +567,7 @@ void Log::put(LogLevel level, const char* msg) {
     }
 
     formatLogLine(buf, level);
-    size_t numChars = static_cast<int>(std::strlen(buf) + std::strlen(msg));
+    auto numChars = static_cast<int>(std::strlen(buf) + std::strlen(msg));
     g_bytesWritten +=
         numChars + 2;  // bcoz we have to count trailing new line (\n)
 
@@ -657,7 +657,7 @@ void Log::put(LogLevel level, const char* msg) {
           char printmsg[256];
           std::snprintf(printmsg, 256, "%s\t%s\n", "Could not delete",
                         fileInfo[fileIndex].first.c_str());
-          int numChars =
+          numChars =
               fprintf(g_log, "%s%s\n", formatLogLine(buf, level), printmsg);
           g_bytesWritten +=
               numChars + 2;  // bcoz we have to count trailing new line (\n)
diff --git a/cppcache/src/MapSegment.cpp b/cppcache/src/MapSegment.cpp
index ca94941..ce88114 100644
--- a/cppcache/src/MapSegment.cpp
+++ b/cppcache/src/MapSegment.cpp
@@ -752,10 +752,9 @@ GfErrType MapSegment::isTombstone(std::shared_ptr<CacheableKey> key,
 
   if (CacheableToken::isTombstone(value)) {
     if (m_tombstoneList->exists(key)) {
-      std::shared_ptr<MapEntry> entry;
-      const auto find = m_map->find(key);
-      if (find != m_map->end()) {
-        auto mePtr = find->second->getImplPtr();
+      const auto& findInTombstoneList = m_map->find(key);
+      if (findInTombstoneList != m_map->end()) {
+        mePtr = findInTombstoneList->second->getImplPtr();
         me = mePtr;
       }
       result = true;
diff --git a/cppcache/src/PdxLocalReader.cpp b/cppcache/src/PdxLocalReader.cpp
index 1178f47..6229f9d 100644
--- a/cppcache/src/PdxLocalReader.cpp
+++ b/cppcache/src/PdxLocalReader.cpp
@@ -239,7 +239,7 @@ std::shared_ptr<PdxRemotePreservedData> PdxLocalReader::getPreservedData(
         resettoPdxHead();
         m_dataInput->advanceCursor(pos);
 
-        for (int i = 0; i < (nFieldPos - pos); i++) {
+        for (int j = 0; j < (nFieldPos - pos); j++) {
           pdVector.push_back(m_dataInput->read());
         }
         resettoPdxHead();
diff --git a/cppcache/src/SerializationRegistry.hpp b/cppcache/src/SerializationRegistry.hpp
index 7c692b9..6aa7fa6 100644
--- a/cppcache/src/SerializationRegistry.hpp
+++ b/cppcache/src/SerializationRegistry.hpp
@@ -200,7 +200,7 @@ class APACHE_GEODE_EXPORT SerializationRegistry {
 
   inline void serializeWithoutHeader(const std::shared_ptr<Serializable>& obj,
                                      DataOutput& output) const {
-    if (auto&& pdxSerializable =
+    if (const auto&& pdxSerializable =
             std::dynamic_pointer_cast<PdxSerializable>(obj)) {
       serializeWithoutHeader(pdxSerializable, output);
     } else if (const auto&& dataSerializableFixedId =
@@ -212,9 +212,6 @@ class APACHE_GEODE_EXPORT SerializationRegistry {
     } else if (const auto&& dataSerializable =
                    std::dynamic_pointer_cast<DataSerializable>(obj)) {
       serializeWithoutHeader(dataSerializable, output);
-    } else if (const auto&& pdxSerializable =
-                   std::dynamic_pointer_cast<PdxSerializable>(obj)) {
-      serializeWithoutHeader(pdxSerializable, output);
     } else if (const auto&& dataSerializableInternal =
                    std::dynamic_pointer_cast<DataSerializableInternal>(obj)) {
       serializeWithoutHeader(dataSerializableInternal, output);
diff --git a/cppcache/src/StructSetImpl.cpp b/cppcache/src/StructSetImpl.cpp
index e8776b2..89a4538 100644
--- a/cppcache/src/StructSetImpl.cpp
+++ b/cppcache/src/StructSetImpl.cpp
@@ -42,7 +42,7 @@ StructSetImpl::StructSetImpl(const std::shared_ptr<CacheableVector>& response,
   size_t valStoredCnt = 0;
   while (valStoredCnt < numOfValues) {
     std::vector<std::shared_ptr<Serializable>> tmpVec;
-    for (size_t i = 0; i < numOfFields; i++) {
+    for (size_t j = 0; j < numOfFields; j++) {
       tmpVec.push_back(response->operator[](valStoredCnt++));
     }
     m_structVector.push_back(std::make_shared<Struct>(this, tmpVec));
diff --git a/cppcache/src/TcrEndpoint.cpp b/cppcache/src/TcrEndpoint.cpp
index 7cfcf85..4d2a093 100644
--- a/cppcache/src/TcrEndpoint.cpp
+++ b/cppcache/src/TcrEndpoint.cpp
@@ -376,7 +376,8 @@ GfErrType TcrEndpoint::registerDM(bool clientNotification, bool isSecondary,
   bool connected = false;
   GfErrType err = GF_NOERR;
 
-  std::lock_guard<decltype(m_connectionLock)> guard(m_connectionLock);
+  std::lock_guard<decltype(m_connectionLock)> connectionLockGuard(
+      m_connectionLock);
   // Three cases here:
   // 1. m_connected is false, m_isActiveEndpoint is false and then
   //    if isActiveEndpoint is true, then create 'max' connections
@@ -439,7 +440,7 @@ GfErrType TcrEndpoint::registerDM(bool clientNotification, bool isSecondary,
           "channel for endpoint %s",
           m_name.c_str());
       // setup notification channel for the first region
-      std::lock_guard<decltype(m_notifyReceiverLock)> guard(
+      std::lock_guard<decltype(m_notifyReceiverLock)> notifyReceiverLockGuard(
           m_notifyReceiverLock);
       if (m_numRegionListener == 0) {
         if ((err = createNewConnection(m_notifyConnection, true, isSecondary,
diff --git a/cppcache/src/ThinClientRedundancyManager.cpp b/cppcache/src/ThinClientRedundancyManager.cpp
index 9e4e485..8538da6 100644
--- a/cppcache/src/ThinClientRedundancyManager.cpp
+++ b/cppcache/src/ThinClientRedundancyManager.cpp
@@ -1102,14 +1102,14 @@ void ThinClientRedundancyManager::readyForEvents() {
 
   while (result != GF_NOERR && epCount <= m_redundantEndpoints.size() +
                                               m_nonredundantEndpoints.size()) {
-    TcrMessageReply reply(true, nullptr);
+    TcrMessageReply tcrMessageReply(true, nullptr);
     maintainRedundancyLevel();
     if (m_redundantEndpoints.size() > 0) {
       primary = m_redundantEndpoints[0];
       if (m_poolHADM) {
-        result = m_poolHADM->sendRequestToEP(request, reply, primary);
+        result = m_poolHADM->sendRequestToEP(request, tcrMessageReply, primary);
       } else {
-        result = primary->send(request, reply);
+        result = primary->send(request, tcrMessageReply);
       }
     }
     epCount++;
diff --git a/cppcache/src/ThinClientRegion.cpp b/cppcache/src/ThinClientRegion.cpp
index 64c7ab0..5a9c070 100644
--- a/cppcache/src/ThinClientRegion.cpp
+++ b/cppcache/src/ThinClientRegion.cpp
@@ -1002,12 +1002,12 @@ GfErrType ThinClientRegion::putNoThrow_remote(
     m_cacheImpl->getCachePerfStats().incDeltaPut();
     if (reply->getMessageType() == TcrMessage::PUT_DELTA_ERROR) {
       // Try without delta
-      TcrMessagePut request(new DataOutput(m_cacheImpl->createDataOutput()),
-                            this, keyPtr, valuePtr, aCallbackArgument, false,
-                            m_tcrdm.get(), false, true);
+      TcrMessagePut putRequest(new DataOutput(m_cacheImpl->createDataOutput()),
+                               this, keyPtr, valuePtr, aCallbackArgument, false,
+                               m_tcrdm.get(), false, true);
       reply = std::unique_ptr<TcrMessageReply>(
           new TcrMessageReply(true, m_tcrdm.get()));
-      err = m_tcrdm->sendSyncRequest(request, *reply);
+      err = m_tcrdm->sendSyncRequest(putRequest, *reply);
     }
   }
   if (err != GF_NOERR) return err;
diff --git a/cppcache/src/TransactionalOperation.cpp b/cppcache/src/TransactionalOperation.cpp
index f0810fb..7dbadb3 100644
--- a/cppcache/src/TransactionalOperation.cpp
+++ b/cppcache/src/TransactionalOperation.cpp
@@ -94,7 +94,7 @@ std::shared_ptr<Cacheable> TransactionalOperation::replay(
                               GF_NOTSUP);
       break;
     case GF_GET_ALL: {
-      const auto result =
+      const auto allInternal =
           std::static_pointer_cast<RegionInternal>(
               cacheImpl->getCache()->getRegion(m_regionName))
               ->getAll_internal(*std::dynamic_pointer_cast<
@@ -107,7 +107,7 @@ std::shared_ptr<Cacheable> TransactionalOperation::replay(
 
       auto values =
           std::dynamic_pointer_cast<HashMapOfCacheable>(m_arguments->at(1));
-      values->insert(result.begin(), result.end());
+      values->insert(allInternal.begin(), allInternal.end());
       break;
     }
     case GF_INVALIDATE: