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: