icwmp/test/cmocka/icwmp_soap_msg_unit_test.c

/*
 *	This program is free software: you can redistribute it and/or modify
 *	it under the terms of the GNU General Public License as published by
 *	the Free Software Foundation, either version 2 of the License, or
 *	(at your option) any later version.
 *
 *	Copyright (C) 2013-2021 iopsys Software Solutions AB
 *	  Author Omar Kallel <omar.kallel@pivasoftware.com>
 */

#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <dirent.h>
#include <string.h>
#include <libxml/tree.h>
#include <libxml/parser.h>

#include "rpc.h"
#include "event.h"
#include "session.h"
#include "config.h"
#include "backupSession.h"
#include "log.h"
#include "download.h"
#include "xml.h"
#include "uci_utils.h"

#include "icwmp_soap_msg_unit_test.h"
#include "cwmp_event.h"

static int instance = 0;
struct list_head force_inform_list;

#define INVALID_PARAM_KEY "ParameterKeyParameterKeyParameter"
#define INVALID_USER "useruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruseruser1"
#define INVALID_PASS "passwordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpassword1"
/*
 * End test clean
 */

static void clean_name_space()
{
	FREE(g_cwmp_ns.soap_env);
	FREE(g_cwmp_ns.soap_enc);
	FREE(g_cwmp_ns.xsd);
	FREE(g_cwmp_ns.xsi);
	FREE(g_cwmp_ns.cwmp);
}

static void unit_test_remove_all_session_events()
{
	while (cwmp_ctx.session->events.next != &(cwmp_ctx.session->events)) {
		struct event_container *event_container;
		event_container = list_entry(cwmp_ctx.session->events.next, struct event_container, list);
		free(event_container->command_key);
		cwmp_free_all_dm_parameter_list(&(event_container->head_dm_parameter));
		list_del(&(event_container->list));
		free(event_container);
	}
}

static void unit_test_end_test_destruction()
{
	unit_test_remove_all_session_events();
}

/*
 * CMOCKA functions
 */
static int soap_unit_tests_init(void **state)
{
	CWMP_MEMSET(&force_inform_list, 0, sizeof(struct list_head));
	INIT_LIST_HEAD(&force_inform_list);
	load_default_forced_inform();
	load_forced_inform_json();

	create_cwmp_session_structure();
	cwmp_session_init();
	log_set_severity_idx("DEBUG");
	return 0;
}

static int soap_unit_tests_clean(void **state)
{
	clean_name_space();
	rpc_exit();
	icwmp_cleanmem();
	clean_force_inform_list();
	FREE(cwmp_ctx.session);
	return 0;
}

/*
 * UNIT Tests
 */
static void get_config_test(void **state)
{
	int error = get_preinit_config();
	assert_int_equal(error, CWMP_OK);
	error = get_global_config();
}

static void get_deviceid_test(void **state)
{
	int error = cwmp_get_deviceid();
	assert_int_equal(error, CWMP_OK);
}

static void add_event_test(void **state)
{
	struct event_container *event_container;
	event_container = cwmp_add_event_container(EVENT_IDX_1BOOT, "");
	assert_non_null(event_container);
	assert_string_equal(EVENT_CONST[event_container->code].CODE, "1 BOOT");
}

static void soap_inform_message_test(void **state)
{
	xmlNode *env = NULL, *n = NULL, *device_id = NULL, *cwmp_inform = NULL;
	struct rpc *rpc_acs;

	rpc_acs = list_entry(&(cwmp_ctx.session->head_rpc_acs), struct rpc, list);
	cwmp_rpc_acs_prepare_message_inform(rpc_acs);

	xmlNode *root = xmlDocGetRootElement(cwmp_ctx.session->tree_out);
	env = xml_find_element(root, root, "soap_env:Envelope", XML_DESCEND);
	assert_non_null(env);
	n = xml_find_element(env, env, "soap_env:Header", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "cwmp:ID", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(env, env, "soap_env:Body", XML_DESCEND);
	assert_non_null(n);
	cwmp_inform = xml_find_element(env, env, "cwmp:Inform", XML_DESCEND);
	assert_non_null(cwmp_inform);
	device_id = xml_find_element(cwmp_inform, cwmp_inform, "DeviceId", XML_DESCEND);
	assert_non_null(device_id);
	n = xml_find_element(device_id, device_id, "Manufacturer", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(device_id, device_id, "OUI", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(device_id, device_id, "ProductClass", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(device_id, device_id, "SerialNumber", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(cwmp_inform, cwmp_inform, "Event", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "EventStruct", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "EventCode", XML_DESCEND);
	assert_non_null(n);
	xmlChar *content = xmlNodeGetContent(n->children);
	assert_string_equal((const char*)content, "1 BOOT");
	xmlFree(content);
	n = xml_find_element(cwmp_inform, cwmp_inform, "ParameterList", XML_DESCEND);
	assert_non_null(n);

	xmlFreeDoc(cwmp_ctx.session->tree_in);
	xmlFreeDoc(cwmp_ctx.session->tree_out);

	unit_test_end_test_destruction();
}

static void prepare_session_for_rpc_method_call()
{
	xmlNode *b;
	char c[128];

	snprintf(c, sizeof(c), "%s:%s", g_cwmp_ns.soap_env, "Body");
	xmlNode *root = xmlDocGetRootElement(cwmp_ctx.session->tree_in);
	b = xml_find_element(root, root, c, XML_DESCEND);
	cwmp_ctx.session->body_in = b;
	xml_prepare_msg_out();
}

static void prepare_gpv_soap_request(char *parameters[], int len)
{
	xmlNode *params = NULL, *n = NULL;
	int i;

	cwmp_ctx.session->tree_in = xmlReadMemory(CWMP_GETPARAMETERVALUES_REQ, strlen(CWMP_GETPARAMETERVALUES_REQ), NULL, NULL, 0);
	xml_recreate_namespace(cwmp_ctx.session->tree_in);
	xmlNode *root = xmlDocGetRootElement(cwmp_ctx.session->tree_in);
	params = xml_find_element(root, root, "ParameterNames", XML_DESCEND);
	for (i = 0; i < len; i++) {
		n = xmlNewChild(params, NULL, BAD_CAST "string", BAD_CAST parameters[i]);
	}
}

static void soap_get_param_value_message_test(void **state)
{
	xmlNode *env = NULL, *n = NULL, *name = NULL, *value = NULL;
	xmlNode *root = NULL;
	xmlChar *content = NULL;

	struct rpc *rpc_cpe = build_sessin_rcp_cpe(RPC_CPE_GET_PARAMETER_VALUES);

	/*
	 * Valid parameter path
	 */
	char *valid_parameters[1] = { "Device.ManagementServer.PeriodicInformEnable" };
	prepare_gpv_soap_request(valid_parameters, 1);

	prepare_session_for_rpc_method_call();

	int ret = cwmp_handle_rpc_cpe_get_parameter_values(rpc_cpe);
	assert_int_equal(ret, 0);

	root = xmlDocGetRootElement(cwmp_ctx.session->tree_out);
	env = xml_find_element(root, root, "soap_env:Envelope", XML_DESCEND);
	assert_non_null(env);
	n = xml_find_element(env, env, "soap_env:Header", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "cwmp:ID", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(env, env, "soap_env:Body", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "cwmp:GetParameterValuesResponse", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "ParameterList", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "ParameterValueStruct", XML_DESCEND);
	assert_non_null(n);

	name = xml_find_element(n, n, "Name", XML_DESCEND);
	assert_non_null(name);
	content = xmlNodeGetContent(name->children);
	assert_string_equal((const char*)content, "Device.ManagementServer.PeriodicInformEnable");
	xmlFree(content);
	value = xml_find_element(n, n, "Value", XML_DESCEND);
	assert_non_null(value);

	xmlFreeDoc(cwmp_ctx.session->tree_in);
	xmlFreeDoc(cwmp_ctx.session->tree_out);

	/*
	* Wrong parameter path
	*/
	xmlNode *fault_code = NULL, *fault_string = NULL, *detail = NULL, *detail_code = NULL, *detail_string = NULL;

	char *invalid_parameter[1] = { "Device.ManagementServereriodicInformEnable" };
	prepare_gpv_soap_request(invalid_parameter, 1);

	prepare_session_for_rpc_method_call();

	ret = cwmp_handle_rpc_cpe_get_parameter_values(rpc_cpe);
	assert_int_equal(ret, 0);

	root = xmlDocGetRootElement(cwmp_ctx.session->tree_out);
	env = xml_find_element(root, root, "soap_env:Envelope", XML_DESCEND);
	assert_non_null(env);
	n = xml_find_element(env, env, "soap_env:Header", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "cwmp:ID", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(env, env, "soap_env:Body", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "soap_env:Fault", XML_DESCEND);
	assert_non_null(n);
	fault_code = xml_find_element(n, n, "faultcode", XML_DESCEND);
	assert_non_null(fault_code);
	fault_string = xml_find_element(n, n, "faultstring", XML_DESCEND);
	assert_non_null(fault_string);
	detail = xml_find_element(n, n, "detail", XML_DESCEND);
	assert_non_null(detail);
	detail = xml_find_element(detail, detail, "cwmp:Fault", XML_DESCEND);
	assert_non_null(detail);
	detail_code = xml_find_element(detail, detail, "FaultCode", XML_DESCEND);
	assert_non_null(detail_code);
	content = xmlNodeGetContent(detail_code->children);
	assert_string_equal((const char*)content, "9005");
	xmlFree(content);
	detail_string = xml_find_element(detail, detail, "FaultString", XML_DESCEND);
	assert_non_null(detail_string);

	xmlFreeDoc(cwmp_ctx.session->tree_in);
	xmlFreeDoc(cwmp_ctx.session->tree_out);
	cwmp_ctx.session->head_rpc_acs.next = NULL;

	unit_test_end_test_destruction();
	clean_name_space();
}

static void prepare_addobj_soap_request(char *object, char *parameter_key)
{
	xmlNode *add_node = NULL, *n = NULL;

	cwmp_ctx.session->tree_in = xmlReadMemory(CWMP_ADDOBJECT_REQ, strlen(CWMP_ADDOBJECT_REQ), NULL, NULL, 0);
	xml_recreate_namespace(cwmp_ctx.session->tree_in);
	xmlNode *root = xmlDocGetRootElement(cwmp_ctx.session->tree_in);
	add_node = xml_find_element(root, root, "cwmp:AddObject", XML_DESCEND);
	n = xml_find_element(add_node, add_node, "ObjectName", XML_DESCEND);
	xmlNodeSetContent(n, BAD_CAST object);
	n = xml_find_element(add_node, add_node, "ParameterKey", XML_DESCEND);
	xmlNodeSetContent(n, BAD_CAST parameter_key);
}

static void soap_add_object_message_test(void **state)
{
	xmlNode *env = NULL, *n = NULL, *add_resp = NULL;
	xmlNode *root = NULL;
	xmlChar *content = NULL;

	struct rpc *rpc_cpe = build_sessin_rcp_cpe(RPC_CPE_ADD_OBJECT);
	/*
	 * Valid path & writable object
	 */
	prepare_addobj_soap_request("Device.WiFi.SSID.", "add_object_test");
	prepare_session_for_rpc_method_call();

	int ret = cwmp_handle_rpc_cpe_add_object(rpc_cpe);
	assert_int_equal(ret, 0);
	icwmp_restart_services(RELOAD_IMMIDIATE, true, false);

	root = xmlDocGetRootElement(cwmp_ctx.session->tree_out);
	env = xml_find_element(root, root, "soap_env:Envelope", XML_DESCEND);
	assert_non_null(env);
	n = xml_find_element(env, env, "soap_env:Header", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "cwmp:ID", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(env, env, "soap_env:Body", XML_DESCEND);
	assert_non_null(n);
	add_resp = xml_find_element(n, n, "cwmp:AddObjectResponse", XML_DESCEND);
	assert_non_null(add_resp);
	n = xml_find_element(add_resp, add_resp, "InstanceNumber", XML_DESCEND);
	assert_non_null(n);
	content = xmlNodeGetContent(n->children);
	instance = (n->children && content) ? atoi((const char*)content) : 1;
	xmlFree(content);
	n = xml_find_element(add_resp, add_resp, "Status", XML_DESCEND);
	assert_non_null(n);
	content = xmlNodeGetContent(n->children);
	assert_string_equal((const char*)content, "0");
	xmlFree(content);
	xmlFreeDoc(cwmp_ctx.session->tree_in);
	xmlFreeDoc(cwmp_ctx.session->tree_out);

	/*
	 * Wrong object path
	 */
	xmlNode *cwmp_fault = NULL;

	prepare_addobj_soap_request("Device.WiFi.SSI.", "add_object_test");
	prepare_session_for_rpc_method_call();

	ret = cwmp_handle_rpc_cpe_add_object(rpc_cpe);
	assert_int_equal(ret, 0);

	root = xmlDocGetRootElement(cwmp_ctx.session->tree_out);
	env = xml_find_element(root, root, "soap_env:Envelope", XML_DESCEND);
	assert_non_null(env);
	n = xml_find_element(env, env, "soap_env:Header", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "cwmp:ID", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(env, env, "soap_env:Body", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "soap_env:Fault", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "detail", XML_DESCEND);
	assert_non_null(n);
	cwmp_fault = xml_find_element(n, n, "cwmp:Fault", XML_DESCEND);
	assert_non_null(cwmp_fault);
	n = xml_find_element(cwmp_fault, cwmp_fault, "FaultCode", XML_DESCEND);
	assert_non_null(n);
	content = xmlNodeGetContent(n->children);
	assert_string_equal((const char*)content, "9005");
	xmlFree(content);
	n = xml_find_element(cwmp_fault, cwmp_fault, "FaultString", XML_DESCEND);
	assert_non_null(n);
	xmlFreeDoc(cwmp_ctx.session->tree_in);
	xmlFreeDoc(cwmp_ctx.session->tree_out);

	/*
	 * Not writable & Valid object path
	 */
	cwmp_fault = NULL;
	prepare_addobj_soap_request("Device.DeviceInfo.Processor.", "add_object_test");
	prepare_session_for_rpc_method_call();

	ret = cwmp_handle_rpc_cpe_add_object(rpc_cpe);
	assert_int_equal(ret, 0);

	root = xmlDocGetRootElement(cwmp_ctx.session->tree_out);
	env = xml_find_element(root, root, "soap_env:Envelope", XML_DESCEND);
	assert_non_null(env);
	n = xml_find_element(env, env, "soap_env:Header", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "cwmp:ID", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(env, env, "soap_env:Body", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(env, env, "soap_env:Fault", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "detail", XML_DESCEND);
	assert_non_null(n);
	cwmp_fault = xml_find_element(n, n, "cwmp:Fault", XML_DESCEND);
	assert_non_null(cwmp_fault);
	n = xml_find_element(cwmp_fault, cwmp_fault, "FaultCode", XML_DESCEND);
	assert_non_null(n);
	content = xmlNodeGetContent(n->children);
	assert_string_equal((const char*)content, "9005");
	xmlFree(content);
	n = xml_find_element(cwmp_fault, cwmp_fault, "FaultString", XML_DESCEND);
	assert_non_null(n);
	xmlFreeDoc(cwmp_ctx.session->tree_in);
	xmlFreeDoc(cwmp_ctx.session->tree_out);

	/*
	 * Invalid parameterkey
	 */
	cwmp_fault = NULL;
	prepare_addobj_soap_request("Device.WiFi.SSID.", INVALID_PARAM_KEY);
	prepare_session_for_rpc_method_call();

	ret = cwmp_handle_rpc_cpe_add_object(rpc_cpe);
	assert_int_equal(ret, 0);

	root = xmlDocGetRootElement(cwmp_ctx.session->tree_out);
	env = xml_find_element(root, root, "soap_env:Envelope", XML_DESCEND);
	assert_non_null(env);
	n = xml_find_element(env, env, "soap_env:Header", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "cwmp:ID", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(env, env, "soap_env:Body", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(env, env, "soap_env:Fault", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "detail", XML_DESCEND);
	assert_non_null(n);
	cwmp_fault = xml_find_element(n, n, "cwmp:Fault", XML_DESCEND);
	assert_non_null(cwmp_fault);
	n = xml_find_element(cwmp_fault, cwmp_fault, "FaultCode", XML_DESCEND);
	assert_non_null(n);
	content = xmlNodeGetContent(n->children);
	assert_string_equal((const char*)content, "9003");
	xmlFree(content);
	n = xml_find_element(cwmp_fault, cwmp_fault, "FaultString", XML_DESCEND);
	assert_non_null(n);
	xmlFreeDoc(cwmp_ctx.session->tree_in);
	xmlFreeDoc(cwmp_ctx.session->tree_out);

	cwmp_ctx.session->head_rpc_acs.next = NULL;
	unit_test_end_test_destruction();
	clean_name_space();
}

static void prepare_delobj_soap_request(char *object, char *parameter_key)
{
	xmlNode *del_node = NULL, *n = NULL;

	cwmp_ctx.session->tree_in = xmlReadMemory(CWMP_DELOBJECT_REQ, strlen(CWMP_DELOBJECT_REQ), NULL, NULL, 0);
	xml_recreate_namespace(cwmp_ctx.session->tree_in);
	xmlNode *root = xmlDocGetRootElement(cwmp_ctx.session->tree_in);
	del_node = xml_find_element(root, root, "cwmp:DeleteObject", XML_DESCEND);
	n = xml_find_element(del_node, del_node, "ObjectName", XML_DESCEND);
	xmlNodeSetContent(n, BAD_CAST object);
	n = xml_find_element(del_node, del_node, "ParameterKey", XML_DESCEND);
	xmlNodeSetContent(n, BAD_CAST parameter_key);
}

static void soap_delete_object_message_test(void **state)
{
	xmlNode *env = NULL, *n = NULL, *add_resp = NULL;
	xmlNode *root = NULL;
	xmlChar *content = NULL;

	struct rpc *rpc_cpe = build_sessin_rcp_cpe(RPC_CPE_DELETE_OBJECT);

	/*
	 * Valid path & writable object
	 */
	char del_obj[32];
	snprintf(del_obj, sizeof(del_obj), "Device.WiFi.SSID.%d.", instance);
	prepare_delobj_soap_request(del_obj, "del_object_test");
	prepare_session_for_rpc_method_call();

	int ret = cwmp_handle_rpc_cpe_delete_object(rpc_cpe);
	assert_int_equal(ret, 0);
	icwmp_restart_services(RELOAD_IMMIDIATE, true, false);

	root = xmlDocGetRootElement(cwmp_ctx.session->tree_out);
	env = xml_find_element(root, root, "soap_env:Envelope", XML_DESCEND);
	assert_non_null(env);
	n = xml_find_element(env, env, "soap_env:Header", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "cwmp:ID", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(env, env, "soap_env:Body", XML_DESCEND);
	assert_non_null(n);
	add_resp = xml_find_element(n, n, "cwmp:DeleteObjectResponse", XML_DESCEND);
	assert_non_null(add_resp);
	n = xml_find_element(add_resp, add_resp, "Status", XML_DESCEND);
	assert_non_null(n);
	content = xmlNodeGetContent(n->children);
	assert_string_equal((const char*)content, "1");
	xmlFree(content);
	xmlFreeDoc(cwmp_ctx.session->tree_in);
	xmlFreeDoc(cwmp_ctx.session->tree_out);

	/*
	 * Wrong object path
	 */
	xmlNode *cwmp_fault = NULL;

	prepare_delobj_soap_request("Device.WiFi.SID.1", "del_object_test");
	prepare_session_for_rpc_method_call();

	ret = cwmp_handle_rpc_cpe_delete_object(rpc_cpe);
	assert_int_equal(ret, 0);

	root = xmlDocGetRootElement(cwmp_ctx.session->tree_out);
	env = xml_find_element(root, root, "soap_env:Envelope", XML_DESCEND);
	assert_non_null(env);
	n = xml_find_element(env, env, "soap_env:Header", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "cwmp:ID", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(env, env, "soap_env:Body", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "soap_env:Fault", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "detail", XML_DESCEND);
	assert_non_null(n);
	cwmp_fault = xml_find_element(n, n, "cwmp:Fault", XML_DESCEND);
	assert_non_null(cwmp_fault);
	n = xml_find_element(cwmp_fault, cwmp_fault, "FaultCode", XML_DESCEND);
	assert_non_null(n);
	content = xmlNodeGetContent(n->children);
	assert_string_equal((const char*)content, "9005");
	xmlFree(content);
	n = xml_find_element(cwmp_fault, cwmp_fault, "FaultString", XML_DESCEND);
	assert_non_null(n);
	xmlFreeDoc(cwmp_ctx.session->tree_in);
	xmlFreeDoc(cwmp_ctx.session->tree_out);

	/*
	 * Not writable & Valid object path
	 */
	cwmp_fault = NULL;
	prepare_delobj_soap_request("Device.DeviceInfo.Processor.2.", "del_object_test");
	prepare_session_for_rpc_method_call();

	ret = cwmp_handle_rpc_cpe_delete_object(rpc_cpe);
	assert_int_equal(ret, 0);

	root = xmlDocGetRootElement(cwmp_ctx.session->tree_out);
	env = xml_find_element(root, root, "soap_env:Envelope", XML_DESCEND);
	assert_non_null(env);
	n = xml_find_element(env, env, "soap_env:Header", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "cwmp:ID", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(env, env, "soap_env:Body", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(env, env, "soap_env:Fault", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "detail", XML_DESCEND);
	assert_non_null(n);
	cwmp_fault = xml_find_element(n, n, "cwmp:Fault", XML_DESCEND);
	assert_non_null(cwmp_fault);
	n = xml_find_element(cwmp_fault, cwmp_fault, "FaultCode", XML_DESCEND);
	assert_non_null(n);
	content = xmlNodeGetContent(n->children);
	assert_string_equal((const char*)content, "9005");
	xmlFree(content);
	n = xml_find_element(cwmp_fault, cwmp_fault, "FaultString", XML_DESCEND);
	assert_non_null(n);
	xmlFreeDoc(cwmp_ctx.session->tree_in);
	xmlFreeDoc(cwmp_ctx.session->tree_out);

	/*
	 * Invalid parameterkey
	 */
	cwmp_fault = NULL;
	prepare_delobj_soap_request("Device.WiFi.SSID.1.", INVALID_PARAM_KEY);
	prepare_session_for_rpc_method_call();

	ret = cwmp_handle_rpc_cpe_delete_object(rpc_cpe);
	assert_int_equal(ret, 0);

	root = xmlDocGetRootElement(cwmp_ctx.session->tree_out);
	env = xml_find_element(root, root, "soap_env:Envelope", XML_DESCEND);
	assert_non_null(env);
	n = xml_find_element(env, env, "soap_env:Header", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "cwmp:ID", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(env, env, "soap_env:Body", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(env, env, "soap_env:Fault", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "detail", XML_DESCEND);
	assert_non_null(n);
	cwmp_fault = xml_find_element(n, n, "cwmp:Fault", XML_DESCEND);
	assert_non_null(cwmp_fault);
	n = xml_find_element(cwmp_fault, cwmp_fault, "FaultCode", XML_DESCEND);
	assert_non_null(n);
	content = xmlNodeGetContent(n->children);
	assert_string_equal((const char*)content, "9003");
	xmlFree(content);
	n = xml_find_element(cwmp_fault, cwmp_fault, "FaultString", XML_DESCEND);
	assert_non_null(n);
	xmlFreeDoc(cwmp_ctx.session->tree_in);
	xmlFreeDoc(cwmp_ctx.session->tree_out);

	cwmp_ctx.session->head_rpc_acs.next = NULL;
	unit_test_end_test_destruction();
	clean_name_space();
}

static void prepare_gpa_soap_request(char *parameter)
{
	xmlNode *n = NULL;

	cwmp_ctx.session->tree_in = xmlReadMemory(CWMP_GETATTRIBUTES_REQ, strlen(CWMP_GETATTRIBUTES_REQ), NULL, NULL, 0);
	xml_recreate_namespace(cwmp_ctx.session->tree_in);
	xmlNode *root = xmlDocGetRootElement(cwmp_ctx.session->tree_in);
	n = xml_find_element(root, root, "cwmp:GetParameterAttributes", XML_DESCEND);
	n = xml_find_element(n, n, "ParameterNames", XML_DESCEND);
	n = xmlNewChild(n, NULL, BAD_CAST "string", BAD_CAST parameter);
}

static void soap_get_parameter_attributes_message_test(void **state)
{
	xmlNode *env = NULL, *n = NULL, *param_attr = NULL;
	xmlNode *root = NULL;
	xmlChar *content = NULL;

	struct rpc *rpc_cpe = build_sessin_rcp_cpe(RPC_CPE_GET_PARAMETER_ATTRIBUTES);

	/*
	 * Valid path
	 */
	prepare_gpa_soap_request("Device.DeviceInfo.UpTime");
	prepare_session_for_rpc_method_call();

	int ret = cwmp_handle_rpc_cpe_get_parameter_attributes(rpc_cpe);
	assert_int_equal(ret, 0);

	root = xmlDocGetRootElement(cwmp_ctx.session->tree_out);
	env = xml_find_element(root, root, "soap_env:Envelope", XML_DESCEND);
	assert_non_null(env);
	n = xml_find_element(env, env, "soap_env:Header", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "cwmp:ID", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(env, env, "soap_env:Body", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "cwmp:GetParameterAttributesResponse", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "ParameterList", XML_DESCEND);
	assert_non_null(n);
	param_attr = xml_find_element(n, n, "ParameterAttributeStruct", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(param_attr, param_attr, "Name", XML_DESCEND);
	assert_non_null(n);
	content = xmlNodeGetContent(n->children);
	assert_string_equal((const char*)content, "Device.DeviceInfo.UpTime");
	xmlFree(content);
	n = xml_find_element(param_attr, param_attr, "Notification", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(param_attr, param_attr, "AccessList", XML_DESCEND);
	assert_non_null(n);

	xmlFreeDoc(cwmp_ctx.session->tree_in);
	xmlFreeDoc(cwmp_ctx.session->tree_out);

	/*
	 * Not Valid path
	 */
	xmlNode *fault_code = NULL, *fault_string = NULL, *detail = NULL, *detail_code = NULL, *detail_string = NULL;

	char *invalid_parameter[1] = { "Device.DeviceInfo.pTime" };
	prepare_gpv_soap_request(invalid_parameter, 1);

	prepare_session_for_rpc_method_call();

	ret = cwmp_handle_rpc_cpe_get_parameter_values(rpc_cpe);
	assert_int_equal(ret, 0);

	root = xmlDocGetRootElement(cwmp_ctx.session->tree_out);
	env = xml_find_element(root, root, "soap_env:Envelope", XML_DESCEND);
	assert_non_null(env);
	n = xml_find_element(env, env, "soap_env:Header", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "cwmp:ID", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(env, env, "soap_env:Body", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "soap_env:Fault", XML_DESCEND);
	assert_non_null(n);
	fault_code = xml_find_element(n, n, "faultcode", XML_DESCEND);
	assert_non_null(fault_code);
	fault_string = xml_find_element(n, n, "faultstring", XML_DESCEND);
	assert_non_null(fault_string);
	detail = xml_find_element(n, n, "detail", XML_DESCEND);
	assert_non_null(detail);
	detail = xml_find_element(detail, detail, "cwmp:Fault", XML_DESCEND);
	assert_non_null(detail);
	detail_code = xml_find_element(detail, detail, "FaultCode", XML_DESCEND);
	assert_non_null(detail_code);
	content = xmlNodeGetContent(detail_code->children);
	assert_string_equal((const char*)content, "9005");
	xmlFree(content);
	detail_string = xml_find_element(detail, detail, "FaultString", XML_DESCEND);
	assert_non_null(detail_string);
	xmlFreeDoc(cwmp_ctx.session->tree_in);
	xmlFreeDoc(cwmp_ctx.session->tree_out);

	cwmp_ctx.session->head_rpc_acs.next = NULL;
	unit_test_end_test_destruction();
	clean_name_space();
}

static void prepare_spa_soap_request(char *parameter, char *notification, char *notification_change)
{
	xmlNode *n = NULL, *set_attr = NULL;

	cwmp_ctx.session->tree_in = xmlReadMemory(CWMP_SETATTRIBUTES_REQ, strlen(CWMP_SETATTRIBUTES_REQ), NULL, NULL, 0);
	xml_recreate_namespace(cwmp_ctx.session->tree_in);
	xmlNode *root = xmlDocGetRootElement(cwmp_ctx.session->tree_in);
	set_attr = xml_find_element(root, root, "SetParameterAttributesStruct", XML_DESCEND);
	n = xml_find_element(set_attr, set_attr, "Name", XML_DESCEND);
	xmlNodeSetContent(n, BAD_CAST parameter);
	n = xml_find_element(set_attr, set_attr, "Notification", XML_DESCEND);
	xmlNodeSetContent(n, BAD_CAST notification);
	n = xml_find_element(set_attr, set_attr, "NotificationChange", XML_DESCEND);
	xmlNodeSetContent(n, BAD_CAST notification_change);
}

static void soap_set_parameter_attributes_message_test(void **state)
{
	xmlNode *env = NULL, *n = NULL;
	xmlNode *root = NULL;
	xmlChar *content = NULL;

	struct rpc *rpc_cpe = build_sessin_rcp_cpe(RPC_CPE_SET_PARAMETER_ATTRIBUTES);

	/*
	 * Valid path
	 */
	prepare_spa_soap_request("Device.DeviceInfo.UpTime", "1", "true");
	prepare_session_for_rpc_method_call();

	int ret = cwmp_handle_rpc_cpe_set_parameter_attributes(rpc_cpe);
	assert_int_equal(ret, 0);

	root = xmlDocGetRootElement(cwmp_ctx.session->tree_out);
	env = xml_find_element(root, root, "soap_env:Envelope", XML_DESCEND);
	assert_non_null(env);
	n = xml_find_element(env, env, "soap_env:Header", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "cwmp:ID", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(env, env, "soap_env:Body", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "cwmp:SetParameterAttributesResponse", XML_DESCEND);
	assert_non_null(n);
	assert_null(n->children);
	xmlFreeDoc(cwmp_ctx.session->tree_in);
	xmlFreeDoc(cwmp_ctx.session->tree_out);

	/*
	 * Not Valid path
	 */
	xmlNode *cwmp_fault = NULL;
	prepare_spa_soap_request("Device.DeviceInfo.pTime", "1", "true");
	prepare_session_for_rpc_method_call();

	ret = cwmp_handle_rpc_cpe_set_parameter_attributes(rpc_cpe);
	assert_int_equal(ret, 0);

	root = xmlDocGetRootElement(cwmp_ctx.session->tree_out);
	env = xml_find_element(root, root, "soap_env:Envelope", XML_DESCEND);
	assert_non_null(env);
	n = xml_find_element(env, env, "soap_env:Header", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "cwmp:ID", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(env, env, "soap_env:Body", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "soap_env:Fault", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "detail", XML_DESCEND);
	assert_non_null(n);
	cwmp_fault = xml_find_element(n, n, "cwmp:Fault", XML_DESCEND);
	assert_non_null(cwmp_fault);
	n = xml_find_element(cwmp_fault, cwmp_fault, "FaultCode", XML_DESCEND);
	assert_non_null(n);
	content = xmlNodeGetContent(n->children);
	assert_string_equal((const char*)content, "9005");
	xmlFree(content);
	n = xml_find_element(cwmp_fault, cwmp_fault, "FaultString", XML_DESCEND);
	assert_non_null(n);

	xmlFreeDoc(cwmp_ctx.session->tree_in);
	xmlFreeDoc(cwmp_ctx.session->tree_out);

	/*
	 * Not Valid Notification value
	 */
	prepare_spa_soap_request("Device.DeviceInfo.UpTime", "8", "true");
	prepare_session_for_rpc_method_call();

	ret = cwmp_handle_rpc_cpe_set_parameter_attributes(rpc_cpe);
	assert_int_equal(ret, 0);

	root = xmlDocGetRootElement(cwmp_ctx.session->tree_out);
	env = xml_find_element(root, root, "soap_env:Envelope", XML_DESCEND);
	assert_non_null(env);
	n = xml_find_element(env, env, "soap_env:Header", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "cwmp:ID", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(env, env, "soap_env:Body", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "soap_env:Fault", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "detail", XML_DESCEND);
	assert_non_null(n);
	cwmp_fault = xml_find_element(n, n, "cwmp:Fault", XML_DESCEND);
	assert_non_null(cwmp_fault);
	n = xml_find_element(cwmp_fault, cwmp_fault, "FaultCode", XML_DESCEND);
	assert_non_null(n);
	content = xmlNodeGetContent(n->children);
	assert_string_equal((const char*)content, "9003");
	xmlFree(content);
	n = xml_find_element(cwmp_fault, cwmp_fault, "FaultString", XML_DESCEND);
	assert_non_null(n);

	xmlFreeDoc(cwmp_ctx.session->tree_in);
	xmlFreeDoc(cwmp_ctx.session->tree_out);

	/*
	 * Invalid Notification String
	 */

	prepare_spa_soap_request("Device.DeviceInfo.UpTime", "balabala", "true");
	prepare_session_for_rpc_method_call();

	ret = cwmp_handle_rpc_cpe_set_parameter_attributes(rpc_cpe);
	assert_int_equal(ret, 0);

	root = xmlDocGetRootElement(cwmp_ctx.session->tree_out);
	env = xml_find_element(root, root, "soap_env:Envelope", XML_DESCEND);
	assert_non_null(env);
	n = xml_find_element(env, env, "soap_env:Header", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "cwmp:ID", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(env, env, "soap_env:Body", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "soap_env:Fault", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "detail", XML_DESCEND);
	assert_non_null(n);
	cwmp_fault = xml_find_element(n, n, "cwmp:Fault", XML_DESCEND);
	assert_non_null(cwmp_fault);
	n = xml_find_element(cwmp_fault, cwmp_fault, "FaultCode", XML_DESCEND);
	assert_non_null(n);
	content = xmlNodeGetContent(n->children);
	assert_string_equal((const char*)content, "9003");
	xmlFree(content);
	n = xml_find_element(cwmp_fault, cwmp_fault, "FaultString", XML_DESCEND);
	assert_non_null(n);

	xmlFreeDoc(cwmp_ctx.session->tree_in);
	xmlFreeDoc(cwmp_ctx.session->tree_out);

	/*
	 * Invalid NotificationChange
	 */

	prepare_spa_soap_request("Device.DeviceInfo.UpTime", "2", "5");
	prepare_session_for_rpc_method_call();

	ret = cwmp_handle_rpc_cpe_set_parameter_attributes(rpc_cpe);
	assert_int_equal(ret, 0);

	root = xmlDocGetRootElement(cwmp_ctx.session->tree_out);
	env = xml_find_element(root, root, "soap_env:Envelope", XML_DESCEND);
	assert_non_null(env);
	n = xml_find_element(env, env, "soap_env:Header", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "cwmp:ID", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(env, env, "soap_env:Body", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "soap_env:Fault", XML_DESCEND);
	assert_non_null(n);
	n = xml_find_element(n, n, "detail", XML_DESCEND);
	assert_non_null(n);
	cwmp_fault = xml_find_element(n, n, "cwmp:Fault", XML_DESCEND);
	assert_non_null(cwmp_fault);
	n = xml_find_element(cwmp_fault, cwmp_fault, "FaultCode", XML_DESCEND);
	assert_non_null(n);
	content = xmlNodeGetContent(n->children);
	assert_string_equal((const char*)content, "9003");
	xmlFree(content);
	n = xml_find_element(cwmp_fault, cwmp_fault, "FaultString", XML_DESCEND);
	assert_non_null(n);

	xmlFreeDoc(cwmp_ctx.session->tree_in);
	xmlFreeDoc(cwmp_ctx.session->tree_out);

	cwmp_ctx.session->head_rpc_acs.next = NULL;
	unit_test_end_test_destruction();
	clean_name_space();
}

int icwmp_soap_msg_test(void)
{
	const struct CMUnitTest tests[] = { //
		    cmocka_unit_test(get_config_test),
		    cmocka_unit_test(get_deviceid_test),
		    cmocka_unit_test(add_event_test),
		    cmocka_unit_test(soap_inform_message_test),
		    cmocka_unit_test(soap_get_param_value_message_test),
		    //cmocka_unit_test(soap_add_object_message_test),
		    //cmocka_unit_test(soap_delete_object_message_test),
		    cmocka_unit_test(soap_get_parameter_attributes_message_test),
		    cmocka_unit_test(soap_set_parameter_attributes_message_test),
	};

	return cmocka_run_group_tests(tests, soap_unit_tests_init, soap_unit_tests_clean);
}