celix-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From abroekh...@apache.org
Subject svn commit: r1043911 - in /incubator/celix/trunk: celix_test/ receiver-2.0/ receiver-2.0/MANIFEST/ receiver/ receiver/MANIFEST/
Date Thu, 09 Dec 2010 11:57:30 GMT
Author: abroekhuis
Date: Thu Dec  9 11:57:29 2010
New Revision: 1043911

URL: http://svn.apache.org/viewvc?rev=1043911&view=rev
Log:
CELIX-1 initial code import

Added:
    incubator/celix/trunk/celix_test/
    incubator/celix/trunk/celix_test/CMakeLists.txt
    incubator/celix/trunk/celix_test/array_list_test.c
    incubator/celix/trunk/celix_test/hash_map_test.c
    incubator/celix/trunk/celix_test/hash_map_test_hash.c
    incubator/celix/trunk/celix_test/test.c
    incubator/celix/trunk/receiver/
    incubator/celix/trunk/receiver-2.0/
    incubator/celix/trunk/receiver-2.0/CMakeLists.txt
    incubator/celix/trunk/receiver-2.0/MANIFEST/
    incubator/celix/trunk/receiver-2.0/MANIFEST/MANIFEST.MF
    incubator/celix/trunk/receiver-2.0/activator.c
    incubator/celix/trunk/receiver-2.0/serviceTest.c
    incubator/celix/trunk/receiver-2.0/serviceTest.h
    incubator/celix/trunk/receiver-2.0/serviceTest_private.h
    incubator/celix/trunk/receiver/CMakeLists.txt
    incubator/celix/trunk/receiver/MANIFEST/
    incubator/celix/trunk/receiver/MANIFEST/MANIFEST.MF
    incubator/celix/trunk/receiver/activator.c
    incubator/celix/trunk/receiver/serviceTest.c
    incubator/celix/trunk/receiver/serviceTest.h
    incubator/celix/trunk/receiver/serviceTest_private.h

Added: incubator/celix/trunk/celix_test/CMakeLists.txt
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/celix_test/CMakeLists.txt?rev=1043911&view=auto
==============================================================================
--- incubator/celix/trunk/celix_test/CMakeLists.txt (added)
+++ incubator/celix/trunk/celix_test/CMakeLists.txt Thu Dec  9 11:57:29 2010
@@ -0,0 +1,18 @@
+include_directories("${PROJECT_SOURCE_DIR}/celix")
+include_directories("/opt/local/include")
+link_directories("/opt/local/lib")
+
+add_executable(hash_map_test hash_map_test.c)
+target_link_libraries(hash_map_test framework cunit ncurses)
+
+add_executable(hash_map_test_hash hash_map_test_hash.c)
+target_link_libraries(hash_map_test_hash framework cunit ncurses)
+
+add_executable(array_list_test array_list_test.c)
+target_link_libraries(array_list_test framework cunit ncurses)
+
+enable_testing()
+#add_test (tester ${EXECUTABLE_OUTPUT_PATH}/tester)
+add_test (hash_map_test ${EXECUTABLE_OUTPUT_PATH}/hash_map_test)
+add_test (hash_map_test_hash ${EXECUTABLE_OUTPUT_PATH}/hash_map_test_hash)
+add_test (array_list_test ${EXECUTABLE_OUTPUT_PATH}/array_list_test)
\ No newline at end of file

Added: incubator/celix/trunk/celix_test/array_list_test.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/celix_test/array_list_test.c?rev=1043911&view=auto
==============================================================================
--- incubator/celix/trunk/celix_test/array_list_test.c (added)
+++ incubator/celix/trunk/celix_test/array_list_test.c Thu Dec  9 11:57:29 2010
@@ -0,0 +1,286 @@
+/*
+ * array_list_test.c
+ *
+ *  Created on: Aug 4, 2010
+ *      Author: alexanderb
+ */
+#include <stdio.h>
+#include <stdbool.h>
+
+#include "CUnit/Basic.h"
+
+#include "array_list.h"
+#include "array_list_private.h"
+
+ARRAY_LIST list;
+
+int setup(void) {
+	list = arrayList_create();
+	if (list == NULL) {
+		return 1;
+	}
+	return 0;
+}
+
+void test_arrayList_create(void) {
+	CU_ASSERT_PTR_NOT_NULL_FATAL(list);
+	CU_ASSERT_EQUAL(list->size, 0);
+}
+
+void test_arrayList_trimToSize(void) {
+	arrayList_clear(list);
+
+	char * entry = "entry";
+	arrayList_add(list, entry);
+	CU_ASSERT_EQUAL(list->size, 1);
+	CU_ASSERT_EQUAL(list->capacity, 10);
+
+	arrayList_trimToSize(list);
+	CU_ASSERT_EQUAL(list->size, 1);
+	CU_ASSERT_EQUAL(list->capacity, 1);
+}
+
+void test_arrayList_ensureCapacity(void) {
+	list = arrayList_create();
+	arrayList_clear(list);
+	CU_ASSERT_EQUAL(list->capacity, 10);
+	CU_ASSERT_EQUAL(list->size, 0);
+	int i;
+	for (i = 0; i < 100; i++) {
+		arrayList_add(list, "entry");
+	}
+	CU_ASSERT_EQUAL(list->capacity, 133);
+	CU_ASSERT_EQUAL(list->size, 100);
+	list = arrayList_create();
+}
+
+void test_arrayList_size(void) {
+	arrayList_clear(list);
+	CU_ASSERT_EQUAL(list->size, 0);
+
+	char * entry = "entry";
+	arrayList_add(list, entry);
+	CU_ASSERT_EQUAL(list->size, 1);
+
+	char * entry2 = "entry";
+	arrayList_add(list, entry2);
+	CU_ASSERT_EQUAL(list->size, 2);
+
+	char * entry3 = "entry";
+	arrayList_add(list, entry3);
+	CU_ASSERT_EQUAL(list->size, 3);
+}
+
+void test_arrayList_isEmpty(void) {
+	arrayList_clear(list);
+	CU_ASSERT_EQUAL(list->size, 0);
+	CU_ASSERT_TRUE(arrayList_isEmpty(list));
+}
+
+void test_arrayList_contains(void) {
+	arrayList_clear(list);
+
+	char * entry = "entry";
+	arrayList_add(list, entry);
+
+	char * entry2 = "entry2";
+	arrayList_add(list, entry2);
+
+	CU_ASSERT_TRUE(arrayList_contains(list, entry));
+	CU_ASSERT_TRUE(arrayList_contains(list, entry2));
+	bool contains = arrayList_contains(list, NULL);
+	CU_ASSERT_FALSE(contains);
+
+	char * entry3 = NULL;
+	arrayList_add(list, entry3);
+
+	CU_ASSERT_TRUE(arrayList_contains(list, entry3));
+}
+
+void test_arrayList_indexOf(void) {
+	arrayList_clear(list);
+
+	char * entry = "entry";
+	arrayList_add(list, entry);
+
+	char * entry2 = "entry2";
+	arrayList_add(list, entry2);
+	arrayList_add(list, entry2);
+	arrayList_add(list, entry2);
+	arrayList_add(list, entry2);
+
+	CU_ASSERT_EQUAL(arrayList_indexOf(list, entry), 0);
+	CU_ASSERT_EQUAL(arrayList_indexOf(list, entry2), 1);
+	CU_ASSERT_EQUAL(arrayList_lastIndexOf(list, entry), 0);
+	CU_ASSERT_EQUAL(arrayList_lastIndexOf(list, entry2), 4);
+}
+
+void test_arrayList_get(void) {
+	arrayList_clear(list);
+
+	char * entry = "entry";
+	arrayList_add(list, entry);
+	char * entry2 = "entry2";
+	arrayList_add(list, entry2);
+
+	char * get = arrayList_get(list, 0);
+	CU_ASSERT_EQUAL(entry, get);
+
+	get = arrayList_get(list, 1);
+	CU_ASSERT_EQUAL(entry2, get);
+
+	char * entry3 = NULL;
+	arrayList_add(list, entry3);
+
+	get = arrayList_get(list, 2);
+	CU_ASSERT_PTR_NULL(get);
+
+	get = arrayList_get(list, 42);
+	CU_ASSERT_PTR_NULL(get);
+}
+
+void test_arrayList_set(void) {
+	arrayList_clear(list);
+
+	char * entry = "entry";
+	arrayList_add(list, entry);
+	char * entry2 = "entry2";
+	arrayList_add(list, entry2);
+
+	char * get = arrayList_get(list, 1);
+	CU_ASSERT_EQUAL(entry2, get);
+
+	char * entry3 = "entry3";
+	char * old = arrayList_set(list, 1, entry3);
+	CU_ASSERT_EQUAL(entry2, old);
+	get = arrayList_get(list, 1);
+	CU_ASSERT_EQUAL(entry3, get);
+}
+
+void test_arrayList_add(void) {
+	arrayList_clear(list);
+
+	char * entry = "entry";
+	arrayList_add(list, entry);
+	char * entry2 = "entry2";
+	arrayList_add(list, entry2);
+
+	char * get = arrayList_get(list, 1);
+	CU_ASSERT_EQUAL(entry2, get);
+
+	char * entry3 = "entry3";
+	arrayList_addIndex(list, 1, entry3);
+
+	get = arrayList_get(list, 1);
+	CU_ASSERT_EQUAL(entry3, get);
+
+	get = arrayList_get(list, 2);
+	CU_ASSERT_EQUAL(entry2, get);
+}
+
+void test_arrayList_remove(void) {
+	arrayList_clear(list);
+
+	char * entry = "entry";
+	arrayList_add(list, entry);
+	char * entry2 = "entry2";
+	arrayList_add(list, entry2);
+
+	char * get = arrayList_get(list, 1);
+	CU_ASSERT_EQUAL(entry2, get);
+
+	// Remove first entry
+	char * removed = arrayList_remove(list, 0);
+	CU_ASSERT_EQUAL(entry, removed);
+
+	// Check the new first element
+	get = arrayList_get(list, 0);
+	CU_ASSERT_EQUAL(entry2, get);
+
+	// Add a new element
+	char * entry3 = "entry3";
+	arrayList_add(list, entry3);
+
+	get = arrayList_get(list, 1);
+	CU_ASSERT_EQUAL(entry3, get);
+}
+
+void test_arrayList_removeElement(void) {
+	arrayList_clear(list);
+
+	char * entry = "entry";
+	arrayList_add(list, entry);
+	char * entry2 = "entry2";
+	arrayList_add(list, entry2);
+
+	// Remove entry
+	CU_ASSERT_TRUE(arrayList_removeElement(list, entry));
+
+	// Check the new first element
+	char * get = arrayList_get(list, 0);
+	CU_ASSERT_EQUAL(entry2, get);
+
+	// Add a new element
+	char * entry3 = "entry3";
+	arrayList_add(list, entry3);
+
+	get = arrayList_get(list, 1);
+	CU_ASSERT_EQUAL(entry3, get);
+}
+
+void test_arrayList_clear(void) {
+	arrayList_clear(list);
+
+	char * entry = "entry";
+	arrayList_add(list, entry);
+	char * entry2 = "entry2";
+	arrayList_add(list, entry2);
+
+	CU_ASSERT_EQUAL(arrayList_size(list), 2);
+	arrayList_clear(list);
+	CU_ASSERT_EQUAL(arrayList_size(list), 0);
+}
+
+
+
+int main (int argc, char** argv) {
+	CU_pSuite pSuite = NULL;
+
+	/* initialize the CUnit test registry */
+	if (CUE_SUCCESS != CU_initialize_registry())
+	  return CU_get_error();
+
+	/* add a suite to the registry */
+	pSuite = CU_add_suite("Suite_1", setup, NULL);
+	if (NULL == pSuite) {
+	  CU_cleanup_registry();
+	  return CU_get_error();
+	}
+
+	/* add the tests to the suite */
+	if (NULL == CU_add_test(pSuite, "Array List Creation Test", test_arrayList_create)
+		|| NULL == CU_add_test(pSuite, "Array List Trim Test", test_arrayList_trimToSize)
+		|| NULL == CU_add_test(pSuite, "Array List Capacity Test", test_arrayList_ensureCapacity)
+		|| NULL == CU_add_test(pSuite, "Array List Size Test", test_arrayList_size)
+		|| NULL == CU_add_test(pSuite, "Array List Is Empty Test", test_arrayList_isEmpty)
+		|| NULL == CU_add_test(pSuite, "Array List Contains Test", test_arrayList_contains)
+		|| NULL == CU_add_test(pSuite, "Array List Index Of Test", test_arrayList_indexOf)
+		|| NULL == CU_add_test(pSuite, "Array List Get Test", test_arrayList_get)
+		|| NULL == CU_add_test(pSuite, "Array List Set Test", test_arrayList_set)
+		|| NULL == CU_add_test(pSuite, "Array List Add Test", test_arrayList_add)
+		|| NULL == CU_add_test(pSuite, "Array List Remove Test", test_arrayList_remove)
+		|| NULL == CU_add_test(pSuite, "Array List Remove Element Test", test_arrayList_removeElement)
+		|| NULL == CU_add_test(pSuite, "Array List Clear Test", test_arrayList_clear)
+	)
+	{
+	  CU_cleanup_registry();
+	  return CU_get_error();
+	}
+
+	/* Run all tests using the CUnit Basic interface */
+	CU_basic_set_mode(CU_BRM_VERBOSE);
+	CU_basic_run_tests();
+	CU_cleanup_registry();
+	return CU_get_error();
+}
+

Added: incubator/celix/trunk/celix_test/hash_map_test.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/celix_test/hash_map_test.c?rev=1043911&view=auto
==============================================================================
--- incubator/celix/trunk/celix_test/hash_map_test.c (added)
+++ incubator/celix/trunk/celix_test/hash_map_test.c Thu Dec  9 11:57:29 2010
@@ -0,0 +1,408 @@
+/*
+ * hash_map_test.c
+ *
+ *  Created on: Jul 25, 2010
+ *      Author: alexanderb
+ */
+#include <stdio.h>
+
+#include "CUnit/Basic.h"
+
+#include "hash_map.h"
+#include "hash_map_private.h"
+
+HASH_MAP map;
+
+int setup(void) {
+	printf("test\n");
+	map = hashMap_create(NULL, NULL, NULL, NULL);
+	if(map == NULL) {
+		return 1;
+	}
+	return 0;
+}
+
+void test_hashMap_create(void) {
+	CU_ASSERT_PTR_NOT_NULL_FATAL(map);
+	CU_ASSERT_EQUAL(map->size, 0);
+	CU_ASSERT_EQUAL(map->equalsKey, hashMap_equals);
+	CU_ASSERT_EQUAL(map->equalsValue, hashMap_equals);
+	CU_ASSERT_EQUAL(map->hashKey, hashMap_hashCode);
+	CU_ASSERT_EQUAL(map->hashValue, hashMap_hashCode);
+}
+
+void test_hashMap_size(void) {
+	CU_ASSERT_EQUAL(map->size, 0);
+
+	// Add one entry
+	char * key = "key";
+	char * value = "value";
+	hashMap_put(map, key, value);
+	CU_ASSERT_EQUAL(map->size, 1);
+
+	// Add second entry
+	char * key2 = "key2";
+	char * value2 = "value2";
+	hashMap_put(map, key2, value2);
+	CU_ASSERT_EQUAL(map->size, 2);
+
+	// Overwrite existing entry
+	char * key3 = "key2";
+	char * value3 = "value3";
+	hashMap_put(map, key3, value3);
+	CU_ASSERT_EQUAL(map->size, 2);
+
+	// Clear map
+	hashMap_clear(map);
+	CU_ASSERT_EQUAL(map->size, 0);
+}
+
+void test_hashMap_isEmpty(void) {
+	hashMap_clear(map);
+	CU_ASSERT_EQUAL(map->size, 0);
+	CU_ASSERT_TRUE(hashMap_isEmpty(map));
+
+	// Add one entry
+	char * key = "key";
+	char * value = "value";
+	hashMap_put(map, key, value);
+	CU_ASSERT_EQUAL(map->size, 1);
+	CU_ASSERT_FALSE(hashMap_isEmpty(map));
+
+	// Remove entry
+	hashMap_remove(map, key);
+	CU_ASSERT_EQUAL(map->size, 0);
+	CU_ASSERT_TRUE(hashMap_isEmpty(map));
+}
+
+void test_hashMap_get(void) {
+	hashMap_clear(map);
+
+	// Add one entry
+	char * key = "key";
+	char * value = "value";
+	hashMap_put(map, key, value);
+
+	// Add second entry
+	char * key2 = "key2";
+	char * value2 = "value2";
+	hashMap_put(map, key2, value2);
+
+	char * get = hashMap_get(map, key);
+	CU_ASSERT_STRING_EQUAL(get, value);
+
+	get = hashMap_get(map, key2);
+	CU_ASSERT_STRING_EQUAL(get, value2);
+
+	char * neKey = "notExisting";
+	get = hashMap_get(map, neKey);
+	CU_ASSERT_EQUAL(get, NULL);
+
+	get = hashMap_get(map, NULL);
+	CU_ASSERT_EQUAL(get, NULL);
+
+	// Add third entry with NULL key
+	char * key3 = NULL;
+	char * value3 = "value3";
+	hashMap_put(map, key3, value3);
+
+	get = hashMap_get(map, NULL);
+	CU_ASSERT_STRING_EQUAL(get, value3);
+}
+
+void test_hashMap_containsKey(void) {
+	hashMap_clear(map);
+
+	// Add one entry
+	char * key = "key";
+	char * value = "value";
+	hashMap_put(map, key, value);
+
+	// Add second entry
+	char * key2 = "key2";
+	char * value2 = "value2";
+	hashMap_put(map, key2, value2);
+
+	CU_ASSERT_TRUE(hashMap_containsKey(map, key));
+	CU_ASSERT_TRUE(hashMap_containsKey(map, key2));
+	char * neKey = "notExisting";
+	CU_ASSERT_FALSE(hashMap_containsKey(map, neKey));
+	CU_ASSERT_FALSE(hashMap_containsKey(map, NULL));
+
+	// Add third entry with NULL key
+	char * key3 = NULL;
+	char * value3 = "value3";
+	hashMap_put(map, key3, value3);
+
+	CU_ASSERT_TRUE(hashMap_containsKey(map, key3));
+}
+
+void test_hashMap_getEntry(void) {
+	hashMap_clear(map);
+
+	// Add one entry
+	char * key = "key";
+	char * value = "value";
+	hashMap_put(map, key, value);
+
+	// Add second entry
+	char * key2 = "key2";
+	char * value2 = "value2";
+	hashMap_put(map, key2, value2);
+
+	HASH_MAP_ENTRY entry = hashMap_getEntry(map, key);
+	CU_ASSERT_STRING_EQUAL(entry->key, key);
+	CU_ASSERT_STRING_EQUAL(entry->value, value);
+
+	entry = hashMap_getEntry(map, key2);
+	CU_ASSERT_STRING_EQUAL(entry->key, key2);
+	CU_ASSERT_STRING_EQUAL(entry->value, value2);
+
+	char * neKey = "notExisting";
+	entry = hashMap_getEntry(map, neKey);
+	CU_ASSERT_EQUAL(entry, NULL);
+
+	entry = hashMap_getEntry(map, NULL);
+	CU_ASSERT_EQUAL(entry, NULL);
+
+	// Add third entry with NULL key
+	char * key3 = NULL;
+	char * value3 = "value3";
+	hashMap_put(map, key3, value3);
+
+	entry = hashMap_getEntry(map, key3);
+	CU_ASSERT_EQUAL(entry->key, key3);
+	CU_ASSERT_STRING_EQUAL(entry->value, value3);
+}
+
+void test_hashMap_put(void) {
+	hashMap_clear(map);
+
+	// Add one entry
+	char * key = "key";
+	char * value = "value";
+	hashMap_put(map, key, value);
+
+	// Add second entry
+	char * key2 = "key2";
+	char * value2 = "value2";
+	hashMap_put(map, key2, value2);
+
+	char * get = hashMap_get(map, key);
+	CU_ASSERT_STRING_EQUAL(get, value);
+
+	get = hashMap_get(map, key2);
+	CU_ASSERT_STRING_EQUAL(get, value2);
+
+	// Overwrite existing entry
+	char * nkey2 = "key2";
+	char * nvalue2 = "value3";
+	char * old = (char *) hashMap_put(map, nkey2, nvalue2);
+	CU_ASSERT_PTR_NOT_NULL_FATAL(old);
+	CU_ASSERT_STRING_EQUAL(old, value2)
+
+	get = hashMap_get(map, key2);
+	CU_ASSERT_STRING_EQUAL(get, nvalue2);
+
+	// Add third entry with NULL key
+	char * key3 = NULL;
+	char * value3 = "value3";
+	hashMap_put(map, key3, value3);
+
+	get = hashMap_get(map, key3);
+	CU_ASSERT_STRING_EQUAL(get, value3);
+
+	// Add fourth entry with NULL value
+	char * key4 = "key4";
+	char * value4 = NULL;
+	hashMap_put(map, key4, value4);
+
+	get = hashMap_get(map, key4);
+	CU_ASSERT_EQUAL(get, value4);
+}
+
+void test_hashMap_resize(void) {
+	hashMap_clear(map);
+
+	CU_ASSERT_EQUAL(map->size, 0);
+	CU_ASSERT_EQUAL(map->tablelength, 16);
+	CU_ASSERT_EQUAL(map->treshold, 12);
+	int i;
+	for (i = 0; i < 12; i++) {
+		char key[6];
+		sprintf(key, "key%d", i);
+		char * k = strdup(key);
+		hashMap_put(map, k, k);
+	}
+	CU_ASSERT_EQUAL(map->size, 12);
+	CU_ASSERT_EQUAL(map->tablelength, 16);
+	CU_ASSERT_EQUAL(map->treshold, 12);
+
+	char key[6];
+	sprintf(key, "key%d", i);
+	hashMap_put(map, strdup(key), strdup(key));
+	CU_ASSERT_EQUAL(map->size, 13);
+	CU_ASSERT_EQUAL(map->tablelength, 32);
+	CU_ASSERT_EQUAL(map->treshold, 24);
+}
+
+void test_hashMap_remove(void) {
+	hashMap_clear(map);
+
+	// Add one entry
+	char * key = "key";
+	char * value = "value";
+	hashMap_put(map, key, value);
+
+	// Add second entry with null key
+	char * key2 = NULL;
+	char * value2 = "value2";
+	hashMap_put(map, key2, value2);
+
+	// Remove unexisting entry for map
+	char * removeKey = "unexisting";
+	hashMap_remove(map, removeKey);
+	CU_ASSERT_EQUAL(map->size, 2);
+	CU_ASSERT_FALSE(hashMap_isEmpty(map));
+
+	hashMap_remove(map, key);
+	CU_ASSERT_EQUAL(map->size, 1);
+
+	hashMap_remove(map, key2);
+	CU_ASSERT_EQUAL(map->size, 0);
+	CU_ASSERT_TRUE(hashMap_isEmpty(map));
+
+	// Remove unexisting entry for empty map
+	removeKey = "unexisting";
+	hashMap_remove(map, removeKey);
+	CU_ASSERT_EQUAL(map->size, 0);
+	CU_ASSERT_TRUE(hashMap_isEmpty(map));
+}
+
+void test_hashMap_removeMapping(void) {
+	hashMap_clear(map);
+
+	// Add one entry
+	char * key = "key";
+	char * value = "value";
+	hashMap_put(map, key, value);
+
+	// Add second entry with null key
+	char * key2 = NULL;
+	char * value2 = "value2";
+	hashMap_put(map, key2, value2);
+
+	HASH_MAP_ENTRY entry1 = hashMap_getEntry(map, key);
+	HASH_MAP_ENTRY entry2 = hashMap_getEntry(map, key2);
+
+	CU_ASSERT_PTR_NOT_NULL_FATAL(entry1);
+	CU_ASSERT_PTR_NOT_NULL_FATAL(entry2);
+
+	HASH_MAP_ENTRY removed = hashMap_removeMapping(map, entry1);
+	CU_ASSERT_PTR_EQUAL(entry1, removed);
+	CU_ASSERT_EQUAL(map->size, 1);
+
+	removed = hashMap_removeMapping(map, entry2);
+	CU_ASSERT_PTR_EQUAL(entry2, removed);
+	CU_ASSERT_EQUAL(map->size, 0);
+
+	// Remove unexisting entry for empty map
+	hashMap_removeMapping(map, NULL);
+	CU_ASSERT_EQUAL(map->size, 0);
+	CU_ASSERT_TRUE(hashMap_isEmpty(map));
+}
+
+void test_hashMap_clear(void) {
+	hashMap_clear(map);
+	// Add one entry
+	char * key = "key";
+	char * value = "value";
+	hashMap_put(map, key, value);
+
+	// Add second entry
+	char * key2 = "key2";
+	char * value2 = "value2";
+	hashMap_put(map, key2, value2);
+
+	// Add third entry with NULL key
+	char * key3 = NULL;
+	char * value3 = "value3";
+	hashMap_put(map, key3, value3);
+
+	// Add fourth entry with NULL value
+	char * key4 = "key4";
+	char * value4 = NULL;
+	hashMap_put(map, key4, value4);
+
+	hashMap_clear(map);
+	CU_ASSERT_EQUAL(map->size, 0);
+}
+
+void test_hashMap_containsValue(void) {
+	hashMap_clear(map);
+
+	// Add one entry
+	char * key = "key";
+	char * value = "value";
+	hashMap_put(map, key, value);
+
+	// Add second entry
+	char * key2 = "key2";
+	char * value2 = "value2";
+	hashMap_put(map, key2, value2);
+
+	CU_ASSERT_TRUE(hashMap_containsValue(map, value));
+	CU_ASSERT_TRUE(hashMap_containsValue(map, value2));
+	char * neValue = "notExisting";
+	CU_ASSERT_FALSE(hashMap_containsValue(map, neValue));
+	CU_ASSERT_FALSE(hashMap_containsValue(map, NULL));
+
+	// Add third entry with NULL value
+	char * key3 = "key3";
+	char * value3 = NULL;
+	hashMap_put(map, key3, value3);
+
+	CU_ASSERT_TRUE(hashMap_containsValue(map, value3));
+}
+
+int main (int argc, char** argv) {
+	CU_pSuite pSuite = NULL;
+
+	/* initialize the CUnit test registry */
+	if (CUE_SUCCESS != CU_initialize_registry())
+	  return CU_get_error();
+
+	/* add a suite to the registry */
+	pSuite = CU_add_suite("Suite_1", setup, NULL);
+	if (NULL == pSuite) {
+	  CU_cleanup_registry();
+	  return CU_get_error();
+	}
+
+	/* add the tests to the suite */
+	if (NULL == CU_add_test(pSuite, "Map Creation Test", test_hashMap_create)
+		|| NULL == CU_add_test(pSuite, "Map Size Test", test_hashMap_size)
+		|| NULL == CU_add_test(pSuite, "Map Is Empty Test", test_hashMap_isEmpty)
+		|| NULL == CU_add_test(pSuite, "Map Get Test", test_hashMap_get)
+		|| NULL == CU_add_test(pSuite, "Map Contains Key Test", test_hashMap_containsKey)
+		|| NULL == CU_add_test(pSuite, "Map Get Entry Test", test_hashMap_getEntry)
+		|| NULL == CU_add_test(pSuite, "Map Put Test", test_hashMap_put)
+		|| NULL == CU_add_test(pSuite, "Map Resize Test", test_hashMap_resize)
+		|| NULL == CU_add_test(pSuite, "Map Remove Test", test_hashMap_remove)
+		|| NULL == CU_add_test(pSuite, "Map Remove Mapping Test", test_hashMap_removeMapping)
+		|| NULL == CU_add_test(pSuite, "Map Clear Test", test_hashMap_clear)
+		|| NULL == CU_add_test(pSuite, "Map Contains Value Test", test_hashMap_containsValue)
+
+
+	)
+	{
+	  CU_cleanup_registry();
+	  return CU_get_error();
+	}
+
+	/* Run all tests using the CUnit Basic interface */
+	CU_basic_set_mode(CU_BRM_VERBOSE);
+	CU_basic_run_tests();
+	CU_cleanup_registry();
+	return CU_get_error();
+}

Added: incubator/celix/trunk/celix_test/hash_map_test_hash.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/celix_test/hash_map_test_hash.c?rev=1043911&view=auto
==============================================================================
--- incubator/celix/trunk/celix_test/hash_map_test_hash.c (added)
+++ incubator/celix/trunk/celix_test/hash_map_test_hash.c Thu Dec  9 11:57:29 2010
@@ -0,0 +1,322 @@
+/*
+ * hash_map_test.c
+ *
+ *  Created on: Jul 25, 2010
+ *      Author: alexanderb
+ */
+#include <stdio.h>
+#include <string.h>
+
+#include "CUnit/Basic.h"
+
+#include "hash_map.h"
+#include "hash_map_private.h"
+
+HASH_MAP map;
+
+unsigned int test_hashKeyChar(void * k) {
+	char * str = (char *) k;
+
+	unsigned int hash = 1315423911;
+	unsigned int i    = 0;
+	int len = strlen(str);
+
+	for(i = 0; i < len; str++, i++)
+	{
+	  hash ^= ((hash << 5) + (*str) + (hash >> 2));
+	}
+
+	return hash;
+}
+
+unsigned int test_hashValueChar(void * v) {
+
+}
+
+int test_equalsKeyChar(void * k, void * o) {
+	return strcmp((char *)k, (char *) o) == 0;
+}
+
+int test_equalsValueChar(void * v, void * o) {
+	return strcmp((char *)v, (char *) o) == 0;
+}
+
+int setup(void) {
+	printf("test\n");
+	map = hashMap_create(test_hashKeyChar, test_hashValueChar, test_equalsKeyChar, test_equalsValueChar);
+	if(map == NULL) {
+		return 1;
+	}
+	return 0;
+}
+
+void test_hashMap_get(void) {
+	hashMap_clear(map);
+
+	// Add one entry
+	char * key = "key";
+	char * value = "value";
+	hashMap_put(map, key, value);
+
+	// Add second entry
+	char * key2 = "key2";
+	char * value2 = "value2";
+	hashMap_put(map, key2, value2);
+
+	// Get with new created key
+	char * getKey = strdup("key");
+	char * get = hashMap_get(map, getKey);
+	CU_ASSERT_PTR_NOT_NULL_FATAL(get);
+	CU_ASSERT_STRING_EQUAL(get, value);
+
+	getKey = strdup("key2");
+	get = hashMap_get(map, getKey);
+	CU_ASSERT_PTR_NOT_NULL_FATAL(get);
+	CU_ASSERT_STRING_EQUAL(get, value2);
+
+	char * neKey = strdup("notExisting");
+	get = hashMap_get(map, neKey);
+	CU_ASSERT_EQUAL(get, NULL);
+
+	get = hashMap_get(map, NULL);
+	CU_ASSERT_EQUAL(get, NULL);
+
+	// Add third entry with NULL key
+	char * key3 = NULL;
+	char * value3 = "value3";
+	hashMap_put(map, key3, value3);
+
+	get = hashMap_get(map, NULL);
+	CU_ASSERT_STRING_EQUAL(get, value3);
+}
+
+void test_hashMap_containsKey(void) {
+	hashMap_clear(map);
+
+	// Add one entry
+	char * key = "key";
+	char * value = "value";
+	hashMap_put(map, key, value);
+
+	// Add second entry
+	char * key2 = "key2";
+	char * value2 = "value2";
+	hashMap_put(map, key2, value2);
+
+	char * containsKey = strdup("key");
+	CU_ASSERT_TRUE(hashMap_containsKey(map, containsKey));
+	containsKey = strdup("key2");
+	CU_ASSERT_TRUE(hashMap_containsKey(map, containsKey));
+	containsKey = strdup("notExisting");
+	CU_ASSERT_FALSE(hashMap_containsKey(map, containsKey));
+	containsKey = NULL;
+	CU_ASSERT_FALSE(hashMap_containsKey(map, containsKey));
+
+	// Add third entry with NULL key
+	char * key3 = NULL;
+	char * value3 = "value3";
+	hashMap_put(map, key3, value3);
+
+	containsKey = NULL;
+	CU_ASSERT_TRUE(hashMap_containsKey(map, containsKey));
+}
+
+void test_hashMap_getEntry(void) {
+	hashMap_clear(map);
+
+	// Add one entry
+	char * key = "key";
+	char * value = "value";
+	hashMap_put(map, key, value);
+
+	// Add second entry
+	char * key2 = "key2";
+	char * value2 = "value2";
+	hashMap_put(map, key2, value2);
+
+	// Get with new created key
+	char * getEntryKey = strdup("key");
+	HASH_MAP_ENTRY entry = hashMap_getEntry(map, getEntryKey);
+	CU_ASSERT_PTR_NOT_NULL_FATAL(entry);
+	CU_ASSERT_STRING_EQUAL(entry->key, key);
+	CU_ASSERT_STRING_EQUAL(entry->value, value);
+
+	getEntryKey = strdup("key2");
+	entry = hashMap_getEntry(map, getEntryKey);
+	CU_ASSERT_PTR_NOT_NULL(entry);
+	CU_ASSERT_STRING_EQUAL(entry->key, key2);
+	CU_ASSERT_STRING_EQUAL(entry->value, value2);
+
+	getEntryKey = strdup("notExisting");
+	entry = hashMap_getEntry(map, getEntryKey);
+	CU_ASSERT_EQUAL(entry, NULL);
+
+	getEntryKey = NULL;
+	entry = hashMap_getEntry(map, getEntryKey);
+	CU_ASSERT_EQUAL(entry, NULL);
+
+	// Add third entry with NULL key
+	char * key3 = NULL;
+	char * value3 = "value3";
+	hashMap_put(map, key3, value3);
+
+	getEntryKey = NULL;
+	entry = hashMap_getEntry(map, getEntryKey);
+	CU_ASSERT_EQUAL(entry->key, key3);
+	CU_ASSERT_STRING_EQUAL(entry->value, value3);
+}
+
+void test_hashMap_put(void) {
+	hashMap_clear(map);
+
+	// Add one entry
+	char * key = "key";
+	char * value = "value";
+	hashMap_put(map, key, value);
+
+	// Add second entry
+	char * key2 = "key2";
+	char * value2 = "value2";
+	hashMap_put(map, key2, value2);
+
+	// Get with new key
+	char * getKey = strdup("key");
+	char * get = hashMap_get(map, getKey);
+	CU_ASSERT_STRING_EQUAL(get, value);
+
+	getKey = strdup("key2");
+	get = hashMap_get(map, getKey);
+	CU_ASSERT_STRING_EQUAL(get, value2);
+
+	// Overwrite existing entry
+	char * nkey2 = strdup("key2");
+	char * nvalue2 = "value3";
+	char * old = (char *) hashMap_put(map, nkey2, nvalue2);
+	CU_ASSERT_PTR_NOT_NULL_FATAL(old);
+	CU_ASSERT_STRING_EQUAL(old, value2)
+
+	getKey = strdup("key2");
+	get = hashMap_get(map, key2);
+	CU_ASSERT_STRING_EQUAL(get, nvalue2);
+
+	// Add third entry with NULL key
+	char * key3 = NULL;
+	char * value3 = "value3";
+	hashMap_put(map, key3, value3);
+
+	getKey = NULL;
+	get = hashMap_get(map, key3);
+	CU_ASSERT_STRING_EQUAL(get, value3);
+
+	// Add fourth entry with NULL value
+	char * key4 = "key4";
+	char * value4 = NULL;
+	hashMap_put(map, key4, value4);
+
+	getKey = strdup("key4");
+	get = hashMap_get(map, key4);
+	CU_ASSERT_EQUAL(get, value4);
+}
+
+void test_hashMap_remove(void) {
+	hashMap_clear(map);
+
+	// Add one entry
+	char * key = "key";
+	char * value = "value";
+	hashMap_put(map, key, value);
+
+	// Add second entry with null key
+	char * key2 = NULL;
+	char * value2 = "value2";
+	hashMap_put(map, key2, value2);
+
+	// Remove unexisting entry for map
+	char * removeKey = strdup("unexisting");
+	hashMap_remove(map, removeKey);
+	CU_ASSERT_EQUAL(map->size, 2);
+	CU_ASSERT_FALSE(hashMap_isEmpty(map));
+
+	// Remove entry with new key
+	removeKey = strdup("key");
+	hashMap_remove(map, removeKey);
+	CU_ASSERT_EQUAL(map->size, 1);
+
+	removeKey = NULL;
+	hashMap_remove(map, removeKey);
+	CU_ASSERT_EQUAL(map->size, 0);
+	CU_ASSERT_TRUE(hashMap_isEmpty(map));
+
+	// Remove unexisting entry for empty map
+	removeKey = strdup("unexisting");
+	hashMap_remove(map, removeKey);
+	CU_ASSERT_EQUAL(map->size, 0);
+	CU_ASSERT_TRUE(hashMap_isEmpty(map));
+}
+
+void test_hashMap_containsValue(void) {
+	hashMap_clear(map);
+
+	// Add one entry
+	char * key = "key";
+	char * value = "value";
+	hashMap_put(map, key, value);
+
+	// Add second entry
+	char * key2 = "key2";
+	char * value2 = "value2";
+	hashMap_put(map, key2, value2);
+
+	char * containsValue = strdup("value");
+	CU_ASSERT_TRUE(hashMap_containsValue(map, containsValue));
+	containsValue = strdup("value2");
+	CU_ASSERT_TRUE(hashMap_containsValue(map, containsValue));
+	containsValue = strdup("notExisting");
+	CU_ASSERT_FALSE(hashMap_containsValue(map, containsValue));
+	containsValue = NULL;
+	CU_ASSERT_FALSE(hashMap_containsValue(map, containsValue));
+
+	// Add third entry with NULL value
+	char * key3 = "key3";
+	char * value3 = NULL;
+	hashMap_put(map, key3, value3);
+
+	containsValue = NULL;
+	CU_ASSERT_TRUE(hashMap_containsValue(map, containsValue));
+}
+
+int main (int argc, char** argv) {
+	CU_pSuite pSuite = NULL;
+
+	/* initialize the CUnit test registry */
+	if (CUE_SUCCESS != CU_initialize_registry())
+	  return CU_get_error();
+
+	/* add a suite to the registry */
+	pSuite = CU_add_suite("Suite_1", setup, NULL);
+	if (NULL == pSuite) {
+	  CU_cleanup_registry();
+	  return CU_get_error();
+	}
+
+	/* add the tests to the suite */
+	if (NULL == CU_add_test(pSuite, "Map Get Test", test_hashMap_get)
+		|| NULL == CU_add_test(pSuite, "Map Contains Key Test", test_hashMap_containsKey)
+		|| NULL == CU_add_test(pSuite, "Map Get Entry Test", test_hashMap_getEntry)
+		|| NULL == CU_add_test(pSuite, "Map Put Test", test_hashMap_put)
+		|| NULL == CU_add_test(pSuite, "Map Remove Test", test_hashMap_remove)
+		|| NULL == CU_add_test(pSuite, "Map Contains Value Test", test_hashMap_containsValue)
+
+
+	)
+	{
+	  CU_cleanup_registry();
+	  return CU_get_error();
+	}
+
+	/* Run all tests using the CUnit Basic interface */
+	CU_basic_set_mode(CU_BRM_VERBOSE);
+	CU_basic_run_tests();
+	CU_cleanup_registry();
+	return CU_get_error();
+}

Added: incubator/celix/trunk/celix_test/test.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/celix_test/test.c?rev=1043911&view=auto
==============================================================================
--- incubator/celix/trunk/celix_test/test.c (added)
+++ incubator/celix/trunk/celix_test/test.c Thu Dec  9 11:57:29 2010
@@ -0,0 +1,52 @@
+/*
+ * test.c
+ *
+ *  Created on: Jul 16, 2010
+ *      Author: alexanderb
+ */
+#include <stdio.h>
+
+#include "CUnit/Basic.h"
+#include "linkedlist.h"
+
+void test_linkedList_create(void) {
+	LINKED_LIST list = linkedList_create();
+	CU_ASSERT(list != NULL);
+}
+
+void test_linkedList_add(void) {
+	LINKED_LIST list = linkedList_create();
+	linkedList_addElement(list, "element");
+
+	CU_ASSERT_EQUAL(linkedList_size(list), 2);
+}
+
+int main (int argc, char** argv) {
+	CU_pSuite pSuite = NULL;
+
+	/* initialize the CUnit test registry */
+	if (CUE_SUCCESS != CU_initialize_registry())
+	  return CU_get_error();
+
+	/* add a suite to the registry */
+	pSuite = CU_add_suite("Suite_1", NULL, NULL);
+	if (NULL == pSuite) {
+	  CU_cleanup_registry();
+	  return CU_get_error();
+	}
+
+	/* add the tests to the suite */
+	if (NULL == CU_add_test(pSuite, "List Creation Test", test_linkedList_create) ||
+		NULL == CU_add_test(pSuite, "List Add Test", test_linkedList_add))
+	{
+	  CU_cleanup_registry();
+	  return CU_get_error();
+	}
+
+	/* Run all tests using the CUnit Basic interface */
+	CU_basic_set_mode(CU_BRM_VERBOSE);
+	CU_basic_run_tests();
+	CU_cleanup_registry();
+	//return CU_get_error();
+	return -1;
+}

Added: incubator/celix/trunk/receiver-2.0/CMakeLists.txt
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/receiver-2.0/CMakeLists.txt?rev=1043911&view=auto
==============================================================================
--- incubator/celix/trunk/receiver-2.0/CMakeLists.txt (added)
+++ incubator/celix/trunk/receiver-2.0/CMakeLists.txt Thu Dec  9 11:57:29 2010
@@ -0,0 +1,6 @@
+add_library(receiver-2.0 SHARED activator serviceTest)
+include_directories("${PROJECT_SOURCE_DIR}/celix" "${PROJECT_SOURCE_DIR}/dependency_manager")

+target_link_libraries(receiver-2.0 dependency_manager framework)
+
+bundle(receiver-2.0)
+package(receiver-2.0 FILES serviceTest.h)
\ No newline at end of file

Added: incubator/celix/trunk/receiver-2.0/MANIFEST/MANIFEST.MF
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/receiver-2.0/MANIFEST/MANIFEST.MF?rev=1043911&view=auto
==============================================================================
--- incubator/celix/trunk/receiver-2.0/MANIFEST/MANIFEST.MF (added)
+++ incubator/celix/trunk/receiver-2.0/MANIFEST/MANIFEST.MF Thu Dec  9 11:57:29 2010
@@ -0,0 +1,5 @@
+Bundle-SymbolicName: receiver
+Bundle-Version: 2.0.0.test
+library: receiver-2.0
+Export-Service: serviceTest;version="2.0.0"
+Import-Service: serviceTest;version="2.0.0"

Added: incubator/celix/trunk/receiver-2.0/activator.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/receiver-2.0/activator.c?rev=1043911&view=auto
==============================================================================
--- incubator/celix/trunk/receiver-2.0/activator.c (added)
+++ incubator/celix/trunk/receiver-2.0/activator.c Thu Dec  9 11:57:29 2010
@@ -0,0 +1,80 @@
+/*
+ * activator.c
+ *
+ *  Created on: Apr 20, 2010
+ *      Author: dk489
+ */
+#include <stdlib.h>
+
+#include "dependency_manager.h"
+#include "dependency_activator_base.h"
+#include "service.h"
+
+#include "bundle_activator.h"
+#include "bundle_context.h"
+#include "serviceTest.h"
+#include "serviceTest_private.h"
+#include "service_component.h"
+#include "service_component_private.h"
+
+SERVICE_REGISTRATION reg;
+SERVICE_REGISTRATION reg2;
+
+SERVICE_TEST m_test;
+
+SERVICE m_service;
+
+void * dm_create() {
+	return NULL;
+}
+
+void dm_init(void * userData, BUNDLE_CONTEXT context, DEPENDENCY_MANAGER manager) {
+	m_test = (SERVICE_TEST) malloc(sizeof(*m_test));
+
+	HASHTABLE props = createProperties();
+	setProperty(props, "test", "test");
+	//setProperty(props, "a", "b");
+	m_test->handle = serviceTest_construct();
+	m_test->doo = doo;
+
+	m_service = dependencyActivatorBase_createService(manager);
+	serviceComponent_setInterface(m_service, SERVICE_TEST_NAME, props);
+	serviceComponent_setImplementation(m_service, m_test);
+
+	dependencyManager_add(manager, m_service);
+}
+
+void dm_destroy(void * userData, BUNDLE_CONTEXT context, DEPENDENCY_MANAGER manager) {
+	dependencyManager_remove(manager, m_service);
+}
+
+void service_init(void * userData) {
+
+}
+void service_start(void * userData) {
+
+}
+void service_stop(void * userData) {
+
+}
+void service_destroy(void * userData) {
+
+}
+
+//void bundleActivator_start(BUNDLE_CONTEXT context) {
+//	m_test = (SERVICE_TEST) malloc(sizeof(*m_test));
+//	HASHTABLE props = createProperties();
+//	setProperty(props, "test", "test");
+//	//setProperty(props, "a", "b");
+//	m_test->handle = serviceTest_construct();
+//	m_test->doo = doo;
+//
+//	reg = register_service(context, SERVICE_TEST_NAME, m_test, props);
+//	//reg2 = register_service(context, SERVICE_TEST_NAME, test, NULL);
+//}
+
+//void bundleActivator_stop(BUNDLE_CONTEXT context) {
+//	serviceRegistration_unregister(reg);
+//	serviceTest_destruct(m_test->handle);
+//	free(m_test);
+//}

Added: incubator/celix/trunk/receiver-2.0/serviceTest.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/receiver-2.0/serviceTest.c?rev=1043911&view=auto
==============================================================================
--- incubator/celix/trunk/receiver-2.0/serviceTest.c (added)
+++ incubator/celix/trunk/receiver-2.0/serviceTest.c Thu Dec  9 11:57:29 2010
@@ -0,0 +1,30 @@
+/*
+ * listenerTest.c
+ *
+ *  Created on: Apr 20, 2010
+ *      Author: dk489
+ */
+#include "serviceTest.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "serviceTest_private.h"
+
+struct serviceDataType {
+	char * test;
+};
+
+SERVICE_DATA_TYPE serviceTest_construct(void) {
+	SERVICE_DATA_TYPE data = (SERVICE_DATA_TYPE) malloc(sizeof(*data));
+	data->test = strdup("hallo 2.0");
+	return data;
+}
+
+void serviceTest_destruct(SERVICE_DATA_TYPE data) {
+	free(data->test);
+	free(data);
+}
+
+void doo(SERVICE_DATA_TYPE handle) {
+	printf("Data: %s\n", handle->test);
+}

Added: incubator/celix/trunk/receiver-2.0/serviceTest.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/receiver-2.0/serviceTest.h?rev=1043911&view=auto
==============================================================================
--- incubator/celix/trunk/receiver-2.0/serviceTest.h (added)
+++ incubator/celix/trunk/receiver-2.0/serviceTest.h Thu Dec  9 11:57:29 2010
@@ -0,0 +1,22 @@
+/*
+ * listenerTest.h
+ *
+ *  Created on: Apr 20, 2010
+ *      Author: dk489
+ */
+
+#ifndef SERVICETEST_H_
+#define SERVICETEST_H_
+
+#define SERVICE_TEST_NAME "serviceTest"
+
+typedef struct serviceDataType * SERVICE_DATA_TYPE;
+
+struct serviceTest {
+	SERVICE_DATA_TYPE handle;
+	void (*doo)(SERVICE_DATA_TYPE handle);
+};
+
+typedef struct serviceTest * SERVICE_TEST;
+
+#endif /* SERVICETEST_H_ */

Added: incubator/celix/trunk/receiver-2.0/serviceTest_private.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/receiver-2.0/serviceTest_private.h?rev=1043911&view=auto
==============================================================================
--- incubator/celix/trunk/receiver-2.0/serviceTest_private.h (added)
+++ incubator/celix/trunk/receiver-2.0/serviceTest_private.h Thu Dec  9 11:57:29 2010
@@ -0,0 +1,19 @@
+/*
+ * serviceTest_private.h
+ *
+ *  Created on: Apr 22, 2010
+ *      Author: dk489
+ */
+
+#ifndef SERVICETEST_PRIVATE_H_
+#define SERVICETEST_PRIVATE_H_
+
+#include "serviceTest.h"
+
+SERVICE_DATA_TYPE serviceTest_construct(void);
+void serviceTest_destruct(SERVICE_DATA_TYPE);
+
+void doo(SERVICE_DATA_TYPE handle);
+
+
+#endif /* SERVICETEST_PRIVATE_H_ */

Added: incubator/celix/trunk/receiver/CMakeLists.txt
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/receiver/CMakeLists.txt?rev=1043911&view=auto
==============================================================================
--- incubator/celix/trunk/receiver/CMakeLists.txt (added)
+++ incubator/celix/trunk/receiver/CMakeLists.txt Thu Dec  9 11:57:29 2010
@@ -0,0 +1,6 @@
+add_library(receiver SHARED activator serviceTest)
+include_directories("${PROJECT_SOURCE_DIR}/celix")
+target_link_libraries(receiver framework)
+
+bundle(receiver)
+package(receiver FILES serviceTest.h)
\ No newline at end of file

Added: incubator/celix/trunk/receiver/MANIFEST/MANIFEST.MF
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/receiver/MANIFEST/MANIFEST.MF?rev=1043911&view=auto
==============================================================================
--- incubator/celix/trunk/receiver/MANIFEST/MANIFEST.MF (added)
+++ incubator/celix/trunk/receiver/MANIFEST/MANIFEST.MF Thu Dec  9 11:57:29 2010
@@ -0,0 +1,5 @@
+Bundle-SymbolicName: receiver
+Bundle-Version: 1.0.0.test
+library: receiver
+Export-Service: serviceTest;version="1.0.0"
+Import-Service: serviceTest;version="1.0.0"

Added: incubator/celix/trunk/receiver/activator.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/receiver/activator.c?rev=1043911&view=auto
==============================================================================
--- incubator/celix/trunk/receiver/activator.c (added)
+++ incubator/celix/trunk/receiver/activator.c Thu Dec  9 11:57:29 2010
@@ -0,0 +1,38 @@
+/*
+ * activator.c
+ *
+ *  Created on: Apr 20, 2010
+ *      Author: dk489
+ */
+#include <stdlib.h>
+#include "bundle_activator.h"
+#include "bundle_context.h"
+#include "serviceTest.h"
+#include "serviceTest_private.h"
+
+SERVICE_REGISTRATION reg;
+SERVICE_REGISTRATION reg2;
+
+SERVICE_TEST m_test;
+
+void bundleActivator_start(void * userData, BUNDLE_CONTEXT context) {
+	m_test = (SERVICE_TEST) malloc(sizeof(*m_test));
+	HASHTABLE props = createProperties();
+	setProperty(props, "test", "test");
+	//setProperty(props, "a", "b");
+	m_test->handle = serviceTest_construct();
+	m_test->doo = doo;
+
+	reg = bundleContext_registerService(context, SERVICE_TEST_NAME, m_test, props);
+	//reg2 = register_service(context, SERVICE_TEST_NAME, test, NULL);
+}
+
+void bundleActivator_stop(void * userData, BUNDLE_CONTEXT context) {
+	serviceRegistration_unregister(reg);
+	serviceTest_destruct(m_test->handle);
+	free(m_test);
+}
+
+void bundleActivator_destroy(void * userData) {
+
+}

Added: incubator/celix/trunk/receiver/serviceTest.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/receiver/serviceTest.c?rev=1043911&view=auto
==============================================================================
--- incubator/celix/trunk/receiver/serviceTest.c (added)
+++ incubator/celix/trunk/receiver/serviceTest.c Thu Dec  9 11:57:29 2010
@@ -0,0 +1,30 @@
+/*
+ * listenerTest.c
+ *
+ *  Created on: Apr 20, 2010
+ *      Author: dk489
+ */
+#include "serviceTest.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "serviceTest_private.h"
+
+struct serviceDataType {
+	char * test;
+};
+
+SERVICE_DATA_TYPE serviceTest_construct(void) {
+	SERVICE_DATA_TYPE data = (SERVICE_DATA_TYPE) malloc(sizeof(*data));
+	data->test = strdup("hallo");
+	return data;
+}
+
+void serviceTest_destruct(SERVICE_DATA_TYPE data) {
+	free(data->test);
+	free(data);
+}
+
+void doo(SERVICE_DATA_TYPE handle) {
+	printf("Data: %s\n", handle->test);
+}

Added: incubator/celix/trunk/receiver/serviceTest.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/receiver/serviceTest.h?rev=1043911&view=auto
==============================================================================
--- incubator/celix/trunk/receiver/serviceTest.h (added)
+++ incubator/celix/trunk/receiver/serviceTest.h Thu Dec  9 11:57:29 2010
@@ -0,0 +1,22 @@
+/*
+ * listenerTest.h
+ *
+ *  Created on: Apr 20, 2010
+ *      Author: dk489
+ */
+
+#ifndef SERVICETEST_H_
+#define SERVICETEST_H_
+
+#define SERVICE_TEST_NAME "serviceTest"
+
+typedef struct serviceDataType * SERVICE_DATA_TYPE;
+
+struct serviceTest {
+	SERVICE_DATA_TYPE handle;
+	void (*doo)(SERVICE_DATA_TYPE handle);
+};
+
+typedef struct serviceTest * SERVICE_TEST;
+
+#endif /* SERVICETEST_H_ */

Added: incubator/celix/trunk/receiver/serviceTest_private.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/receiver/serviceTest_private.h?rev=1043911&view=auto
==============================================================================
--- incubator/celix/trunk/receiver/serviceTest_private.h (added)
+++ incubator/celix/trunk/receiver/serviceTest_private.h Thu Dec  9 11:57:29 2010
@@ -0,0 +1,19 @@
+/*
+ * serviceTest_private.h
+ *
+ *  Created on: Apr 22, 2010
+ *      Author: dk489
+ */
+
+#ifndef SERVICETEST_PRIVATE_H_
+#define SERVICETEST_PRIVATE_H_
+
+#include "serviceTest.h"
+
+SERVICE_DATA_TYPE serviceTest_construct(void);
+void serviceTest_destruct(SERVICE_DATA_TYPE);
+
+void doo(SERVICE_DATA_TYPE handle);
+
+
+#endif /* SERVICETEST_PRIVATE_H_ */



Mime
View raw message