binding-c/runtime/c/src/test/common/test_cache.c - etch - Git at Google

 /* $Id$
  *
  * 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.
  */

 /*
  * test_cache.c
  * test the runtime object cache
  * we can swap out cache back ends and this test should work the same regardless
  */
 #include "etch_runtime.h"
 #include "etch_cache.h"
 #include "etch_arraylist.h"
 #include "etch_hash.h"
 #include "etch_mem.h"

 #include <stdio.h>
 #include "CUnit.h"


 #define IS_DEBUG_CONSOLE FALSE


 /* - - - - - - - - - - - - - -
  * unit test infrastructure
  * - - - - - - - - - - - - - -
  */


 static int init_suite(void)
 {
     etch_status_t etch_status = ETCH_SUCCESS;

     return etch_runtime_initialize(NULL);
 }

 static int clean_suite(void)
 {
     etch_runtime_shutdown();
     return 0;
 }


 static int test_cache_freehook_func(void* key, void* value)
 {
     //etch_free(key);
     //if(value) {
     //    etch_free(value);
     //}
     return 0;
 }

 /**
  * This subtest instantiates various etch objects which cache some part of
  * themselves, and destroys the objects. At each step the test verifies that
  * the cache contains the expected number of entries, e.g. if I create
  * multiple hashtables I should only have cached one hashtable vtable.
  */
 static void test_multiple_items(void)
 {
     int cache_start_count = 0, cache_current_count;
     int result1 = 0, result2 = 0, result3 = 0;
     etch_hashtable* myhashtab1 = NULL;
     etch_hashtable* myhashtab2 = NULL;
     etch_hashtable* myhashtab3 = NULL;
     etch_hashitem   hashbucket;
     etch_hashitem*  myentry = &hashbucket;

     wchar_t* wstr1 = L"abracadabra";
     wchar_t* wstr2 = L"gilgamesh";
     wchar_t* wstr3 = L"antidisestablishmentarianism";

     const size_t numElements1 = wcslen(wstr1);
     const size_t numElements2 = wcslen(wstr2);
     const size_t numElements3 = wcslen(wstr3);

     const size_t numBytes1 = sizeof(wchar_t) * numElements1;
     const size_t numBytes2 = sizeof(wchar_t) * numElements2;
     const size_t numBytes3 = sizeof(wchar_t) * numElements3;

     size_t actlen1 = 0, actlen2 = 0, actlen3 = 0;
     wchar_t *key1 = NULL, *key2 = NULL, *key3 = NULL;

     // set freehook for cache
     etch_cache_set_freehook(test_cache_freehook_func);

     key1 = etch_malloc(numBytes1 + sizeof(wchar_t), 0);
     key2 = etch_malloc(numBytes2 + sizeof(wchar_t), 0);
     key3 = etch_malloc(numBytes3 + sizeof(wchar_t), 0);
     CU_ASSERT_PTR_NOT_NULL_FATAL(key1);
     CU_ASSERT_PTR_NOT_NULL_FATAL(key2);
     CU_ASSERT_PTR_NOT_NULL_FATAL(key3);

     /* create one hashtable first, so in case we are tracking memory, we ensure that
      * the hashtable code module paths will already be cached. */
     myhashtab1 = new_hashtable(16);

     cache_start_count = etch_cache_count();

 #if defined(WIN32) && !defined(_WIN32_WCE)
 	result1 = wcscpy_s(key1, numElements1+1, wstr1);  /* wcscpy_s param 2 must be */
     result2 = wcscpy_s(key2, numElements2+1, wstr2);  /* number of characters + 1 */
     result3 = wcscpy_s(key3, numElements3+1, wstr3);
 #elif defined(_WIN32_WCE)
 	wcsncpy(key1, wstr1, numElements1);
 	wcsncpy(key2, wstr2, numElements2);
 	wcsncpy(key3, wstr3, numElements3);
 #else
     result1 = wcscpy(key1, wstr1);
     result2 = wcscpy(key2, wstr2);
     result3 = wcscpy(key3, wstr3);
 #endif
     actlen1 = wcslen(key1);
     actlen2 = wcslen(key2);
     actlen3 = wcslen(key3);

     myhashtab2 = new_hashtable(16);
     myhashtab3 = new_hashtable(16);

     /* we should not have cached any more hashtable vtables */
     cache_current_count = etch_cache_count();
     CU_ASSERT_EQUAL(cache_current_count, cache_start_count);

     ((struct i_hashtable*)((etch_object*)myhashtab1)->vtab)->insert(myhashtab1->realtable, key1, (int)numBytes1, NULL,0,0,0);
     ((struct i_hashtable*)((etch_object*)myhashtab2)->vtab)->insert(myhashtab2->realtable, key2, (int)numBytes2, NULL,0,0,0);
     ((struct i_hashtable*)((etch_object*)myhashtab2)->vtab)->insert(myhashtab3->realtable, key3, (int)numBytes3, NULL,0,0,0);

     /* TODO instantiate some other object here which uses the cache */

     destroy_hashtable(myhashtab1, TRUE, TRUE);
     destroy_hashtable(myhashtab2, TRUE, TRUE);
     destroy_hashtable(myhashtab3, TRUE, TRUE);
     /* note that key1 and key2 are now dangling pointers since we asked the
      * hashtable to free keys and values memory
      */
     etch_free(key1);
     etch_free(key2);
     etch_free(key3);

 }


 /**
  * test_intkeys()
  * tests caching using integer keys as we might do for etchobjects such as vtables
  */
 static void test_intkeys(void)
 {
     int i, startsize, size;
     const int STARTKEY = 0, ENDKEY = 512, KEYCOUNT = ENDKEY - STARTKEY;
     char* teststring = "it works!";
     char* item = etch_malloc(sizeof(teststring),0);
     memcpy(item, teststring, sizeof(teststring));

     // set freehook for cache
     etch_cache_set_freehook(test_cache_freehook_func);

     startsize = etch_cache_count();

     for(i = STARTKEY; i < ENDKEY; i++)
         etch_cache_add(i, item);

     size = etch_cache_count();
     CU_ASSERT_EQUAL(size, KEYCOUNT + startsize);

     for(i = STARTKEY; i < ENDKEY; i++)
         CU_ASSERT_PTR_NOT_NULL(etch_cache_find(i, 0));

     for(i = STARTKEY; i < ENDKEY; i++)
         CU_ASSERT_PTR_NOT_NULL(etch_cache_del(i));

     size = etch_cache_count();
     CU_ASSERT_EQUAL(size, startsize);

     etch_free(item);

 #ifdef ETCH_DEBUGALLOC
    g_bytes_allocated = etch_showmem(0,0);  /* verify all memory freed */
    CU_ASSERT_EQUAL(g_bytes_allocated, 0);
    // start fresh for next test
    memtable_clear();
 #endif
 }


 /**
  * test_intkeys()
  * tests caching using string keys with no values, as we might do for source
  * file paths in the debug allocator
  */
 static void test_pathkeys(void)
 {
     char* path1 = "..\\..\\foo\\bar\\file1.dat";
     char* path2 = "..\\..\\foo\\bar\\file2.dat";
     char* path3 = "c:\\the\\quick\\brown\\fox\\jumped\\over\\the\\lazy\\dog\\file3.dat";
     unsigned hash1 = 0, hash2 = 0, hash3 = 0;
     char* namefound = NULL;
     etch_hashitem  hashbucket;
     etch_hashitem* thisitem = &hashbucket;
     int result = 0;
     int len1 = (int)strlen(path1), len2 = (int)strlen(path2), len3 = (int)strlen(path3);

     // set freehook for cache
     etch_cache_set_freehook(test_cache_freehook_func);

     hash1 = etch_cache_insertx (path1, NULL, FALSE);
     hash2 = etch_cache_insertx (path2, NULL, FALSE);
     hash3 = etch_cache_insertx (path3, NULL, FALSE);

     memset(thisitem, 0, sizeof(etch_hashitem));
     etch_cache_findx(path1, &thisitem);
     CU_ASSERT_PTR_NOT_NULL(thisitem->key);
     CU_ASSERT_EQUAL(hash1, thisitem->hash);
     result = strncmp(path1, thisitem->key, len1);
     CU_ASSERT_EQUAL(result,0);

     memset(thisitem, 0, sizeof(etch_hashitem));
     etch_cache_findx(path2, &thisitem);
     CU_ASSERT_PTR_NOT_NULL(thisitem->key);
     CU_ASSERT_EQUAL(hash2, thisitem->hash);
     result = strncmp(path2, thisitem->key, len2);
     CU_ASSERT_EQUAL(result,0);

     memset(thisitem, 0, sizeof(etch_hashitem));
     etch_cache_findx(path3, &thisitem);
     CU_ASSERT_PTR_NOT_NULL(thisitem->key);
     CU_ASSERT_EQUAL(hash3, thisitem->hash);
     result = strncmp(path3, thisitem->key, len3);
     CU_ASSERT_EQUAL(result,0);

     memset(thisitem, 0, sizeof(etch_hashitem));
     etch_cache_find_by_hash(hash1, &thisitem);
     CU_ASSERT_PTR_NOT_NULL(thisitem->key);
     result = strncmp(path1, thisitem->key, len1);
     CU_ASSERT_EQUAL(result,0);

     memset(thisitem, 0, sizeof(etch_hashitem));
     etch_cache_find_by_hash(hash2, &thisitem);
     CU_ASSERT_PTR_NOT_NULL(thisitem->key);
     result = strncmp(path2, thisitem->key, len2);
     CU_ASSERT_EQUAL(result,0);

     memset(thisitem, 0, sizeof(etch_hashitem));
     etch_cache_find_by_hash(hash3, &thisitem);
     CU_ASSERT_PTR_NOT_NULL(thisitem->key);
     result = strncmp(path3, thisitem->key, len3);
     CU_ASSERT_EQUAL(result,0);
 }

 CU_pSuite test_cache_suite()
 {
     CU_pSuite pSuite = CU_add_suite("etch_cache", init_suite, clean_suite);

     CU_add_test(pSuite, "test path strings as keys", test_pathkeys);
     CU_add_test(pSuite, "multiple of same object test", test_multiple_items);
     CU_add_test(pSuite, "integer cache key test", test_intkeys);
     return pSuite;
 }
	/* $Id$
	*
	* 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.
	*/

	/*
	* test_cache.c
	* test the runtime object cache
	* we can swap out cache back ends and this test should work the same regardless
	*/
	#include "etch_runtime.h"
	#include "etch_cache.h"
	#include "etch_arraylist.h"
	#include "etch_hash.h"
	#include "etch_mem.h"

	#include <stdio.h>
	#include "CUnit.h"


	#define IS_DEBUG_CONSOLE FALSE


	/* - - - - - - - - - - - - - -
	* unit test infrastructure
	* - - - - - - - - - - - - - -
	*/


	static int init_suite(void)
	{
	etch_status_t etch_status = ETCH_SUCCESS;

	return etch_runtime_initialize(NULL);
	}

	static int clean_suite(void)
	{
	etch_runtime_shutdown();
	return 0;
	}


	static int test_cache_freehook_func(void* key, void* value)
	{
	//etch_free(key);
	//if(value) {
	// etch_free(value);
	//}
	return 0;
	}

	/**
	* This subtest instantiates various etch objects which cache some part of
	* themselves, and destroys the objects. At each step the test verifies that
	* the cache contains the expected number of entries, e.g. if I create
	* multiple hashtables I should only have cached one hashtable vtable.
	*/
	static void test_multiple_items(void)
	{
	int cache_start_count = 0, cache_current_count;
	int result1 = 0, result2 = 0, result3 = 0;
	etch_hashtable* myhashtab1 = NULL;
	etch_hashtable* myhashtab2 = NULL;
	etch_hashtable* myhashtab3 = NULL;
	etch_hashitem hashbucket;
	etch_hashitem* myentry = &hashbucket;

	wchar_t* wstr1 = L"abracadabra";
	wchar_t* wstr2 = L"gilgamesh";
	wchar_t* wstr3 = L"antidisestablishmentarianism";

	const size_t numElements1 = wcslen(wstr1);
	const size_t numElements2 = wcslen(wstr2);
	const size_t numElements3 = wcslen(wstr3);

	const size_t numBytes1 = sizeof(wchar_t) * numElements1;
	const size_t numBytes2 = sizeof(wchar_t) * numElements2;
	const size_t numBytes3 = sizeof(wchar_t) * numElements3;

	size_t actlen1 = 0, actlen2 = 0, actlen3 = 0;
	wchar_t key1 = NULL, key2 = NULL, *key3 = NULL;

	// set freehook for cache
	etch_cache_set_freehook(test_cache_freehook_func);

	key1 = etch_malloc(numBytes1 + sizeof(wchar_t), 0);
	key2 = etch_malloc(numBytes2 + sizeof(wchar_t), 0);
	key3 = etch_malloc(numBytes3 + sizeof(wchar_t), 0);
	CU_ASSERT_PTR_NOT_NULL_FATAL(key1);
	CU_ASSERT_PTR_NOT_NULL_FATAL(key2);
	CU_ASSERT_PTR_NOT_NULL_FATAL(key3);

	/* create one hashtable first, so in case we are tracking memory, we ensure that
	* the hashtable code module paths will already be cached. */
	myhashtab1 = new_hashtable(16);

	cache_start_count = etch_cache_count();

	#if defined(WIN32) && !defined(_WIN32_WCE)
	result1 = wcscpy_s(key1, numElements1+1, wstr1); /* wcscpy_s param 2 must be */
	result2 = wcscpy_s(key2, numElements2+1, wstr2); /* number of characters + 1 */
	result3 = wcscpy_s(key3, numElements3+1, wstr3);
	#elif defined(_WIN32_WCE)
	wcsncpy(key1, wstr1, numElements1);
	wcsncpy(key2, wstr2, numElements2);
	wcsncpy(key3, wstr3, numElements3);
	#else
	result1 = wcscpy(key1, wstr1);
	result2 = wcscpy(key2, wstr2);
	result3 = wcscpy(key3, wstr3);
	#endif
	actlen1 = wcslen(key1);
	actlen2 = wcslen(key2);
	actlen3 = wcslen(key3);

	myhashtab2 = new_hashtable(16);
	myhashtab3 = new_hashtable(16);

	/* we should not have cached any more hashtable vtables */
	cache_current_count = etch_cache_count();
	CU_ASSERT_EQUAL(cache_current_count, cache_start_count);

	((struct i_hashtable)((etch_object)myhashtab1)->vtab)->insert(myhashtab1->realtable, key1, (int)numBytes1, NULL,0,0,0);
	((struct i_hashtable)((etch_object)myhashtab2)->vtab)->insert(myhashtab2->realtable, key2, (int)numBytes2, NULL,0,0,0);
	((struct i_hashtable)((etch_object)myhashtab2)->vtab)->insert(myhashtab3->realtable, key3, (int)numBytes3, NULL,0,0,0);

	/* TODO instantiate some other object here which uses the cache */

	destroy_hashtable(myhashtab1, TRUE, TRUE);
	destroy_hashtable(myhashtab2, TRUE, TRUE);
	destroy_hashtable(myhashtab3, TRUE, TRUE);
	/* note that key1 and key2 are now dangling pointers since we asked the
	* hashtable to free keys and values memory
	*/
	etch_free(key1);
	etch_free(key2);
	etch_free(key3);

	}


	/**
	* test_intkeys()
	* tests caching using integer keys as we might do for etchobjects such as vtables
	*/
	static void test_intkeys(void)
	{
	int i, startsize, size;
	const int STARTKEY = 0, ENDKEY = 512, KEYCOUNT = ENDKEY - STARTKEY;
	char* teststring = "it works!";
	char* item = etch_malloc(sizeof(teststring),0);
	memcpy(item, teststring, sizeof(teststring));

	// set freehook for cache
	etch_cache_set_freehook(test_cache_freehook_func);

	startsize = etch_cache_count();

	for(i = STARTKEY; i < ENDKEY; i++)
	etch_cache_add(i, item);

	size = etch_cache_count();
	CU_ASSERT_EQUAL(size, KEYCOUNT + startsize);

	for(i = STARTKEY; i < ENDKEY; i++)
	CU_ASSERT_PTR_NOT_NULL(etch_cache_find(i, 0));

	for(i = STARTKEY; i < ENDKEY; i++)
	CU_ASSERT_PTR_NOT_NULL(etch_cache_del(i));

	size = etch_cache_count();
	CU_ASSERT_EQUAL(size, startsize);

	etch_free(item);

	#ifdef ETCH_DEBUGALLOC
	g_bytes_allocated = etch_showmem(0,0); /* verify all memory freed */
	CU_ASSERT_EQUAL(g_bytes_allocated, 0);
	// start fresh for next test
	memtable_clear();
	#endif
	}


	/**
	* test_intkeys()
	* tests caching using string keys with no values, as we might do for source
	* file paths in the debug allocator
	*/
	static void test_pathkeys(void)
	{
	char* path1 = "..\\..\\foo\\bar\\file1.dat";
	char* path2 = "..\\..\\foo\\bar\\file2.dat";
	char* path3 = "c:\\the\\quick\\brown\\fox\\jumped\\over\\the\\lazy\\dog\\file3.dat";
	unsigned hash1 = 0, hash2 = 0, hash3 = 0;
	char* namefound = NULL;
	etch_hashitem hashbucket;
	etch_hashitem* thisitem = &hashbucket;
	int result = 0;
	int len1 = (int)strlen(path1), len2 = (int)strlen(path2), len3 = (int)strlen(path3);

	// set freehook for cache
	etch_cache_set_freehook(test_cache_freehook_func);

	hash1 = etch_cache_insertx (path1, NULL, FALSE);
	hash2 = etch_cache_insertx (path2, NULL, FALSE);
	hash3 = etch_cache_insertx (path3, NULL, FALSE);

	memset(thisitem, 0, sizeof(etch_hashitem));
	etch_cache_findx(path1, &thisitem);
	CU_ASSERT_PTR_NOT_NULL(thisitem->key);
	CU_ASSERT_EQUAL(hash1, thisitem->hash);
	result = strncmp(path1, thisitem->key, len1);
	CU_ASSERT_EQUAL(result,0);

	memset(thisitem, 0, sizeof(etch_hashitem));
	etch_cache_findx(path2, &thisitem);
	CU_ASSERT_PTR_NOT_NULL(thisitem->key);
	CU_ASSERT_EQUAL(hash2, thisitem->hash);
	result = strncmp(path2, thisitem->key, len2);
	CU_ASSERT_EQUAL(result,0);

	memset(thisitem, 0, sizeof(etch_hashitem));
	etch_cache_findx(path3, &thisitem);
	CU_ASSERT_PTR_NOT_NULL(thisitem->key);
	CU_ASSERT_EQUAL(hash3, thisitem->hash);
	result = strncmp(path3, thisitem->key, len3);
	CU_ASSERT_EQUAL(result,0);

	memset(thisitem, 0, sizeof(etch_hashitem));
	etch_cache_find_by_hash(hash1, &thisitem);
	CU_ASSERT_PTR_NOT_NULL(thisitem->key);
	result = strncmp(path1, thisitem->key, len1);
	CU_ASSERT_EQUAL(result,0);

	memset(thisitem, 0, sizeof(etch_hashitem));
	etch_cache_find_by_hash(hash2, &thisitem);
	CU_ASSERT_PTR_NOT_NULL(thisitem->key);
	result = strncmp(path2, thisitem->key, len2);
	CU_ASSERT_EQUAL(result,0);

	memset(thisitem, 0, sizeof(etch_hashitem));
	etch_cache_find_by_hash(hash3, &thisitem);
	CU_ASSERT_PTR_NOT_NULL(thisitem->key);
	result = strncmp(path3, thisitem->key, len3);
	CU_ASSERT_EQUAL(result,0);
	}

	CU_pSuite test_cache_suite()
	{
	CU_pSuite pSuite = CU_add_suite("etch_cache", init_suite, clean_suite);

	CU_add_test(pSuite, "test path strings as keys", test_pathkeys);
	CU_add_test(pSuite, "multiple of same object test", test_multiple_items);
	CU_add_test(pSuite, "integer cache key test", test_intkeys);
	return pSuite;
	}