libsemanage/tests/test_node.c - platform/external/selinux - Git at Google

 /*
  * Authors: Jan Zarsky <[email protected]>
  *
  * Copyright (C) 2019 Red Hat, Inc.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */

 #include "utilities.h"
 #include "test_node.h"

 #define NODE_COUNT 3

 #define NODE1_ADDR "192.168.0.0"
 #define NODE1_MASK "255.255.255.0"
 #define NODE1_PROTO SEPOL_PROTO_IP4
 #define NODE1_CONTEXT "system_u:object_r:first_node_t:s0"

 #define NODE2_ADDR "2001:db8:85a3::8a2e:370:7334"
 #define NODE2_MASK "2001:db8:85a3::8a2e:370:7334"
 #define NODE2_PROTO SEPOL_PROTO_IP6
 #define NODE2_CONTEXT "system_u:object_r:second_node_t:s0"

 #define NODE3_ADDR "127.0.0.1"
 #define NODE3_MASK "255.255.0.0"
 #define NODE3_PROTO SEPOL_PROTO_IP4
 #define NODE3_CONTEXT "system_u:object_r:third_node_t:s0"

 /* node_record.h */
 static void test_node_compare(void);
 static void test_node_compare2(void);
 static void test_node_key_create(void);
 static void test_node_key_extract(void);
 static void test_node_get_set_addr(void);
 static void test_node_get_set_addr_bytes(void);
 static void test_node_get_set_mask(void);
 static void test_node_get_set_mask_bytes(void);
 static void test_node_get_set_proto(void);
 static void test_node_get_proto_str(void);
 static void test_node_get_set_con(void);
 static void test_node_create(void);
 static void test_node_clone(void);

 /* nodes_policy.h */
 static void test_node_query(void);
 static void test_node_exists(void);
 static void test_node_count(void);
 static void test_node_iterate(void);
 static void test_node_list(void);

 /* nodes_local.h */
 static void test_node_modify_del_query_local(void);
 static void test_node_exists_local(void);
 static void test_node_count_local(void);
 static void test_node_iterate_local(void);
 static void test_node_list_local(void);

 extern semanage_handle_t *sh;

 int node_test_init(void)
 {
 	if (create_test_store() < 0) {
 		fprintf(stderr, "Could not create test store\n");
 		return 1;
 	}

 	if (write_test_policy_from_file("test_node.policy") < 0) {
 		fprintf(stderr, "Could not write test policy\n");
 		return 1;
 	}

 	return 0;
 }

 int node_test_cleanup(void)
 {
 	if (destroy_test_store() < 0) {
 		fprintf(stderr, "Could destroy test store\n");
 		return 1;
 	}

 	return 0;
 }

 int node_add_tests(CU_pSuite suite)
 {
 	CU_add_test(suite, "node_compare", test_node_compare);
 	CU_add_test(suite, "node_compare2", test_node_compare2);
 	CU_add_test(suite, "node_key_create", test_node_key_create);
 	CU_add_test(suite, "node_key_extract", test_node_key_extract);
 	CU_add_test(suite, "node_get_set_addr", test_node_get_set_addr);
 	CU_add_test(suite, "node_get_set_addr_bytes",
 		    test_node_get_set_addr_bytes);
 	CU_add_test(suite, "node_get_set_mask", test_node_get_set_mask);
 	CU_add_test(suite, "node_get_set_mask_bytes",
 		    test_node_get_set_mask_bytes);
 	CU_add_test(suite, "node_get_set_proto", test_node_get_set_proto);
 	CU_add_test(suite, "node_get_proto_str", test_node_get_proto_str);
 	CU_add_test(suite, "node_get_set_con", test_node_get_set_con);
 	CU_add_test(suite, "node_create", test_node_create);
 	CU_add_test(suite, "node_clone", test_node_clone);

 	CU_add_test(suite, "node_query", test_node_query);
 	CU_add_test(suite, "node_exists", test_node_exists);
 	CU_add_test(suite, "node_count", test_node_count);
 	CU_add_test(suite, "node_iterate", test_node_iterate);
 	CU_add_test(suite, "node_list", test_node_list);

 	CU_add_test(suite, "node_modify_del_query_local",
 		    test_node_modify_del_query_local);
 	CU_add_test(suite, "node_exists_local", test_node_exists_local);
 	CU_add_test(suite, "node_count_local", test_node_count_local);
 	CU_add_test(suite, "node_iterate_local", test_node_iterate_local);
 	CU_add_test(suite, "node_list_local", test_node_list_local);

 	return 0;
 }

 /* Helpers */

 static semanage_node_t *get_node_nth(int idx)
 {
 	semanage_node_t **records;
 	semanage_node_t *node;
 	unsigned int count;

 	if (idx == I_NULL)
 		return NULL;

 	CU_ASSERT_FATAL(semanage_node_list(sh, &records, &count) >= 0);
 	CU_ASSERT_FATAL(count >= (unsigned int) idx + 1);

 	node = records[idx];

 	for (unsigned int i = 0; i < count; i++)
 		if (i != (unsigned int) idx)
 			semanage_node_free(records[i]);

 	free(records);

 	return node;
 }

 static semanage_node_key_t *get_node_key_nth(int idx)
 {
 	semanage_node_key_t *key;
 	semanage_node_t *node;
 	int res;

 	if (idx == I_NULL)
 		return NULL;

 	node = get_node_nth(idx);

 	res = semanage_node_key_extract(sh, node, &key);

 	CU_ASSERT_FATAL(res >= 0);
 	CU_ASSERT_PTR_NOT_NULL_FATAL(key);

 	semanage_node_free(node);

 	return key;
 }

 static void add_local_node(int idx)
 {
 	semanage_node_t *node;
 	semanage_node_key_t *key = NULL;

 	node = get_node_nth(idx);

 	CU_ASSERT_FATAL(semanage_node_key_extract(sh, node, &key) >= 0);
 	CU_ASSERT_PTR_NOT_NULL_FATAL(key);

 	CU_ASSERT_FATAL(semanage_node_modify_local(sh, key, node) >= 0);

 	/* cleanup */
 	semanage_node_key_free(key);
 	semanage_node_free(node);
 }

 static void delete_local_node(int idx)
 {
 	semanage_node_key_t *key = NULL;

 	key = get_node_key_nth(idx);

 	CU_ASSERT_FATAL(semanage_node_del_local(sh, key) >= 0);

 	/* cleanup */
 	semanage_node_key_free(key);
 }

 /* Function semanage_node_compare */
 static void test_node_compare(void)
 {
 	semanage_node_t *node = NULL;
 	semanage_node_key_t *key1 = NULL;
 	semanage_node_key_t *key2 = NULL;
 	int res = 42;

 	/* setup */
 	setup_handle(SH_CONNECT);
 	node = get_node_nth(I_FIRST);
 	key1 = get_node_key_nth(I_FIRST);
 	CU_ASSERT(semanage_node_key_create(sh, "192.168.0.1", "255.255.0.0",
 					   SEMANAGE_PROTO_IP4, &key2) >= 0);
 	CU_ASSERT_PTR_NOT_NULL(key2);

 	/* test */
 	res = semanage_node_compare(node, key1);
 	CU_ASSERT(res == 0);
 	res = semanage_node_compare(node, key2);
 	CU_ASSERT(res != 0);

 	/* cleanup */
 	semanage_node_free(node);
 	semanage_node_key_free(key1);
 	semanage_node_key_free(key2);
 	cleanup_handle(SH_CONNECT);
 }

 /* Function semanage_node_compare2 */
 static void test_node_compare2(void)
 {
 	semanage_node_t *node1 = NULL;
 	semanage_node_t *node2 = NULL;
 	semanage_node_t *node3 = NULL;
 	int res = 42;

 	/* setup */
 	setup_handle(SH_CONNECT);
 	node1 = get_node_nth(I_FIRST);
 	node2 = get_node_nth(I_FIRST);
 	node3 = get_node_nth(I_SECOND);

 	/* test */
 	res = semanage_node_compare2(node1, node2);
 	CU_ASSERT(res == 0);
 	res = semanage_node_compare2(node1, node3);
 	CU_ASSERT(res != 0);

 	/* cleanup */
 	semanage_node_free(node1);
 	semanage_node_free(node2);
 	semanage_node_free(node3);
 	cleanup_handle(SH_CONNECT);
 }

 /* Function semanage_node_key_create */
 static void test_node_key_create(void)
 {
 	semanage_node_key_t *key = NULL;

 	/* setup */
 	setup_handle(SH_CONNECT);

 	/* test */
 	CU_ASSERT(semanage_node_key_create(sh, "127.0.0.1", "255.255.255.255",
 					   SEMANAGE_PROTO_IP4, &key) >= 0);
 	CU_ASSERT_PTR_NOT_NULL(key);

 	/* cleanup */
 	semanage_node_key_free(key);
 	cleanup_handle(SH_CONNECT);
 }

 /* Function semanage_node_key_extract */
 static void test_node_key_extract(void)
 {
 	semanage_node_t *node = NULL;
 	semanage_node_key_t *key = NULL;

 	/* setup */
 	setup_handle(SH_CONNECT);
 	node = get_node_nth(I_FIRST);

 	/* test */
 	CU_ASSERT(semanage_node_key_extract(sh, node, &key) >= 0);
 	CU_ASSERT_PTR_NOT_NULL(key);

 	/* cleanup */
 	semanage_node_free(node);
 	semanage_node_key_free(key);
 	cleanup_handle(SH_CONNECT);
 }

 /* Function semanage_node_get_addr, semanage_node_set_addr */
 static void test_node_get_set_addr(void)
 {
 	semanage_node_t *node = NULL;
 	char *addr = NULL;

 	/* setup */
 	setup_handle(SH_CONNECT);
 	CU_ASSERT(semanage_node_create(sh, &node) >= 0);

 	/* test */
 	CU_ASSERT(semanage_node_set_addr(sh, node, SEMANAGE_PROTO_IP4,
 					 "192.168.0.1") == 0);
 	CU_ASSERT(semanage_node_get_addr(sh, node, &addr) >= 0);
 	CU_ASSERT_PTR_NOT_NULL(addr);
 	assert(addr);
 	CU_ASSERT_STRING_EQUAL(addr, "192.168.0.1");

 	/* cleanup */
 	free(addr);
 	semanage_node_free(node);
 	cleanup_handle(SH_CONNECT);
 }

 /* Function semanage_node_get_addr_bytes, semanage_node_set_addr_bytes */
 static void test_node_get_set_addr_bytes(void)
 {
 	semanage_node_t *node = NULL;
 	char addr1[] = { 192, 168, 0, 1 };
 	size_t addr1_size = sizeof(addr1);
 	char *addr2 = NULL;
 	size_t addr2_size = 0;

 	/* setup */
 	setup_handle(SH_CONNECT);
 	CU_ASSERT(semanage_node_create(sh, &node) >= 0);

 	/* test */
 	CU_ASSERT(semanage_node_set_addr_bytes(sh, node, addr1,
 					       addr1_size) == 0);
 	CU_ASSERT(semanage_node_get_addr_bytes(sh, node, &addr2,
 					       &addr2_size) >= 0);
 	CU_ASSERT_PTR_NOT_NULL(addr2);
 	assert(addr2);

 	for (size_t i = 0; i < addr2_size; i++)
 		CU_ASSERT(addr1[i] == addr2[i]);

 	/* cleanup */
 	free(addr2);
 	semanage_node_free(node);
 	cleanup_handle(SH_CONNECT);
 }

 /* Function semanage_node_get_mask, semanage_node_set_mask */
 static void test_node_get_set_mask(void)
 {
 	semanage_node_t *node = NULL;
 	char *mask = NULL;

 	/* setup */
 	setup_handle(SH_CONNECT);
 	CU_ASSERT(semanage_node_create(sh, &node) >= 0);

 	/* test */
 	CU_ASSERT(semanage_node_set_mask(sh, node, SEMANAGE_PROTO_IP4,
 					 "255.255.255.0") == 0);
 	CU_ASSERT(semanage_node_get_mask(sh, node, &mask) >= 0);
 	CU_ASSERT_PTR_NOT_NULL(mask);
 	assert(mask);
 	CU_ASSERT_STRING_EQUAL(mask, "255.255.255.0");

 	/* cleanup */
 	free(mask);
 	semanage_node_free(node);
 	cleanup_handle(SH_CONNECT);
 }

 /* Function semanage_node_get_mask_bytes, semanage_node_set_mask_bytes */
 static void test_node_get_set_mask_bytes(void)
 {
 	semanage_node_t *node = NULL;
 	char mask1[] = { 255, 255, 255, 0 };
 	size_t mask1_size = sizeof(mask1);
 	char *mask2 = NULL;
 	size_t mask2_size = 0;

 	/* setup */
 	setup_handle(SH_CONNECT);
 	CU_ASSERT(semanage_node_create(sh, &node) >= 0);

 	/* test */
 	CU_ASSERT(semanage_node_set_mask_bytes(sh, node, mask1,
 					       mask1_size) == 0);
 	CU_ASSERT(semanage_node_get_mask_bytes(sh, node, &mask2,
 					       &mask2_size) >= 0);
 	CU_ASSERT_PTR_NOT_NULL(mask2);
 	assert(mask2);

 	for (size_t i = 0; i < mask2_size; i++)
 		CU_ASSERT(mask1[i] == mask2[i]);

 	/* cleanup */
 	free(mask2);
 	semanage_node_free(node);
 	cleanup_handle(SH_CONNECT);
 }

 /* Function semanage_node_get_proto, semanage_node_set_proto */
 static void test_node_get_set_proto(void)
 {
 	semanage_node_t *node = NULL;

 	/* setup */
 	setup_handle(SH_CONNECT);
 	CU_ASSERT(semanage_node_create(sh, &node) >= 0);

 	/* test */
 	semanage_node_set_proto(node, SEMANAGE_PROTO_IP4);
 	CU_ASSERT(semanage_node_get_proto(node) == SEMANAGE_PROTO_IP4);

 	/* cleanup */
 	semanage_node_free(node);
 	cleanup_handle(SH_CONNECT);
 }

 /* Function semanage_node_get_proto_str */
 static void test_node_get_proto_str(void)
 {
 	CU_ASSERT_STRING_EQUAL(semanage_node_get_proto_str(SEMANAGE_PROTO_IP4),
 							   "ipv4");
 	CU_ASSERT_STRING_EQUAL(semanage_node_get_proto_str(SEMANAGE_PROTO_IP6),
 							   "ipv6");
 }

 /* Function semanage_node_get_con, semanage_node_set_con */
 static void test_node_get_set_con(void)
 {
 	semanage_node_t *node = NULL;
 	semanage_context_t *con1 = NULL;
 	semanage_context_t *con2 = NULL;

 	/* setup */
 	setup_handle(SH_CONNECT);
 	CU_ASSERT(semanage_node_create(sh, &node) >= 0);
 	CU_ASSERT(semanage_context_from_string(sh,
 			       "my_user_u:my_role_r:my_type_t:s0", &con1) >= 0);

 	/* test */
 	CU_ASSERT(semanage_node_set_con(sh, node, con1) == 0);
 	con2 = semanage_node_get_con(node);
 	CU_ASSERT_CONTEXT_EQUAL(con1, con2);

 	/* cleanup */
 	semanage_context_free(con1);
 	semanage_node_free(node);
 	cleanup_handle(SH_CONNECT);
 }

 /* Function semanage_node_create */
 static void test_node_create(void)
 {
 	semanage_node_t *node = NULL;
 	semanage_context_t *con = NULL;

 	/* setup */
 	setup_handle(SH_CONNECT);

 	/* test */
 	CU_ASSERT(semanage_node_create(sh, &node) >= 0);
 	CU_ASSERT(semanage_node_set_addr(sh, node, SEMANAGE_PROTO_IP4,
 					 "127.0.0.1") >= 0);
 	CU_ASSERT(semanage_node_set_mask(sh, node, SEMANAGE_PROTO_IP4,
 					 "255.255.255.0") >= 0);
 	semanage_node_set_proto(node, SEMANAGE_PROTO_IP4);
 	CU_ASSERT(semanage_context_from_string(sh, "user_u:role_r:type_t:s0",
 					       &con) >= 0);
 	CU_ASSERT(semanage_node_set_con(sh, node, con) >= 0);

 	/* cleanup */
 	semanage_context_free(con);
 	semanage_node_free(node);
 	cleanup_handle(SH_CONNECT);
 }

 /* Function semanage_node_clone */
 static void test_node_clone(void)
 {
 	semanage_node_t *node = NULL;
 	semanage_node_t *node_clone = NULL;
 	semanage_context_t *con = NULL;
 	semanage_context_t *con2 = NULL;
 	const char *addr1 = "127.0.0.1";
 	char *addr2 = NULL;
 	const char *mask1 = "255.255.255.0";
 	char *mask2 = NULL;

 	/* setup */
 	setup_handle(SH_CONNECT);
 	CU_ASSERT(semanage_node_create(sh, &node) >= 0);
 	CU_ASSERT(semanage_node_set_addr(sh, node, SEMANAGE_PROTO_IP4,
 					 addr1) >= 0);
 	CU_ASSERT(semanage_node_set_mask(sh, node, SEMANAGE_PROTO_IP4,
 					 mask1) >= 0);
 	semanage_node_set_proto(node, SEMANAGE_PROTO_IP4);
 	CU_ASSERT(semanage_context_from_string(sh, "user_u:role_r:type_t:s0",
 					       &con) >= 0);
 	CU_ASSERT(semanage_node_set_con(sh, node, con) >= 0);

 	/* test */
 	CU_ASSERT(semanage_node_clone(sh, node, &node_clone) >= 0);

 	CU_ASSERT(semanage_node_get_addr(sh, node_clone, &addr2) >= 0);
 	CU_ASSERT_PTR_NOT_NULL(addr2);
 	assert(addr2);
 	CU_ASSERT_STRING_EQUAL(addr1, addr2);

 	CU_ASSERT(semanage_node_get_mask(sh, node_clone, &mask2) >= 0);
 	CU_ASSERT_PTR_NOT_NULL(mask2);
 	assert(mask2);
 	CU_ASSERT_STRING_EQUAL(mask1, mask2);

 	CU_ASSERT(semanage_node_get_proto(node_clone) == SEMANAGE_PROTO_IP4);

 	con2 = semanage_node_get_con(node_clone);
 	CU_ASSERT_CONTEXT_EQUAL(con, con2);

 	/* cleanup */
 	free(mask2);
 	free(addr2);
 	semanage_context_free(con);
 	semanage_node_free(node);
 	semanage_node_free(node_clone);
 	cleanup_handle(SH_CONNECT);
 }

 /* Function semanage_node_query */
 static void test_node_query(void)
 {
 	semanage_node_t *node = NULL;
 	semanage_node_t *node_exp = NULL;
 	semanage_node_key_t *key = NULL;
 	char *str = NULL;
 	char *str_exp = NULL;
 	semanage_context_t *con = NULL;
 	semanage_context_t *con_exp = NULL;

 	/* setup */
 	setup_handle(SH_CONNECT);
 	key = get_node_key_nth(I_FIRST);
 	node_exp = get_node_nth(I_FIRST);

 	/* test */
 	CU_ASSERT(semanage_node_query(sh, key, &node) >= 0);

 	CU_ASSERT(semanage_node_get_addr(sh, node, &str) >= 0);
 	CU_ASSERT(semanage_node_get_addr(sh, node_exp, &str_exp) >= 0);
 	CU_ASSERT_STRING_EQUAL(str, str_exp);
 	free(str);
 	free(str_exp);

 	CU_ASSERT(semanage_node_get_mask(sh, node, &str) >= 0);
 	CU_ASSERT(semanage_node_get_mask(sh, node_exp, &str_exp) >= 0);
 	CU_ASSERT_STRING_EQUAL(str, str_exp);
 	free(str);
 	free(str_exp);

 	CU_ASSERT(semanage_node_get_proto(node) ==
 			  semanage_node_get_proto(node_exp));

 	con = semanage_node_get_con(node);
 	con_exp = semanage_node_get_con(node_exp);
 	CU_ASSERT_CONTEXT_EQUAL(con, con_exp);

 	/* cleanup */
 	semanage_node_key_free(key);
 	semanage_node_free(node_exp);
 	semanage_node_free(node);
 	cleanup_handle(SH_CONNECT);
 }

 /* Function semanage_node_exists */
 static void test_node_exists(void)
 {
 	semanage_node_key_t *key1 = NULL;
 	semanage_node_key_t *key2 = NULL;
 	int resp = 42;

 	/* setup */
 	setup_handle(SH_CONNECT);
 	key1 = get_node_key_nth(I_FIRST);
 	CU_ASSERT(semanage_node_key_create(sh, "1.2.3.4", "255.255.0.0",
 					   SEMANAGE_PROTO_IP4, &key2) >= 0);

 	/* test */
 	CU_ASSERT(semanage_node_exists(sh, key1, &resp) >= 0);
 	CU_ASSERT(resp);
 	CU_ASSERT(semanage_node_exists(sh, key2, &resp) >= 0);
 	CU_ASSERT(!resp);

 	/* cleanup */
 	semanage_node_key_free(key1);
 	semanage_node_key_free(key2);
 	cleanup_handle(SH_CONNECT);
 }

 /* Function semanage_node_count */
 static void test_node_count(void)
 {
 	unsigned int count = 42;

 	/* setup */
 	setup_handle(SH_CONNECT);

 	/* test */
 	CU_ASSERT(semanage_node_count(sh, &count) >= 0);
 	CU_ASSERT(count == NODE_COUNT);

 	/* cleanup */
 	cleanup_handle(SH_CONNECT);
 }

 /* Function semanage_node_iterate */
 unsigned int counter_node_iterate = 0;

 static int handler_node_iterate(const semanage_node_t *record, void *varg)
 {
 	counter_node_iterate++;
 	return 0;
 }

 static void test_node_iterate(void)
 {
 	/* setup */
 	setup_handle(SH_CONNECT);

 	/* test */
 	semanage_node_iterate(sh, handler_node_iterate, NULL);
 	CU_ASSERT(counter_node_iterate == NODE_COUNT);

 	/* cleanup */
 	cleanup_handle(SH_CONNECT);
 }

 /* Function semanage_node_list */
 static void test_node_list(void)
 {
 	semanage_node_t **records = NULL;
 	unsigned int count = 42;

 	/* setup */
 	setup_handle(SH_CONNECT);

 	/* test */
 	CU_ASSERT(semanage_node_list(sh, &records, &count) >= 0);
 	CU_ASSERT(count == NODE_COUNT);

 	for (unsigned int i = 0; i < count; i++)
 		CU_ASSERT_PTR_NOT_NULL(records[i]);

 	for (unsigned int i = 0; i < count; i++)
 		semanage_node_free(records[i]);

 	free(records);

 	/* cleanup */
 	cleanup_handle(SH_CONNECT);
 }

 /* Function semanage_node_modify_local, semanage_node_del_local,
  * semanage_node_query_local
  */
 static void test_node_modify_del_query_local(void)
 {
 	semanage_node_t *node;
 	semanage_node_t *node_local;
 	semanage_node_t *node_tmp;
 	semanage_node_key_t *key = NULL;
 	semanage_node_key_t *key_tmp = NULL;

 	/* setup */
 	setup_handle(SH_TRANS);
 	node = get_node_nth(I_FIRST);
 	CU_ASSERT(semanage_node_key_extract(sh, node, &key) >= 0);
 	CU_ASSERT_PTR_NOT_NULL(key);

 	/* add second record, so that semanage_node_compare2_qsort
 	 * will be called
 	 */
 	node_tmp = get_node_nth(I_FIRST);

 	CU_ASSERT(semanage_node_set_addr(sh, node_tmp, SEMANAGE_PROTO_IP4,
 					 "10.0.0.1") >= 0);
 	CU_ASSERT(semanage_node_key_extract(sh, node_tmp, &key_tmp) >= 0);
 	CU_ASSERT_PTR_NOT_NULL(key_tmp);

 	/* test */
 	CU_ASSERT(semanage_node_modify_local(sh, key, node) >= 0);
 	CU_ASSERT(semanage_node_modify_local(sh, key_tmp, node_tmp) >= 0);

 	/* write changes to file */
 	helper_commit();
 	helper_begin_transaction();

 	CU_ASSERT(semanage_node_query_local(sh, key, &node_local) >= 0);
 	CU_ASSERT_PTR_NOT_NULL_FATAL(node_local);
 	semanage_node_free(node_local);

 	CU_ASSERT(semanage_node_del_local(sh, key) >= 0);
 	CU_ASSERT(semanage_node_del_local(sh, key_tmp) >= 0);

 	CU_ASSERT(semanage_node_query_local(sh, key, &node_local) < 0);

 	/* cleanup */
 	semanage_node_key_free(key_tmp);
 	semanage_node_key_free(key);
 	semanage_node_free(node);
 	semanage_node_free(node_tmp);
 	cleanup_handle(SH_TRANS);
 }

 /* Function semanage_node_exists_local */
 static void test_node_exists_local(void)
 {
 	semanage_node_key_t *key1 = NULL;
 	semanage_node_key_t *key2 = NULL;
 	int resp = 42;

 	/* setup */
 	setup_handle(SH_TRANS);
 	add_local_node(I_FIRST);
 	key1 = get_node_key_nth(I_FIRST);
 	key2 = get_node_key_nth(I_SECOND);

 	/* test */
 	CU_ASSERT(semanage_node_exists_local(sh, key1, &resp) >= 0);
 	CU_ASSERT(resp);
 	CU_ASSERT(semanage_node_exists_local(sh, key2, &resp) >= 0);
 	CU_ASSERT(!resp);

 	/* cleanup */
 	CU_ASSERT(semanage_node_del_local(sh, key1) >= 0);
 	semanage_node_key_free(key1);
 	semanage_node_key_free(key2);
 	cleanup_handle(SH_TRANS);
 }

 /* Function semanage_node_count_local */
 static void test_node_count_local(void)
 {
 	unsigned int count = 42;

 	/* setup */
 	setup_handle(SH_TRANS);

 	/* test */
 	CU_ASSERT(semanage_node_count_local(sh, &count) >= 0);
 	CU_ASSERT(count == 0);

 	add_local_node(I_FIRST);
 	CU_ASSERT(semanage_node_count_local(sh, &count) >= 0);
 	CU_ASSERT(count == 1);

 	add_local_node(I_SECOND);
 	CU_ASSERT(semanage_node_count_local(sh, &count) >= 0);
 	CU_ASSERT(count == 2);

 	delete_local_node(I_SECOND);
 	CU_ASSERT(semanage_node_count_local(sh, &count) >= 0);
 	CU_ASSERT(count == 1);

 	delete_local_node(I_FIRST);
 	CU_ASSERT(semanage_node_count_local(sh, &count) >= 0);
 	CU_ASSERT(count == 0);

 	/* cleanup */
 	cleanup_handle(SH_TRANS);
 }

 /* Function semanage_node_iterate_local */
 unsigned int counter_node_iterate_local = 0;

 static int handler_node_iterate_local(const semanage_node_t *record, void *varg)
 {
 	counter_node_iterate_local++;
 	return 0;
 }

 static void test_node_iterate_local(void)
 {
 	/* setup */
 	setup_handle(SH_TRANS);
 	add_local_node(I_FIRST);
 	add_local_node(I_SECOND);
 	add_local_node(I_THIRD);

 	/* test */
 	semanage_node_iterate_local(sh, handler_node_iterate_local, NULL);
 	CU_ASSERT(counter_node_iterate_local == 3);

 	/* cleanup */
 	delete_local_node(I_FIRST);
 	delete_local_node(I_SECOND);
 	delete_local_node(I_THIRD);
 	cleanup_handle(SH_TRANS);
 }

 /* Function semanage_node_list_local */
 static void test_node_list_local(void)
 {
 	semanage_node_t **records = NULL;
 	unsigned int count = 42;

 	/* setup */
 	setup_handle(SH_TRANS);
 	add_local_node(I_FIRST);
 	add_local_node(I_SECOND);
 	add_local_node(I_THIRD);

 	/* test */
 	CU_ASSERT(semanage_node_list_local(sh, &records, &count) >= 0);
 	CU_ASSERT(count == 3);

 	for (unsigned int i = 0; i < count; i++)
 		CU_ASSERT_PTR_NOT_NULL(records[i]);

 	/* cleanup */
 	for (unsigned int i = 0; i < count; i++)
 		semanage_node_free(records[i]);

 	free(records);

 	delete_local_node(I_FIRST);
 	delete_local_node(I_SECOND);
 	delete_local_node(I_THIRD);
 	cleanup_handle(SH_TRANS);
 }
	/*
	* Authors: Jan Zarsky <[email protected]>
	*
	* Copyright (C) 2019 Red Hat, Inc.
	*
	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public
	* License as published by the Free Software Foundation; either
	* version 2.1 of the License, or (at your option) any later version.
	*
	* This library is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public
	* License along with this library; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	*/

	#include "utilities.h"
	#include "test_node.h"

	#define NODE_COUNT 3

	#define NODE1_ADDR "192.168.0.0"
	#define NODE1_MASK "255.255.255.0"
	#define NODE1_PROTO SEPOL_PROTO_IP4
	#define NODE1_CONTEXT "system_u:object_r:first_node_t:s0"

	#define NODE2_ADDR "2001:db8:85a3::8a2e:370:7334"
	#define NODE2_MASK "2001:db8:85a3::8a2e:370:7334"
	#define NODE2_PROTO SEPOL_PROTO_IP6
	#define NODE2_CONTEXT "system_u:object_r:second_node_t:s0"

	#define NODE3_ADDR "127.0.0.1"
	#define NODE3_MASK "255.255.0.0"
	#define NODE3_PROTO SEPOL_PROTO_IP4
	#define NODE3_CONTEXT "system_u:object_r:third_node_t:s0"

	/* node_record.h */
	static void test_node_compare(void);
	static void test_node_compare2(void);
	static void test_node_key_create(void);
	static void test_node_key_extract(void);
	static void test_node_get_set_addr(void);
	static void test_node_get_set_addr_bytes(void);
	static void test_node_get_set_mask(void);
	static void test_node_get_set_mask_bytes(void);
	static void test_node_get_set_proto(void);
	static void test_node_get_proto_str(void);
	static void test_node_get_set_con(void);
	static void test_node_create(void);
	static void test_node_clone(void);

	/* nodes_policy.h */
	static void test_node_query(void);
	static void test_node_exists(void);
	static void test_node_count(void);
	static void test_node_iterate(void);
	static void test_node_list(void);

	/* nodes_local.h */
	static void test_node_modify_del_query_local(void);
	static void test_node_exists_local(void);
	static void test_node_count_local(void);
	static void test_node_iterate_local(void);
	static void test_node_list_local(void);

	extern semanage_handle_t *sh;

	int node_test_init(void)
	{
	if (create_test_store() < 0) {
	fprintf(stderr, "Could not create test store\n");
	return 1;
	}

	if (write_test_policy_from_file("test_node.policy") < 0) {
	fprintf(stderr, "Could not write test policy\n");
	return 1;
	}

	return 0;
	}

	int node_test_cleanup(void)
	{
	if (destroy_test_store() < 0) {
	fprintf(stderr, "Could destroy test store\n");
	return 1;
	}

	return 0;
	}

	int node_add_tests(CU_pSuite suite)
	{
	CU_add_test(suite, "node_compare", test_node_compare);
	CU_add_test(suite, "node_compare2", test_node_compare2);
	CU_add_test(suite, "node_key_create", test_node_key_create);
	CU_add_test(suite, "node_key_extract", test_node_key_extract);
	CU_add_test(suite, "node_get_set_addr", test_node_get_set_addr);
	CU_add_test(suite, "node_get_set_addr_bytes",
	test_node_get_set_addr_bytes);
	CU_add_test(suite, "node_get_set_mask", test_node_get_set_mask);
	CU_add_test(suite, "node_get_set_mask_bytes",
	test_node_get_set_mask_bytes);
	CU_add_test(suite, "node_get_set_proto", test_node_get_set_proto);
	CU_add_test(suite, "node_get_proto_str", test_node_get_proto_str);
	CU_add_test(suite, "node_get_set_con", test_node_get_set_con);
	CU_add_test(suite, "node_create", test_node_create);
	CU_add_test(suite, "node_clone", test_node_clone);

	CU_add_test(suite, "node_query", test_node_query);
	CU_add_test(suite, "node_exists", test_node_exists);
	CU_add_test(suite, "node_count", test_node_count);
	CU_add_test(suite, "node_iterate", test_node_iterate);
	CU_add_test(suite, "node_list", test_node_list);

	CU_add_test(suite, "node_modify_del_query_local",
	test_node_modify_del_query_local);
	CU_add_test(suite, "node_exists_local", test_node_exists_local);
	CU_add_test(suite, "node_count_local", test_node_count_local);
	CU_add_test(suite, "node_iterate_local", test_node_iterate_local);
	CU_add_test(suite, "node_list_local", test_node_list_local);

	return 0;
	}

	/* Helpers */

	static semanage_node_t *get_node_nth(int idx)
	{
	semanage_node_t **records;
	semanage_node_t *node;
	unsigned int count;

	if (idx == I_NULL)
	return NULL;

	CU_ASSERT_FATAL(semanage_node_list(sh, &records, &count) >= 0);
	CU_ASSERT_FATAL(count >= (unsigned int) idx + 1);

	node = records[idx];

	for (unsigned int i = 0; i < count; i++)
	if (i != (unsigned int) idx)
	semanage_node_free(records[i]);

	free(records);

	return node;
	}

	static semanage_node_key_t *get_node_key_nth(int idx)
	{
	semanage_node_key_t *key;
	semanage_node_t *node;
	int res;

	if (idx == I_NULL)
	return NULL;

	node = get_node_nth(idx);

	res = semanage_node_key_extract(sh, node, &key);

	CU_ASSERT_FATAL(res >= 0);
	CU_ASSERT_PTR_NOT_NULL_FATAL(key);

	semanage_node_free(node);

	return key;
	}

	static void add_local_node(int idx)
	{
	semanage_node_t *node;
	semanage_node_key_t *key = NULL;

	node = get_node_nth(idx);

	CU_ASSERT_FATAL(semanage_node_key_extract(sh, node, &key) >= 0);
	CU_ASSERT_PTR_NOT_NULL_FATAL(key);

	CU_ASSERT_FATAL(semanage_node_modify_local(sh, key, node) >= 0);

	/* cleanup */
	semanage_node_key_free(key);
	semanage_node_free(node);
	}

	static void delete_local_node(int idx)
	{
	semanage_node_key_t *key = NULL;

	key = get_node_key_nth(idx);

	CU_ASSERT_FATAL(semanage_node_del_local(sh, key) >= 0);

	/* cleanup */
	semanage_node_key_free(key);
	}

	/* Function semanage_node_compare */
	static void test_node_compare(void)
	{
	semanage_node_t *node = NULL;
	semanage_node_key_t *key1 = NULL;
	semanage_node_key_t *key2 = NULL;
	int res = 42;

	/* setup */
	setup_handle(SH_CONNECT);
	node = get_node_nth(I_FIRST);
	key1 = get_node_key_nth(I_FIRST);
	CU_ASSERT(semanage_node_key_create(sh, "192.168.0.1", "255.255.0.0",
	SEMANAGE_PROTO_IP4, &key2) >= 0);
	CU_ASSERT_PTR_NOT_NULL(key2);

	/* test */
	res = semanage_node_compare(node, key1);
	CU_ASSERT(res == 0);
	res = semanage_node_compare(node, key2);
	CU_ASSERT(res != 0);

	/* cleanup */
	semanage_node_free(node);
	semanage_node_key_free(key1);
	semanage_node_key_free(key2);
	cleanup_handle(SH_CONNECT);
	}

	/* Function semanage_node_compare2 */
	static void test_node_compare2(void)
	{
	semanage_node_t *node1 = NULL;
	semanage_node_t *node2 = NULL;
	semanage_node_t *node3 = NULL;
	int res = 42;

	/* setup */
	setup_handle(SH_CONNECT);
	node1 = get_node_nth(I_FIRST);
	node2 = get_node_nth(I_FIRST);
	node3 = get_node_nth(I_SECOND);

	/* test */
	res = semanage_node_compare2(node1, node2);
	CU_ASSERT(res == 0);
	res = semanage_node_compare2(node1, node3);
	CU_ASSERT(res != 0);

	/* cleanup */
	semanage_node_free(node1);
	semanage_node_free(node2);
	semanage_node_free(node3);
	cleanup_handle(SH_CONNECT);
	}

	/* Function semanage_node_key_create */
	static void test_node_key_create(void)
	{
	semanage_node_key_t *key = NULL;

	/* setup */
	setup_handle(SH_CONNECT);

	/* test */
	CU_ASSERT(semanage_node_key_create(sh, "127.0.0.1", "255.255.255.255",
	SEMANAGE_PROTO_IP4, &key) >= 0);
	CU_ASSERT_PTR_NOT_NULL(key);

	/* cleanup */
	semanage_node_key_free(key);
	cleanup_handle(SH_CONNECT);
	}

	/* Function semanage_node_key_extract */
	static void test_node_key_extract(void)
	{
	semanage_node_t *node = NULL;
	semanage_node_key_t *key = NULL;

	/* setup */
	setup_handle(SH_CONNECT);
	node = get_node_nth(I_FIRST);

	/* test */
	CU_ASSERT(semanage_node_key_extract(sh, node, &key) >= 0);
	CU_ASSERT_PTR_NOT_NULL(key);

	/* cleanup */
	semanage_node_free(node);
	semanage_node_key_free(key);
	cleanup_handle(SH_CONNECT);
	}

	/* Function semanage_node_get_addr, semanage_node_set_addr */
	static void test_node_get_set_addr(void)
	{
	semanage_node_t *node = NULL;
	char *addr = NULL;

	/* setup */
	setup_handle(SH_CONNECT);
	CU_ASSERT(semanage_node_create(sh, &node) >= 0);

	/* test */
	CU_ASSERT(semanage_node_set_addr(sh, node, SEMANAGE_PROTO_IP4,
	"192.168.0.1") == 0);
	CU_ASSERT(semanage_node_get_addr(sh, node, &addr) >= 0);
	CU_ASSERT_PTR_NOT_NULL(addr);
	assert(addr);
	CU_ASSERT_STRING_EQUAL(addr, "192.168.0.1");

	/* cleanup */
	free(addr);
	semanage_node_free(node);
	cleanup_handle(SH_CONNECT);
	}

	/* Function semanage_node_get_addr_bytes, semanage_node_set_addr_bytes */
	static void test_node_get_set_addr_bytes(void)
	{
	semanage_node_t *node = NULL;
	char addr1[] = { 192, 168, 0, 1 };
	size_t addr1_size = sizeof(addr1);
	char *addr2 = NULL;
	size_t addr2_size = 0;

	/* setup */
	setup_handle(SH_CONNECT);
	CU_ASSERT(semanage_node_create(sh, &node) >= 0);

	/* test */
	CU_ASSERT(semanage_node_set_addr_bytes(sh, node, addr1,
	addr1_size) == 0);
	CU_ASSERT(semanage_node_get_addr_bytes(sh, node, &addr2,
	&addr2_size) >= 0);
	CU_ASSERT_PTR_NOT_NULL(addr2);
	assert(addr2);

	for (size_t i = 0; i < addr2_size; i++)
	CU_ASSERT(addr1[i] == addr2[i]);

	/* cleanup */
	free(addr2);
	semanage_node_free(node);
	cleanup_handle(SH_CONNECT);
	}

	/* Function semanage_node_get_mask, semanage_node_set_mask */
	static void test_node_get_set_mask(void)
	{
	semanage_node_t *node = NULL;
	char *mask = NULL;

	/* setup */
	setup_handle(SH_CONNECT);
	CU_ASSERT(semanage_node_create(sh, &node) >= 0);

	/* test */
	CU_ASSERT(semanage_node_set_mask(sh, node, SEMANAGE_PROTO_IP4,
	"255.255.255.0") == 0);
	CU_ASSERT(semanage_node_get_mask(sh, node, &mask) >= 0);
	CU_ASSERT_PTR_NOT_NULL(mask);
	assert(mask);
	CU_ASSERT_STRING_EQUAL(mask, "255.255.255.0");

	/* cleanup */
	free(mask);
	semanage_node_free(node);
	cleanup_handle(SH_CONNECT);
	}

	/* Function semanage_node_get_mask_bytes, semanage_node_set_mask_bytes */
	static void test_node_get_set_mask_bytes(void)
	{
	semanage_node_t *node = NULL;
	char mask1[] = { 255, 255, 255, 0 };
	size_t mask1_size = sizeof(mask1);
	char *mask2 = NULL;
	size_t mask2_size = 0;

	/* setup */
	setup_handle(SH_CONNECT);
	CU_ASSERT(semanage_node_create(sh, &node) >= 0);

	/* test */
	CU_ASSERT(semanage_node_set_mask_bytes(sh, node, mask1,
	mask1_size) == 0);
	CU_ASSERT(semanage_node_get_mask_bytes(sh, node, &mask2,
	&mask2_size) >= 0);
	CU_ASSERT_PTR_NOT_NULL(mask2);
	assert(mask2);

	for (size_t i = 0; i < mask2_size; i++)
	CU_ASSERT(mask1[i] == mask2[i]);

	/* cleanup */
	free(mask2);
	semanage_node_free(node);
	cleanup_handle(SH_CONNECT);
	}

	/* Function semanage_node_get_proto, semanage_node_set_proto */
	static void test_node_get_set_proto(void)
	{
	semanage_node_t *node = NULL;

	/* setup */
	setup_handle(SH_CONNECT);
	CU_ASSERT(semanage_node_create(sh, &node) >= 0);

	/* test */
	semanage_node_set_proto(node, SEMANAGE_PROTO_IP4);
	CU_ASSERT(semanage_node_get_proto(node) == SEMANAGE_PROTO_IP4);

	/* cleanup */
	semanage_node_free(node);
	cleanup_handle(SH_CONNECT);
	}

	/* Function semanage_node_get_proto_str */
	static void test_node_get_proto_str(void)
	{
	CU_ASSERT_STRING_EQUAL(semanage_node_get_proto_str(SEMANAGE_PROTO_IP4),
	"ipv4");
	CU_ASSERT_STRING_EQUAL(semanage_node_get_proto_str(SEMANAGE_PROTO_IP6),
	"ipv6");
	}

	/* Function semanage_node_get_con, semanage_node_set_con */
	static void test_node_get_set_con(void)
	{
	semanage_node_t *node = NULL;
	semanage_context_t *con1 = NULL;
	semanage_context_t *con2 = NULL;

	/* setup */
	setup_handle(SH_CONNECT);
	CU_ASSERT(semanage_node_create(sh, &node) >= 0);
	CU_ASSERT(semanage_context_from_string(sh,
	"my_user_u:my_role_r:my_type_t:s0", &con1) >= 0);

	/* test */
	CU_ASSERT(semanage_node_set_con(sh, node, con1) == 0);
	con2 = semanage_node_get_con(node);
	CU_ASSERT_CONTEXT_EQUAL(con1, con2);

	/* cleanup */
	semanage_context_free(con1);
	semanage_node_free(node);
	cleanup_handle(SH_CONNECT);
	}

	/* Function semanage_node_create */
	static void test_node_create(void)
	{
	semanage_node_t *node = NULL;
	semanage_context_t *con = NULL;

	/* setup */
	setup_handle(SH_CONNECT);

	/* test */
	CU_ASSERT(semanage_node_create(sh, &node) >= 0);
	CU_ASSERT(semanage_node_set_addr(sh, node, SEMANAGE_PROTO_IP4,
	"127.0.0.1") >= 0);
	CU_ASSERT(semanage_node_set_mask(sh, node, SEMANAGE_PROTO_IP4,
	"255.255.255.0") >= 0);
	semanage_node_set_proto(node, SEMANAGE_PROTO_IP4);
	CU_ASSERT(semanage_context_from_string(sh, "user_u:role_r:type_t:s0",
	&con) >= 0);
	CU_ASSERT(semanage_node_set_con(sh, node, con) >= 0);

	/* cleanup */
	semanage_context_free(con);
	semanage_node_free(node);
	cleanup_handle(SH_CONNECT);
	}

	/* Function semanage_node_clone */
	static void test_node_clone(void)
	{
	semanage_node_t *node = NULL;
	semanage_node_t *node_clone = NULL;
	semanage_context_t *con = NULL;
	semanage_context_t *con2 = NULL;
	const char *addr1 = "127.0.0.1";
	char *addr2 = NULL;
	const char *mask1 = "255.255.255.0";
	char *mask2 = NULL;

	/* setup */
	setup_handle(SH_CONNECT);
	CU_ASSERT(semanage_node_create(sh, &node) >= 0);
	CU_ASSERT(semanage_node_set_addr(sh, node, SEMANAGE_PROTO_IP4,
	addr1) >= 0);
	CU_ASSERT(semanage_node_set_mask(sh, node, SEMANAGE_PROTO_IP4,
	mask1) >= 0);
	semanage_node_set_proto(node, SEMANAGE_PROTO_IP4);
	CU_ASSERT(semanage_context_from_string(sh, "user_u:role_r:type_t:s0",
	&con) >= 0);
	CU_ASSERT(semanage_node_set_con(sh, node, con) >= 0);

	/* test */
	CU_ASSERT(semanage_node_clone(sh, node, &node_clone) >= 0);

	CU_ASSERT(semanage_node_get_addr(sh, node_clone, &addr2) >= 0);
	CU_ASSERT_PTR_NOT_NULL(addr2);
	assert(addr2);
	CU_ASSERT_STRING_EQUAL(addr1, addr2);

	CU_ASSERT(semanage_node_get_mask(sh, node_clone, &mask2) >= 0);
	CU_ASSERT_PTR_NOT_NULL(mask2);
	assert(mask2);
	CU_ASSERT_STRING_EQUAL(mask1, mask2);

	CU_ASSERT(semanage_node_get_proto(node_clone) == SEMANAGE_PROTO_IP4);

	con2 = semanage_node_get_con(node_clone);
	CU_ASSERT_CONTEXT_EQUAL(con, con2);

	/* cleanup */
	free(mask2);
	free(addr2);
	semanage_context_free(con);
	semanage_node_free(node);
	semanage_node_free(node_clone);
	cleanup_handle(SH_CONNECT);
	}

	/* Function semanage_node_query */
	static void test_node_query(void)
	{
	semanage_node_t *node = NULL;
	semanage_node_t *node_exp = NULL;
	semanage_node_key_t *key = NULL;
	char *str = NULL;
	char *str_exp = NULL;
	semanage_context_t *con = NULL;
	semanage_context_t *con_exp = NULL;

	/* setup */
	setup_handle(SH_CONNECT);
	key = get_node_key_nth(I_FIRST);
	node_exp = get_node_nth(I_FIRST);

	/* test */
	CU_ASSERT(semanage_node_query(sh, key, &node) >= 0);

	CU_ASSERT(semanage_node_get_addr(sh, node, &str) >= 0);
	CU_ASSERT(semanage_node_get_addr(sh, node_exp, &str_exp) >= 0);
	CU_ASSERT_STRING_EQUAL(str, str_exp);
	free(str);
	free(str_exp);

	CU_ASSERT(semanage_node_get_mask(sh, node, &str) >= 0);
	CU_ASSERT(semanage_node_get_mask(sh, node_exp, &str_exp) >= 0);
	CU_ASSERT_STRING_EQUAL(str, str_exp);
	free(str);
	free(str_exp);

	CU_ASSERT(semanage_node_get_proto(node) ==
	semanage_node_get_proto(node_exp));

	con = semanage_node_get_con(node);
	con_exp = semanage_node_get_con(node_exp);
	CU_ASSERT_CONTEXT_EQUAL(con, con_exp);

	/* cleanup */
	semanage_node_key_free(key);
	semanage_node_free(node_exp);
	semanage_node_free(node);
	cleanup_handle(SH_CONNECT);
	}

	/* Function semanage_node_exists */
	static void test_node_exists(void)
	{
	semanage_node_key_t *key1 = NULL;
	semanage_node_key_t *key2 = NULL;
	int resp = 42;

	/* setup */
	setup_handle(SH_CONNECT);
	key1 = get_node_key_nth(I_FIRST);
	CU_ASSERT(semanage_node_key_create(sh, "1.2.3.4", "255.255.0.0",
	SEMANAGE_PROTO_IP4, &key2) >= 0);

	/* test */
	CU_ASSERT(semanage_node_exists(sh, key1, &resp) >= 0);
	CU_ASSERT(resp);
	CU_ASSERT(semanage_node_exists(sh, key2, &resp) >= 0);
	CU_ASSERT(!resp);

	/* cleanup */
	semanage_node_key_free(key1);
	semanage_node_key_free(key2);
	cleanup_handle(SH_CONNECT);
	}

	/* Function semanage_node_count */
	static void test_node_count(void)
	{
	unsigned int count = 42;

	/* setup */
	setup_handle(SH_CONNECT);

	/* test */
	CU_ASSERT(semanage_node_count(sh, &count) >= 0);
	CU_ASSERT(count == NODE_COUNT);

	/* cleanup */
	cleanup_handle(SH_CONNECT);
	}

	/* Function semanage_node_iterate */
	unsigned int counter_node_iterate = 0;

	static int handler_node_iterate(const semanage_node_t record, void varg)
	{
	counter_node_iterate++;
	return 0;
	}

	static void test_node_iterate(void)
	{
	/* setup */
	setup_handle(SH_CONNECT);

	/* test */
	semanage_node_iterate(sh, handler_node_iterate, NULL);
	CU_ASSERT(counter_node_iterate == NODE_COUNT);

	/* cleanup */
	cleanup_handle(SH_CONNECT);
	}

	/* Function semanage_node_list */
	static void test_node_list(void)
	{
	semanage_node_t **records = NULL;
	unsigned int count = 42;

	/* setup */
	setup_handle(SH_CONNECT);

	/* test */
	CU_ASSERT(semanage_node_list(sh, &records, &count) >= 0);
	CU_ASSERT(count == NODE_COUNT);

	for (unsigned int i = 0; i < count; i++)
	CU_ASSERT_PTR_NOT_NULL(records[i]);

	for (unsigned int i = 0; i < count; i++)
	semanage_node_free(records[i]);

	free(records);

	/* cleanup */
	cleanup_handle(SH_CONNECT);
	}

	/* Function semanage_node_modify_local, semanage_node_del_local,
	* semanage_node_query_local
	*/
	static void test_node_modify_del_query_local(void)
	{
	semanage_node_t *node;
	semanage_node_t *node_local;
	semanage_node_t *node_tmp;
	semanage_node_key_t *key = NULL;
	semanage_node_key_t *key_tmp = NULL;

	/* setup */
	setup_handle(SH_TRANS);
	node = get_node_nth(I_FIRST);
	CU_ASSERT(semanage_node_key_extract(sh, node, &key) >= 0);
	CU_ASSERT_PTR_NOT_NULL(key);

	/* add second record, so that semanage_node_compare2_qsort
	* will be called
	*/
	node_tmp = get_node_nth(I_FIRST);

	CU_ASSERT(semanage_node_set_addr(sh, node_tmp, SEMANAGE_PROTO_IP4,
	"10.0.0.1") >= 0);
	CU_ASSERT(semanage_node_key_extract(sh, node_tmp, &key_tmp) >= 0);
	CU_ASSERT_PTR_NOT_NULL(key_tmp);

	/* test */
	CU_ASSERT(semanage_node_modify_local(sh, key, node) >= 0);
	CU_ASSERT(semanage_node_modify_local(sh, key_tmp, node_tmp) >= 0);

	/* write changes to file */
	helper_commit();
	helper_begin_transaction();

	CU_ASSERT(semanage_node_query_local(sh, key, &node_local) >= 0);
	CU_ASSERT_PTR_NOT_NULL_FATAL(node_local);
	semanage_node_free(node_local);

	CU_ASSERT(semanage_node_del_local(sh, key) >= 0);
	CU_ASSERT(semanage_node_del_local(sh, key_tmp) >= 0);

	CU_ASSERT(semanage_node_query_local(sh, key, &node_local) < 0);

	/* cleanup */
	semanage_node_key_free(key_tmp);
	semanage_node_key_free(key);
	semanage_node_free(node);
	semanage_node_free(node_tmp);
	cleanup_handle(SH_TRANS);
	}

	/* Function semanage_node_exists_local */
	static void test_node_exists_local(void)
	{
	semanage_node_key_t *key1 = NULL;
	semanage_node_key_t *key2 = NULL;
	int resp = 42;

	/* setup */
	setup_handle(SH_TRANS);
	add_local_node(I_FIRST);
	key1 = get_node_key_nth(I_FIRST);
	key2 = get_node_key_nth(I_SECOND);

	/* test */
	CU_ASSERT(semanage_node_exists_local(sh, key1, &resp) >= 0);
	CU_ASSERT(resp);
	CU_ASSERT(semanage_node_exists_local(sh, key2, &resp) >= 0);
	CU_ASSERT(!resp);

	/* cleanup */
	CU_ASSERT(semanage_node_del_local(sh, key1) >= 0);
	semanage_node_key_free(key1);
	semanage_node_key_free(key2);
	cleanup_handle(SH_TRANS);
	}

	/* Function semanage_node_count_local */
	static void test_node_count_local(void)
	{
	unsigned int count = 42;

	/* setup */
	setup_handle(SH_TRANS);

	/* test */
	CU_ASSERT(semanage_node_count_local(sh, &count) >= 0);
	CU_ASSERT(count == 0);

	add_local_node(I_FIRST);
	CU_ASSERT(semanage_node_count_local(sh, &count) >= 0);
	CU_ASSERT(count == 1);

	add_local_node(I_SECOND);
	CU_ASSERT(semanage_node_count_local(sh, &count) >= 0);
	CU_ASSERT(count == 2);

	delete_local_node(I_SECOND);
	CU_ASSERT(semanage_node_count_local(sh, &count) >= 0);
	CU_ASSERT(count == 1);

	delete_local_node(I_FIRST);
	CU_ASSERT(semanage_node_count_local(sh, &count) >= 0);
	CU_ASSERT(count == 0);

	/* cleanup */
	cleanup_handle(SH_TRANS);
	}

	/* Function semanage_node_iterate_local */
	unsigned int counter_node_iterate_local = 0;

	static int handler_node_iterate_local(const semanage_node_t record, void varg)
	{
	counter_node_iterate_local++;
	return 0;
	}

	static void test_node_iterate_local(void)
	{
	/* setup */
	setup_handle(SH_TRANS);
	add_local_node(I_FIRST);
	add_local_node(I_SECOND);
	add_local_node(I_THIRD);

	/* test */
	semanage_node_iterate_local(sh, handler_node_iterate_local, NULL);
	CU_ASSERT(counter_node_iterate_local == 3);

	/* cleanup */
	delete_local_node(I_FIRST);
	delete_local_node(I_SECOND);
	delete_local_node(I_THIRD);
	cleanup_handle(SH_TRANS);
	}

	/* Function semanage_node_list_local */
	static void test_node_list_local(void)
	{
	semanage_node_t **records = NULL;
	unsigned int count = 42;

	/* setup */
	setup_handle(SH_TRANS);
	add_local_node(I_FIRST);
	add_local_node(I_SECOND);
	add_local_node(I_THIRD);

	/* test */
	CU_ASSERT(semanage_node_list_local(sh, &records, &count) >= 0);
	CU_ASSERT(count == 3);

	for (unsigned int i = 0; i < count; i++)
	CU_ASSERT_PTR_NOT_NULL(records[i]);

	/* cleanup */
	for (unsigned int i = 0; i < count; i++)
	semanage_node_free(records[i]);

	free(records);

	delete_local_node(I_FIRST);
	delete_local_node(I_SECOND);
	delete_local_node(I_THIRD);
	cleanup_handle(SH_TRANS);
	}