/*
 * 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