Google Git
Sign in
apache / geode-native / 24c5c785aa7fb8df92f14397068c29db8679df95 / . / cppcache / integration-test / testThinClientPdxInstance.cpp
blob: 1c917dbaf8a6bdb96584b3d7d4ea970a4badeee6 [file] [log] [blame]
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <string>
#include <ace/OS.h>
#include <ace/High_Res_Timer.h>
#include <ace/Date_Time.h>
#include <geode/PdxInstance.hpp>
#include <geode/PdxInstanceFactory.hpp>
#include <geode/WritablePdxInstance.hpp>
#include "fw_dunit.hpp"
#include "testobject/PdxType.hpp"
#include "testobject/NestedPdxObject.hpp"
#include "CachePerfStats.hpp"
#include "LocalRegion.hpp"
#define ROOT_NAME "testThinClientPdxInstance"
#define ROOT_SCOPE DISTRIBUTED_ACK
#include "CacheHelper.hpp"
#include "CacheImpl.hpp"
#include "SerializationRegistry.hpp"
#include "CacheRegionHelper.hpp"
using PdxTests::Address;
using testobject::ChildPdx;
using testobject::ParentPdx;
using testobject::SerializePdx;
using apache::geode::client::Cacheable;
using apache::geode::client::CacheableArrayList;
using apache::geode::client::CacheableDate;
using apache::geode::client::CacheableEnum;
using apache::geode::client::CacheableHashMap;
using apache::geode::client::CacheableHashSet;
using apache::geode::client::CacheableInt32;
using apache::geode::client::CacheableKey;
using apache::geode::client::CacheableLinkedHashSet;
using apache::geode::client::CacheableObjectArray;
using apache::geode::client::CacheableVector;
using apache::geode::client::CacheHelper;
using apache::geode::client::CacheRegionHelper;
using apache::geode::client::IllegalStateException;
using apache::geode::client::LocalRegion;
using apache::geode::client::PdxFieldTypes;
using apache::geode::client::PdxInstance;
using apache::geode::client::PdxSerializable;
using apache::geode::client::Properties;
using apache::geode::client::WritablePdxInstance;
bool isLocalServer = false;
CacheHelper *cacheHelper = nullptr;
#define CLIENT1 s1p1
#define CLIENT2 s1p2
#define SERVER1 s2p1
static bool isLocator = false;
const bool USE_ACK = true;
const bool NO_ACK = false;
const char *locatorsG =
CacheHelper::getLocatorHostPort(isLocator, isLocalServer, 1);
const char *regionNames[] = {"DistRegionAck", "DistRegionNoAck"};
template <typename T1, typename T2>
bool genericValCompare(T1 value1, T2 value2) /*const*/
{
if (value1 != value2) return false;
return true;
}
template <typename T1, typename T2, typename L>
bool genericCompare(std::vector<T1> value1, std::vector<T2> value2,
L length) /*const*/
{
L i = 0;
while (i < length) {
if (value1[i] != value2[i]) {
return false;
} else {
i++;
}
}
return true;
}
template <typename T1, typename T2>
bool generic2DCompare(T1 **value1, T2 **value2, int length,
int *arrLengths) /*const*/
{
for (int j = 0; j < length; j++) {
for (int k = 0; k < arrLengths[j]; k++) {
LOGINFO("generic2DCompare value1 = %d \t value2 = %d ", value1[j][k],
value2[j][k]);
if (value1[j][k] != value2[j][k]) return false;
}
}
LOGINFO("PdxObject::genericCompare Line_34");
return true;
}
void initClient(const bool isthinClient, bool isPdxReadSerailized) {
LOGINFO("isPdxReadSerailized = %d ", isPdxReadSerailized);
if (cacheHelper == nullptr) {
auto config = Properties::create();
config->insert("enable-time-statistics", "true");
LOGINFO("enabled-time-statistics ");
cacheHelper = new CacheHelper(isthinClient, false, isPdxReadSerailized,
config, false);
}
ASSERT(cacheHelper, "Failed to create a CacheHelper client instance.");
}
static int clientWithXml = 0;
void initClient(const char *clientXmlFile) {
if (cacheHelper == nullptr) {
auto config = Properties::create();
if (clientWithXml > 2) config->insert("grid-client", "true");
clientWithXml += 1;
config->insert("enable-time-statistics", "true");
cacheHelper = new CacheHelper(nullptr, clientXmlFile, config);
}
ASSERT(cacheHelper, "Failed to create a CacheHelper client instance.");
}
void cleanProc() {
if (cacheHelper != nullptr) {
delete cacheHelper;
cacheHelper = nullptr;
}
}
CacheHelper *getHelper() {
ASSERT(cacheHelper != nullptr, "No cacheHelper initialized.");
return cacheHelper;
}
void createPooledRegion(const char *name, bool ackMode, const char *locators,
const char *poolname,
bool clientNotificationEnabled = false,
bool cachingEnable = true) {
LOG("createRegion_Pool() entered.");
fprintf(stdout, "Creating region -- %s ackMode is %d\n", name, ackMode);
fflush(stdout);
auto regPtr =
getHelper()->createPooledRegion(name, ackMode, locators, poolname,
cachingEnable, clientNotificationEnabled);
ASSERT(regPtr != nullptr, "Failed to create region.");
LOG("Pooled Region created.");
}
DUNIT_TASK_DEFINITION(SERVER1, CreateLocator1)
{
// starting locator
if (isLocator) CacheHelper::initLocator(1);
LOG("Locator1 started");
}
END_TASK_DEFINITION
DUNIT_TASK_DEFINITION(SERVER1, CreateServer1)
{
if (isLocalServer) {
CacheHelper::initServer(1, "cacheserver_pdxinstance_hashcode.xml");
}
LOG("SERVER1 started");
}
END_TASK_DEFINITION
DUNIT_TASK_DEFINITION(SERVER1, CreateServer1_With_Locator)
{
if (isLocalServer) {
CacheHelper::initServer(1, "cacheserver_pdxinstance_hashcode.xml",
locatorsG);
}
LOG("SERVER1 with locator started");
}
END_TASK_DEFINITION
DUNIT_TASK_DEFINITION(CLIENT1, StepOne_Pooled_Locator_PdxReadSerialized)
{
initClient(true, true);
createPooledRegion(regionNames[0], USE_ACK, locatorsG, "__TEST_POOL1__",
false, false);
LOG("StepOne_Pooled_Locator complete.");
}
END_TASK_DEFINITION
DUNIT_TASK_DEFINITION(CLIENT2, StepTwo_Pooled_Locator_PdxReadSerialized)
{
initClient(true, true);
createPooledRegion(regionNames[0], USE_ACK, locatorsG, "__TEST_POOL1__",
false, false);
LOG("StepOne_Pooled_Locator complete.");
}
END_TASK_DEFINITION
DUNIT_TASK_DEFINITION(CLIENT2,
StepTwo_Pooled_Locator_CachingEnabled_PdxReadSerialized)
{
initClient(true, true);
createPooledRegion(regionNames[0], USE_ACK, locatorsG, "__TEST_POOL1__",
false, true);
LOG("StepTwo_Pooled_Locator complete.");
}
END_TASK_DEFINITION
DUNIT_TASK_DEFINITION(CLIENT1, StepOne_Pooled_Locator)
{
initClient(true, false);
createPooledRegion(regionNames[0], USE_ACK, locatorsG, "__TEST_POOL1__",
false, false);
LOG("StepOne_Pooled_Locator complete.");
}
END_TASK_DEFINITION
DUNIT_TASK_DEFINITION(CLIENT2, StepTwo_Pooled_Locator)
{
initClient(true, false);
createPooledRegion(regionNames[0], USE_ACK, locatorsG, "__TEST_POOL1__",
false, false);
LOG("StepTwo_Pooled_Locator complete.");
}
END_TASK_DEFINITION
DUNIT_TASK_DEFINITION(CLIENT2, testReadSerializedXMLProperty_Client2)
{
ASSERT(cacheHelper->getCache()->getPdxReadSerialized() == true,
"Pdx read serialized property should be true.");
LOG("testReadSerializedXMLProperty complete.");
}
END_TASK_DEFINITION
DUNIT_TASK_DEFINITION(CLIENT1, testReadSerializedXMLProperty_Client1)
{
ASSERT(cacheHelper->getCache()->getPdxReadSerialized() == true,
"Pdx read serialized property should be true.");
LOG("testReadSerializedXMLProperty complete.");
}
END_TASK_DEFINITION
DUNIT_TASK_DEFINITION(CLIENT1, putPdxWithIdentityField)
{
LOG("putPdxWithIdentityField started ");
try {
auto serializationRegistry =
CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
->getSerializationRegistry();
serializationRegistry->addPdxSerializableType(
SerializePdx::createDeserializable);
LOG("SerializePdx Registered Successfully....");
} catch (apache::geode::client::IllegalStateException & /* ex*/) {
LOG("SerializePdx IllegalStateException");
}
auto rptr = getHelper()->getRegion(regionNames[0]);
// Creating object of type PdxObject
/*SerializePdxPtr*/ auto sp = std::make_shared<SerializePdx>(true);
// PUT Operation
rptr->put(CacheableInt32::create(1), sp);
LOG("pdxPut 1 completed ");
LOG("putPdxWithIdentityField complete.");
}
END_TASK_DEFINITION
DUNIT_TASK_DEFINITION(CLIENT1, putCacheableObjectArrayWithPdxFields)
{
LOG("putCacheableObjectArrayWithPdxFields started ");
try {
auto serializationRegistry =
CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
->getSerializationRegistry();
serializationRegistry->addPdxSerializableType(
Address::createDeserializable);
LOG("Address Registered Successfully....");
} catch (apache::geode::client::IllegalStateException & /* ex*/) {
LOG("Address IllegalStateException");
}
auto rptr = getHelper()->getRegion(regionNames[0]);
// Creating CacheableobjectArray of type PdxObject
std::shared_ptr<CacheableObjectArray> objectArray =
CacheableObjectArray::create();
objectArray->push_back(
std::shared_ptr<Address>(new Address(1, "street0", "city0")));
objectArray->push_back(
std::shared_ptr<Address>(new Address(2, "street1", "city1")));
objectArray->push_back(
std::shared_ptr<Address>(new Address(3, "street2", "city2")));
objectArray->push_back(
std::shared_ptr<Address>(new Address(4, "street3", "city3")));
objectArray->push_back(
std::shared_ptr<Address>(new Address(5, "street4", "city4")));
objectArray->push_back(
std::shared_ptr<Address>(new Address(6, "street5", "city5")));
objectArray->push_back(
std::shared_ptr<Address>(new Address(7, "street6", "city6")));
objectArray->push_back(
std::shared_ptr<Address>(new Address(8, "street7", "city7")));
objectArray->push_back(
std::shared_ptr<Address>(new Address(9, "street8", "city8")));
objectArray->push_back(
std::shared_ptr<Address>(new Address(10, "street9", "city9")));
// PUT Operation
rptr->put(CacheableInt32::create(100), objectArray);
LOG("putCacheableObjectArrayWithPdxFields on key 100 completed ");
LOG("putCacheableObjectArrayWithPdxFields complete.");
}
END_TASK_DEFINITION
DUNIT_TASK_DEFINITION(CLIENT2, verifyPdxIdentityField)
{
LOG("verifyPdxIdentityField started ");
try {
auto serializationRegistry =
CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
->getSerializationRegistry();
serializationRegistry->addPdxSerializableType(
SerializePdx::createDeserializable);
LOG("SerializePdx Registered Successfully....");
} catch (apache::geode::client::IllegalStateException & /* ex*/) {
LOG("SerializePdx IllegalStateException");
}
auto rptr = getHelper()->getRegion(regionNames[0]);
auto pi = std::dynamic_pointer_cast<PdxInstance>(
rptr->get(CacheableInt32::create(1)));
LOG("PdxInstancePtr get complete");
LOG("Statistics for for (PdxTests.PdxType) PdxInstance");
LocalRegion *lregPtr = (dynamic_cast<LocalRegion *>(rptr.get()));
LOGINFO(
"pdxInstanceDeserializations for (PdxTests.PdxType) PdxInstance = %d ",
lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceDeserializations());
LOGINFO(
"pdxInstanceCreations for (PdxTests.PdxType) PdxInstance = %d ",
lregPtr->getCacheImpl()->getCachePerfStats().getPdxInstanceCreations());
LOGINFO(
"pdxInstanceDeserializationTime for(PdxTests.PdxType) PdxInstance = "
"%d ",
lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceDeserializationTime());
ASSERT(lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceDeserializations() == 0,
"pdxInstanceDeserialization should be equal to 0.");
ASSERT(lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceCreations() == 1,
"pdxInstanceCreations should be equal to 1.");
ASSERT(lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceDeserializationTime() > 0,
"pdxInstanceDeserializationTime should be greater than equal to 0.");
ASSERT(pi->getFieldNames()->length() == 4,
"number of fields should be four in SerializePdx");
ASSERT(pi->isIdentityField("i1") == true,
"SerializePdx1.i1 should be identity field");
ASSERT(pi->isIdentityField("i2") == false,
"SerializePdx1.i2 should NOT be identity field");
ASSERT(pi->hasField("i1") == true,
"SerializePdx1.i1 should be in PdxInstance stream");
ASSERT(pi->hasField("i3") == false,
"There is no field i3 in SerializePdx1's PdxInstance stream");
std::shared_ptr<CacheableKey> javaPdxHCKey =
CacheableKey::create("javaPdxHC");
auto pIPtr2 = std::dynamic_pointer_cast<Cacheable>(rptr->get(javaPdxHCKey));
LOG("javaPdxHCKey get done");
CacheableInt32 *val = dynamic_cast<CacheableInt32 *>(pIPtr2.get());
LOG("javaPdxHCKey cast done");
int javaPdxHC = val->value();
LOGINFO("javaPdxHC hash code = %d ", javaPdxHC);
int pdxInstHashcode = pi->hashcode();
ASSERT(
javaPdxHC == pdxInstHashcode,
"Pdxhashcode for identity field object SerializePdx1 not matched with "
"java pdx hash code.");
auto pi2 = std::dynamic_pointer_cast<PdxInstance>(
rptr->get(CacheableInt32::create(1)));
LOGINFO(
"pdxInstanceDeserializations for (PdxTests.PdxType) PdxInstance = %d ",
lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceDeserializations());
LOGINFO(
"pdxInstanceCreations for (PdxTests.PdxType) PdxInstance = %d ",
lregPtr->getCacheImpl()->getCachePerfStats().getPdxInstanceCreations());
LOGINFO(
"pdxInstanceDeserializationTime for(PdxTests.PdxType) PdxInstance = "
"%d ",
lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceDeserializationTime());
ASSERT(lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceDeserializations() == 0,
"pdxInstanceDeserialization should be equal to 0.");
ASSERT(lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceCreations() == 2,
"pdxInstanceCreations should be equal to 2.");
ASSERT(lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceDeserializationTime() > 0,
"pdxInstanceDeserializationTime should be greater than 0.");
bool ret = false;
ret = (*pi == *pi2);
LOGINFO("PdxObject ret = %d ", ret);
ASSERT(ret == true, "Both PdxInstances should be equal.");
LOG("verifyPdxIdentityField complete.");
}
END_TASK_DEFINITION
DUNIT_TASK_DEFINITION(CLIENT2, verifyCacheableObjectArrayWithPdxField)
{
LOG("verifyCacheableObjectArrayWithPdxField started ");
try {
auto serializationRegistry =
CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
->getSerializationRegistry();
serializationRegistry->addPdxSerializableType(
Address::createDeserializable);
LOG("Address Registered Successfully....");
} catch (apache::geode::client::IllegalStateException & /* ex*/) {
LOG("Address IllegalStateException");
}
auto rptr = getHelper()->getRegion(regionNames[0]);
auto objectArrayPtr = std::dynamic_pointer_cast<CacheableObjectArray>(
rptr->get(CacheableInt32::create(100)));
LOG("PdxInstancePtr get on key 100 complete");
for (size_t i = 0; i < objectArrayPtr->size(); i++) {
auto pi = std::dynamic_pointer_cast<PdxInstance>(objectArrayPtr->at(i));
LOG("PdxInstancePtr obtained from CacheableObjectArray");
auto pdxFactory =
cacheHelper->getCache()->createPdxInstanceFactory("PdxTests.Address");
LOG("PdxInstanceFactoryPtr created for PdxTests.Address....");
pdxFactory.writeInt("_aptNumber", static_cast<int32_t>(i + 1));
char streetStr[256] = {0};
sprintf(streetStr, "street%zd", i);
pdxFactory.writeString("_street", streetStr);
char cityStr[256] = {0};
sprintf(cityStr, "city%zd", i);
pdxFactory.writeString("_city", cityStr);
auto addrPtr = std::dynamic_pointer_cast<Address>(pi->getObject());
LOG("AddressPtr created using PdxInstance getObject()....");
auto newAddrPtr = std::make_shared<Address>(static_cast<int32_t>(i + 1),
streetStr, cityStr);
LOG("AddressPtr created using new....");
ASSERT(addrPtr->equals(*newAddrPtr) == true,
"Both PdxInstances should be equal.");
auto retPtr = pdxFactory.create();
LOG("PdxInstancePtr created....");
bool ret = false;
ret = (*pi == *retPtr);
LOGINFO("PdxObject ret = %d ", ret);
ASSERT(ret == true, "Both PdxInstances should be equal.");
}
LOG("verifyCacheableObjectArrayWithPdxField complete.");
}
END_TASK_DEFINITION
DUNIT_TASK_DEFINITION(CLIENT1, putPdxWithNullIdentityFields)
{
LOG("putPdxWithNullIdentityFields started ");
auto rptr = getHelper()->getRegion(regionNames[0]);
// Creating object of type PdxObject
auto sp = std::make_shared<SerializePdx>(false);
// PUT Operation
rptr->put(CacheableInt32::create(2), sp);
LOG("pdxPut 1 completed ");
LOG("putPdxWithNullIdentityFields complete.");
}
END_TASK_DEFINITION
DUNIT_TASK_DEFINITION(CLIENT2, verifyPdxNullIdentityFieldHC)
{
LOG("verifyPdxNullIdentityFieldHC started ");
auto rptr = getHelper()->getRegion(regionNames[0]);
auto pi = std::dynamic_pointer_cast<PdxInstance>(
rptr->get(CacheableInt32::create(2)));
LOG("PdxInstancePtr get complete");
std::shared_ptr<CacheableKey> javaPdxHCKey =
CacheableKey::create("javaPdxHC");
auto pIPtr2 = std::dynamic_pointer_cast<Cacheable>(rptr->get(javaPdxHCKey));
LOG("javaPdxHCKey get done");
CacheableInt32 *val = dynamic_cast<CacheableInt32 *>(pIPtr2.get());
LOG("javaPdxHCKey cast done");
int javaPdxHC = val->value();
LOGINFO("javaPdxHC hash code = %d ", javaPdxHC);
int pdxInstHashcode = pi->hashcode();
ASSERT(
javaPdxHC == pdxInstHashcode,
"Pdxhashcode for identity field object SerializePdx1 not matched with "
"java pdx hash code.");
auto pi2 = std::dynamic_pointer_cast<PdxInstance>(
rptr->get(CacheableInt32::create(2)));
bool ret = false;
ret = (*pi == *pi2);
LOGINFO("PdxObject ret = %d ", ret);
ASSERT(ret == true, "Both PdxInstances should be equal.");
std::vector<std::shared_ptr<CacheableKey>> keys1;
keys1.push_back(CacheableInt32::create(1));
keys1.push_back(CacheableInt32::create(2));
const auto valuesMap = rptr->getAll(keys1);
LOG("getAll on Pdx objects completed.");
ASSERT(valuesMap.size() == keys1.size(), "getAll size did not match");
LOG("verifyPdxNullIdentityFieldHC complete.");
}
END_TASK_DEFINITION
DUNIT_TASK_DEFINITION(CLIENT1, pdxPut)
{
LOG("pdxPut started ");
auto serializationRegistry =
CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
->getSerializationRegistry();
try {
serializationRegistry->addPdxSerializableType(
PdxTests::PdxType::createDeserializable);
LOG("PdxObject Registered Successfully....");
} catch (apache::geode::client::IllegalStateException & /* ex*/) {
LOG("PdxObject IllegalStateException");
}
// Creating object of type PdxObject
auto pdxobj = std::make_shared<PdxTests::PdxType>();
auto keyport = CacheableKey::create("pdxput");
auto keyport1 = CacheableKey::create("pdxput2");
auto rptr = getHelper()->getRegion(regionNames[0]);
// PUT Operation
rptr->put(keyport, pdxobj);
LOG("pdxPut 1 completed ");
auto pIPtr1 = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
LOG("Statistics for for (PdxTests.PdxType) PdxInstance");
LocalRegion *lregPtr = (dynamic_cast<LocalRegion *>(rptr.get()));
LOGINFO(
"pdxInstanceDeserializations for (PdxTests.PdxType) PdxInstance = %d ",
lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceDeserializations());
LOGINFO(
"pdxInstanceCreations for (PdxTests.PdxType) PdxInstance = %d ",
lregPtr->getCacheImpl()->getCachePerfStats().getPdxInstanceCreations());
LOGINFO(
"pdxInstanceDeserializationTime for(PdxTests.PdxType) PdxInstance = "
"%d ",
lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceDeserializationTime());
ASSERT(lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceDeserializations() == 0,
"pdxInstanceDeserialization should be equal to 0.");
ASSERT(lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceCreations() == 1,
"pdxInstanceCreations should be equal to 1.");
ASSERT(lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceDeserializationTime() > 0,
"pdxInstanceDeserializationTime should be greater than 0.");
auto toString = pIPtr1->toString();
LOGINFO("pdxinstance toString = %s ", toString.c_str());
int pdxInstHashcode = pIPtr1->hashcode();
LOGINFO("pdxinstance hash code = %d ", pdxInstHashcode);
auto javaPdxHCKey = CacheableKey::create("javaPdxHC");
auto pIPtr2 = std::dynamic_pointer_cast<Cacheable>(rptr->get(javaPdxHCKey));
LOG("In verifyPdxInstanceHashcode get done");
CacheableInt32 *val = dynamic_cast<CacheableInt32 *>(pIPtr2.get());
LOG("In verifyPdxInstanceHashcode cast done");
int javaPdxHC = val->value();
LOGINFO("javaPdxHC hash code = %d ", javaPdxHC);
ASSERT(javaPdxHC == pdxInstHashcode,
"Pdxhashcode hashcode not matched with java pdx hash code.");
// Creating object of type ParentPdx
auto parentPdxObj = std::make_shared<ParentPdx>(1);
LOG("pdxPut parentPdxObj created ");
rptr->put(keyport1, parentPdxObj);
LOG("pdxPut 2 completed ");
LOG("pdxPut complete.");
}
END_TASK_DEFINITION
DUNIT_TASK_DEFINITION(CLIENT2, getObject)
{
LOG("getObject started ");
auto serializationRegistry =
CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
->getSerializationRegistry();
try {
serializationRegistry->addPdxSerializableType(
PdxTests::PdxType::createDeserializable);
LOG("PdxObject Registered Successfully....");
} catch (apache::geode::client::IllegalStateException & /* ex*/) {
LOG("PdxObject IllegalStateException");
}
try {
serializationRegistry->addPdxSerializableType(
ChildPdx::createDeserializable);
LOG("ChildPdx Registered Successfully....");
} catch (apache::geode::client::IllegalStateException & /* ex*/) {
LOG("ChildPdx IllegalStateException");
}
try {
serializationRegistry->addPdxSerializableType(
ParentPdx::createDeserializable);
LOG("ParentPdx Registered Successfully....");
} catch (apache::geode::client::IllegalStateException & /* ex*/) {
LOG("ParentPdx IllegalStateException");
}
auto keyport = CacheableKey::create("pdxput");
auto keyport1 = CacheableKey::create("pdxput2");
auto rptr = getHelper()->getRegion(regionNames[0]);
auto pIPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
LOG("PdxObject get Successful....");
LOGINFO("pdxinstance classname = " + pIPtr->getClassName());
ASSERT(pIPtr->getClassName() == "PdxTests.PdxType",
"pdxInstance.getClassName should return PdxTests.PdxType.");
auto pt = pIPtr->getObject();
LOG("PdxObject getObject Successful....");
LOG("Statistics for for (PdxTests.PdxType) PdxInstance ");
auto &&lregPtr = std::dynamic_pointer_cast<LocalRegion>(rptr);
LOGINFO(
"pdxInstanceDeserializations for (PdxTests.PdxType) PdxInstance = %d ",
lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceDeserializations());
LOGINFO(
"pdxInstanceCreations for (PdxTests.PdxType) PdxInstance = %d ",
lregPtr->getCacheImpl()->getCachePerfStats().getPdxInstanceCreations());
LOGINFO(
"pdxInstanceDeserializationTime for(PdxTests.PdxType) PdxInstance = "
"%d ",
lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceDeserializationTime());
ASSERT(lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceDeserializations() == 1,
"pdxInstanceDeserialization should be equal to 1.");
ASSERT(
lregPtr->getCacheImpl()->getCachePerfStats().getPdxInstanceCreations() >
1,
"pdxInstanceCreations should be greater than 1.");
ASSERT(lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceDeserializationTime() > 0,
"pdxInstanceDeserializationTime should be greater than 0.");
auto ptorig = std::make_shared<PdxTests::PdxType>();
LOG("PdxObject ptorig Successful....");
PdxTests::PdxType *obj1 = ptorig.get();
LOG("obj1 Successful....");
PdxTests::PdxType *obj2 = dynamic_cast<PdxTests::PdxType *>(pt.get());
LOG("obj2 Successful....");
ASSERT(obj1->equals(*obj2, true) == true,
"PdxInstance.getObject not equals original object.");
auto pIPtr1 = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport1));
LOG("ParentPdxObject get Successful....");
auto toString = pIPtr1->toString();
LOGINFO("ParentPdxObject toString = %s ", toString.c_str());
auto pt1 = std::dynamic_pointer_cast<ParentPdx>(pIPtr1->getObject());
LOG("ParentPdxObject getObject Successful....");
LOGINFO(
"pdxInstanceDeserializations for (PdxTests.PdxType) PdxInstance = %d ",
lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceDeserializations());
LOGINFO(
"pdxInstanceCreations for (PdxTests.PdxType) PdxInstance = %d ",
lregPtr->getCacheImpl()->getCachePerfStats().getPdxInstanceCreations());
LOGINFO(
"pdxInstanceDeserializationTime for(PdxTests.PdxType) PdxInstance = "
"%d ",
lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceDeserializationTime());
ASSERT(lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceDeserializations() == 2,
"pdxInstanceDeserialization should be equal to 2.");
ASSERT(
lregPtr->getCacheImpl()->getCachePerfStats().getPdxInstanceCreations() >
1,
"pdxInstanceCreations should be greater than 1.");
ASSERT(lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceDeserializationTime() > 0,
"pdxInstanceDeserializationTime should be greater than 0.");
auto parentPdxObj = std::make_shared<ParentPdx>(1);
LOG("ParentPdxObject parentPdxObj Successful....");
ParentPdx *parentObj1 = parentPdxObj.get();
LOG("parentObj1 Successful....");
ParentPdx *parentObj2 = dynamic_cast<ParentPdx *>(pt1.get());
LOG("parentObj2 Successful....");
ASSERT(parentObj1->equals(*parentObj2, true) == true,
"PdxInstance.getObject not equals original object.");
LOG("getObject complete.");
}
END_TASK_DEFINITION
DUNIT_TASK_DEFINITION(CLIENT2, verifyPdxInstanceEquals)
{
LOG("Task verifyPdxInstanceEquals started.");
try {
auto serializationRegistry =
CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
->getSerializationRegistry();
serializationRegistry->addPdxSerializableType(
PdxTests::PdxType::createDeserializable);
LOG("PdxObject Registered Successfully....");
} catch (apache::geode::client::IllegalStateException & /* ex*/) {
LOG("PdxObject IllegalStateException");
}
auto keyport = CacheableKey::create("pdxput");
auto keyport1 = CacheableKey::create("pdxput2");
auto rptr = getHelper()->getRegion(regionNames[0]);
auto pIPtr1 = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
LOG("get1 Successfully....");
auto pIPtr2 = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
LOG("get2 Successfully....");
bool ret = false;
ret = (*pIPtr1 == *pIPtr2);
LOGINFO("PdxObject ret = %d ", ret);
ASSERT(ret == true, "Both PdxInstances should be equal.");
pIPtr1 = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport1));
LOG("parentPdx get1 Successfully....");
pIPtr2 = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport1));
LOG("parentPdx get2 Successfully....");
ret = (*pIPtr1 == *pIPtr2);
LOGINFO("parentPdx ret = %d ", ret);
ASSERT(ret == true, "Both PdxInstances should be equal.");
LOG("Task verifyPdxInstanceEquals complete.");
}
END_TASK_DEFINITION
DUNIT_TASK_DEFINITION(CLIENT2, verifyPdxInstanceHashcode)
{
LOG("verifyPdxInstanceHashcode started ");
auto rptr = getHelper()->getRegion(regionNames[0]);
auto keyport1 = CacheableKey::create("javaPdxHC");
auto keyport2 = CacheableKey::create("pdxput2");
auto pIPtr1 = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport2));
int pdxInstHashcode = pIPtr1->hashcode();
LOGINFO("pdxinstance hash code = %d ", pdxInstHashcode);
auto pIPtr2 = std::dynamic_pointer_cast<Cacheable>(rptr->get(keyport1));
LOG("In verifyPdxInstanceHashcode get done");
CacheableInt32 *val1 = dynamic_cast<CacheableInt32 *>(pIPtr2.get());
LOG("In verifyPdxInstanceHashcode cast done");
int javaPdxHC = val1->value();
LOGINFO("javaPdxHC hash code again = %d ", javaPdxHC);
ASSERT(javaPdxHC == pdxInstHashcode,
"Pdxhashcode hashcode not matched with java padx hash code.");
LOG("verifyPdxInstanceHashcode complete");
}
END_TASK_DEFINITION
DUNIT_TASK_DEFINITION(CLIENT2, accessPdxInstance)
{
LOG("accessPdxInstance started ");
auto serializationRegistry =
CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
->getSerializationRegistry();
try {
serializationRegistry->addPdxSerializableType(
PdxTests::PdxType::createDeserializable);
LOG("PdxObject Registered Successfully....");
} catch (apache::geode::client::IllegalStateException & /* ex*/) {
LOG("PdxObject IllegalStateException");
}
try {
serializationRegistry->addPdxSerializableType(
Address::createDeserializable);
LOG("Address Registered Successfully....");
} catch (apache::geode::client::IllegalStateException & /* ex*/) {
LOG("Address IllegalStateException");
}
auto keyport = CacheableKey::create("pdxput");
auto keyport1 = CacheableKey::create("pdxput2");
auto rptr = getHelper()->getRegion(regionNames[0]);
auto pIPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
LOGINFO("PdxInstancePtr created ");
auto pdxobjPtr = std::make_shared<PdxTests::PdxType>();
bool bval = pIPtr->getBooleanField("m_bool");
ASSERT(pdxobjPtr->getBool() == bval, "bool values should be equal");
ASSERT(pIPtr->getFieldType("m_bool") == PdxFieldTypes::BOOLEAN,
"Type Value BOOLEAN Mismatch");
signed char byteVal = pIPtr->getByteField("m_byte");
ASSERT(pdxobjPtr->getByte() == byteVal, "byte values should be equal");
ASSERT(pIPtr->getFieldType("m_byte") == PdxFieldTypes::BYTE,
"Type Value BYTE Mismatch");
byteVal = pIPtr->getByteField("m_sbyte");
ASSERT(pdxobjPtr->getSByte() == byteVal, "Sbyte values should be equal");
ASSERT(pIPtr->getFieldType("m_sbyte") == PdxFieldTypes::BYTE,
"Type Value BYTE Mismatch");
int16_t shortVal = pIPtr->getShortField("m_int16");
ASSERT(pdxobjPtr->getShort() == shortVal, "shortVal should be equal");
ASSERT(pIPtr->getFieldType("m_int16") == PdxFieldTypes::SHORT,
"Type Value SHORT Mismatch");
shortVal = pIPtr->getShortField("m_uint16");
ASSERT(pdxobjPtr->getUint16() == shortVal, "m_uint16 should be equal");
ASSERT(pIPtr->getFieldType("m_uint16") == PdxFieldTypes::SHORT,
"Type Value SHORT Mismatch");
int val = pIPtr->getIntField("m_int32");
ASSERT(pdxobjPtr->getInt() == val, "int32 values should be equal");
ASSERT(pIPtr->getFieldType("m_int32") == PdxFieldTypes::INT,
"Type Value INT Mismatch");
val = pIPtr->getIntField("m_uint32");
ASSERT(pdxobjPtr->getUInt() == val, "m_uint32 values should be equal");
ASSERT(pIPtr->getFieldType("m_uint32") == PdxFieldTypes::INT,
"Type Value INT Mismatch");
int64_t longVal = pIPtr->getLongField("m_long");
ASSERT(pdxobjPtr->getLong() == longVal, "int64 values should be equal");
ASSERT(pIPtr->getFieldType("m_long") == PdxFieldTypes::LONG,
"Type Value LONG Mismatch");
longVal = pIPtr->getLongField("m_ulong");
ASSERT(pdxobjPtr->getULong() == longVal, "m_ulong values should be equal");
ASSERT(pIPtr->getFieldType("m_ulong") == PdxFieldTypes::LONG,
"Type Value LONG Mismatch");
float floatVal = pIPtr->getFloatField("m_float");
ASSERT(pdxobjPtr->getFloat() == floatVal, "floatVal should be equal");
ASSERT(pIPtr->getFieldType("m_float") == PdxFieldTypes::FLOAT,
"Type Value FLOAT Mismatch");
double doubleVal = pIPtr->getDoubleField("m_double");
ASSERT(pdxobjPtr->getDouble() == doubleVal, "doubleVal should be equal");
ASSERT(pIPtr->getFieldType("m_double") == PdxFieldTypes::DOUBLE,
"Type Value DOUBLE Mismatch");
auto stringVal = pIPtr->getStringField("m_string");
ASSERT(stringVal == pdxobjPtr->getString(), "stringVal should be equal");
ASSERT(pIPtr->getFieldType("m_string") == PdxFieldTypes::STRING,
"Type Value STRING Mismatch");
auto stringArrayVal = pIPtr->getStringArrayField("m_stringArray");
ASSERT(pdxobjPtr->getStringArrayLength() ==
static_cast<int32_t>(stringArrayVal.size()),
"stringArrayLen should be equal");
ASSERT(pIPtr->getFieldType("m_stringArray") == PdxFieldTypes::STRING_ARRAY,
"Type Value STRING_ARRAY Mismatch");
auto strArray = pdxobjPtr->getStringArray();
for (size_t i = 0; i < stringArrayVal.size(); i++) {
ASSERT(strArray[i] == stringArrayVal[i],
"All stringVals should be equal");
}
auto byteArray = pIPtr->getByteArrayField("m_byteArray");
ASSERT(genericValCompare(pdxobjPtr->getByteArrayLength(),
static_cast<int32_t>(byteArray.size())) == true,
"byteArrayLength should be equal");
ASSERT(genericCompare(pdxobjPtr->getByteArray(), byteArray,
byteArray.size()) == true,
"byteArray should be equal");
ASSERT(pIPtr->getFieldType("m_byteArray") == PdxFieldTypes::BYTE_ARRAY,
"Type Value BYTE_ARRAY Mismatch");
auto charArray = pIPtr->getCharArrayField("m_charArray");
ASSERT(genericValCompare(pdxobjPtr->getCharArrayLength(),
static_cast<int32_t>(charArray.size())) == true,
"charArrayLength should be equal");
ASSERT(genericCompare(pdxobjPtr->getCharArray(), charArray,
charArray.size()) == true,
"charArray should be equal");
ASSERT(pIPtr->getFieldType("m_charArray") == PdxFieldTypes::CHAR_ARRAY,
"Type Value CHAR_ARRAY Mismatch");
byteArray = pIPtr->getByteArrayField("m_sbyteArray");
ASSERT(genericValCompare(pdxobjPtr->getByteArrayLength(),
static_cast<int32_t>(byteArray.size())) == true,
"sbyteArrayLength should be equal");
ASSERT(genericCompare(pdxobjPtr->getSByteArray(), byteArray,
byteArray.size()) == true,
"m_sbyteArray should be equal");
ASSERT(pIPtr->getFieldType("m_sbyteArray") == PdxFieldTypes::BYTE_ARRAY,
"Type Value BYTE_ARRAY Mismatch");
auto boolArray = pIPtr->getBooleanArrayField("m_boolArray");
auto boolArrayLength = boolArray.size();
ASSERT(genericValCompare(pdxobjPtr->getBoolArrayLength(),
static_cast<int32_t>(boolArrayLength)) == true,
"boolArrayLength should be equal");
ASSERT(genericCompare(pdxobjPtr->getBoolArray(), boolArray,
boolArrayLength) == true,
"boolArray should be equal");
ASSERT(pIPtr->getFieldType("m_boolArray") == PdxFieldTypes::BOOLEAN_ARRAY,
"Type Value BOOLEAN_ARRAY Mismatch");
auto shortArray = pIPtr->getShortArrayField("m_int16Array");
auto shortArrayLength = shortArray.size();
ASSERT(genericValCompare(pdxobjPtr->getShortArrayLength(),
static_cast<int32_t>(shortArrayLength)) == true,
"shortArrayLength should be equal");
ASSERT(genericCompare(pdxobjPtr->getShortArray(), shortArray,
shortArrayLength) == true,
"shortArray should be equal");
ASSERT(pIPtr->getFieldType("m_int16Array") == PdxFieldTypes::SHORT_ARRAY,
"Type Value SHORT_ARRAY Mismatch");
shortArray = pIPtr->getShortArrayField("m_uint16Array");
shortArrayLength = shortArray.size();
ASSERT(genericValCompare(pdxobjPtr->getShortArrayLength(),
static_cast<int32_t>(shortArrayLength)) == true,
"shortArrayLength should be equal");
ASSERT(genericCompare(pdxobjPtr->getUInt16Array(), shortArray,
shortArrayLength) == true,
"m_uint16Array should be equal");
ASSERT(pIPtr->getFieldType("m_uint16Array") == PdxFieldTypes::SHORT_ARRAY,
"Type Value SHORT_ARRAY Mismatch");
auto intArray = pIPtr->getIntArrayField("m_int32Array");
auto intArrayLength = intArray.size();
ASSERT(genericValCompare(pdxobjPtr->getIntArrayLength(),
static_cast<int32_t>(intArrayLength)) == true,
"intArrayLength should be equal");
ASSERT(genericCompare(pdxobjPtr->getIntArray(), intArray, intArrayLength) ==
true,
"intArray should be equal");
ASSERT(pIPtr->getFieldType("m_int32Array") == PdxFieldTypes::INT_ARRAY,
"Type Value INT_ARRAY Mismatch");
intArray = pIPtr->getIntArrayField("m_uint32Array");
ASSERT(genericValCompare(pdxobjPtr->getIntArrayLength(),
static_cast<int32_t>(intArrayLength)) == true,
"intArrayLength should be equal");
ASSERT(genericCompare(pdxobjPtr->getUIntArray(), intArray,
intArrayLength) == true,
"m_uint32Array should be equal");
ASSERT(pIPtr->getFieldType("m_uint32Array") == PdxFieldTypes::INT_ARRAY,
"Type Value INT_ARRAY Mismatch");
auto longArray = pIPtr->getLongArrayField("m_longArray");
auto longArrayLength = longArray.size();
ASSERT(genericValCompare(pdxobjPtr->getLongArrayLength(),
static_cast<int32_t>(longArrayLength)) == true,
"longArrayLength should be equal");
ASSERT(genericCompare(pdxobjPtr->getLongArray(), longArray,
longArrayLength) == true,
"longArray should be equal");
ASSERT(pIPtr->getFieldType("m_longArray") == PdxFieldTypes::LONG_ARRAY,
"Type Value LONG_ARRAY Mismatch");
longArray = pIPtr->getLongArrayField("m_ulongArray");
longArrayLength = longArray.size();
ASSERT(genericValCompare(pdxobjPtr->getLongArrayLength(),
static_cast<int32_t>(longArrayLength)) == true,
"longArrayLength should be equal");
ASSERT(genericCompare(pdxobjPtr->getULongArray(), longArray,
longArrayLength) == true,
"m_ulongArray should be equal");
ASSERT(pIPtr->getFieldType("m_ulongArray") == PdxFieldTypes::LONG_ARRAY,
"Type Value LONG_ARRAY Mismatch");
auto doubleArray = pIPtr->getDoubleArrayField("m_doubleArray");
auto doubleArrayLength = doubleArray.size();
ASSERT(genericValCompare(pdxobjPtr->getDoubleArrayLength(),
static_cast<int32_t>(doubleArrayLength)) == true,
"doubleArrayLength should be equal");
ASSERT(genericCompare(pdxobjPtr->getDoubleArray(), doubleArray,
doubleArrayLength) == true,
"doubleArray should be equal");
ASSERT(pIPtr->getFieldType("m_doubleArray") == PdxFieldTypes::DOUBLE_ARRAY,
"Type Value DOUBLE_ARRAY Mismatch");
auto floatArray = pIPtr->getFloatArrayField("m_floatArray");
auto floatArrayLength = floatArray.size();
ASSERT(genericValCompare(pdxobjPtr->getFloatArrayLength(),
static_cast<int32_t>(floatArrayLength)) == true,
"floatArrayLength should be equal");
ASSERT(genericCompare(pdxobjPtr->getFloatArray(), floatArray,
floatArrayLength) == true,
"floatArray should be equal");
ASSERT(pIPtr->getFieldType("m_floatArray") == PdxFieldTypes::FLOAT_ARRAY,
"Type Value FLOAT_ARRAY Mismatch");
auto object = pIPtr->getCacheableField("m_pdxEnum");
ASSERT(object != nullptr, "enumObject should not be nullptr");
auto enumObject = std::dynamic_pointer_cast<CacheableEnum>(object);
ASSERT(
enumObject->getEnumOrdinal() == pdxobjPtr->getEnum()->getEnumOrdinal(),
"enumObject ordinal should be equal");
ASSERT(enumObject->getEnumClassName() ==
pdxobjPtr->getEnum()->getEnumClassName(),
"enumObject classname should be equal");
ASSERT(enumObject->getEnumName() == pdxobjPtr->getEnum()->getEnumName(),
"enumObject enumname should be equal");
ASSERT(pIPtr->getFieldType("m_pdxEnum") == PdxFieldTypes::OBJECT,
"Type Value OBJECT Mismatch");
auto dateObject = pIPtr->getCacheableDateField("m_dateTime");
ASSERT(dateObject != nullptr, "date should not be nullptr");
ASSERT((*(dateObject.get()) == *(pdxobjPtr->getDate().get())) == true,
"dateObject should be equal");
ASSERT(pIPtr->getFieldType("m_dateTime") == PdxFieldTypes::DATE,
"Type Value DATE Mismatch");
auto object2 = pIPtr->getCacheableField("m_map");
ASSERT(object2 != nullptr, "object2 should not be nullptr");
auto mapObject = std::dynamic_pointer_cast<CacheableHashMap>(object2);
ASSERT(genericValCompare(pdxobjPtr->getHashMap()->size(),
mapObject->size()) == true,
"mapobject size should be equal");
ASSERT(pIPtr->getFieldType("m_map") == PdxFieldTypes::OBJECT,
"Type Value OBJECT Mismatch");
object2 = pIPtr->getCacheableField("m_vector");
ASSERT(object2 != nullptr, "object2 should not be nullptr");
auto vec = std::dynamic_pointer_cast<CacheableVector>(object2);
ASSERT(
genericValCompare(pdxobjPtr->getVector()->size(), vec->size()) == true,
"vec size should be equal");
ASSERT(pIPtr->getFieldType("m_vector") == PdxFieldTypes::OBJECT,
"Type Value OBJECT Mismatch");
object2 = pIPtr->getCacheableField("m_arraylist");
ASSERT(object2 != nullptr, "object2 should not be nullptr");
auto arrList = std::dynamic_pointer_cast<CacheableArrayList>(object2);
ASSERT(genericValCompare(pdxobjPtr->getArrayList()->size(),
arrList->size()) == true,
"arrList size should be equal");
ASSERT(pIPtr->getFieldType("m_arraylist") == PdxFieldTypes::OBJECT,
"Type Value OBJECT Mismatch");
object2 = pIPtr->getCacheableField("m_chs");
ASSERT(object2 != nullptr, "object2 should not be nullptr");
auto hashSet = std::dynamic_pointer_cast<CacheableHashSet>(object2);
ASSERT(genericValCompare(pdxobjPtr->getHashSet()->size(),
hashSet->size()) == true,
"hashSet size should be equal");
ASSERT(pIPtr->getFieldType("m_chs") == PdxFieldTypes::OBJECT,
"Type Value OBJECT Mismatch");
object2 = pIPtr->getCacheableField("m_clhs");
ASSERT(object2 != nullptr, "object2 should not be nullptr");
auto linkedHashSet =
std::dynamic_pointer_cast<CacheableLinkedHashSet>(object2);
ASSERT(genericValCompare(pdxobjPtr->getLinkedHashSet()->size(),
linkedHashSet->size()) == true,
"linkedHashSet size should be equal");
ASSERT(pIPtr->getFieldType("m_clhs") == PdxFieldTypes::OBJECT,
"Type Value OBJECT Mismatch");
int8_t **byteByteArrayVal = nullptr;
int32_t byteArrayLen = 0;
int32_t *elementLength = nullptr;
pIPtr->getField("m_byteByteArray", &byteByteArrayVal, byteArrayLen,
elementLength);
ASSERT(genericValCompare(pdxobjPtr->getbyteByteArrayLength(),
byteArrayLen) == true,
"byteByteArrayLength should be equal");
int8_t **bytArray = pdxobjPtr->getArrayOfByteArrays();
ASSERT(generic2DCompare(byteByteArrayVal, bytArray, byteArrayLen,
elementLength) == true,
"byteByteArray should be equal");
ASSERT(pIPtr->getFieldType("m_byteByteArray") ==
PdxFieldTypes::ARRAY_OF_BYTE_ARRAYS,
"Type Value ARRAY_OF_BYTE_ARRAYS Mismatch");
auto objectArray = pIPtr->getCacheableObjectArrayField("m_objectArray");
ASSERT(objectArray != nullptr, "objectArray should not be nullptr");
ASSERT(genericValCompare(pdxobjPtr->getCacheableObjectArray()->size(),
objectArray->size()) == true,
"objectArray size should be equal");
ASSERT(pIPtr->getFieldType("m_objectArray") == PdxFieldTypes::OBJECT_ARRAY,
"Type Value OBJECT_ARRAY Mismatch");
auto objectArrayEmptyFieldName = pIPtr->getCacheableObjectArrayField("");
ASSERT(objectArrayEmptyFieldName != nullptr,
"objectArrayEmptyFieldName should not be nullptr");
ASSERT(genericValCompare(
pdxobjPtr->getCacheableObjectArrayEmptyPdxFieldName()->size(),
objectArrayEmptyFieldName->size()) == true,
"objectArrayEmptyFieldName size should be equal");
for (size_t i = 0; i < objectArray->size(); i++) {
auto pi = std::dynamic_pointer_cast<PdxInstance>(objectArray->at(i));
LOG("PdxInstancePtr obtained from CacheableObjectArray");
auto pdxFactory =
cacheHelper->getCache()->createPdxInstanceFactory("PdxTests.Address");
LOG("PdxInstanceFactoryPtr created for PdxTests.Address....");
pdxFactory.writeInt("_aptNumber", static_cast<int32_t>(i + 1));
char streetStr[256] = {0};
sprintf(streetStr, "street%zd", i);
pdxFactory.writeString("_street", streetStr);
char cityStr[256] = {0};
sprintf(cityStr, "city%zd", i);
pdxFactory.writeString("_city", cityStr);
auto addrPtr = std::dynamic_pointer_cast<Address>(pi->getObject());
LOG("AddressPtr created using PdxInstance getObject()....");
auto newAddrPtr = std::make_shared<Address>(static_cast<int32_t>(i + 1),
streetStr, cityStr);
LOG("AddressPtr created using new....");
ASSERT(addrPtr->equals(*newAddrPtr) == true,
"Both PdxInstances should be equal.");
auto retPtr = pdxFactory.create();
LOG("PdxInstancePtr created....");
bool ret = false;
ret = (*pi == *retPtr);
LOGINFO("PdxObject ret = %d ", ret);
ASSERT(ret == true, "Both PdxInstances should be equal.");
}
LOGINFO("PdxInstancePtr for ParentPdx accessPdxInstance ");
pIPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport1));
LOGINFO("PdxInstancePtr for ParentPdx object got ");
auto childObjPtr = pIPtr->getCacheableField("m_childPdx");
ASSERT(childObjPtr != nullptr, "childObjPtr should not be nullptr");
LOGINFO("got childPdx field ");
auto cpi = std::dynamic_pointer_cast<PdxInstance>(childObjPtr);
LOGINFO("cast to pdxinstance done ");
auto cpo = std::dynamic_pointer_cast<ChildPdx>(cpi->getObject());
LOGINFO("got childPdx getObject ");
auto childpdxobjPtr = std::make_shared<ChildPdx>(1);
LOGINFO("created new childPdx");
ASSERT(cpo->equals(*childpdxobjPtr) == true, "child pdx should be equal");
LOG("accessPdxInstance complete");
}
END_TASK_DEFINITION
DUNIT_TASK_DEFINITION(CLIENT2, modifyPdxInstance)
{
LOG("modifyPdxInstance started ");
auto rptr = getHelper()->getRegion(regionNames[0]);
auto keyport = CacheableKey::create("pdxput");
auto keyport1 = CacheableKey::create("pdxput2");
auto pIPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
LOG("modifyPdxInstance get complete.");
std::shared_ptr<WritablePdxInstance> wpiPtr(pIPtr->createWriter());
ASSERT(pIPtr != nullptr, "pIPtr != nullptr expected");
int val = 0;
int newVal = 0;
ASSERT(pIPtr->hasField("m_int32") == true, "m_id1 = true expected");
val = pIPtr->getIntField("m_int32");
wpiPtr->setField("m_int32", val + 1);
rptr->put(keyport, wpiPtr);
auto newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(newPiPtr->hasField("m_int32") == true, "m_int32 = true expected");
newVal = newPiPtr->getIntField("m_int32");
ASSERT(val + 1 == newVal, "val + 1 == newVal expected");
ASSERT((*pIPtr == *newPiPtr) == false, "PdxInstance should not be equal");
wpiPtr = pIPtr->createWriter();
try {
wpiPtr->setField("m_int32", false);
FAIL(
"setField on m_int32 with bool value should throw expected "
"IllegalStateException");
} catch (IllegalStateException &) {
LOG("setField on m_int32 with bool value caught expected "
"IllegalStateException");
}
bool boolVal = true;
wpiPtr = pIPtr->createWriter();
wpiPtr->setField("m_bool", false);
rptr->put(keyport, wpiPtr);
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(newPiPtr->hasField("m_bool") == true, "m_bool = true expected");
boolVal = newPiPtr->getBooleanField("m_bool");
ASSERT(boolVal == false, "bool is not equal");
ASSERT((*pIPtr == *newPiPtr) == false, "PdxInstance should not be equal");
wpiPtr = pIPtr->createWriter();
try {
wpiPtr->setField("m_bool", 500);
FAIL(
"setField on m_bool with int value should throw expected "
"IllegalStateException");
} catch (IllegalStateException &) {
LOG("setField on m_bool with int value caught expected "
"IllegalStateException");
}
wpiPtr = pIPtr->createWriter();
try {
wpiPtr->setField("m_char", 500.0);
FAIL(
"setField on m_char with float value should throw expected "
"IllegalStateException");
} catch (IllegalStateException &) {
LOG("setField on m_char with float value caught expected "
"IllegalStateException");
}
signed char byteVal = 0;
signed char setByteVal = 0x75;
wpiPtr = pIPtr->createWriter();
wpiPtr->setField("m_byte", setByteVal);
rptr->put(keyport, wpiPtr);
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(newPiPtr->hasField("m_byte") == true, "m_byte = true expected");
byteVal = newPiPtr->getByteField("m_byte");
ASSERT(byteVal == setByteVal, "byte is not equal");
ASSERT((*pIPtr == *newPiPtr) == false, "PdxInstance should not be equal");
signed char setSByteVal = 0x57;
wpiPtr = pIPtr->createWriter();
wpiPtr->setField("m_sbyte", setSByteVal);
rptr->put(keyport, wpiPtr);
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(newPiPtr->hasField("m_sbyte") == true, "m_sbyte = true expected");
byteVal = newPiPtr->getByteField("m_sbyte");
ASSERT(byteVal == setSByteVal, "m_sbyte is not equal");
ASSERT((*pIPtr == *newPiPtr) == false, "PdxInstance should not be equal");
wpiPtr = pIPtr->createWriter();
try {
wpiPtr->setField("m_byte", static_cast<int64_t>(0x56787878));
FAIL(
"setField on m_byte with int64_t value should throw expected "
"IllegalStateException");
} catch (IllegalStateException &) {
LOG("setField on m_byte with int64_t value caught expected "
"IllegalStateException");
}
int16_t shortVal = 0;
wpiPtr = pIPtr->createWriter();
wpiPtr->setField("m_int16", static_cast<int16_t>(0x5678));
rptr->put(keyport, wpiPtr);
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(newPiPtr->hasField("m_int16") == true, "m_int16 = true expected");
shortVal = newPiPtr->getShortField("m_int16");
ASSERT(shortVal == 0x5678, "short is not equal");
ASSERT((*pIPtr == *newPiPtr) == false, "PdxInstance should not be equal");
wpiPtr = pIPtr->createWriter();
try {
wpiPtr->setField("m_int16", static_cast<int64_t>(0x56787878));
FAIL(
"setField on m_int16 with int64_t value should throw expected "
"IllegalStateException");
} catch (IllegalStateException &) {
LOG("setField on m_int16 with int64_t value caught expected "
"IllegalStateException");
}
int64_t longVal = 0;
wpiPtr = pIPtr->createWriter();
wpiPtr->setField("m_long", static_cast<int64_t>(0x56787878));
rptr->put(keyport, wpiPtr);
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(newPiPtr->hasField("m_long") == true, "m_long = true expected");
longVal = newPiPtr->getLongField("m_long");
ASSERT(longVal == 0x56787878, "long is not equal");
ASSERT((*pIPtr == *newPiPtr) == false, "PdxInstance should not be equal");
wpiPtr = pIPtr->createWriter();
try {
wpiPtr->setField("m_long", 18389.34f);
FAIL(
"setField on m_long with float value should throw expected "
"IllegalStateException");
} catch (IllegalStateException &) {
LOG("setField on m_long with float value caught expected "
"IllegalStateException");
}
float fVal = 0.0f;
wpiPtr = pIPtr->createWriter();
wpiPtr->setField("m_float", 18389.34f);
rptr->put(keyport, wpiPtr);
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(newPiPtr->hasField("m_float") == true, "m_float = true expected");
fVal = newPiPtr->getFloatField("m_float");
ASSERT(fVal == 18389.34f, "fval is not equal");
ASSERT((*pIPtr == *newPiPtr) == false, "PdxInstance should not be equal");
wpiPtr = pIPtr->createWriter();
try {
wpiPtr->setField("m_float", 'D');
FAIL(
"setField on m_float with char value should throw expected "
"IllegalStateException");
} catch (IllegalStateException &) {
LOG("setField on m_float with char value caught expected "
"IllegalStateException");
}
double dVal = 0.0;
wpiPtr = pIPtr->createWriter();
wpiPtr->setField("m_double", 18389.34);
rptr->put(keyport, wpiPtr);
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(newPiPtr->hasField("m_double") == true, "m_double = true expected");
dVal = newPiPtr->getDoubleField("m_double");
ASSERT(dVal == 18389.34, "dval is not equal");
ASSERT((*pIPtr == *newPiPtr) == false, "PdxInstance should not be equal");
wpiPtr = pIPtr->createWriter();
try {
wpiPtr->setField("m_double", 'D');
FAIL(
"setField on m_double with char value should throw expected "
"IllegalStateException");
} catch (IllegalStateException &) {
LOG("setField on m_double with char value caught expected "
"IllegalStateException");
}
std::vector<bool> setBoolArray{true, false, true, false,
true, true, false, true};
wpiPtr->setField("m_boolArray", setBoolArray);
rptr->put(keyport, wpiPtr);
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(newPiPtr->hasField("m_boolArray") == true,
"m_boolArray = true expected");
auto getBoolArray = newPiPtr->getBooleanArrayField("m_boolArray");
ASSERT(getBoolArray.size() == 8, "Arraylength == 8 expected");
ASSERT(
genericCompare(setBoolArray, getBoolArray, getBoolArray.size()) == true,
"boolArray should be equal");
ASSERT((*pIPtr == *newPiPtr) == false, "PdxInstance should not be equal");
wpiPtr = pIPtr->createWriter();
try {
wpiPtr->setField("m_boolArray", 'D');
FAIL(
"setField on m_boolArray with char value should throw expected "
"IllegalStateException");
} catch (IllegalStateException &) {
LOG("setField on m_boolArray with char value caught expected "
"IllegalStateException");
}
std::vector<int8_t> setByteArray{0x34, 0x64, 0x34, 0x64};
wpiPtr->setField("m_byteArray", setByteArray);
rptr->put(keyport, wpiPtr);
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(newPiPtr->hasField("m_byteArray") == true,
"m_byteArray = true expected");
auto getByteArray = newPiPtr->getByteArrayField("m_byteArray");
ASSERT(getByteArray.size() == 4, "Arraylength == 4 expected");
ASSERT(
genericCompare(setByteArray, getByteArray, getByteArray.size()) == true,
"byteArray should be equal");
ASSERT((*pIPtr == *newPiPtr) == false, "PdxInstance should not be equal");
wpiPtr = pIPtr->createWriter();
try {
wpiPtr->setField("m_byteArray", "string");
FAIL(
"setField on m_byteArray with string value should throw expected "
"IllegalStateException");
} catch (IllegalStateException &) {
LOG("setField on m_byteArray with string value caught expected "
"IllegalStateException");
}
std::vector<char16_t> setCharArray{'c', 'v', 'c', 'v'};
wpiPtr->setField("m_charArray", setCharArray);
rptr->put(keyport, wpiPtr);
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(newPiPtr->hasField("m_charArray") == true,
"m_charArray = true expected");
auto getCharArray = newPiPtr->getCharArrayField("m_charArray");
ASSERT(getCharArray.size() == 4, "Arraylength == 4 expected");
ASSERT(
genericCompare(setCharArray, getCharArray, getCharArray.size()) == true,
"charArray should be equal");
ASSERT((*pIPtr == *newPiPtr) == false, "PdxInstance should not be equal");
wpiPtr = pIPtr->createWriter();
try {
wpiPtr->setField("m_charArray", "string");
FAIL(
"setField on m_charArray with string value should throw expected "
"IllegalStateException");
} catch (IllegalStateException &) {
LOG("setField on m_charArray with string value caught expected "
"IllegalStateException");
}
std::vector<int16_t> setShortArray{0x2332, 0x4545, 0x88, 0x898};
wpiPtr->setField("m_int16Array", setShortArray);
rptr->put(keyport, wpiPtr);
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(newPiPtr->hasField("m_int16Array") == true,
"m_int16Array = true expected");
auto getShortArray = newPiPtr->getShortArrayField("m_int16Array");
ASSERT(getShortArray.size() == 4, "Arraylength == 4 expected");
ASSERT(genericCompare(setShortArray, getShortArray, getShortArray.size()) ==
true,
"shortArray should be equal");
ASSERT((*pIPtr == *newPiPtr) == false, "PdxInstance should not be equal");
wpiPtr = pIPtr->createWriter();
try {
wpiPtr->setField("m_int16Array", setCharArray);
FAIL(
"setField on m_int16Array with setCharArray value should throw "
"expected IllegalStateException");
} catch (IllegalStateException &) {
LOG("setField on m_int16Array with setCharArray value caught expected "
"IllegalStateException");
}
std::vector<int32_t> setIntArray{23, 676868, 34343};
wpiPtr->setField("m_int32Array", setIntArray);
rptr->put(keyport, wpiPtr);
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(newPiPtr->hasField("m_int32Array") == true,
"m_int32Array = true expected");
auto newValArray = newPiPtr->getIntArrayField("m_int32Array");
ASSERT(newValArray.size() == 3, "Arraylength == 3 expected");
ASSERT(genericCompare(setIntArray, newValArray, newValArray.size()) == true,
"intArray should be equal");
ASSERT((*pIPtr == *newPiPtr) == false, "PdxInstance should not be equal");
wpiPtr = pIPtr->createWriter();
try {
wpiPtr->setField("m_int32Array", setShortArray);
FAIL(
"setField on m_int32Array with setShortArray value should throw "
"expected IllegalStateException");
} catch (IllegalStateException &) {
LOG("setField on m_int32Array with setShortArray value caught expected "
"IllegalStateException");
}
std::vector<int64_t> setLongArray{3245435, 3425435};
wpiPtr->setField("m_longArray", setLongArray);
rptr->put(keyport, wpiPtr);
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(newPiPtr->hasField("m_longArray") == true,
"m_longArray = true expected");
auto getLongArray = newPiPtr->getLongArrayField("m_longArray");
ASSERT(getLongArray.size() == 2, "Arraylength == 2 expected");
ASSERT(
genericCompare(setLongArray, getLongArray, getLongArray.size()) == true,
"longArray should be equal");
ASSERT((*pIPtr == *newPiPtr) == false, "PdxInstance should not be equal");
wpiPtr = pIPtr->createWriter();
try {
wpiPtr->setField("m_longArray", setIntArray);
FAIL(
"setField on m_longArray with setIntArray value should throw "
"expected "
"IllegalStateException");
} catch (IllegalStateException &) {
LOG("setField on m_longArray with setIntArray value caught expected "
"IllegalStateException");
}
std::vector<float> setFloatArray{232.565f, 234323354.67f};
wpiPtr->setField("m_floatArray", setFloatArray);
rptr->put(keyport, wpiPtr);
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(newPiPtr->hasField("m_floatArray") == true,
"m_floatArray = true expected");
auto getFloatArray = newPiPtr->getFloatArrayField("m_floatArray");
ASSERT(getFloatArray.size() == 2, "Arraylength == 2 expected");
ASSERT(genericCompare(setFloatArray, getFloatArray, getFloatArray.size()) ==
true,
"floatArray should be equal");
ASSERT((*pIPtr == *newPiPtr) == false, "PdxInstance should not be equal");
wpiPtr = pIPtr->createWriter();
try {
wpiPtr->setField("m_floatArray", setLongArray);
FAIL(
"setField on m_floatArray with setLongArray value should throw "
"expected IllegalStateException");
} catch (IllegalStateException &) {
LOG("setField on m_floatArray with setLongArray value caught expected "
"IllegalStateException");
}
std::vector<double> setDoubleArray{23423432.00, 43242354315.00};
wpiPtr->setField("m_doubleArray", setDoubleArray);
rptr->put(keyport, wpiPtr);
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(newPiPtr->hasField("m_doubleArray") == true,
"m_doubleArray = true expected");
auto getDoubleArray = newPiPtr->getDoubleArrayField("m_doubleArray");
ASSERT(getDoubleArray.size() == 2, "Arraylength == 2 expected");
ASSERT(genericCompare(setDoubleArray, getDoubleArray,
getDoubleArray.size()) == true,
"doubleArray should be equal");
ASSERT((*pIPtr == *newPiPtr) == false, "PdxInstance should not be equal");
wpiPtr = pIPtr->createWriter();
try {
wpiPtr->setField("m_doubleArray", setFloatArray);
FAIL(
"setField on m_doubleArray with setFloatArray value should throw "
"expected IllegalStateException");
} catch (IllegalStateException &) {
LOG("setField on m_doubleArray with setFloatArray value caught expected "
"IllegalStateException");
}
wpiPtr = pIPtr->createWriter();
try {
wpiPtr->setField("m_string", setFloatArray);
FAIL(
"setField on m_string with setFloatArray value should throw expected "
"IllegalStateException");
} catch (IllegalStateException &) {
LOG("setField on m_string with setFloatArray value caught expected "
"IllegalStateException");
}
std::string setString = "change the string";
wpiPtr->setField("m_string", setString);
rptr->put(keyport, wpiPtr);
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(pIPtr->hasField("m_string") == true, "m_string = true expected");
ASSERT(newPiPtr->hasField("m_string") == true, "m_string = true expected");
auto stringVal = newPiPtr->getStringField("m_string");
ASSERT(stringVal == setString, "stringVal should be equal");
ASSERT((*pIPtr == *newPiPtr) == false, "PdxInstance should not be equal");
std::shared_ptr<CacheableDate> dateVal;
wpiPtr = pIPtr->createWriter();
time_t timeofday = 0;
const ACE_Time_Value currentTime = ACE_OS::gettimeofday();
timeofday = currentTime.sec();
auto datePtr = CacheableDate::create(timeofday);
wpiPtr->setField("m_dateTime", datePtr);
rptr->put(keyport, wpiPtr);
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(newPiPtr->hasField("m_dateTime") == true,
"m_dateTime = true expected");
ASSERT(pIPtr->hasField("m_dateTime") == true, "m_date = true expected");
dateVal = newPiPtr->getCacheableDateField("m_dateTime");
ASSERT((*dateVal == *datePtr) == true, "dateObject should be equal");
ASSERT((*pIPtr == *newPiPtr) == false, "PdxInstance should not be equal");
wpiPtr = pIPtr->createWriter();
try {
wpiPtr->setField("m_dateTime", setString);
FAIL(
"setField on m_dateTime with setString value should throw expected "
"IllegalStateException");
} catch (IllegalStateException &) {
LOG("setField on m_dateTime with setString value caught expected "
"IllegalStateException");
}
std::shared_ptr<Cacheable> object;
wpiPtr = pIPtr->createWriter();
auto setVec = CacheableVector::create();
setVec->push_back(CacheableInt32::create(3));
setVec->push_back(CacheableInt32::create(4));
wpiPtr->setField("m_vector", setVec);
rptr->put(keyport, wpiPtr);
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(newPiPtr->hasField("m_vector") == true, "m_vector = true expected");
ASSERT(pIPtr->hasField("m_vector") == true, "m_vector = true expected");
object = newPiPtr->getCacheableField("m_vector");
auto vecVal = std::dynamic_pointer_cast<CacheableVector>(object);
ASSERT(genericValCompare(setVec->size(), vecVal->size()) == true,
"vec size should be equal");
for (size_t j = 0; j < vecVal->size(); j++) {
genericValCompare(setVec->at(j), vecVal->at(j));
}
wpiPtr = pIPtr->createWriter();
try {
wpiPtr->setField("m_vector", setString);
FAIL(
"setField on m_vector with setString value should throw expected "
"IllegalStateException");
} catch (IllegalStateException &) {
LOG("setField on m_vector with setString value caught expected "
"IllegalStateException");
}
wpiPtr = pIPtr->createWriter();
auto setarr = CacheableArrayList::create();
setarr->push_back(CacheableInt32::create(3));
setarr->push_back(CacheableInt32::create(4));
setarr->push_back(CacheableInt32::create(5));
wpiPtr->setField("m_arraylist", setarr);
rptr->put(keyport, wpiPtr);
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(newPiPtr->hasField("m_arraylist") == true,
"m_arraylist = true expected");
ASSERT(pIPtr->hasField("m_arraylist") == true,
"m_arraylist = true expected");
object = newPiPtr->getCacheableField("m_arraylist");
auto arrVal = std::dynamic_pointer_cast<CacheableArrayList>(object);
ASSERT(genericValCompare(setarr->size(), arrVal->size()) == true,
"arrList size should be equal");
for (size_t j = 0; j < arrVal->size(); j++) {
genericValCompare(setarr->at(j), arrVal->at(j));
}
wpiPtr = pIPtr->createWriter();
try {
wpiPtr->setField("m_arraylist", setFloatArray);
FAIL(
"setField on m_arraylist with setFloatArray value should throw "
"expected IllegalStateException");
} catch (IllegalStateException &) {
LOG("setField on m_arraylist with setFloatArray value caught expected "
"IllegalStateException");
}
wpiPtr = pIPtr->createWriter();
auto hashset = CacheableHashSet::create();
hashset->insert(CacheableInt32::create(3));
hashset->insert(CacheableInt32::create(4));
hashset->insert(CacheableInt32::create(5));
wpiPtr->setField("m_chs", hashset);
rptr->put(keyport, wpiPtr);
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(newPiPtr->hasField("m_chs") == true, "m_chs = true expected");
ASSERT(pIPtr->hasField("m_chs") == true, "m_chs = true expected");
object = newPiPtr->getCacheableField("m_chs");
auto hashsetVal = std::dynamic_pointer_cast<CacheableHashSet>(object);
ASSERT(genericValCompare(hashset->size(), hashsetVal->size()) == true,
"m_chs size should be equal");
wpiPtr = pIPtr->createWriter();
try {
wpiPtr->setField("m_chs", 100);
FAIL(
"setField on m_chs with int value should throw expected "
"IllegalStateException");
} catch (IllegalStateException &) {
LOG("setField on m_chs with int value caught expected "
"IllegalStateException");
}
wpiPtr = pIPtr->createWriter();
auto hashmap = CacheableHashMap::create();
hashmap->emplace(CacheableInt32::create(3), CacheableInt32::create(3));
hashmap->emplace(CacheableInt32::create(4), CacheableInt32::create(4));
hashmap->emplace(CacheableInt32::create(5), CacheableInt32::create(5));
wpiPtr->setField("m_map", hashmap);
rptr->put(keyport, wpiPtr);
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(newPiPtr->hasField("m_map") == true, "m_map = true expected");
ASSERT(pIPtr->hasField("m_map") == true, "m_map = true expected");
object = newPiPtr->getCacheableField("m_map");
auto hashmapVal = std::dynamic_pointer_cast<CacheableHashMap>(object);
ASSERT(genericValCompare(hashmap->size(), hashmapVal->size()) == true,
"m_map size should be equal");
wpiPtr = pIPtr->createWriter();
try {
wpiPtr->setField("m_map", 0.0f);
FAIL(
"setField on m_map with float value should throw expected "
"IllegalStateException");
} catch (IllegalStateException &) {
LOG("setField on m_map with float value caught expected "
"IllegalStateException");
}
wpiPtr = pIPtr->createWriter();
auto linkedhashset = CacheableLinkedHashSet::create();
linkedhashset->insert(CacheableInt32::create(3));
linkedhashset->insert(CacheableInt32::create(4));
linkedhashset->insert(CacheableInt32::create(5));
wpiPtr->setField("m_clhs", linkedhashset);
rptr->put(keyport, wpiPtr);
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(newPiPtr->hasField("m_clhs") == true, "m_clhs = true expected");
ASSERT(pIPtr->hasField("m_clhs") == true, "m_clhs = true expected");
object = newPiPtr->getCacheableField("m_clhs");
auto linkedhashsetVal =
std::dynamic_pointer_cast<CacheableLinkedHashSet>(object);
ASSERT(genericValCompare(linkedhashsetVal->size(), linkedhashset->size()) ==
true,
"m_clhs size should be equal");
wpiPtr = pIPtr->createWriter();
try {
wpiPtr->setField("m_clhs", 'c');
FAIL(
"setField on m_clhs with char value should throw expected "
"IllegalStateException");
} catch (IllegalStateException &) {
LOG("setField on m_clhs with char value caught expected "
"IllegalStateException");
}
LOGINFO("Testing byteByteArray");
int8_t **getbyteByteArray = nullptr;
int byteByteArrayLength = 0;
int32_t *elementLength = nullptr;
int8_t **setbyteByteArray = new int8_t *[4];
setbyteByteArray[0] = new int8_t[1];
setbyteByteArray[1] = new int8_t[2];
setbyteByteArray[2] = new int8_t[1];
setbyteByteArray[3] = new int8_t[2];
setbyteByteArray[0][0] = 0x23;
setbyteByteArray[1][0] = 0x34;
setbyteByteArray[1][1] = 0x55;
setbyteByteArray[2][0] = 0x23;
setbyteByteArray[3][0] = 0x34;
setbyteByteArray[3][1] = 0x55;
wpiPtr = pIPtr->createWriter();
int *lengthArr = new int[4];
lengthArr[0] = 1;
lengthArr[1] = 2;
lengthArr[2] = 1;
lengthArr[3] = 2;
wpiPtr->setField("m_byteByteArray", setbyteByteArray, 4, lengthArr);
LOGINFO("Testing byteByteArray setField");
rptr->put(keyport, wpiPtr);
LOGINFO("Testing byteByteArray put");
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
LOGINFO("Testing byteByteArray get");
ASSERT(newPiPtr->hasField("m_byteByteArray") == true,
"m_byteByteArray = true expected");
LOGINFO("Testing byteByteArray hasField");
ASSERT(pIPtr->hasField("m_byteByteArray") == true,
"m_byteByteArray = true expected");
newPiPtr->getField("m_byteByteArray", &getbyteByteArray,
byteByteArrayLength, elementLength);
LOGINFO("Testing byteByteArray getField");
ASSERT(genericValCompare(4, byteByteArrayLength) == true,
"byteByteArrayLength should be equal");
ASSERT(generic2DCompare(getbyteByteArray, setbyteByteArray,
byteByteArrayLength, elementLength) == true,
"byteByteArray should be equal");
wpiPtr = pIPtr->createWriter();
try {
wpiPtr->setField("m_byteByteArray", linkedhashset);
FAIL(
"setField on m_byteByteArray with linkedhashset value should throw "
"expected IllegalStateException");
} catch (IllegalStateException &) {
LOG("setField on m_byteByteArray with linkedhashset value caught "
"expected "
"IllegalStateException");
}
auto setStringArray = new std::string[3]{"test1", "test2", "test3"};
wpiPtr->setField("m_stringArray", setStringArray, 3);
rptr->put(keyport, wpiPtr);
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
auto getStringArray = newPiPtr->getStringArrayField("m_stringArray");
ASSERT(getStringArray.size() == 3, "Arraylength == 3 expected");
for (size_t i = 0; i < getStringArray.size(); i++) {
LOGINFO("set string is %s ", setStringArray[i].c_str());
LOGINFO("get string is %s ", getStringArray[i].c_str());
ASSERT(setStringArray[i] == getStringArray[i],
"All stringVals should be equal");
}
ASSERT((*pIPtr == *newPiPtr) == false, "PdxInstance should not be equal");
LOGINFO("PdxInstancePtr for ParentPdx modifyPdxInstance ");
pIPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport1));
LOGINFO("PdxInstancePtr for ParentPdx object got ");
auto childObjPtr = pIPtr->getCacheableField("m_childPdx");
ASSERT(childObjPtr != nullptr, "childObjPtr should not be nullptr");
LOGINFO("got childPdx field ");
auto cpi = std::dynamic_pointer_cast<PdxInstance>(childObjPtr);
LOGINFO("cast to pdxinstance done ");
wpiPtr = pIPtr->createWriter();
auto childpdxobjPtr = std::make_shared<ChildPdx>(2);
LOGINFO("created new childPdx");
wpiPtr->setField("m_childPdx", childpdxobjPtr);
LOGINFO("childPdx seField done");
rptr->put(keyport1, wpiPtr);
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport1));
LOGINFO("ChildPdx object put get done");
ASSERT((*pIPtr == *newPiPtr) == false, "PdxInstance should not be equal");
childObjPtr = newPiPtr->getCacheableField("m_childPdx");
ASSERT(childObjPtr != nullptr, "childObjPtr should not be nullptr");
LOGINFO("got childPdx field ");
auto cpi1 = std::dynamic_pointer_cast<PdxInstance>(childObjPtr);
ASSERT((*cpi == *cpi1) == false, "PdxInstance should not be equal");
auto cpo = std::dynamic_pointer_cast<ChildPdx>(cpi1->getObject());
LOGINFO("got childPdx getObject ");
ASSERT(cpo->equals(*childpdxobjPtr) == true, "child pdx should be equal");
char16_t parentCharSetVal = 'Z';
wpiPtr = pIPtr->createWriter();
wpiPtr->setField("m_char", parentCharSetVal);
rptr->put(keyport1, wpiPtr);
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport1));
ASSERT(newPiPtr->hasField("m_char") == true, "m_char = true expected");
auto parentCharVal = newPiPtr->getCharField("m_char");
ASSERT(parentCharVal == parentCharSetVal, "char is not equal");
std::vector<char16_t> setParentCharArray{'c', 'v', 'c', 'v'};
wpiPtr->setField("m_charArray", setParentCharArray);
rptr->put(keyport1, wpiPtr);
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport1));
ASSERT(newPiPtr->hasField("m_charArray") == true,
"m_charArray = true expected");
auto getParentCharArray = newPiPtr->getCharArrayField("m_charArray");
ASSERT(getParentCharArray.size() == 4, "Arraylength == 4 expected");
ASSERT(genericCompare(setParentCharArray, getParentCharArray,
getParentCharArray.size()) == true,
"charArray should be equal");
LOG("modifyPdxInstance complete.");
}
END_TASK_DEFINITION
DUNIT_TASK_DEFINITION(CLIENT2, modifyPdxInstanceAndCheckLocally)
{
LOG("modifyPdxInstanceAndCheckLocally started ");
auto rptr = getHelper()->getRegion(regionNames[0]);
auto keyport = CacheableKey::create("pdxput");
auto pIPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
LOG("modifyPdxInstanceAndCheckLocally get complete.");
LOG("Statistics for for (PdxTests.PdxType) PdxInstance ");
LocalRegion *lregPtr = (dynamic_cast<LocalRegion *>(rptr.get()));
LOGINFO(
"pdxInstanceDeserializations for (PdxTests.PdxType) PdxInstance = %d ",
lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceDeserializations());
LOGINFO(
"pdxInstanceCreations for (PdxTests.PdxType) PdxInstance = %d ",
lregPtr->getCacheImpl()->getCachePerfStats().getPdxInstanceCreations());
LOGINFO(
"pdxInstanceDeserializationTime for(PdxTests.PdxType) PdxInstance = "
"%d ",
lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceDeserializationTime());
ASSERT(lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceDeserializations() == 0,
"pdxInstanceDeserialization should be equal to 0.");
ASSERT(lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceCreations() == 1,
"pdxInstanceCreations should be equal to 1.");
ASSERT(lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceDeserializationTime() > 0,
"pdxInstanceDeserializationTime should be greater than 0.");
std::shared_ptr<WritablePdxInstance> wpiPtr(pIPtr->createWriter());
ASSERT(pIPtr != nullptr, "pIPtr != nullptr expected");
int val = 0;
int newVal = 0;
ASSERT(pIPtr->hasField("m_int32") == true, "m_int32 = true expected");
val = pIPtr->getIntField("m_int32");
LOGINFO("PdxInstance val is %d ", val);
ASSERT(val == 591768540, "val = 591768540 expected");
wpiPtr->setField("m_int32", val + 1);
rptr->put(keyport, wpiPtr);
LOG("modifyPdxInstanceAndCheckLocally put complete.");
auto newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
LOG("modifyPdxInstanceAndCheckLocally get complete.");
ASSERT(newPiPtr->hasField("m_int32") == true, "m_id1 = true expected");
newVal = newPiPtr->getIntField("m_int32");
LOGINFO("PdxInstance newVal is %d ", newVal);
ASSERT(val + 1 == newVal, "val + 1 == newVal expected");
ASSERT((*pIPtr == *newPiPtr) == false, "PdxInstance should not be equal");
std::vector<bool> setBoolArray{true, false, true, false,
true, true, false, true};
wpiPtr->setField("m_boolArray", setBoolArray);
rptr->put(keyport, wpiPtr);
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(pIPtr->hasField("m_boolArray") == true,
"m_boolArray = true expected");
auto getBoolArray = newPiPtr->getBooleanArrayField("m_boolArray");
auto arrayLen = getBoolArray.size();
ASSERT(arrayLen == 8, "Arraylength == 8 expected");
ASSERT(genericCompare(setBoolArray, getBoolArray, arrayLen) == true,
"boolArray should be equal");
ASSERT((*pIPtr == *newPiPtr) == false, "PdxInstance should not be equal");
std::vector<int8_t> setByteArray{0x34, 0x64, 0x34, 0x64};
wpiPtr->setField("m_byteArray", setByteArray);
rptr->put(keyport, wpiPtr);
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(pIPtr->hasField("m_byteArray") == true,
"m_byteArray = true expected");
auto getByteArray = newPiPtr->getByteArrayField("m_byteArray");
arrayLen = getByteArray.size();
ASSERT(arrayLen == 4, "Arraylength == 4 expected");
ASSERT(genericCompare(setByteArray, getByteArray, arrayLen) == true,
"byteArray should be equal");
ASSERT((*pIPtr == *newPiPtr) == false, "PdxInstance should not be equal");
std::vector<int16_t> setShortArray{0x2332, 0x4545, 0x88, 0x898};
wpiPtr->setField("m_int16Array", setShortArray);
rptr->put(keyport, wpiPtr);
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(pIPtr->hasField("m_int16Array") == true,
"m_int16Array = true expected");
auto getShortArray = newPiPtr->getShortArrayField("m_int16Array");
arrayLen = getShortArray.size();
ASSERT(arrayLen == 4, "Arraylength == 4 expected");
ASSERT(genericCompare(setShortArray, getShortArray, arrayLen) == true,
"shortArray should be equal");
ASSERT((*pIPtr == *newPiPtr) == false, "PdxInstance should not be equal");
std::vector<int32_t> setIntArray{23, 676868, 34343};
wpiPtr->setField("m_int32Array", setIntArray);
rptr->put(keyport, wpiPtr);
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(pIPtr->hasField("m_int32Array") == true,
"m_int32Array = true expected");
auto newValArray = newPiPtr->getIntArrayField("m_int32Array");
arrayLen = newValArray.size();
ASSERT(arrayLen == 3, "Arraylength == 3 expected");
ASSERT(genericCompare(setIntArray, newValArray, arrayLen) == true,
"intArray should be equal");
ASSERT((*pIPtr == *newPiPtr) == false, "PdxInstance should not be equal");
std::vector<int64_t> setLongArray{3245435, 3425435};
wpiPtr->setField("m_longArray", setLongArray);
rptr->put(keyport, wpiPtr);
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(pIPtr->hasField("m_longArray") == true,
"m_longArray = true expected");
auto getLongArray = newPiPtr->getLongArrayField("m_longArray");
arrayLen = getLongArray.size();
ASSERT(arrayLen == 2, "Arraylength == 2 expected");
ASSERT(genericCompare(setLongArray, getLongArray, arrayLen) == true,
"longArray should be equal");
ASSERT((*pIPtr == *newPiPtr) == false, "PdxInstance should not be equal");
std::vector<float> setFloatArray{232.565f, 234323354.67f};
wpiPtr->setField("m_floatArray", setFloatArray);
rptr->put(keyport, wpiPtr);
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(pIPtr->hasField("m_floatArray") == true,
"m_floatArray = true expected");
auto getFloatArray = newPiPtr->getFloatArrayField("m_floatArray");
arrayLen = getFloatArray.size();
ASSERT(arrayLen == 2, "Arraylength == 2 expected");
ASSERT(genericCompare(setFloatArray, getFloatArray, arrayLen) == true,
"floatArray should be equal");
ASSERT((*pIPtr == *newPiPtr) == false, "PdxInstance should not be equal");
std::vector<double> setDoubleArray{23423432.00, 43242354315.00};
wpiPtr->setField("m_doubleArray", setDoubleArray);
rptr->put(keyport, wpiPtr);
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(pIPtr->hasField("m_doubleArray") == true,
"m_doubleArray = true expected");
auto getDoubleArray = newPiPtr->getDoubleArrayField("m_doubleArray");
arrayLen = getDoubleArray.size();
ASSERT(arrayLen == 2, "Arraylength == 2 expected");
ASSERT(genericCompare(setDoubleArray, getDoubleArray, arrayLen) == true,
"doubleArray should be equal");
ASSERT((*pIPtr == *newPiPtr) == false, "PdxInstance should not be equal");
bool boolVal = true;
wpiPtr = pIPtr->createWriter();
wpiPtr->setField("m_bool", false);
LOG("modifyPdxInstanceAndCheckLocally setField bool done.");
rptr->put(keyport, wpiPtr);
LOG("modifyPdxInstanceAndCheckLocally put again complete.");
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(pIPtr->hasField("m_bool") == true, "m_bool = true expected");
LOG("modifyPdxInstanceAndCheckLocally get again complete.");
boolVal = newPiPtr->getBooleanField("m_bool");
LOG("modifyPdxInstanceAndCheckLocally getField complete.");
ASSERT(boolVal == false, "bool is not equal");
ASSERT((*pIPtr == *newPiPtr) == false, "PdxInstance should not be equal");
wpiPtr = pIPtr->createWriter();
wpiPtr->setField("m_bool", true);
LOG("modifyPdxInstanceAndCheckLocally setField bool done.");
rptr->put(keyport, wpiPtr);
LOG("modifyPdxInstanceAndCheckLocally put again complete.");
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(pIPtr->hasField("m_bool") == true, "m_bool = true expected");
LOG("modifyPdxInstanceAndCheckLocally get again complete.");
boolVal = newPiPtr->getBooleanField("m_bool");
LOG("modifyPdxInstanceAndCheckLocally getField complete.");
ASSERT(boolVal == true, "bool is not equal");
ASSERT((*pIPtr == *newPiPtr) == true, "PdxInstance should be equal");
float fVal = 0.0f;
wpiPtr = pIPtr->createWriter();
wpiPtr->setField("m_float", 18389.34f);
LOG("modifyPdxInstanceAndCheckLocally setField float done.");
rptr->put(keyport, wpiPtr);
LOG("modifyPdxInstanceAndCheckLocally put again complete.");
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(pIPtr->hasField("m_float") == true, "m_float = true expected");
LOG("modifyPdxInstanceAndCheckLocally get again complete.");
fVal = newPiPtr->getFloatField("m_float");
LOGINFO("modifyPdxInstanceAndCheckLocally getField complete. fval = %f",
fVal);
ASSERT(fVal == 18389.34f, "fval is not equal");
ASSERT((*pIPtr == *newPiPtr) == false, "PdxInstance should not be equal");
double dVal = 0.0;
wpiPtr = pIPtr->createWriter();
wpiPtr->setField("m_double", 18389.34);
LOG("modifyPdxInstanceAndCheckLocally setField float done.");
rptr->put(keyport, wpiPtr);
LOG("modifyPdxInstanceAndCheckLocally put again complete.");
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(pIPtr->hasField("m_double") == true, "m_double = true expected");
LOG("modifyPdxInstanceAndCheckLocally get again complete.");
dVal = newPiPtr->getDoubleField("m_double");
LOGINFO("modifyPdxInstanceAndCheckLocally getField complete. fval = %lf",
dVal);
ASSERT(dVal == 18389.34, "fval is not equal");
ASSERT((*pIPtr == *newPiPtr) == false, "PdxInstance should not be equal");
signed char byteVal = 0;
signed char setSByteVal = 0x74;
wpiPtr = pIPtr->createWriter();
wpiPtr->setField("m_byte", setSByteVal);
LOG("modifyPdxInstanceAndCheckLocally setField byte done.");
rptr->put(keyport, wpiPtr);
LOG("modifyPdxInstanceAndCheckLocally put again complete.");
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(pIPtr->hasField("m_byte") == true, "m_byte = true expected");
LOG("modifyPdxInstanceAndCheckLocally get again complete.");
byteVal = newPiPtr->getByteField("m_byte");
LOGINFO("modifyPdxInstanceAndCheckLocally getField complete byteVal = %d ",
byteVal);
ASSERT(byteVal == setSByteVal, "byte is not equal");
ASSERT((*pIPtr == *newPiPtr) == true, "PdxInstance should be equal");
int16_t shortVal = 0;
wpiPtr = pIPtr->createWriter();
wpiPtr->setField("m_int16", static_cast<int16_t>(0x5678));
LOG("modifyPdxInstanceAndCheckLocally setField short done.");
rptr->put(keyport, wpiPtr);
LOG("modifyPdxInstanceAndCheckLocally put again complete.");
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(pIPtr->hasField("m_int16") == true, "m_int16 = true expected");
LOG("modifyPdxInstanceAndCheckLocally get again complete.");
shortVal = newPiPtr->getShortField("m_int16");
LOGINFO("modifyPdxInstanceAndCheckLocally getField complete shortVal = %d ",
shortVal);
ASSERT(shortVal == 0x5678, "short is not equal");
ASSERT((*pIPtr == *newPiPtr) == false, "PdxInstance should not be equal");
int64_t longVal = 0;
wpiPtr = pIPtr->createWriter();
wpiPtr->setField("m_long", static_cast<int64_t>(0x56787878));
LOG("modifyPdxInstanceAndCheckLocally setField short done.");
rptr->put(keyport, wpiPtr);
LOG("modifyPdxInstanceAndCheckLocally put again complete.");
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(pIPtr->hasField("m_long") == true, "m_long = true expected");
LOG("modifyPdxInstanceAndCheckLocally get again complete.");
longVal = newPiPtr->getLongField("m_long");
LOGINFO("modifyPdxInstanceAndCheckLocally getField complete longVal = %ld ",
longVal);
ASSERT(longVal == 0x56787878, "long is not equal");
ASSERT((*pIPtr == *newPiPtr) == false, "PdxInstance should not be equal");
std::string str1 = "change the string";
wpiPtr->setField("m_string", str1);
rptr->put(keyport, wpiPtr);
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(pIPtr->hasField("m_string") == true, "m_string = true expected");
LOG("modifyPdxInstanceAndCheckLocally get string complete.");
auto getstringVal = newPiPtr->getStringField("m_string");
LOGINFO("modifyPdxInstanceAndCheckLocally getstringVal = %s , str1 = %s ",
getstringVal.c_str(), str1.c_str());
ASSERT(getstringVal == str1, "getstringVal should be equal");
ASSERT((*pIPtr == *newPiPtr) == false, "PdxInstance should not be equal");
std::shared_ptr<CacheableDate> dateVal;
wpiPtr = pIPtr->createWriter();
time_t timeofday = 0;
const ACE_Time_Value currentTime = ACE_OS::gettimeofday();
timeofday = currentTime.sec();
auto datePtr = CacheableDate::create(timeofday);
wpiPtr->setField("m_dateTime", datePtr);
rptr->put(keyport, wpiPtr);
newPiPtr = std::dynamic_pointer_cast<PdxInstance>(rptr->get(keyport));
ASSERT(pIPtr->hasField("m_dateTime") == true, "m_date = true expected");
dateVal = newPiPtr->getCacheableDateField("m_dateTime");
ASSERT((*(dateVal.get()) == *(datePtr.get())) == true,
"dateObject should be equal");
ASSERT((*pIPtr == *newPiPtr) == false, "PdxInstance should not be equal");
LOG("modifyPdxInstanceAndCheckLocally complete.");
}
END_TASK_DEFINITION
DUNIT_TASK_DEFINITION(CLIENT1, pdxIFPutGetTest)
{
LOG("pdxIFPutGetTest started ");
auto serializationRegistry =
CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
->getSerializationRegistry();
try {
serializationRegistry->addPdxSerializableType(
Address::createDeserializable);
LOG("Address Registered Successfully....");
} catch (apache::geode::client::IllegalStateException & /* ex*/) {
LOG("Address IllegalStateException");
}
try {
serializationRegistry->addPdxSerializableType(
PdxTests::PdxType::createDeserializable);
LOG("PdxObject Registered Successfully....");
} catch (apache::geode::client::IllegalStateException & /* ex*/) {
LOG("PdxObject IllegalStateException");
}
try {
serializationRegistry->addPdxSerializableType(
ChildPdx::createDeserializable);
LOG("ChildPdx Registered Successfully....");
} catch (apache::geode::client::IllegalStateException & /* ex*/) {
LOG("ChildPdx IllegalStateException");
}
try {
serializationRegistry->addPdxSerializableType(
ParentPdx::createDeserializable);
LOG("ParentPdx Registered Successfully....");
} catch (apache::geode::client::IllegalStateException & /* ex*/) {
LOG("ParentPdx IllegalStateException");
}
auto rptr = getHelper()->getRegion(regionNames[0]);
auto pdxobj = std::make_shared<PdxTests::PdxType>();
auto pdxFactory =
cacheHelper->getCache()->createPdxInstanceFactory("PdxTests.PdxType");
LOG("PdxInstanceFactoryPtr created....");
int *lengthArr = new int[2];
lengthArr[0] = 1;
lengthArr[1] = 2;
pdxFactory.writeBoolean("m_bool", pdxobj->getBool());
try {
pdxFactory.writeBoolean("m_bool", pdxobj->getBool());
FAIL(
"calling writeBoolean on same fieldname should have thrown "
"IllegalStateException");
} catch (IllegalStateException &) {
LOG("Got expected IllegalStateException for m_bool");
}
pdxFactory.markIdentityField("m_bool");
pdxFactory.writeByte("m_byte", pdxobj->getByte());
pdxFactory.markIdentityField("m_byte");
pdxFactory.writeShort("m_int16", pdxobj->getShort());
pdxFactory.markIdentityField("m_int16");
pdxFactory.writeInt("m_int32", pdxobj->getInt());
pdxFactory.markIdentityField("m_int32");
pdxFactory.writeLong("m_long", pdxobj->getLong());
pdxFactory.markIdentityField("m_long");
pdxFactory.writeFloat("m_float", pdxobj->getFloat());
pdxFactory.markIdentityField("m_float");
pdxFactory.writeDouble("m_double", pdxobj->getDouble());
pdxFactory.markIdentityField("m_double");
pdxFactory.writeString("m_string", pdxobj->getString());
pdxFactory.markIdentityField("m_string");
pdxFactory.writeDate("m_dateTime", pdxobj->getDate());
pdxFactory.markIdentityField("m_dateTime");
pdxFactory.writeBooleanArray("m_boolArray", pdxobj->getBoolArray());
pdxFactory.markIdentityField("m_boolArray");
pdxFactory.writeByteArray("m_byteArray", pdxobj->getByteArray());
pdxFactory.markIdentityField("m_byteArray");
pdxFactory.writeShortArray("m_int16Array", pdxobj->getShortArray());
pdxFactory.markIdentityField("m_int16Array");
pdxFactory.writeIntArray("m_int32Array", pdxobj->getIntArray());
pdxFactory.markIdentityField("m_int32Array");
pdxFactory.writeLongArray("m_longArray", pdxobj->getLongArray());
pdxFactory.markIdentityField("m_longArray");
pdxFactory.writeFloatArray("m_floatArray", pdxobj->getFloatArray());
pdxFactory.markIdentityField("m_floatArray");
pdxFactory.writeDoubleArray("m_doubleArray", pdxobj->getDoubleArray());
pdxFactory.markIdentityField("m_doubleArray");
pdxFactory.writeObject("m_map", pdxobj->getHashMap());
pdxFactory.markIdentityField("m_map");
pdxFactory.writeStringArray("m_stringArray", pdxobj->getStringArray());
pdxFactory.markIdentityField("m_stringArray");
pdxFactory.writeObjectArray("m_objectArray",
pdxobj->getCacheableObjectArray());
pdxFactory.writeObject("m_pdxEnum", pdxobj->getEnum());
pdxFactory.markIdentityField("m_pdxEnum");
pdxFactory.writeObject("m_arraylist", pdxobj->getArrayList());
pdxFactory.markIdentityField("m_arraylist");
pdxFactory.writeObject("m_linkedlist", pdxobj->getLinkedList());
pdxFactory.markIdentityField("m_linkedlist");
pdxFactory.writeObject("m_hashtable", pdxobj->getHashTable());
pdxFactory.markIdentityField("m_hashtable");
pdxFactory.writeObject("m_vector", pdxobj->getVector());
pdxFactory.markIdentityField("m_vector");
pdxFactory.writeArrayOfByteArrays(
"m_byteByteArray", pdxobj->getArrayOfByteArrays(), 2, lengthArr);
pdxFactory.markIdentityField("m_byteByteArray");
pdxFactory.writeChar("m_char", pdxobj->getChar());
pdxFactory.markIdentityField("m_char");
pdxFactory.writeCharArray("m_charArray", pdxobj->getCharArray());
pdxFactory.markIdentityField("m_charArray");
pdxFactory.writeObject("m_chs", pdxobj->getHashSet());
pdxFactory.markIdentityField("m_chs");
pdxFactory.writeObject("m_clhs", pdxobj->getLinkedHashSet());
pdxFactory.markIdentityField("m_clhs");
pdxFactory.writeByte("m_sbyte", pdxobj->getSByte());
pdxFactory.markIdentityField("m_sbyte");
pdxFactory.writeByteArray("m_sbyteArray", pdxobj->getSByteArray());
pdxFactory.markIdentityField("m_sbyteArray");
pdxFactory.writeShort("m_uint16", pdxobj->getUint16());
pdxFactory.markIdentityField("m_uint16");
pdxFactory.writeInt("m_uint32", pdxobj->getUInt());
pdxFactory.markIdentityField("m_uint32");
pdxFactory.writeLong("m_ulong", pdxobj->getULong());
pdxFactory.markIdentityField("m_ulong");
pdxFactory.writeShortArray("m_uint16Array", pdxobj->getUInt16Array());
pdxFactory.markIdentityField("m_uint16Array");
pdxFactory.writeIntArray("m_uint32Array", pdxobj->getUIntArray());
pdxFactory.markIdentityField("m_uint32Array");
pdxFactory.writeLongArray("m_ulongArray", pdxobj->getULongArray());
pdxFactory.markIdentityField("m_ulongArray");
pdxFactory.writeByteArray("m_byte252", pdxobj->getByte252());
pdxFactory.markIdentityField("m_byte252");
pdxFactory.writeByteArray("m_byte253", pdxobj->getByte253());
pdxFactory.markIdentityField("m_byte253");
pdxFactory.writeByteArray("m_byte65535", pdxobj->getByte65535());
pdxFactory.markIdentityField("m_byte65535");
pdxFactory.writeByteArray("m_byte65536", pdxobj->getByte65536());
pdxFactory.markIdentityField("m_byte65536");
pdxFactory.writeObject("m_address", pdxobj->getCacheableObjectArray());
pdxFactory.writeObjectArray(
"", pdxobj->getCacheableObjectArrayEmptyPdxFieldName());
std::shared_ptr<PdxInstance> ret = pdxFactory.create();
LOG("PdxInstancePtr created....");
ASSERT(ret->getClassName() == "PdxTests.PdxType",
"pdxInstance.getClassName should return PdxTests.PdxType.");
auto psPtr = ret->getObject();
LOG("getObject created....");
LOG("Statistics for for (PdxTests.PdxType) PdxInstance ");
auto &&lregPtr = std::dynamic_pointer_cast<LocalRegion>(rptr);
LOGINFO(
"pdxInstanceDeserializations for (PdxTests.PdxType) PdxInstance = %d ",
lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceDeserializations());
LOGINFO(
"pdxInstanceCreations for (PdxTests.PdxType) PdxInstance = %d ",
lregPtr->getCacheImpl()->getCachePerfStats().getPdxInstanceCreations());
LOGINFO(
"pdxInstanceDeserializationTime for(PdxTests.PdxType) PdxInstance = "
"%d ",
lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceDeserializationTime());
ASSERT(lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceDeserializations() == 1,
"pdxInstanceDeserialization should be equal to 1.");
ASSERT(lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceCreations() == 0,
"pdxInstanceCreations should be equal to 0.");
ASSERT(lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceDeserializationTime() == 0,
"pdxInstanceDeserializationTime should be equal to 0.");
PdxTests::PdxType *obj2 = pdxobj.get();
PdxTests::PdxType *obj1 = dynamic_cast<PdxTests::PdxType *>(psPtr.get());
LOGINFO("Avinash Equal Starts");
ASSERT(obj1->equals(*obj2, false) == true, "PdxObjects should be equal.");
LOGINFO("Avinash Equal Finish");
auto key = CacheableKey::create("pi");
rptr->put(key, ret);
LOG("put done....");
auto newPiPtr = std::dynamic_pointer_cast<PdxSerializable>(rptr->get(key));
LOG("get done....");
LOGINFO(
"pdxInstanceDeserializations for (PdxTests.PdxType) PdxInstance = %d ",
lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceDeserializations());
LOGINFO(
"pdxInstanceCreations for (PdxTests.PdxType) PdxInstance = %d ",
lregPtr->getCacheImpl()->getCachePerfStats().getPdxInstanceCreations());
LOGINFO(
"pdxInstanceDeserializationTime for(PdxTests.PdxType) PdxInstance = "
"%d ",
lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceDeserializationTime());
ASSERT(lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceDeserializations() == 1,
"pdxInstanceDeserialization should be equal to 1.");
ASSERT(lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceCreations() == 0,
"pdxInstanceCreations should be equal to 0.");
ASSERT(lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceDeserializationTime() > 0,
"pdxInstanceDeserializationTime should be greater than 0.");
PdxTests::PdxType *obj3 = dynamic_cast<PdxTests::PdxType *>(newPiPtr.get());
ASSERT(obj2->equals(*obj3, false) == true, "PdxObjects should be equal.");
int pdxInstHashcode = ret->hashcode();
LOGINFO("pdxinstance hash code = %d ", pdxInstHashcode);
auto javaPdxHCKey = CacheableKey::create("javaPdxHC");
auto pIPtr2 = std::dynamic_pointer_cast<Cacheable>(rptr->get(javaPdxHCKey));
LOG("In pdxIFPutGetTest get done");
CacheableInt32 *val = dynamic_cast<CacheableInt32 *>(pIPtr2.get());
LOG("In pdxIFPutGetTest cast done");
int javaPdxHC = val->value();
LOGINFO("javaPdxHC hash code = %d ", javaPdxHC);
ASSERT(javaPdxHC == pdxInstHashcode,
"Pdxhashcode hashcode not matched with java pdx hash code.");
auto pp = std::make_shared<ParentPdx>(10);
auto pdxFactory2 = cacheHelper->getCache()->createPdxInstanceFactory(
"testobject.ParentPdx");
pdxFactory2.writeInt("m_parentId", pp->getParentId());
pdxFactory2.writeObject("m_enum", pp->getEnum());
pdxFactory2.writeString("m_parentName", pp->getParentName());
pdxFactory2.writeObject("m_childPdx", pp->getChildPdx());
pdxFactory2.writeChar("m_char", pp->getChar());
pdxFactory2.writeChar("m_wideChar", pp->getChar());
pdxFactory2.writeCharArray("m_charArray", pp->getCharArray());
LOG("write set done....");
std::shared_ptr<PdxInstance> ip2 = pdxFactory2.create();
LOG("PdxInstancePtr created");
LOGINFO("PdxInstance getClassName = " + ip2->getClassName());
ASSERT(ip2->getClassName() == "testobject.ParentPdx",
"pdxInstance.getClassName should return testobject.ParentPdx.");
auto keyport = CacheableKey::create("pp");
rptr->put(keyport, ip2);
LOG("put done....");
newPiPtr = std::dynamic_pointer_cast<PdxSerializable>(rptr->get(keyport));
LOG("get done....");
LOGINFO(
"pdxInstanceDeserializations for (testobject::ParentPdx) PdxInstance = "
"%d ",
lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceDeserializations());
LOGINFO(
"pdxInstanceCreations for (testobject::ParentPdx) PdxInstance = %d ",
lregPtr->getCacheImpl()->getCachePerfStats().getPdxInstanceCreations());
LOGINFO(
"pdxInstanceDeserializationTime for(testobject::ParentPdx) PdxInstance "
"= %d ",
lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceDeserializationTime());
ASSERT(lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceDeserializations() == 1,
"pdxInstanceDeserialization should be equal to 1.");
ASSERT(lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceCreations() == 0,
"pdxInstanceCreations should be equal to 0.");
ASSERT(lregPtr->getCacheImpl()
->getCachePerfStats()
.getPdxInstanceDeserializationTime() > 0,
"pdxInstanceDeserializationTime should be greater than 0.");
auto pp1 = std::dynamic_pointer_cast<ParentPdx>(newPiPtr);
LOG("got std::shared_ptr<ParentPdx>....");
ParentPdx *rawPP1 = dynamic_cast<ParentPdx *>(pp1.get());
LOG("got rawPP1....");
ParentPdx *rawPP2 = dynamic_cast<ParentPdx *>(pp.get());
LOG("got rawpp2....");
ASSERT(rawPP1->equals(*rawPP2, false) == true,
"ParentPdx objects should be equal.");
LOG("pdxIFPutGetTest complete.");
}
END_TASK_DEFINITION
DUNIT_TASK_DEFINITION(CLIENT1, pdxInstanceWithEmptyKeys)
{
LOG("pdxInstanceWithEmptyKeys started ");
auto rptr = getHelper()->getRegion(regionNames[0]);
auto pdxFactory =
cacheHelper->getCache()->createPdxInstanceFactory("EMPTY_KEY_NAME");
LOG("PdxInstanceFactoryPtr created....");
bool falseValue = false;
pdxFactory.writeBoolean("", falseValue);
std::shared_ptr<PdxInstance> putValue = pdxFactory.create();
auto key = CacheableKey::create("pp");
rptr->put(key, putValue);
LOG("put done with boolean Value and Empty Key....");
auto getValue = std::dynamic_pointer_cast<PdxInstance>(rptr->get(key));
LOG("get done with boolean Value and Empty Key....");
ASSERT(*putValue == *getValue,
"Boolean Value Did not match in case of Empty PdxField Key");
bool fieldValue = getValue->getBooleanField("");
ASSERT(fieldValue == falseValue,
"Mismatch in the PdxInstance with Empty key");
LOG("pdxInstanceWithEmptyKeys complete.");
}
END_TASK_DEFINITION
DUNIT_TASK_DEFINITION(SERVER1, CloseServer1)
{
if (isLocalServer) {
CacheHelper::closeServer(1);
LOG("SERVER1 stopped");
}
}
END_TASK_DEFINITION
DUNIT_TASK_DEFINITION(CLIENT1, CloseCache1)
{ cleanProc(); }
END_TASK_DEFINITION
DUNIT_TASK_DEFINITION(CLIENT2, CloseCache2)
{ cleanProc(); }
END_TASK_DEFINITION
DUNIT_TASK_DEFINITION(SERVER1, CloseLocator1)
{
// stop locator
if (isLocator) {
CacheHelper::closeLocator(1);
LOG("Locator1 stopped");
}
}
END_TASK_DEFINITION
void testPdxInstance() {
CALL_TASK(CreateLocator1);
CALL_TASK(CreateServer1_With_Locator)
CALL_TASK(StepOne_Pooled_Locator);
CALL_TASK(StepTwo_Pooled_Locator);
CALL_TASK(pdxIFPutGetTest);
CALL_TASK(CloseCache1);
CALL_TASK(CloseCache2);
CALL_TASK(CloseServer1);
CALL_TASK(CloseLocator1);
}
void testPdxInstanceWithPdxReadSerializedAndCaching() {
CALL_TASK(CreateLocator1);
CALL_TASK(CreateServer1_With_Locator)
CALL_TASK(StepOne_Pooled_Locator_PdxReadSerialized);
CALL_TASK(StepTwo_Pooled_Locator_CachingEnabled_PdxReadSerialized);
CALL_TASK(pdxPut);
CALL_TASK(modifyPdxInstanceAndCheckLocally);
CALL_TASK(pdxInstanceWithEmptyKeys);
CALL_TASK(CloseCache1);
CALL_TASK(CloseCache2);
CALL_TASK(CloseServer1);
CALL_TASK(CloseLocator1);
}
void testPdxInstanceWithPdxReadSerialized() {
CALL_TASK(CreateLocator1);
CALL_TASK(CreateServer1_With_Locator)
CALL_TASK(StepOne_Pooled_Locator_PdxReadSerialized);
CALL_TASK(StepTwo_Pooled_Locator_PdxReadSerialized);
CALL_TASK(pdxPut);
CALL_TASK(getObject);
CALL_TASK(verifyPdxInstanceEquals);
CALL_TASK(verifyPdxInstanceHashcode);
CALL_TASK(accessPdxInstance);
CALL_TASK(modifyPdxInstance);
CALL_TASK(CloseCache1);
CALL_TASK(CloseCache2);
CALL_TASK(CloseServer1);
CALL_TASK(CloseLocator1);
}
DUNIT_MAIN
{
// testPdxInstance();
// testPdxInstanceWithPdxReadSerializedAndCaching();
testPdxInstanceWithPdxReadSerialized();
}
END_MAIN