src/cppcache/integration-test/testEntriesMap.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.
  */

 #define ROOT_NAME "testEntriesMap"

 #include "fw_helper.hpp"

 #ifdef WIN32

 BEGIN_TEST(NotOnWindows)
   { LOG("Too many non-external symbols used too fix right now on windows."); }
 END_TEST(NotOnWindows)

 #else

 //#define BUILD_CPPCACHE 1
 #include <gfcpp/GeodeCppCache.hpp>
 #include <LRUEntriesMap.hpp>
 #include <LRUMapEntry.hpp>
 #include <VersionTag.hpp>
 #include <stdlib.h>

 using namespace apache::geode::client;
 using namespace std;

 typedef std::vector<MapEntryImplPtr> VectorOfMapEntry;

 CacheableStringPtr createCacheable(const char* value) {
   CacheableStringPtr result = CacheableString::create(value);
   ASSERT(result != NULLPTR, "expected result non-NULL");
   return result;
 }

 BEGIN_TEST(PutAndGet)
   {
     CacheableStringPtr ccstr = createCacheable("100");
     CacheablePtr ct = ccstr;
     EntryFactory* entryFactory = EntryFactory::singleton;
     EntriesMap* entries = new ConcurrentEntriesMap(entryFactory, false);
     entries->open();
     CacheableKeyPtr keyPtr = CacheableKey::create((char*)"foobar");
     ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
     MapEntryImplPtr me;
     VersionTagPtr versionTag;
     CacheablePtr oldValue;
     entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag);
     CacheablePtr myValuePtr;
     entries->get(keyPtr, myValuePtr, me);
     ASSERT(myValuePtr != NULLPTR, "expected non-NULL");
     CacheableStringPtr strValue = dynCast<CacheableStringPtr>(myValuePtr);
     ASSERT(ccstr->operator==(*strValue), "expected 100");
     delete entries;
   }
 END_TEST(PutAndGet)

 BEGIN_TEST(CheckMapEntryImplPtr)
   {
     char error[1000] ATTR_UNUSED;
     MapEntryImplPtr mePtr;
     ASSERT(mePtr == NULLPTR, "expected mePtr to be NULL");
     CacheableKeyPtr keyPtr = CacheableKey::create(fwtest_Name);
     ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
     EntryFactory::singleton->newMapEntry(keyPtr, mePtr);
     ASSERT(mePtr != NULLPTR, "expected to not be null.");
   }
 END_TEST(CheckMapEntryImplPtr)

 BEGIN_TEST(RemoveTest)
   {
     CacheableStringPtr cst = createCacheable("200");
     CacheablePtr ct = cst;
     EntryFactory* entryFactory = EntryFactory::singleton;
     EntriesMap* entries = new ConcurrentEntriesMap(entryFactory, false);
     entries->open();
     CacheableKeyPtr keyPtr = CacheableKey::create(fwtest_Name);
     MapEntryImplPtr me;
     ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
     CacheablePtr oldValue;
     VersionTagPtr versionTag;
     entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag);
     CacheablePtr myValuePtr;
     (void)entries->remove(keyPtr, myValuePtr, me, -1, versionTag, false);
     CacheableStringPtr resPtr = dynCast<CacheableStringPtr>(myValuePtr);
     ASSERT(myValuePtr != NULLPTR, "expected to not be null.");
     ASSERT(resPtr->operator==(*createCacheable("200")),
            "CustomerType with m_foobar 200.");
     (void)entries->remove(keyPtr, myValuePtr, me, -1, versionTag, false);
     ASSERT(myValuePtr == NULLPTR,
            "expected already removed, and null result should clear ptr.");
   }
 END_TEST(RemoveTest)

 BEGIN_TEST(GetEntryTest)
   {
     CacheableStringPtr cst = createCacheable("200");
     CacheablePtr ct = cst;
     EntryFactory* entryFactory = EntryFactory::singleton;
     EntriesMap* entries = new ConcurrentEntriesMap(entryFactory, false);
     entries->open();
     CacheableKeyPtr keyPtr;
     MapEntryImplPtr me;
     keyPtr = CacheableKey::create(fwtest_Name);
     ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
     CacheablePtr oldValue;
     VersionTagPtr versionTag;
     entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag);
     MapEntryImplPtr mePtr;
     CacheablePtr ctPtr;
     entries->getEntry(keyPtr, mePtr, ctPtr);
     ASSERT(mePtr != NULLPTR, "should not be null.");
     CacheableStringPtr valPtr = dynCast<CacheableStringPtr>(ctPtr);
     ASSERT(valPtr->operator==(*cst),
            "Entry should have a CustomerType Value of 200");
     CacheableKeyPtr keyPtr1;
     mePtr->getKey(keyPtr1);
     ASSERT(keyPtr1->operator==(*keyPtr), "should have same key.");
   }
 END_TEST(GetEntryTest)

 BEGIN_TEST(MapEntryImplPtrRCTest)
   {
     // Test Reference Counting and destruction for MapEntry.
     CacheableKeyPtr keyPtr = CacheableKey::create("foobar");
     ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
     MapEntryImplPtr mePtr;
     EntryFactory ef;
     ef.newMapEntry(keyPtr, mePtr);
     CacheablePtr ct = createCacheable("someval");
     mePtr->setValue(ct);
   }
 END_TEST(MapEntryImplPtrRCTest)

 BEGIN_TEST(VectorOfMapEntryTestA)
   {
     VectorOfMapEntry* meVec = new VectorOfMapEntry();
     delete meVec;
   }
 END_TEST(VectorOfMapEntryTestA)

 BEGIN_TEST(VectorOfMapEntryTestB)
   {
     VectorOfMapEntry* meVec = new VectorOfMapEntry();
     meVec->resize(100);
     meVec->clear();
     meVec->resize(10);
     MapEntryImplPtr mePtr;
     for (int i = 0; i < 10; i++) {
       meVec->push_back(mePtr);
     }
     for (int j = 0; j < 10; j++) {
       meVec->pop_back();
     }
     delete meVec;
   }
 END_TEST(VectorOfMapEntryTestB)

 BEGIN_TEST(EntriesTest)
   {
     EntryFactory* entryFactory = EntryFactory::singleton;
     EntriesMap* entries = new ConcurrentEntriesMap(entryFactory, false);
     entries->open();
     char keyBuf[100];
     char valBuf[100];
     VersionTagPtr versionTag;
     MapEntryImplPtr me;
     for (int i = 0; i < 10; i++) {
       sprintf(keyBuf, "key_%d", i);
       sprintf(valBuf, "%d", i);
       CacheableKeyPtr keyPtr = CacheableKey::create(keyBuf);
       ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
       CacheablePtr v = createCacheable(valBuf);
       CacheablePtr oldValue;
       entries->put(keyPtr, v, me, oldValue, -1, 0, versionTag);
     }
     VectorOfRegionEntry* entriesVec = new VectorOfRegionEntry();
     entriesVec->resize(1);
     entries->entries(*entriesVec);
     // should be 10, but they are hashed so, we don't know what order they will
     // come in...
     int total = 0;
     int expectedTotal = 0;
     for (int k = 0; k < 10; k++) {
       expectedTotal += k;
       RegionEntryPtr rePtr = entriesVec->back();
       CacheableStringPtr ctPtr;
       CacheablePtr ccPtr;
       ccPtr = rePtr->getValue();
       ctPtr = dynCast<CacheableStringPtr>(ccPtr);
       test::cout << "value is " << ctPtr->asChar() << test::endl;
       int val = atoi(ctPtr->asChar());
       test::cout << "atoi returned " << val << test::endl;
       total += val;
       entriesVec->pop_back();
     }
     entriesVec->clear();
     entriesVec->resize(0);
     delete entriesVec;
     sprintf(keyBuf, "total = %d, expected = %d", total, expectedTotal);
     ASSERT(total == expectedTotal, keyBuf);
     delete entries;
   }
 END_TEST(EntriesTest)

 BEGIN_TEST(ValuesTest)
   {
     EntryFactory* entryFactory = EntryFactory::singleton;
     EntriesMap* entries = new ConcurrentEntriesMap(entryFactory, false);
     entries->open();
     char keyBuf[100];
     char valBuf[100];
     VersionTagPtr versionTag;
     MapEntryImplPtr me;
     for (int i = 0; i < 10; i++) {
       sprintf(keyBuf, "key_%d", i);
       sprintf(valBuf, "%d", i);
       CacheableKeyPtr keyPtr = CacheableKey::create(keyBuf);
       ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
       CacheablePtr v = createCacheable(valBuf);
       CacheablePtr oldValue;
       entries->put(keyPtr, v, me, oldValue, -1, 0, versionTag);
     }
     VectorOfCacheable* valuesVec = new VectorOfCacheable();
     valuesVec->resize(1);
     entries->values(*valuesVec);
     // should be 10, but they are hashed so, we don't know what order they will
     // come in...
     int total = 0;
     int expectedTotal = 0;
     for (int k = 0; k < 10; k++) {
       expectedTotal += k;
       CacheableStringPtr valuePtr =
           dynCast<CacheableStringPtr>(valuesVec->back());
       total += atoi(valuePtr->asChar());
       valuesVec->pop_back();
     }
     delete valuesVec;
     sprintf(keyBuf, "total = %d, expected = %d", total, expectedTotal);
     ASSERT(total == expectedTotal, keyBuf);
     delete entries;
   }
 END_TEST(ValuesTest)

 BEGIN_TEST(KeysTest)
   {
     EntryFactory* entryFactory = EntryFactory::singleton;
     EntriesMap* entries = new ConcurrentEntriesMap(entryFactory, false);
     entries->open();
     char keyBuf[100];
     char valBuf[100];
     VersionTagPtr versionTag;
     MapEntryImplPtr me;
     for (int i = 0; i < 10; i++) {
       sprintf(keyBuf, "key_%d", i);
       sprintf(valBuf, "%d", i);
       CacheableKeyPtr keyPtr = CacheableKey::create(keyBuf);
       ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
       CacheablePtr v = createCacheable(valBuf);
       CacheablePtr oldValue;
       entries->put(keyPtr, v, me, oldValue, -1, 0, versionTag);
     }
     VectorOfCacheableKey keysVec;
     // keysVec.resize( 1 );
     entries->keys(keysVec);
     // should be 10, but they are hashed so, we don't know what order they will
     // come in...
     int total = 0;
     int expectedTotal = 0;
     for (int k = 0; k < 10; k++) {
       expectedTotal += k;
       CacheableKeyPtr keyPtr = keysVec.back();
       CacheablePtr cvPtr;
       entries->get(keyPtr, cvPtr, me);
       CacheableStringPtr valuePtr = dynCast<CacheableStringPtr>(cvPtr);
       total += atoi(valuePtr->asChar());
       keysVec.pop_back();
     }
     sprintf(keyBuf, "total = %d, expected = %d", total, expectedTotal);
     ASSERT(total == expectedTotal, keyBuf);
     delete entries;
   }
 END_TEST(KeysTest)

 BEGIN_TEST(TestRehash)
   {
     EntryFactory* entryFactory = EntryFactory::singleton;
     ConcurrentEntriesMap* entries =
         new ConcurrentEntriesMap(entryFactory, false, NULL, 1);
     entries->open(10);
     ASSERT(entries->totalSegmentRehashes() == 0,
            "should not have rehashed yet.");
     char keyBuf[100];
     char valBuf[100];
     MapEntryImplPtr me;

     for (uint32_t i = 0; i < 10000; i++) {
       sprintf(keyBuf, "key_%d", i);
       sprintf(valBuf, "%d", i);
       CacheableKeyPtr keyPtr = CacheableKey::create(keyBuf);
       ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
       CacheablePtr v = createCacheable(valBuf);
       CacheablePtr oldValue;
       VersionTagPtr versionTag;
       entries->put(keyPtr, v, me, oldValue, -1, 0, versionTag);
     }
     // check rehash count...
     ASSERT(entries->totalSegmentRehashes() > 0,
            "should have rehashed several times.");
     // VectorOfMapEntry result ;
     // entries->entries( result );
     //  printf("entries->size()=%d\n", entries->size());
     ASSERT(entries->size() == 10000, "should be 10k items");
     for (uint32_t j = 0; j < 10000; j++) {
       sprintf(keyBuf, "key_%d", j);
       CacheableStringPtr valuePtr;
       CacheableKeyPtr keyPtr = CacheableKey::create(keyBuf);
       ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
       CacheablePtr cvPtr;
       entries->get(keyPtr, cvPtr, me);
       valuePtr = dynCast<CacheableStringPtr>(cvPtr);
       if (valuePtr == NULLPTR) {
         test::cout << "error finding key: " << keyBuf << test::endl;
         FAIL("should have found value for all keys after rehash.");
       }
     }
   }
 END_TEST(TestRehash)

 //---- LRU variants

 BEGIN_TEST(LRUPutAndGet)
   {
     CacheableStringPtr cst = createCacheable("100");
     CacheablePtr ct = cst;
     MapEntryImplPtr me;
     EntryFactory* entryFactory = LRUEntryFactory::singleton;
     EntriesMap* entries = new LRUEntriesMap(
         entryFactory, NULL, LRUAction::LOCAL_DESTROY, 20, false);
     entries->open();
     ASSERT(entries->size() == 0, "expected size 0.");
     CacheableKeyPtr keyPtr = CacheableKey::create("foobar");
     CacheablePtr oldValue;
     VersionTagPtr versionTag;
     entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag);
     ASSERT(entries->size() == 1, "expected size 1.");
     CacheableStringPtr myValuePtr;
     CacheablePtr cvPtr;
     ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
     entries->get(keyPtr, cvPtr, me);
     myValuePtr = dynCast<CacheableStringPtr>(cvPtr);
     ASSERT(myValuePtr != NULLPTR, "expected non-NULL");
     ASSERT(cst->operator==(*myValuePtr), "expected 100");
     delete entries;
   }
 END_TEST(LRUPutAndGet)

 BEGIN_TEST(CheckLRUMapEntryImplPtr)
   {
     char error[1000] ATTR_UNUSED;
     MapEntryImplPtr mePtr;
     ASSERT(mePtr == NULLPTR, "expected mePtr to be NULL");
     CacheableKeyPtr keyPtr = CacheableKey::create(fwtest_Name);
     ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
     LRUEntryFactory::singleton->newMapEntry(keyPtr, mePtr);
     ASSERT(mePtr != NULLPTR, "expected to not be null.");
     LRUMapEntryPtr lmePtr = dynCast<LRUMapEntryPtr>(mePtr);
     ASSERT(lmePtr != NULLPTR, "expected to cast successfully to LRUMapEntry.");
   }
 END_TEST(LRUCheckMapEntryImplPtr)

 BEGIN_TEST(LRURemoveTest)
   {
     CacheableStringPtr cst = createCacheable("200");
     CacheablePtr ct = cst;
     EntryFactory* entryFactory = LRUEntryFactory::singleton;
     EntriesMap* entries = new LRUEntriesMap(
         entryFactory, NULL, LRUAction::LOCAL_DESTROY, 20, false);
     entries->open();
     ASSERT(entries->size() == 0, "expected size 0.");
     CacheableKeyPtr keyPtr;
     MapEntryImplPtr me;
     keyPtr = CacheableKey::create(fwtest_Name);
     CacheablePtr oldValue;
     VersionTagPtr versionTag;
     entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag);
     ASSERT(entries->size() == 1, "expected size 1.");
     CacheableStringPtr myValuePtr;
     CacheablePtr cvPtr;
     (void)entries->remove(keyPtr, cvPtr, me, -1, versionTag, false);
     myValuePtr = dynCast<CacheableStringPtr>(cvPtr);
     ASSERT(entries->size() == 0, "expected size 0.");
     ASSERT(cvPtr != NULLPTR, "expected to not be null.");
     ASSERT(myValuePtr->operator==(*createCacheable("200")),
            "CustomerType with m_foobar 200.");

     (void)entries->remove(keyPtr, cvPtr, me, -1, versionTag, false);
     ASSERT(cvPtr == NULLPTR,
            "expected already removed, and null result should clear ptr.");
   }
 END_TEST(LRURemoveTest)

 BEGIN_TEST(LRUGetEntryTest)
   {
     CacheableStringPtr cst = createCacheable("200");
     CacheablePtr ct = cst;
     EntryFactory* entryFactory = LRUEntryFactory::singleton;
     EntriesMap* entries = new LRUEntriesMap(
         entryFactory, NULL, LRUAction::LOCAL_DESTROY, 20, false);
     entries->open();
     CacheableKeyPtr keyPtr;
     MapEntryImplPtr me;
     keyPtr = CacheableKey::create(fwtest_Name);
     ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
     CacheablePtr oldValue;
     VersionTagPtr versionTag;
     entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag);
     ASSERT(entries->size() == 1, "expected size 1.");
     MapEntryImplPtr mePtr;
     CacheablePtr cvPtr;
     entries->getEntry(keyPtr, mePtr, cvPtr);
     ASSERT(mePtr != NULLPTR, "should not be null.");
     CacheableStringPtr ctPtr;
     ctPtr = dynCast<CacheableStringPtr>(cvPtr);
     ASSERT(ctPtr->operator==(*cst),
            "Entry should have a CustomerType Value of 200");
     CacheableKeyPtr keyPtr1;
     mePtr->getKey(keyPtr1);
     ASSERT(keyPtr1->operator==(*keyPtr), "should have same key.");
   }
 END_TEST(LRUGetEntryTest)

 BEGIN_TEST(LRULimitEvictTest)
   {
     EntryFactory* entryFactory = LRUEntryFactory::singleton;
     EntriesMap* entries = new LRUEntriesMap(entryFactory, NULL,
                                             LRUAction::LOCAL_DESTROY, 5, false);
     entries->open();
     MapEntryImplPtr me;
     CacheablePtr ct = createCacheable("somevalue");
     CacheablePtr oldValue;
     CacheableKeyPtr keyPtr = CacheableKey::create("1");
     ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
     VersionTagPtr versionTag;
     entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag);
     ASSERT(entries->size() == 1, "expected size 1.");
     keyPtr = CacheableKey::create("2");
     ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
     entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag);
     ASSERT(entries->size() == 2, "expected size 2.");
     keyPtr = CacheableKey::create("3");
     ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
     entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag);
     ASSERT(entries->size() == 3, "expected size 3.");
     keyPtr = CacheableKey::create("4");
     ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
     entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag);
     ASSERT(entries->size() == 4, "expected size 4.");
     keyPtr = CacheableKey::create("5");
     ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
     entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag);
     ASSERT(entries->size() == 5, "expected size 5.");
     LOG("Map is now at the limit.");
     keyPtr = CacheableKey::create("6");
     ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
     LOG("About to spill over.");
     entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag);
     LOG("Spilled over.");
     ASSERT(entries->size() == 5, "expected size 5.");
     LOG("Limit was preserved.");
   }
 END_TEST(LRULimitEvictTest)

 #endif
	/*
	* 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.
	*/

	#define ROOT_NAME "testEntriesMap"

	#include "fw_helper.hpp"

	#ifdef WIN32

	BEGIN_TEST(NotOnWindows)
	{ LOG("Too many non-external symbols used too fix right now on windows."); }
	END_TEST(NotOnWindows)

	#else

	//#define BUILD_CPPCACHE 1
	#include <gfcpp/GeodeCppCache.hpp>
	#include <LRUEntriesMap.hpp>
	#include <LRUMapEntry.hpp>
	#include <VersionTag.hpp>
	#include <stdlib.h>

	using namespace apache::geode::client;
	using namespace std;

	typedef std::vector<MapEntryImplPtr> VectorOfMapEntry;

	CacheableStringPtr createCacheable(const char* value) {
	CacheableStringPtr result = CacheableString::create(value);
	ASSERT(result != NULLPTR, "expected result non-NULL");
	return result;
	}

	BEGIN_TEST(PutAndGet)
	{
	CacheableStringPtr ccstr = createCacheable("100");
	CacheablePtr ct = ccstr;
	EntryFactory* entryFactory = EntryFactory::singleton;
	EntriesMap* entries = new ConcurrentEntriesMap(entryFactory, false);
	entries->open();
	CacheableKeyPtr keyPtr = CacheableKey::create((char*)"foobar");
	ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
	MapEntryImplPtr me;
	VersionTagPtr versionTag;
	CacheablePtr oldValue;
	entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag);
	CacheablePtr myValuePtr;
	entries->get(keyPtr, myValuePtr, me);
	ASSERT(myValuePtr != NULLPTR, "expected non-NULL");
	CacheableStringPtr strValue = dynCast<CacheableStringPtr>(myValuePtr);
	ASSERT(ccstr->operator==(*strValue), "expected 100");
	delete entries;
	}
	END_TEST(PutAndGet)

	BEGIN_TEST(CheckMapEntryImplPtr)
	{
	char error[1000] ATTR_UNUSED;
	MapEntryImplPtr mePtr;
	ASSERT(mePtr == NULLPTR, "expected mePtr to be NULL");
	CacheableKeyPtr keyPtr = CacheableKey::create(fwtest_Name);
	ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
	EntryFactory::singleton->newMapEntry(keyPtr, mePtr);
	ASSERT(mePtr != NULLPTR, "expected to not be null.");
	}
	END_TEST(CheckMapEntryImplPtr)

	BEGIN_TEST(RemoveTest)
	{
	CacheableStringPtr cst = createCacheable("200");
	CacheablePtr ct = cst;
	EntryFactory* entryFactory = EntryFactory::singleton;
	EntriesMap* entries = new ConcurrentEntriesMap(entryFactory, false);
	entries->open();
	CacheableKeyPtr keyPtr = CacheableKey::create(fwtest_Name);
	MapEntryImplPtr me;
	ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
	CacheablePtr oldValue;
	VersionTagPtr versionTag;
	entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag);
	CacheablePtr myValuePtr;
	(void)entries->remove(keyPtr, myValuePtr, me, -1, versionTag, false);
	CacheableStringPtr resPtr = dynCast<CacheableStringPtr>(myValuePtr);
	ASSERT(myValuePtr != NULLPTR, "expected to not be null.");
	ASSERT(resPtr->operator==(*createCacheable("200")),
	"CustomerType with m_foobar 200.");
	(void)entries->remove(keyPtr, myValuePtr, me, -1, versionTag, false);
	ASSERT(myValuePtr == NULLPTR,
	"expected already removed, and null result should clear ptr.");
	}
	END_TEST(RemoveTest)

	BEGIN_TEST(GetEntryTest)
	{
	CacheableStringPtr cst = createCacheable("200");
	CacheablePtr ct = cst;
	EntryFactory* entryFactory = EntryFactory::singleton;
	EntriesMap* entries = new ConcurrentEntriesMap(entryFactory, false);
	entries->open();
	CacheableKeyPtr keyPtr;
	MapEntryImplPtr me;
	keyPtr = CacheableKey::create(fwtest_Name);
	ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
	CacheablePtr oldValue;
	VersionTagPtr versionTag;
	entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag);
	MapEntryImplPtr mePtr;
	CacheablePtr ctPtr;
	entries->getEntry(keyPtr, mePtr, ctPtr);
	ASSERT(mePtr != NULLPTR, "should not be null.");
	CacheableStringPtr valPtr = dynCast<CacheableStringPtr>(ctPtr);
	ASSERT(valPtr->operator==(*cst),
	"Entry should have a CustomerType Value of 200");
	CacheableKeyPtr keyPtr1;
	mePtr->getKey(keyPtr1);
	ASSERT(keyPtr1->operator==(*keyPtr), "should have same key.");
	}
	END_TEST(GetEntryTest)

	BEGIN_TEST(MapEntryImplPtrRCTest)
	{
	// Test Reference Counting and destruction for MapEntry.
	CacheableKeyPtr keyPtr = CacheableKey::create("foobar");
	ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
	MapEntryImplPtr mePtr;
	EntryFactory ef;
	ef.newMapEntry(keyPtr, mePtr);
	CacheablePtr ct = createCacheable("someval");
	mePtr->setValue(ct);
	}
	END_TEST(MapEntryImplPtrRCTest)

	BEGIN_TEST(VectorOfMapEntryTestA)
	{
	VectorOfMapEntry* meVec = new VectorOfMapEntry();
	delete meVec;
	}
	END_TEST(VectorOfMapEntryTestA)

	BEGIN_TEST(VectorOfMapEntryTestB)
	{
	VectorOfMapEntry* meVec = new VectorOfMapEntry();
	meVec->resize(100);
	meVec->clear();
	meVec->resize(10);
	MapEntryImplPtr mePtr;
	for (int i = 0; i < 10; i++) {
	meVec->push_back(mePtr);
	}
	for (int j = 0; j < 10; j++) {
	meVec->pop_back();
	}
	delete meVec;
	}
	END_TEST(VectorOfMapEntryTestB)

	BEGIN_TEST(EntriesTest)
	{
	EntryFactory* entryFactory = EntryFactory::singleton;
	EntriesMap* entries = new ConcurrentEntriesMap(entryFactory, false);
	entries->open();
	char keyBuf[100];
	char valBuf[100];
	VersionTagPtr versionTag;
	MapEntryImplPtr me;
	for (int i = 0; i < 10; i++) {
	sprintf(keyBuf, "key_%d", i);
	sprintf(valBuf, "%d", i);
	CacheableKeyPtr keyPtr = CacheableKey::create(keyBuf);
	ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
	CacheablePtr v = createCacheable(valBuf);
	CacheablePtr oldValue;
	entries->put(keyPtr, v, me, oldValue, -1, 0, versionTag);
	}
	VectorOfRegionEntry* entriesVec = new VectorOfRegionEntry();
	entriesVec->resize(1);
	entries->entries(*entriesVec);
	// should be 10, but they are hashed so, we don't know what order they will
	// come in...
	int total = 0;
	int expectedTotal = 0;
	for (int k = 0; k < 10; k++) {
	expectedTotal += k;
	RegionEntryPtr rePtr = entriesVec->back();
	CacheableStringPtr ctPtr;
	CacheablePtr ccPtr;
	ccPtr = rePtr->getValue();
	ctPtr = dynCast<CacheableStringPtr>(ccPtr);
	test::cout << "value is " << ctPtr->asChar() << test::endl;
	int val = atoi(ctPtr->asChar());
	test::cout << "atoi returned " << val << test::endl;
	total += val;
	entriesVec->pop_back();
	}
	entriesVec->clear();
	entriesVec->resize(0);
	delete entriesVec;
	sprintf(keyBuf, "total = %d, expected = %d", total, expectedTotal);
	ASSERT(total == expectedTotal, keyBuf);
	delete entries;
	}
	END_TEST(EntriesTest)

	BEGIN_TEST(ValuesTest)
	{
	EntryFactory* entryFactory = EntryFactory::singleton;
	EntriesMap* entries = new ConcurrentEntriesMap(entryFactory, false);
	entries->open();
	char keyBuf[100];
	char valBuf[100];
	VersionTagPtr versionTag;
	MapEntryImplPtr me;
	for (int i = 0; i < 10; i++) {
	sprintf(keyBuf, "key_%d", i);
	sprintf(valBuf, "%d", i);
	CacheableKeyPtr keyPtr = CacheableKey::create(keyBuf);
	ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
	CacheablePtr v = createCacheable(valBuf);
	CacheablePtr oldValue;
	entries->put(keyPtr, v, me, oldValue, -1, 0, versionTag);
	}
	VectorOfCacheable* valuesVec = new VectorOfCacheable();
	valuesVec->resize(1);
	entries->values(*valuesVec);
	// should be 10, but they are hashed so, we don't know what order they will
	// come in...
	int total = 0;
	int expectedTotal = 0;
	for (int k = 0; k < 10; k++) {
	expectedTotal += k;
	CacheableStringPtr valuePtr =
	dynCast<CacheableStringPtr>(valuesVec->back());
	total += atoi(valuePtr->asChar());
	valuesVec->pop_back();
	}
	delete valuesVec;
	sprintf(keyBuf, "total = %d, expected = %d", total, expectedTotal);
	ASSERT(total == expectedTotal, keyBuf);
	delete entries;
	}
	END_TEST(ValuesTest)

	BEGIN_TEST(KeysTest)
	{
	EntryFactory* entryFactory = EntryFactory::singleton;
	EntriesMap* entries = new ConcurrentEntriesMap(entryFactory, false);
	entries->open();
	char keyBuf[100];
	char valBuf[100];
	VersionTagPtr versionTag;
	MapEntryImplPtr me;
	for (int i = 0; i < 10; i++) {
	sprintf(keyBuf, "key_%d", i);
	sprintf(valBuf, "%d", i);
	CacheableKeyPtr keyPtr = CacheableKey::create(keyBuf);
	ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
	CacheablePtr v = createCacheable(valBuf);
	CacheablePtr oldValue;
	entries->put(keyPtr, v, me, oldValue, -1, 0, versionTag);
	}
	VectorOfCacheableKey keysVec;
	// keysVec.resize( 1 );
	entries->keys(keysVec);
	// should be 10, but they are hashed so, we don't know what order they will
	// come in...
	int total = 0;
	int expectedTotal = 0;
	for (int k = 0; k < 10; k++) {
	expectedTotal += k;
	CacheableKeyPtr keyPtr = keysVec.back();
	CacheablePtr cvPtr;
	entries->get(keyPtr, cvPtr, me);
	CacheableStringPtr valuePtr = dynCast<CacheableStringPtr>(cvPtr);
	total += atoi(valuePtr->asChar());
	keysVec.pop_back();
	}
	sprintf(keyBuf, "total = %d, expected = %d", total, expectedTotal);
	ASSERT(total == expectedTotal, keyBuf);
	delete entries;
	}
	END_TEST(KeysTest)

	BEGIN_TEST(TestRehash)
	{
	EntryFactory* entryFactory = EntryFactory::singleton;
	ConcurrentEntriesMap* entries =
	new ConcurrentEntriesMap(entryFactory, false, NULL, 1);
	entries->open(10);
	ASSERT(entries->totalSegmentRehashes() == 0,
	"should not have rehashed yet.");
	char keyBuf[100];
	char valBuf[100];
	MapEntryImplPtr me;

	for (uint32_t i = 0; i < 10000; i++) {
	sprintf(keyBuf, "key_%d", i);
	sprintf(valBuf, "%d", i);
	CacheableKeyPtr keyPtr = CacheableKey::create(keyBuf);
	ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
	CacheablePtr v = createCacheable(valBuf);
	CacheablePtr oldValue;
	VersionTagPtr versionTag;
	entries->put(keyPtr, v, me, oldValue, -1, 0, versionTag);
	}
	// check rehash count...
	ASSERT(entries->totalSegmentRehashes() > 0,
	"should have rehashed several times.");
	// VectorOfMapEntry result ;
	// entries->entries( result );
	// printf("entries->size()=%d\n", entries->size());
	ASSERT(entries->size() == 10000, "should be 10k items");
	for (uint32_t j = 0; j < 10000; j++) {
	sprintf(keyBuf, "key_%d", j);
	CacheableStringPtr valuePtr;
	CacheableKeyPtr keyPtr = CacheableKey::create(keyBuf);
	ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
	CacheablePtr cvPtr;
	entries->get(keyPtr, cvPtr, me);
	valuePtr = dynCast<CacheableStringPtr>(cvPtr);
	if (valuePtr == NULLPTR) {
	test::cout << "error finding key: " << keyBuf << test::endl;
	FAIL("should have found value for all keys after rehash.");
	}
	}
	}
	END_TEST(TestRehash)

	//---- LRU variants

	BEGIN_TEST(LRUPutAndGet)
	{
	CacheableStringPtr cst = createCacheable("100");
	CacheablePtr ct = cst;
	MapEntryImplPtr me;
	EntryFactory* entryFactory = LRUEntryFactory::singleton;
	EntriesMap* entries = new LRUEntriesMap(
	entryFactory, NULL, LRUAction::LOCAL_DESTROY, 20, false);
	entries->open();
	ASSERT(entries->size() == 0, "expected size 0.");
	CacheableKeyPtr keyPtr = CacheableKey::create("foobar");
	CacheablePtr oldValue;
	VersionTagPtr versionTag;
	entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag);
	ASSERT(entries->size() == 1, "expected size 1.");
	CacheableStringPtr myValuePtr;
	CacheablePtr cvPtr;
	ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
	entries->get(keyPtr, cvPtr, me);
	myValuePtr = dynCast<CacheableStringPtr>(cvPtr);
	ASSERT(myValuePtr != NULLPTR, "expected non-NULL");
	ASSERT(cst->operator==(*myValuePtr), "expected 100");
	delete entries;
	}
	END_TEST(LRUPutAndGet)

	BEGIN_TEST(CheckLRUMapEntryImplPtr)
	{
	char error[1000] ATTR_UNUSED;
	MapEntryImplPtr mePtr;
	ASSERT(mePtr == NULLPTR, "expected mePtr to be NULL");
	CacheableKeyPtr keyPtr = CacheableKey::create(fwtest_Name);
	ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
	LRUEntryFactory::singleton->newMapEntry(keyPtr, mePtr);
	ASSERT(mePtr != NULLPTR, "expected to not be null.");
	LRUMapEntryPtr lmePtr = dynCast<LRUMapEntryPtr>(mePtr);
	ASSERT(lmePtr != NULLPTR, "expected to cast successfully to LRUMapEntry.");
	}
	END_TEST(LRUCheckMapEntryImplPtr)

	BEGIN_TEST(LRURemoveTest)
	{
	CacheableStringPtr cst = createCacheable("200");
	CacheablePtr ct = cst;
	EntryFactory* entryFactory = LRUEntryFactory::singleton;
	EntriesMap* entries = new LRUEntriesMap(
	entryFactory, NULL, LRUAction::LOCAL_DESTROY, 20, false);
	entries->open();
	ASSERT(entries->size() == 0, "expected size 0.");
	CacheableKeyPtr keyPtr;
	MapEntryImplPtr me;
	keyPtr = CacheableKey::create(fwtest_Name);
	CacheablePtr oldValue;
	VersionTagPtr versionTag;
	entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag);
	ASSERT(entries->size() == 1, "expected size 1.");
	CacheableStringPtr myValuePtr;
	CacheablePtr cvPtr;
	(void)entries->remove(keyPtr, cvPtr, me, -1, versionTag, false);
	myValuePtr = dynCast<CacheableStringPtr>(cvPtr);
	ASSERT(entries->size() == 0, "expected size 0.");
	ASSERT(cvPtr != NULLPTR, "expected to not be null.");
	ASSERT(myValuePtr->operator==(*createCacheable("200")),
	"CustomerType with m_foobar 200.");

	(void)entries->remove(keyPtr, cvPtr, me, -1, versionTag, false);
	ASSERT(cvPtr == NULLPTR,
	"expected already removed, and null result should clear ptr.");
	}
	END_TEST(LRURemoveTest)

	BEGIN_TEST(LRUGetEntryTest)
	{
	CacheableStringPtr cst = createCacheable("200");
	CacheablePtr ct = cst;
	EntryFactory* entryFactory = LRUEntryFactory::singleton;
	EntriesMap* entries = new LRUEntriesMap(
	entryFactory, NULL, LRUAction::LOCAL_DESTROY, 20, false);
	entries->open();
	CacheableKeyPtr keyPtr;
	MapEntryImplPtr me;
	keyPtr = CacheableKey::create(fwtest_Name);
	ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
	CacheablePtr oldValue;
	VersionTagPtr versionTag;
	entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag);
	ASSERT(entries->size() == 1, "expected size 1.");
	MapEntryImplPtr mePtr;
	CacheablePtr cvPtr;
	entries->getEntry(keyPtr, mePtr, cvPtr);
	ASSERT(mePtr != NULLPTR, "should not be null.");
	CacheableStringPtr ctPtr;
	ctPtr = dynCast<CacheableStringPtr>(cvPtr);
	ASSERT(ctPtr->operator==(*cst),
	"Entry should have a CustomerType Value of 200");
	CacheableKeyPtr keyPtr1;
	mePtr->getKey(keyPtr1);
	ASSERT(keyPtr1->operator==(*keyPtr), "should have same key.");
	}
	END_TEST(LRUGetEntryTest)

	BEGIN_TEST(LRULimitEvictTest)
	{
	EntryFactory* entryFactory = LRUEntryFactory::singleton;
	EntriesMap* entries = new LRUEntriesMap(entryFactory, NULL,
	LRUAction::LOCAL_DESTROY, 5, false);
	entries->open();
	MapEntryImplPtr me;
	CacheablePtr ct = createCacheable("somevalue");
	CacheablePtr oldValue;
	CacheableKeyPtr keyPtr = CacheableKey::create("1");
	ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
	VersionTagPtr versionTag;
	entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag);
	ASSERT(entries->size() == 1, "expected size 1.");
	keyPtr = CacheableKey::create("2");
	ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
	entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag);
	ASSERT(entries->size() == 2, "expected size 2.");
	keyPtr = CacheableKey::create("3");
	ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
	entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag);
	ASSERT(entries->size() == 3, "expected size 3.");
	keyPtr = CacheableKey::create("4");
	ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
	entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag);
	ASSERT(entries->size() == 4, "expected size 4.");
	keyPtr = CacheableKey::create("5");
	ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
	entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag);
	ASSERT(entries->size() == 5, "expected size 5.");
	LOG("Map is now at the limit.");
	keyPtr = CacheableKey::create("6");
	ASSERT(keyPtr != NULLPTR, "expected keyPtr non-NULL");
	LOG("About to spill over.");
	entries->put(keyPtr, ct, me, oldValue, -1, 0, versionTag);
	LOG("Spilled over.");
	ASSERT(entries->size() == 5, "expected size 5.");
	LOG("Limit was preserved.");
	}
	END_TEST(LRULimitEvictTest)

	#endif