src/cppcache/integration-test/testSerialization.cpp - geode-native - Git at Google

 /*
  * 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 <gfcpp/gf_base.hpp>

 #include "fw_dunit.hpp"
 #include "ThinClientHelper.hpp"

 #define ROOT_SCOPE DISTRIBUTED_ACK

 #include <gfcpp/GeodeCppCache.hpp>
 #include <SerializationRegistry.hpp>
 #include <gfcpp/CacheableString.hpp>
 #include <gfcpp/GeodeTypeIds.hpp>
 #include <GeodeTypeIdsImpl.hpp>

 // Use to init lib when testing components.
 #include <CppCacheLibrary.hpp>

 #include "CacheHelper.hpp"

 using namespace apache::geode::client;

 #include "locator_globals.hpp"

 int32_t g_classIdToReturn = 0x04;
 int32_t g_classIdToReturn2 = 0x1234;
 int32_t g_classIdToReturn4 = 0x123456;

 template <class T>
 SharedPtr<T> duplicate(const SharedPtr<T>& orig) {
   SharedPtr<T> result;
   DataOutput dout;
   SerializationRegistry::serialize(orig, dout);
   // dout.writeObject(orig);

   uint32_t length = 0;
   const uint8_t* buffer = dout.getBuffer(&length);
   DataInput din(buffer, length);
   result = static_cast<T*>(SerializationRegistry::deserialize(din).ptr());
   // din.readObject(result);

   return result;
 }

 struct CData {
   int a;
   bool b;
   char c;
   double d;
   uint64_t e;
 };

 class OtherType : public Serializable {
  public:
   CData m_struct;
   int32_t m_classIdToReturn;

   explicit OtherType(int32_t classIdToReturn = g_classIdToReturn)
       : m_classIdToReturn(classIdToReturn) {
     m_struct.a = 0;
     m_struct.b = 0;
     m_struct.c = 0;
     m_struct.d = 0;
   }

   virtual void toData(DataOutput& output) const {
     output.writeBytes((uint8_t*)&m_struct, sizeof(CData));
     output.writeInt(m_classIdToReturn);
   }

   virtual uint32_t objectSize() const { return sizeof(CData); }

   virtual Serializable* fromData(DataInput& input) {
     int32_t size = 0;
     input.readArrayLen(&size);
     input.readBytesOnly(reinterpret_cast<uint8_t*>(&m_struct), size);
     input.readInt(&m_classIdToReturn);
     return this;
   }

   static Serializable* createDeserializable() {
     return new OtherType(g_classIdToReturn);
   }

   static Serializable* createDeserializable2() {
     return new OtherType(g_classIdToReturn2);
   }

   static Serializable* createDeserializable4() {
     return new OtherType(g_classIdToReturn4);
   }

   virtual int32_t classId() const { return m_classIdToReturn; }

   uint32_t size() const { return sizeof(CData); }

   static CacheablePtr uniqueCT(int32_t i,
                                int32_t classIdToReturn = g_classIdToReturn) {
     OtherType* ot = new OtherType(classIdToReturn);
     ot->m_struct.a = (int)i;
     ot->m_struct.b = (i % 2 == 0) ? true : false;
     ot->m_struct.c = static_cast<char>(65) + i;
     ot->m_struct.d = ((2.0) * static_cast<double>(i));

     printf("Created OtherType: %d, %s, %c, %e\n", ot->m_struct.a,
            ot->m_struct.b ? "true" : "false", ot->m_struct.c, ot->m_struct.d);

     printf("double hex 0x%016" PRIX64 "\n", ot->m_struct.e);

     return CacheablePtr(ot);
   }

   static void validateCT(int32_t i, const CacheablePtr otPtr) {
     char logmsg[1000];
     sprintf(logmsg, "validateCT for %d", i);
     LOG(logmsg);
     XASSERT(otPtr != NULLPTR);
     OtherType* ot = static_cast<OtherType*>(otPtr.ptr());
     XASSERT(ot != NULL);

     printf("Validating OtherType: %d, %s, %c, %e\n", ot->m_struct.a,
            ot->m_struct.b ? "true" : "false", ot->m_struct.c, ot->m_struct.d);

     printf("double hex 0x%016" PRIX64 "\n", ot->m_struct.e);

     XASSERT(ot->m_struct.a == (int)i);
     XASSERT(ot->m_struct.b == ((i % 2 == 0) ? true : false));
     XASSERT(ot->m_struct.c == (char)65 + i);
     XASSERT((ot->m_struct.d == (((double)2.0) * (double)i)));
   }
 };

 #define NoDist s2p2
 #define Sender s1p1
 #define Receiver s1p2

 DUNIT_TASK(NoDist, SerializeInMemory)
   {
     CppCacheLibrary::initLib();

     CacheableStringPtr str = CacheableString::create("hello");
     ASSERT(str->length() == 5, "expected length 5.");

     CacheableStringPtr copy = duplicate(str);

     ASSERT(*str == *copy, "expected copy to be hello.");
     ASSERT(str != copy, "expected copy to be different object.");

     str = CacheableString::create("");
     copy = duplicate(str);
     ASSERT(copy != NULLPTR, "error null copy.");
     ASSERT(copy->length() == 0, "expected 0 length.");

     CacheableInt32Ptr intkey = CacheableInt32::create(1);
     CacheableInt32Ptr intcopy = duplicate(intkey);
     ASSERT(intcopy->value() == 1, "expected value 1.");

     CacheableInt64Ptr longkey = CacheableInt64::create(0x1122334455667788LL);
     CacheableInt64Ptr longcopy = duplicate(longkey);
     ASSERT(longcopy->value() == 0x1122334455667788LL,
            "expected value 0x1122334455667788.");

     struct blob {
       int m_a;
       bool m_b;
       char m_name[100];
     };
     struct blob borig;
     borig.m_a = 1;
     borig.m_b = true;
     strcpy(borig.m_name, "Joe Cool Coder");

     CacheableBytesPtr bytes = CacheableBytes::create(
         reinterpret_cast<uint8_t*>(&borig), sizeof(blob));
     CacheableBytesPtr bytesCopy = duplicate(bytes);
     struct blob* bcopy = (struct blob*)bytesCopy->value();
     ASSERT(0 == strcmp(bcopy->m_name, borig.m_name), "expected Joe Cool Coder");
     ASSERT(1 == bcopy->m_a, "expected value 1");
   }
 ENDTASK

 DUNIT_TASK(NoDist, OtherTypeInMemory)
   {
     Serializable::registerType(OtherType::createDeserializable);
     SharedPtr<OtherType> ot(new OtherType());
     ot->m_struct.a = 1;
     ot->m_struct.b = true;
     ot->m_struct.c = 2;
     ot->m_struct.d = 3.0;

     SharedPtr<OtherType> copy = duplicate(ot);

     ASSERT(copy->classId() == g_classIdToReturn, "unexpected classId");
     if (copy->classId() > 0xFFFF) {
       ASSERT(copy->typeId() == GeodeTypeIdsImpl::CacheableUserData4,
              "typeId should be equal to GeodeTypeIdsImpl::CacheableUserData4.");
     } else if (copy->classId() > 0xFF) {
       ASSERT(copy->typeId() == GeodeTypeIdsImpl::CacheableUserData2,
              "typeId should be equal to GeodeTypeIdsImpl::CacheableUserData2.");
     } else {
       ASSERT(copy->typeId() == GeodeTypeIdsImpl::CacheableUserData,
              "typeId should be equal to GeodeTypeIdsImpl::CacheableUserData.");
     }
     ASSERT(copy != ot, "expected different instance.");
     ASSERT(copy->m_struct.a == 1, "a == 1");
     ASSERT(copy->m_struct.b == true, "b == true");
     ASSERT(copy->m_struct.c == 2, "c == 2");
     ASSERT(copy->m_struct.d == 3.0, "d == 3.0");
   }
 ENDTASK

 RegionPtr regionPtr;

 DUNIT_TASK(Receiver, SetupR)
   {
     CacheHelper::initLocator(1);
     CacheHelper::initServer(1, "cacheserver_notify_subscription.xml",
                             locatorsG);
     LOG("SERVER started");
   }
 ENDTASK

 DUNIT_TASK(Sender, SetupAndPutInts)
   {
     Serializable::registerType(OtherType::createDeserializable);
     Serializable::registerType(OtherType::createDeserializable2);
     Serializable::registerType(OtherType::createDeserializable4);
     initClientWithPool(true, "__TEST_POOL1__", locatorsG, "ServerGroup1",
                        NULLPTR, 0, true);
     getHelper()->createPooledRegion("DistRegionAck", USE_ACK, locatorsG,
                                     "__TEST_POOL1__", true, true);
     LOG("SenderInit complete.");

     regionPtr = getHelper()->getRegion("DistRegionAck");
     for (int32_t i = 0; i < 10; i++) {
       regionPtr->put(i, CacheableInt32::create(i));
     }
   }
 ENDTASK

 DUNIT_TASK(Sender, SendCT)
   {
     for (int32_t i = 0; i < 30; i += 3) {
       try {
         regionPtr->put(i, OtherType::uniqueCT(i, g_classIdToReturn));
         regionPtr->put(i + 1, OtherType::uniqueCT(i + 1, g_classIdToReturn2));
         regionPtr->put(i + 2, OtherType::uniqueCT(i + 2, g_classIdToReturn4));
       } catch (const apache::geode::client::TimeoutException&) {
       }
     }
   }
 ENDTASK

 DUNIT_TASK(Sender, RValidateCT)
   {
     for (int32_t i = 0; i < 30; i += 3) {
       OtherType::validateCT(i, regionPtr->get(i));
       OtherType::validateCT(i + 1, regionPtr->get(i + 1));
       OtherType::validateCT(i + 2, regionPtr->get(i + 2));
     }
   }
 ENDTASK

 DUNIT_TASK(Receiver, CloseCacheR)
   {
     CacheHelper::closeServer(1);
     CacheHelper::closeLocator(1);
     LOG("SERVER closed");
   }
 ENDTASK

 DUNIT_TASK(Sender, CloseCacheS)
   {
     regionPtr = NULLPTR;
     cleanProc();
   }
 ENDTASK
	/*
	* 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 <gfcpp/gf_base.hpp>

	#include "fw_dunit.hpp"
	#include "ThinClientHelper.hpp"

	#define ROOT_SCOPE DISTRIBUTED_ACK

	#include <gfcpp/GeodeCppCache.hpp>
	#include <SerializationRegistry.hpp>
	#include <gfcpp/CacheableString.hpp>
	#include <gfcpp/GeodeTypeIds.hpp>
	#include <GeodeTypeIdsImpl.hpp>

	// Use to init lib when testing components.
	#include <CppCacheLibrary.hpp>

	#include "CacheHelper.hpp"

	using namespace apache::geode::client;

	#include "locator_globals.hpp"

	int32_t g_classIdToReturn = 0x04;
	int32_t g_classIdToReturn2 = 0x1234;
	int32_t g_classIdToReturn4 = 0x123456;

	template <class T>
	SharedPtr<T> duplicate(const SharedPtr<T>& orig) {
	SharedPtr<T> result;
	DataOutput dout;
	SerializationRegistry::serialize(orig, dout);
	// dout.writeObject(orig);

	uint32_t length = 0;
	const uint8_t* buffer = dout.getBuffer(&length);
	DataInput din(buffer, length);
	result = static_cast<T*>(SerializationRegistry::deserialize(din).ptr());
	// din.readObject(result);

	return result;
	}

	struct CData {
	int a;
	bool b;
	char c;
	double d;
	uint64_t e;
	};

	class OtherType : public Serializable {
	public:
	CData m_struct;
	int32_t m_classIdToReturn;

	explicit OtherType(int32_t classIdToReturn = g_classIdToReturn)
	: m_classIdToReturn(classIdToReturn) {
	m_struct.a = 0;
	m_struct.b = 0;
	m_struct.c = 0;
	m_struct.d = 0;
	}

	virtual void toData(DataOutput& output) const {
	output.writeBytes((uint8_t*)&m_struct, sizeof(CData));
	output.writeInt(m_classIdToReturn);
	}

	virtual uint32_t objectSize() const { return sizeof(CData); }

	virtual Serializable* fromData(DataInput& input) {
	int32_t size = 0;
	input.readArrayLen(&size);
	input.readBytesOnly(reinterpret_cast<uint8_t*>(&m_struct), size);
	input.readInt(&m_classIdToReturn);
	return this;
	}

	static Serializable* createDeserializable() {
	return new OtherType(g_classIdToReturn);
	}

	static Serializable* createDeserializable2() {
	return new OtherType(g_classIdToReturn2);
	}

	static Serializable* createDeserializable4() {
	return new OtherType(g_classIdToReturn4);
	}

	virtual int32_t classId() const { return m_classIdToReturn; }

	uint32_t size() const { return sizeof(CData); }

	static CacheablePtr uniqueCT(int32_t i,
	int32_t classIdToReturn = g_classIdToReturn) {
	OtherType* ot = new OtherType(classIdToReturn);
	ot->m_struct.a = (int)i;
	ot->m_struct.b = (i % 2 == 0) ? true : false;
	ot->m_struct.c = static_cast<char>(65) + i;
	ot->m_struct.d = ((2.0) * static_cast<double>(i));

	printf("Created OtherType: %d, %s, %c, %e\n", ot->m_struct.a,
	ot->m_struct.b ? "true" : "false", ot->m_struct.c, ot->m_struct.d);

	printf("double hex 0x%016" PRIX64 "\n", ot->m_struct.e);

	return CacheablePtr(ot);
	}

	static void validateCT(int32_t i, const CacheablePtr otPtr) {
	char logmsg[1000];
	sprintf(logmsg, "validateCT for %d", i);
	LOG(logmsg);
	XASSERT(otPtr != NULLPTR);
	OtherType* ot = static_cast<OtherType*>(otPtr.ptr());
	XASSERT(ot != NULL);

	printf("Validating OtherType: %d, %s, %c, %e\n", ot->m_struct.a,
	ot->m_struct.b ? "true" : "false", ot->m_struct.c, ot->m_struct.d);

	printf("double hex 0x%016" PRIX64 "\n", ot->m_struct.e);

	XASSERT(ot->m_struct.a == (int)i);
	XASSERT(ot->m_struct.b == ((i % 2 == 0) ? true : false));
	XASSERT(ot->m_struct.c == (char)65 + i);
	XASSERT((ot->m_struct.d == (((double)2.0) * (double)i)));
	}
	};

	#define NoDist s2p2
	#define Sender s1p1
	#define Receiver s1p2

	DUNIT_TASK(NoDist, SerializeInMemory)
	{
	CppCacheLibrary::initLib();

	CacheableStringPtr str = CacheableString::create("hello");
	ASSERT(str->length() == 5, "expected length 5.");

	CacheableStringPtr copy = duplicate(str);

	ASSERT(str == copy, "expected copy to be hello.");
	ASSERT(str != copy, "expected copy to be different object.");

	str = CacheableString::create("");
	copy = duplicate(str);
	ASSERT(copy != NULLPTR, "error null copy.");
	ASSERT(copy->length() == 0, "expected 0 length.");

	CacheableInt32Ptr intkey = CacheableInt32::create(1);
	CacheableInt32Ptr intcopy = duplicate(intkey);
	ASSERT(intcopy->value() == 1, "expected value 1.");

	CacheableInt64Ptr longkey = CacheableInt64::create(0x1122334455667788LL);
	CacheableInt64Ptr longcopy = duplicate(longkey);
	ASSERT(longcopy->value() == 0x1122334455667788LL,
	"expected value 0x1122334455667788.");

	struct blob {
	int m_a;
	bool m_b;
	char m_name[100];
	};
	struct blob borig;
	borig.m_a = 1;
	borig.m_b = true;
	strcpy(borig.m_name, "Joe Cool Coder");

	CacheableBytesPtr bytes = CacheableBytes::create(
	reinterpret_cast<uint8_t*>(&borig), sizeof(blob));
	CacheableBytesPtr bytesCopy = duplicate(bytes);
	struct blob* bcopy = (struct blob*)bytesCopy->value();
	ASSERT(0 == strcmp(bcopy->m_name, borig.m_name), "expected Joe Cool Coder");
	ASSERT(1 == bcopy->m_a, "expected value 1");
	}
	ENDTASK

	DUNIT_TASK(NoDist, OtherTypeInMemory)
	{
	Serializable::registerType(OtherType::createDeserializable);
	SharedPtr<OtherType> ot(new OtherType());
	ot->m_struct.a = 1;
	ot->m_struct.b = true;
	ot->m_struct.c = 2;
	ot->m_struct.d = 3.0;

	SharedPtr<OtherType> copy = duplicate(ot);

	ASSERT(copy->classId() == g_classIdToReturn, "unexpected classId");
	if (copy->classId() > 0xFFFF) {
	ASSERT(copy->typeId() == GeodeTypeIdsImpl::CacheableUserData4,
	"typeId should be equal to GeodeTypeIdsImpl::CacheableUserData4.");
	} else if (copy->classId() > 0xFF) {
	ASSERT(copy->typeId() == GeodeTypeIdsImpl::CacheableUserData2,
	"typeId should be equal to GeodeTypeIdsImpl::CacheableUserData2.");
	} else {
	ASSERT(copy->typeId() == GeodeTypeIdsImpl::CacheableUserData,
	"typeId should be equal to GeodeTypeIdsImpl::CacheableUserData.");
	}
	ASSERT(copy != ot, "expected different instance.");
	ASSERT(copy->m_struct.a == 1, "a == 1");
	ASSERT(copy->m_struct.b == true, "b == true");
	ASSERT(copy->m_struct.c == 2, "c == 2");
	ASSERT(copy->m_struct.d == 3.0, "d == 3.0");
	}
	ENDTASK

	RegionPtr regionPtr;

	DUNIT_TASK(Receiver, SetupR)
	{
	CacheHelper::initLocator(1);
	CacheHelper::initServer(1, "cacheserver_notify_subscription.xml",
	locatorsG);
	LOG("SERVER started");
	}
	ENDTASK

	DUNIT_TASK(Sender, SetupAndPutInts)
	{
	Serializable::registerType(OtherType::createDeserializable);
	Serializable::registerType(OtherType::createDeserializable2);
	Serializable::registerType(OtherType::createDeserializable4);
	initClientWithPool(true, "__TEST_POOL1__", locatorsG, "ServerGroup1",
	NULLPTR, 0, true);
	getHelper()->createPooledRegion("DistRegionAck", USE_ACK, locatorsG,
	"__TEST_POOL1__", true, true);
	LOG("SenderInit complete.");

	regionPtr = getHelper()->getRegion("DistRegionAck");
	for (int32_t i = 0; i < 10; i++) {
	regionPtr->put(i, CacheableInt32::create(i));
	}
	}
	ENDTASK

	DUNIT_TASK(Sender, SendCT)
	{
	for (int32_t i = 0; i < 30; i += 3) {
	try {
	regionPtr->put(i, OtherType::uniqueCT(i, g_classIdToReturn));
	regionPtr->put(i + 1, OtherType::uniqueCT(i + 1, g_classIdToReturn2));
	regionPtr->put(i + 2, OtherType::uniqueCT(i + 2, g_classIdToReturn4));
	} catch (const apache::geode::client::TimeoutException&) {
	}
	}
	}
	ENDTASK

	DUNIT_TASK(Sender, RValidateCT)
	{
	for (int32_t i = 0; i < 30; i += 3) {
	OtherType::validateCT(i, regionPtr->get(i));
	OtherType::validateCT(i + 1, regionPtr->get(i + 1));
	OtherType::validateCT(i + 2, regionPtr->get(i + 2));
	}
	}
	ENDTASK

	DUNIT_TASK(Receiver, CloseCacheR)
	{
	CacheHelper::closeServer(1);
	CacheHelper::closeLocator(1);
	LOG("SERVER closed");
	}
	ENDTASK

	DUNIT_TASK(Sender, CloseCacheS)
	{
	regionPtr = NULLPTR;
	cleanProc();
	}
	ENDTASK