framework/private/test/resolver_test.cpp - celix - 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.
  */
 /*
  * resolver_test.cpp
  *
  *  \date       Feb 11, 2013
  *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
  *  \copyright  Apache License, Version 2.0
  */
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>

 #include "CppUTest/TestHarness.h"
 #include "CppUTest/TestHarness_c.h"
 #include "CppUTest/CommandLineTestRunner.h"
 #include "CppUTestExt/MockSupport.h"

 extern "C" {
 #include "resolver.h"
 #include "celix_log.h"
 #include "manifest_parser.h"
 #include "requirement_private.h"
 #include "capability_private.h"
 #include "version_private.h"

 framework_logger_pt logger = (framework_logger_pt) 0x42;
 }

 int main(int argc, char** argv) {
 	return RUN_ALL_TESTS(argc, argv);
 }

 static char* my_strdup(const char* s) {
 	if (s == NULL) {
 		return NULL;
 	}

 	size_t len = strlen(s);

 	char *d = (char*) calloc(len + 1, sizeof(char));

 	if (d == NULL) {
 		return NULL;
 	}

 	strncpy(d, s, len);
 	return d;
 }

 TEST_GROUP(resolver) {
 	void setup(void){
 	}

 	void teardown(){
 		mock().checkExpectations();
 		mock().clear();
 	}
 };

 TEST(resolver, resolve){
 	module_pt module;
 	module_pt module2;
 	manifest_pt manifest = (manifest_pt) 0x01;
 	manifest_pt manifest2 = (manifest_pt) 0x02;
 	manifest_parser_pt parser = (manifest_parser_pt) 0x03;
 	manifest_parser_pt parser2 = (manifest_parser_pt) 0x04;
 	bundle_pt bundle = (bundle_pt) 0x05;
 	version_pt version = (version_pt) malloc(sizeof(*version));
 	linked_list_pt capabilities = NULL;
 	linked_list_pt requirements = NULL;
 	linked_list_pt empty_capabilities = NULL;
 	linked_list_pt empty_requirements = NULL;
 	char * name = my_strdup("module_one");
 	char * name2 = my_strdup("module_two");
 	char * id = my_strdup("42");
 	char * id2 = my_strdup("43");
 	char * service_name = my_strdup("test_service_foo");
 	char * service_name2 = my_strdup("test_service_bar");
 	requirement_pt req = (requirement_pt) 0x06;
 	requirement_pt req2= (requirement_pt) 0x07;
 	capability_pt cap = (capability_pt) 0x08;
 	capability_pt cap2= (capability_pt) 0x09;

 	importer_wires_pt get_importer_wires;
 	linked_list_pt get_wire_list;
 	linked_list_pt get_wire_list2;

 	//creating modules
 	linkedList_create(&capabilities);
 	linkedList_create(&empty_capabilities);
 	linkedList_create(&requirements);
 	linkedList_create(&empty_requirements);

 	linkedList_addElement(requirements, req);
 	linkedList_addElement(requirements, req2);
 	linkedList_addElement(capabilities, cap);
 	linkedList_addElement(capabilities, cap2);


 	mock().expectOneCall("manifestParser_create")
 			.withParameter("manifest", manifest)
 			.withOutputParameterReturning("manifest_parser", &parser, sizeof(parser))
 			.ignoreOtherParameters();
 	mock().expectOneCall("manifestParser_getSymbolicName")
 			.withParameter("parser", parser)
 			.withOutputParameterReturning("symbolicName", &name, sizeof(name));
 	mock().expectOneCall("manifestParser_getBundleVersion")
 			.withParameter("parser", parser)
 			.withOutputParameterReturning("version", &version, sizeof(version_pt));
 	mock().expectOneCall("manifestParser_getCapabilities")
 			.withParameter("parser", parser)
 			.withOutputParameterReturning("capabilities", &empty_capabilities, sizeof(empty_capabilities));
 	mock().expectOneCall("manifestParser_getCurrentRequirements")
 			.withParameter("parser", parser)
 			.withOutputParameterReturning("requirements", &requirements, sizeof(requirements));
 	mock().expectOneCall("manifestParser_destroy")
 			.withParameter("manifest_parser", parser);

 	mock().expectOneCall("manifestParser_create")
 			.withParameter("manifest", manifest2)
 			.withOutputParameterReturning("manifest_parser", &parser2, sizeof(parser2))
 			.ignoreOtherParameters();
 	mock().expectOneCall("manifestParser_getSymbolicName")
 			.withParameter("parser", parser2)
 			.withOutputParameterReturning("symbolicName", &name2, sizeof(name2));
 	mock().expectOneCall("manifestParser_getBundleVersion")
 			.withParameter("parser", parser2)
 			.withOutputParameterReturning("version", &version, sizeof(version_pt));
 	mock().expectOneCall("manifestParser_getCapabilities")
 			.withParameter("parser", parser2)
 			.withOutputParameterReturning("capabilities", &capabilities, sizeof(linked_list_pt));
 	mock().expectOneCall("manifestParser_getCurrentRequirements")
 			.withParameter("parser", parser2)
 			.withOutputParameterReturning("requirements", &empty_requirements, sizeof(linked_list_pt));
 	mock().expectOneCall("manifestParser_destroy")
 			.withParameter("manifest_parser", parser2);


 	module = module_create(manifest, id, bundle);
 	module2 = module_create(manifest2, id2, bundle);

 	mock().expectOneCall("capability_getServiceName")
 			.withParameter("capability", cap)
 			.withOutputParameterReturning("serviceName", &service_name, sizeof(service_name));

 	mock().expectOneCall("capability_getServiceName")
 			.withParameter("capability", cap2)
 			.withOutputParameterReturning("serviceName", &service_name2, sizeof(service_name2));

 	resolver_addModule(module2);

 	mock().expectOneCall( "requirement_getTargetName")
 			.withParameter("requirement", req)
 			.withOutputParameterReturning("targetName", &service_name, sizeof(service_name));

 	mock().expectOneCall("requirement_getTargetName")
 			.withParameter("requirement", req2)
 			.withOutputParameterReturning("targetName", &service_name2, sizeof(service_name2));

 	bool out = true;
 	mock().expectOneCall("requirement_isSatisfied")
 			.withParameter("requirement", req)
 			.withParameter("capability", cap)
 			.withOutputParameterReturning("inRange", &out, sizeof(out));

 	mock().expectOneCall("requirement_isSatisfied")
 			.withParameter("requirement", req2)
 			.withParameter("capability", cap2)
 			.withOutputParameterReturning("inRange", &out, sizeof(out));

 	mock().expectNCalls(2, "capability_getModule")
 			.withParameter("capability", cap)
 			.withOutputParameterReturning("module", &module2, sizeof(module2));

 	mock().expectNCalls(2, "capability_getModule")
 			.withParameter("capability", cap2)
 			.withOutputParameterReturning("module", &module2, sizeof(module2));


 	get_wire_list = resolver_resolve(module);
 	LONGS_EQUAL(2, linkedList_size(get_wire_list));
 	get_wire_list2 = resolver_resolve(module2);
 	LONGS_EQUAL(1, linkedList_size(get_wire_list2)); //creates one empty importer wires struct

 	get_importer_wires = (importer_wires_pt) linkedList_removeLast(get_wire_list2);
 	LONGS_EQUAL(0, linkedList_size(get_importer_wires->wires));
 	linkedList_destroy(get_importer_wires->wires);
 	free(get_importer_wires);
 	linkedList_destroy(get_wire_list2);

 	get_importer_wires = (importer_wires_pt) linkedList_removeLast(get_wire_list);
 	if ( get_importer_wires->importer == module ) {
 		module_setWires(module, get_importer_wires->wires);
 		free(get_importer_wires);
 		get_importer_wires = (importer_wires_pt) linkedList_removeLast(get_wire_list);
 		POINTERS_EQUAL(get_importer_wires->importer, module2);
 		module_setWires(module2, get_importer_wires->wires);
 		free(get_importer_wires);
 	} else {
 		POINTERS_EQUAL(get_importer_wires->importer, module2);
 		module_setWires(module2, get_importer_wires->wires);
 		free(get_importer_wires);
 		get_importer_wires = (importer_wires_pt) linkedList_removeLast(get_wire_list);
 		POINTERS_EQUAL(get_importer_wires->importer, module);
 		module_setWires(module, get_importer_wires->wires);
 		free(get_importer_wires);
 	}

 	//register as resolved
 	module_setResolved(module);
 	module_setResolved(module2);

 	mock().expectNCalls(2, "capability_getServiceName")
 			.withParameter("capability", cap)
 			.withOutputParameterReturning("serviceName", &service_name, sizeof(service_name));

 	mock().expectNCalls(2, "capability_getServiceName")
 			.withParameter("capability", cap2)
 			.withOutputParameterReturning("serviceName", &service_name2, sizeof(service_name2));

 	resolver_moduleResolved(module2);

 	//test resolved module checking
 	POINTERS_EQUAL(NULL, resolver_resolve(module));

 	//CLEAN UP
 	mock().expectOneCall("capability_getServiceName")
 			.withParameter("capability", cap)
 			.withOutputParameterReturning("serviceName", &service_name, sizeof(service_name));

 	mock().expectOneCall("capability_getServiceName")
 			.withParameter("capability", cap2)
 			.withOutputParameterReturning("serviceName", &service_name2, sizeof(service_name2));

 	resolver_removeModule(module2);

 	mock().expectOneCall("requirement_destroy")
 			.withParameter("requirement", req);

 	mock().expectOneCall("requirement_destroy")
 			.withParameter("requirement", req2);

 	mock().expectOneCall("capability_destroy")
 			.withParameter("capability", cap);

 	mock().expectOneCall("capability_destroy")
 			.withParameter("capability", cap2);

 	mock().expectNCalls(2, "version_destroy")
 			.withParameter("version", version);

 	module_destroy(module);
 	module_destroy(module2);

 	linkedList_destroy(get_wire_list);
 	free(id);
 	free(id2);
 	free(service_name);
 	free(service_name2);
 	free(version);
 }

 TEST(resolver, resolve_fail){
 	module_pt module;
 	manifest_pt manifest = (manifest_pt) 0x01;
 	manifest_parser_pt parser = (manifest_parser_pt) 0x03;
 	bundle_pt bundle = (bundle_pt) 0x05;
 	version_pt version = (version_pt) malloc(sizeof(*version));
 	linked_list_pt requirements = NULL;
 	linked_list_pt empty_capabilities = NULL;
 	char * name = my_strdup("module_one");
 	char * id = my_strdup("42");
 	char * service_name = my_strdup("test_service_foo");
 	requirement_pt req = (requirement_pt) 0x06;
 	requirement_pt req2= (requirement_pt) 0x07;
 	linked_list_pt get_wire_map;

 	//creating modules
 	linkedList_create(&empty_capabilities);
 	linkedList_create(&requirements);

 	linkedList_addElement(requirements, req);
 	linkedList_addElement(requirements, req2);


 	mock().expectOneCall("manifestParser_create")
 			.withParameter("manifest", manifest)
 			.withOutputParameterReturning("manifest_parser", &parser, sizeof(parser))
 			.ignoreOtherParameters();
 	mock().expectOneCall("manifestParser_getSymbolicName")
 			.withParameter("parser", parser)
 			.withOutputParameterReturning("symbolicName", &name, sizeof(name));
 	mock().expectOneCall("manifestParser_getBundleVersion")
 			.withParameter("parser", parser)
 			.withOutputParameterReturning("version", &version, sizeof(version_pt));
 	mock().expectOneCall("manifestParser_getCapabilities")
 			.withParameter("parser", parser)
 			.withOutputParameterReturning("capabilities", &empty_capabilities, sizeof(empty_capabilities));
 	mock().expectOneCall("manifestParser_getCurrentRequirements")
 			.withParameter("parser", parser)
 			.withOutputParameterReturning("requirements", &requirements, sizeof(requirements));
 	mock().expectOneCall("manifestParser_destroy")
 			.withParameter("manifest_parser", parser);

 	module = module_create(manifest, id, bundle);

 	resolver_addModule(module);

 	mock().expectOneCall( "requirement_getTargetName")
 			.withParameter("requirement", req)
 			.withOutputParameterReturning("targetName", &service_name, sizeof(service_name));

 	mock().expectOneCall("framework_log");

 	get_wire_map = resolver_resolve(module);
 	POINTERS_EQUAL(NULL, get_wire_map);

 	//cleanup
 	resolver_removeModule(module);

 	mock().expectOneCall("requirement_destroy")
 			.withParameter("requirement", req);

 	mock().expectOneCall("requirement_destroy")
 			.withParameter("requirement", req2);

 	mock().expectOneCall("version_destroy")
 			.withParameter("version", version);

 	module_destroy(module);

 	free(service_name);
 	free(version);
 	free(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.
	*/
	/*
	* resolver_test.cpp
	*
	* \date Feb 11, 2013
	* \author <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
	* \copyright Apache License, Version 2.0
	*/
	#include <stdlib.h>
	#include <stdio.h>
	#include <string.h>

	#include "CppUTest/TestHarness.h"
	#include "CppUTest/TestHarness_c.h"
	#include "CppUTest/CommandLineTestRunner.h"
	#include "CppUTestExt/MockSupport.h"

	extern "C" {
	#include "resolver.h"
	#include "celix_log.h"
	#include "manifest_parser.h"
	#include "requirement_private.h"
	#include "capability_private.h"
	#include "version_private.h"

	framework_logger_pt logger = (framework_logger_pt) 0x42;
	}

	int main(int argc, char** argv) {
	return RUN_ALL_TESTS(argc, argv);
	}

	static char* my_strdup(const char* s) {
	if (s == NULL) {
	return NULL;
	}

	size_t len = strlen(s);

	char d = (char) calloc(len + 1, sizeof(char));

	if (d == NULL) {
	return NULL;
	}

	strncpy(d, s, len);
	return d;
	}

	TEST_GROUP(resolver) {
	void setup(void){
	}

	void teardown(){
	mock().checkExpectations();
	mock().clear();
	}
	};

	TEST(resolver, resolve){
	module_pt module;
	module_pt module2;
	manifest_pt manifest = (manifest_pt) 0x01;
	manifest_pt manifest2 = (manifest_pt) 0x02;
	manifest_parser_pt parser = (manifest_parser_pt) 0x03;
	manifest_parser_pt parser2 = (manifest_parser_pt) 0x04;
	bundle_pt bundle = (bundle_pt) 0x05;
	version_pt version = (version_pt) malloc(sizeof(*version));
	linked_list_pt capabilities = NULL;
	linked_list_pt requirements = NULL;
	linked_list_pt empty_capabilities = NULL;
	linked_list_pt empty_requirements = NULL;
	char * name = my_strdup("module_one");
	char * name2 = my_strdup("module_two");
	char * id = my_strdup("42");
	char * id2 = my_strdup("43");
	char * service_name = my_strdup("test_service_foo");
	char * service_name2 = my_strdup("test_service_bar");
	requirement_pt req = (requirement_pt) 0x06;
	requirement_pt req2= (requirement_pt) 0x07;
	capability_pt cap = (capability_pt) 0x08;
	capability_pt cap2= (capability_pt) 0x09;

	importer_wires_pt get_importer_wires;
	linked_list_pt get_wire_list;
	linked_list_pt get_wire_list2;

	//creating modules
	linkedList_create(&capabilities);
	linkedList_create(&empty_capabilities);
	linkedList_create(&requirements);
	linkedList_create(&empty_requirements);

	linkedList_addElement(requirements, req);
	linkedList_addElement(requirements, req2);
	linkedList_addElement(capabilities, cap);
	linkedList_addElement(capabilities, cap2);


	mock().expectOneCall("manifestParser_create")
	.withParameter("manifest", manifest)
	.withOutputParameterReturning("manifest_parser", &parser, sizeof(parser))
	.ignoreOtherParameters();
	mock().expectOneCall("manifestParser_getSymbolicName")
	.withParameter("parser", parser)
	.withOutputParameterReturning("symbolicName", &name, sizeof(name));
	mock().expectOneCall("manifestParser_getBundleVersion")
	.withParameter("parser", parser)
	.withOutputParameterReturning("version", &version, sizeof(version_pt));
	mock().expectOneCall("manifestParser_getCapabilities")
	.withParameter("parser", parser)
	.withOutputParameterReturning("capabilities", &empty_capabilities, sizeof(empty_capabilities));
	mock().expectOneCall("manifestParser_getCurrentRequirements")
	.withParameter("parser", parser)
	.withOutputParameterReturning("requirements", &requirements, sizeof(requirements));
	mock().expectOneCall("manifestParser_destroy")
	.withParameter("manifest_parser", parser);

	mock().expectOneCall("manifestParser_create")
	.withParameter("manifest", manifest2)
	.withOutputParameterReturning("manifest_parser", &parser2, sizeof(parser2))
	.ignoreOtherParameters();
	mock().expectOneCall("manifestParser_getSymbolicName")
	.withParameter("parser", parser2)
	.withOutputParameterReturning("symbolicName", &name2, sizeof(name2));
	mock().expectOneCall("manifestParser_getBundleVersion")
	.withParameter("parser", parser2)
	.withOutputParameterReturning("version", &version, sizeof(version_pt));
	mock().expectOneCall("manifestParser_getCapabilities")
	.withParameter("parser", parser2)
	.withOutputParameterReturning("capabilities", &capabilities, sizeof(linked_list_pt));
	mock().expectOneCall("manifestParser_getCurrentRequirements")
	.withParameter("parser", parser2)
	.withOutputParameterReturning("requirements", &empty_requirements, sizeof(linked_list_pt));
	mock().expectOneCall("manifestParser_destroy")
	.withParameter("manifest_parser", parser2);


	module = module_create(manifest, id, bundle);
	module2 = module_create(manifest2, id2, bundle);

	mock().expectOneCall("capability_getServiceName")
	.withParameter("capability", cap)
	.withOutputParameterReturning("serviceName", &service_name, sizeof(service_name));

	mock().expectOneCall("capability_getServiceName")
	.withParameter("capability", cap2)
	.withOutputParameterReturning("serviceName", &service_name2, sizeof(service_name2));

	resolver_addModule(module2);

	mock().expectOneCall( "requirement_getTargetName")
	.withParameter("requirement", req)
	.withOutputParameterReturning("targetName", &service_name, sizeof(service_name));

	mock().expectOneCall("requirement_getTargetName")
	.withParameter("requirement", req2)
	.withOutputParameterReturning("targetName", &service_name2, sizeof(service_name2));

	bool out = true;
	mock().expectOneCall("requirement_isSatisfied")
	.withParameter("requirement", req)
	.withParameter("capability", cap)
	.withOutputParameterReturning("inRange", &out, sizeof(out));

	mock().expectOneCall("requirement_isSatisfied")
	.withParameter("requirement", req2)
	.withParameter("capability", cap2)
	.withOutputParameterReturning("inRange", &out, sizeof(out));

	mock().expectNCalls(2, "capability_getModule")
	.withParameter("capability", cap)
	.withOutputParameterReturning("module", &module2, sizeof(module2));

	mock().expectNCalls(2, "capability_getModule")
	.withParameter("capability", cap2)
	.withOutputParameterReturning("module", &module2, sizeof(module2));


	get_wire_list = resolver_resolve(module);
	LONGS_EQUAL(2, linkedList_size(get_wire_list));
	get_wire_list2 = resolver_resolve(module2);
	LONGS_EQUAL(1, linkedList_size(get_wire_list2)); //creates one empty importer wires struct

	get_importer_wires = (importer_wires_pt) linkedList_removeLast(get_wire_list2);
	LONGS_EQUAL(0, linkedList_size(get_importer_wires->wires));
	linkedList_destroy(get_importer_wires->wires);
	free(get_importer_wires);
	linkedList_destroy(get_wire_list2);

	get_importer_wires = (importer_wires_pt) linkedList_removeLast(get_wire_list);
	if ( get_importer_wires->importer == module ) {
	module_setWires(module, get_importer_wires->wires);
	free(get_importer_wires);
	get_importer_wires = (importer_wires_pt) linkedList_removeLast(get_wire_list);
	POINTERS_EQUAL(get_importer_wires->importer, module2);
	module_setWires(module2, get_importer_wires->wires);
	free(get_importer_wires);
	} else {
	POINTERS_EQUAL(get_importer_wires->importer, module2);
	module_setWires(module2, get_importer_wires->wires);
	free(get_importer_wires);
	get_importer_wires = (importer_wires_pt) linkedList_removeLast(get_wire_list);
	POINTERS_EQUAL(get_importer_wires->importer, module);
	module_setWires(module, get_importer_wires->wires);
	free(get_importer_wires);
	}

	//register as resolved
	module_setResolved(module);
	module_setResolved(module2);

	mock().expectNCalls(2, "capability_getServiceName")
	.withParameter("capability", cap)
	.withOutputParameterReturning("serviceName", &service_name, sizeof(service_name));

	mock().expectNCalls(2, "capability_getServiceName")
	.withParameter("capability", cap2)
	.withOutputParameterReturning("serviceName", &service_name2, sizeof(service_name2));

	resolver_moduleResolved(module2);

	//test resolved module checking
	POINTERS_EQUAL(NULL, resolver_resolve(module));

	//CLEAN UP
	mock().expectOneCall("capability_getServiceName")
	.withParameter("capability", cap)
	.withOutputParameterReturning("serviceName", &service_name, sizeof(service_name));

	mock().expectOneCall("capability_getServiceName")
	.withParameter("capability", cap2)
	.withOutputParameterReturning("serviceName", &service_name2, sizeof(service_name2));

	resolver_removeModule(module2);

	mock().expectOneCall("requirement_destroy")
	.withParameter("requirement", req);

	mock().expectOneCall("requirement_destroy")
	.withParameter("requirement", req2);

	mock().expectOneCall("capability_destroy")
	.withParameter("capability", cap);

	mock().expectOneCall("capability_destroy")
	.withParameter("capability", cap2);

	mock().expectNCalls(2, "version_destroy")
	.withParameter("version", version);

	module_destroy(module);
	module_destroy(module2);

	linkedList_destroy(get_wire_list);
	free(id);
	free(id2);
	free(service_name);
	free(service_name2);
	free(version);
	}

	TEST(resolver, resolve_fail){
	module_pt module;
	manifest_pt manifest = (manifest_pt) 0x01;
	manifest_parser_pt parser = (manifest_parser_pt) 0x03;
	bundle_pt bundle = (bundle_pt) 0x05;
	version_pt version = (version_pt) malloc(sizeof(*version));
	linked_list_pt requirements = NULL;
	linked_list_pt empty_capabilities = NULL;
	char * name = my_strdup("module_one");
	char * id = my_strdup("42");
	char * service_name = my_strdup("test_service_foo");
	requirement_pt req = (requirement_pt) 0x06;
	requirement_pt req2= (requirement_pt) 0x07;
	linked_list_pt get_wire_map;

	//creating modules
	linkedList_create(&empty_capabilities);
	linkedList_create(&requirements);

	linkedList_addElement(requirements, req);
	linkedList_addElement(requirements, req2);


	mock().expectOneCall("manifestParser_create")
	.withParameter("manifest", manifest)
	.withOutputParameterReturning("manifest_parser", &parser, sizeof(parser))
	.ignoreOtherParameters();
	mock().expectOneCall("manifestParser_getSymbolicName")
	.withParameter("parser", parser)
	.withOutputParameterReturning("symbolicName", &name, sizeof(name));
	mock().expectOneCall("manifestParser_getBundleVersion")
	.withParameter("parser", parser)
	.withOutputParameterReturning("version", &version, sizeof(version_pt));
	mock().expectOneCall("manifestParser_getCapabilities")
	.withParameter("parser", parser)
	.withOutputParameterReturning("capabilities", &empty_capabilities, sizeof(empty_capabilities));
	mock().expectOneCall("manifestParser_getCurrentRequirements")
	.withParameter("parser", parser)
	.withOutputParameterReturning("requirements", &requirements, sizeof(requirements));
	mock().expectOneCall("manifestParser_destroy")
	.withParameter("manifest_parser", parser);

	module = module_create(manifest, id, bundle);

	resolver_addModule(module);

	mock().expectOneCall( "requirement_getTargetName")
	.withParameter("requirement", req)
	.withOutputParameterReturning("targetName", &service_name, sizeof(service_name));

	mock().expectOneCall("framework_log");

	get_wire_map = resolver_resolve(module);
	POINTERS_EQUAL(NULL, get_wire_map);

	//cleanup
	resolver_removeModule(module);

	mock().expectOneCall("requirement_destroy")
	.withParameter("requirement", req);

	mock().expectOneCall("requirement_destroy")
	.withParameter("requirement", req2);

	mock().expectOneCall("version_destroy")
	.withParameter("version", version);

	module_destroy(module);

	free(service_name);
	free(version);
	free(id);
	}