selinux/libsepol/cil/test/unit/test_cil_resolve_ast.c

/*
 * Copyright 2011 Tresys Technology, LLC. All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 * 
 *    1. Redistributions of source code must retain the above copyright notice,
 *       this list of conditions and the following disclaimer.
 * 
 *    2. Redistributions in binary form must reproduce the above copyright notice,
 *       this list of conditions and the following disclaimer in the documentation
 *       and/or other materials provided with the distribution.
 * 
 * THIS SOFTWARE IS PROVIDED BY TRESYS TECHNOLOGY, LLC ``AS IS'' AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
 * EVENT SHALL TRESYS TECHNOLOGY, LLC OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * 
 * The views and conclusions contained in the software and documentation are those
 * of the authors and should not be interpreted as representing official policies,
 * either expressed or implied, of Tresys Technology, LLC.
 */

#include <sepol/policydb/policydb.h>

#include "CuTest.h"
#include "CilTest.h"

#include "../../src/cil_build_ast.h"
#include "../../src/cil_resolve_ast.h"
#include "../../src/cil_verify.h"
#include "../../src/cil_internal.h"

/* this all needs to be moved to a private header file */
int __cil_resolve_ast_node_helper(struct cil_tree_node *, uint32_t *, void *);
int __cil_disable_children_helper(struct cil_tree_node *node, __attribute__((unused)) uint32_t *finished, void *);

struct cil_args_resolve {
	struct cil_db *db;
	enum cil_pass pass;
	uint32_t *changed;
	struct cil_tree_node *callstack;
	struct cil_tree_node *optstack;
	struct cil_tree_node *macro;
};

struct cil_args_resolve *gen_resolve_args(struct cil_db *db, enum cil_pass pass, uint32_t *changed, struct cil_tree_node *calls, struct cil_tree_node *opts, struct cil_tree_node *macro)
{
	struct cil_args_resolve *args = cil_malloc(sizeof(*args));
	args->db = db;
	args->pass = pass;
	args->changed = changed;
	args->callstack = calls;
	args->optstack = opts;
	args->macro = macro;

	return args;
}

void test_cil_resolve_name(CuTest *tc) {
	char *line[] = { "(", "block", "foo", 
				"(", "typealias", "test", "type_t", ")", 
				"(", "type", "test", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	struct cil_tree_node *test_curr = test_db->ast->root->cl_head->cl_head;
	struct cil_typealias *test_alias = (struct cil_typealias*)test_curr->data;
	struct cil_tree_node *type_node = NULL;

	int rc = cil_resolve_name(test_curr, test_alias->type_str, CIL_SYM_TYPES, args, &type_node);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_name_invalid_type_neg(CuTest *tc) {
	char *line[] = { "(", "block", "foo", 
				"(", "typealias", "foo.test2", "type_t", ")", 
				"(", "type", "test", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	struct cil_tree_node *test_curr = test_db->ast->root->cl_head->cl_head;
	struct cil_typealias *test_alias = (struct cil_typealias*)test_curr->data;
	struct cil_tree_node *type_node = NULL;

	int rc = cil_resolve_name(test_curr, test_alias->type_str, CIL_SYM_TYPES, args, &type_node);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_ast_curr_null_neg(CuTest *tc) {
	struct cil_db *test_db;
	cil_db_init(&test_db);

	test_db->ast->root = NULL;

	int rc = cil_resolve_ast(test_db, test_db->ast->root);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
}


/*
	cil_resolve test cases
*/

void test_cil_resolve_roleallow(CuTest *tc) {
	char *line[] = {"(", "role", "foo", ")", \
			"(", "role", "bar", ")", \
			"(", "roleallow", "foo", "bar", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_roleallow(test_db->ast->root->cl_head->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_roleallow_srcdecl_neg(CuTest *tc) {
	char *line[] = {"(", "role", "bar", ")", \
			"(", "roleallow", "foo", "bar", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	int rc1=cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	rc1 = rc1;

	int rc = cil_resolve_roleallow(test_db->ast->root->cl_head->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_roleallow_tgtdecl_neg(CuTest *tc) {
	char *line[] = {"(", "role", "foo", ")", \
			"(", "roleallow", "foo", "bar", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_roleallow(test_db->ast->root->cl_head->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_classmapping_anon(CuTest *tc) {
	char *line[] = {"(", "class", "file", "(", "open", ")", ")",
			"(", "classmap", "files", "(", "read", ")", ")",
			"(", "classmapping", "files", "read", "(", "file", "(", "open", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_classmapping(test_db->ast->root->cl_head->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_classmapping_anon_inmacro(CuTest *tc) {
	char *line[] = {"(", "classmap", "files", "(", "read", ")", ")",
			"(", "class", "file", "(", "open", ")", ")",
			"(", "macro", "mm", "(", "(", "classpermissionset", "a", ")", ")", 
				"(", "classmapping", "files", "read", "a", ")", ")",
			"(", "call", "mm", "(", "(", "file", "(", "open", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL); 

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	args->pass = CIL_PASS_CALL1;
	
	int rc2 = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	int rc3 = cil_resolve_call2(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_MISC3;
	args->callstack = test_db->ast->root->cl_head->next->next->next;

	int rc = cil_resolve_classmapping(test_db->ast->root->cl_head->next->next->next->cl_head, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, SEPOL_OK, rc2);
	CuAssertIntEquals(tc, SEPOL_OK, rc3);
}

void test_cil_resolve_classmapping_anon_inmacro_neg(CuTest *tc) {
	char *line[] = {"(", "classmap", "files", "(", "read", ")", ")",
			"(", "class", "file", "(", "open", ")", ")",
			"(", "macro", "mm", "(", "(", "classpermissionset", "a", ")", ")", 
				"(", "classmapping", "files", "read", "a", ")", ")",
			"(", "call", "mm", "(", "(", "DNE", "(", "open", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL); 

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	args->pass = CIL_PASS_CALL1;
	
	int rc2 = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	int rc3 = cil_resolve_call2(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_MISC3;
	args->callstack = test_db->ast->root->cl_head->next->next->next;

	int rc = cil_resolve_classmapping(test_db->ast->root->cl_head->next->next->next->cl_head, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, SEPOL_OK, rc2);
	CuAssertIntEquals(tc, SEPOL_OK, rc3);
}

void test_cil_resolve_classmapping_named(CuTest *tc) {
	char *line[] = {"(", "classmap", "files", "(", "read", ")", ")",
			"(", "classpermissionset", "char_w", "(", "char", "(", "read", ")", ")", ")",
			"(", "classmapping", "files", "read", "char_w", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_classmapping(test_db->ast->root->cl_head->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_classmapping_named_classmapname_neg(CuTest *tc) {
	char *line[] = {"(", "classpermissionset", "char_w", "(", "char", "(", "read", ")", ")", ")",
			"(", "classmap", "files", "(", "read", ")", ")",
			"(", "classmapping", "files", "read", "foo", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_classmapping(test_db->ast->root->cl_head->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_classmapping_anon_classmapname_neg(CuTest *tc) {
	char *line[] = {"(", "class", "file", "(", "open", ")", ")",
			"(", "classmap", "files", "(", "read", ")", ")",
			"(", "classmapping", "dne", "read", "(", "file", "(", "open", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_classmapping(test_db->ast->root->cl_head->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_classmapping_anon_permset_neg(CuTest *tc) {
	char *line[] = {"(", "class", "file", "(", "open", ")", ")",
			"(", "classmap", "files", "(", "read", ")", ")",
			"(", "classmapping", "files", "read", "(", "dne", "(", "open", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_classmapping(test_db->ast->root->cl_head->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_rolebounds(CuTest *tc) {
	char *line[] = {"(", "role", "role1", ")", 
			"(", "role", "role2", ")", 
			"(", "rolebounds", "role1", "role2", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_rolebounds(test_db->ast->root->cl_head->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_rolebounds_exists_neg(CuTest *tc) {
	char *line[] = {"(", "role", "role1", ")", 
			"(", "role", "role2", ")", 
			"(", "rolebounds", "role1", "role2", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_rolebounds(test_db->ast->root->cl_head->next->next, args);
	int rc = cil_resolve_rolebounds(test_db->ast->root->cl_head->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
}

void test_cil_resolve_rolebounds_role1_neg(CuTest *tc) {
	char *line[] = {"(", "role", "role1", ")", 
			"(", "role", "role2", ")", 
			"(", "rolebounds", "role_DNE", "role2", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_rolebounds(test_db->ast->root->cl_head->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_rolebounds_role2_neg(CuTest *tc) {
	char *line[] = {"(", "role", "role1", ")", 
			"(", "role", "role2", ")", 
			"(", "rolebounds", "role1", "role_DNE", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_rolebounds(test_db->ast->root->cl_head->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_sensalias(CuTest *tc) {
	char *line[] = {"(", "sensitivity", "s0", ")",
			"(", "sensitivityalias", "s0", "alias", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_sensalias(test_db->ast->root->cl_head->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_sensalias_sensdecl_neg(CuTest *tc) {
	char *line[] = {"(", "sensitivityalias", "s0", "alias", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MLS, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_sensalias(test_db->ast->root->cl_head, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_catalias(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")", 
			"(", "categoryalias", "c0", "red", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_catalias(test_db->ast->root->cl_head->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_catalias_catdecl_neg(CuTest *tc) {
	char *line[] = {"(", "categoryalias", "c0", "red", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_catalias(test_db->ast->root->cl_head, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);	
}

void test_cil_resolve_catorder(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")", 
			"(", "category", "c3", ")",
			"(", "categoryorder", "(", "c0", "c3", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC1, &changed, NULL, NULL, NULL);

	int rc = cil_resolve_catorder(test_db->ast->root->cl_head->next->next, args);
	int rc2 = cil_resolve_catorder(test_db->ast->root->cl_head->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, SEPOL_OK, rc2);
}

void test_cil_resolve_catorder_neg(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")", 
			"(", "category", "c3", ")",
			"(", "categoryorder", "(", "c5", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_catorder(test_db->ast->root->cl_head->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_dominance(CuTest *tc) {
	char *line[] = {"(", "sensitivity", "s0", ")", 
			"(", "sensitivity", "s1", ")",
			"(", "sensitivity", "s2", ")",
			"(", "dominance", "(", "s0", "s1", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC1, &changed, NULL, NULL, NULL);

	int rc = cil_resolve_dominance(test_db->ast->root->cl_head->next->next->next, args);
	int rc2 = cil_resolve_dominance(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, SEPOL_OK, rc2);
}

void test_cil_resolve_dominance_neg(CuTest *tc) {
	char *line[] = {"(", "sensitivity", "s0", ")", 
			"(", "sensitivity", "s1", ")",
			"(", "sensitivity", "s2", ")",
			"(", "dominance", "(", "s6", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_dominance(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_cat_list(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "category", "c1", ")",
			"(", "category", "c2", ")",
			"(", "categoryset", "somecats", "(", "c0", "c1", "c2", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MLS, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	struct cil_list *test_cat_list;
	cil_list_init(&test_cat_list);

	struct cil_catset *test_catset = (struct cil_catset*)test_db->ast->root->cl_head->next->next->next->data;

	int rc = cil_resolve_cat_list(test_db->ast->root->cl_head->next->next->next, test_catset->cat_list_str, test_cat_list, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_cat_list_catlistnull_neg(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "category", "c1", ")",
			"(", "category", "c2", ")",
			"(", "categoryset", "somecats", "(", "c0", "c1", "c2", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MLS, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	struct cil_list *test_cat_list;
	cil_list_init(&test_cat_list);

	struct cil_catset *test_catset = (struct cil_catset*)test_db->ast->root->cl_head->next->next->next->data;
	test_catset->cat_list_str = NULL;

	int rc = cil_resolve_cat_list(test_db->ast->root->cl_head->next->next->next, test_catset->cat_list_str, test_cat_list, args);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
}

void test_cil_resolve_cat_list_rescatlistnull_neg(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "category", "c1", ")",
			"(", "category", "c2", ")",
			"(", "categoryset", "somecats", "(", "c0", "c1", "c2", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MLS, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	struct cil_list *test_cat_list = NULL;

	struct cil_catset *test_catset = (struct cil_catset*)test_db->ast->root->cl_head->next->next->next->data;

	int rc = cil_resolve_cat_list(test_db->ast->root->cl_head->next->next->next, test_catset->cat_list_str, test_cat_list, args);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
}

void test_cil_resolve_cat_list_catrange(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "category", "c1", ")",
			"(", "category", "c2", ")",
			"(", "categoryorder", "(", "c0", "c1", "c2", ")", ")",
			"(", "categoryset", "somecats", "(", "c0", "(", "c1", "c2", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC1, &changed, NULL, NULL, NULL);

	cil_tree_walk(test_db->ast->root, __cil_resolve_ast_node_helper, NULL, NULL, args);
	__cil_verify_order(test_db->catorder, test_db->ast->root, CIL_CAT);

	struct cil_list *test_cat_list;
	cil_list_init(&test_cat_list);

	struct cil_catset *test_catset = (struct cil_catset*)test_db->ast->root->cl_head->next->next->next->next->data;

	int rc = cil_resolve_cat_list(test_db->ast->root->cl_head->next->next->next->next, test_catset->cat_list_str, test_cat_list, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_cat_list_catrange_neg(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "category", "c1", ")",
			"(", "category", "c2", ")",
			"(", "categoryorder", "(", "c0", "c1", "c2", ")", ")",
			"(", "categoryset", "somecats", "(", "c0", "(", "c2", "c1", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	struct cil_list *test_cat_list;
	cil_list_init(&test_cat_list);

	cil_resolve_catorder(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_MLS;

	struct cil_catset *test_catset = (struct cil_catset*)test_db->ast->root->cl_head->next->next->next->next->data;

	int rc = cil_resolve_cat_list(test_db->ast->root->cl_head->next->next->next->next, test_catset->cat_list_str, test_cat_list, args);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
}

void test_cil_resolve_cat_list_catname_neg(CuTest *tc) {
	char *line[] = {"(", "category", "c5", ")",
			"(", "category", "c6", ")",
			"(", "category", "c7", ")",
			"(", "categoryorder", "(", "c0", "c1", "c2", ")", ")",
			"(", "categoryset", "somecats", "(", "c0", "(", "c1", "c2", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	cil_resolve_catorder(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_MLS;
	struct cil_list *test_cat_list;
	cil_list_init(&test_cat_list);

	struct cil_catset *test_catset = (struct cil_catset*)test_db->ast->root->cl_head->next->next->next->next->data;
	
	int rc = cil_resolve_cat_list(test_db->ast->root->cl_head->next->next->next->next, test_catset->cat_list_str, test_cat_list, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_catset(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "category", "c1", ")",
			"(", "category", "c2", ")",
			"(", "categoryset", "somecats", "(", "c0", "c1", "c2", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MLS, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	struct cil_catset *test_catset = (struct cil_catset *)test_db->ast->root->cl_head->next->next->next->data;
	
	int rc = cil_resolve_catset(test_db->ast->root->cl_head->next->next->next, test_catset, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_catset_catlist_neg(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "category", "c1", ")",
			"(", "category", "c2", ")",
			"(", "categoryset", "somecats", "(", "c0", "c1", "c2", "c4", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MLS, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	struct cil_catset *test_catset = (struct cil_catset *)test_db->ast->root->cl_head->next->next->next->data;
	
	int rc = cil_resolve_catset(test_db->ast->root->cl_head->next->next->next, test_catset, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_catrange(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
                        "(", "category", "c255", ")",
                        "(", "categoryorder", "(", "c0", "c255", ")", ")",
                        "(", "categoryrange", "range", "(", "c0", "c255", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	cil_resolve_catorder(test_db->ast->root->cl_head->next->next, args);
	__cil_verify_order(test_db->catorder, test_db->ast->root, CIL_CAT);

	args->pass = CIL_PASS_MLS;

	int rc = cil_resolve_catrange(test_db->ast->root->cl_head->next->next->next, (struct cil_catrange*)test_db->ast->root->cl_head->next->next->next->data, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_catrange_catloworder_neg(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
                        "(", "category", "c255", ")",
                        "(", "categoryorder", "(", "c0", "c255", ")", ")",
                        "(", "categoryrange", "range", "(", "c0", "c255", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	cil_resolve_catorder(test_db->ast->root->cl_head->next->next, args);
	__cil_verify_order(test_db->catorder, test_db->ast->root, CIL_CAT);

	test_db->catorder->head = test_db->catorder->head->next;
	test_db->catorder->head->next = NULL;

	args->pass = CIL_PASS_MLS;

	int rc = cil_resolve_catrange(test_db->ast->root->cl_head->next->next->next, (struct cil_catrange*)test_db->ast->root->cl_head->next->next->next->data, args);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
}

void test_cil_resolve_catrange_cathighorder_neg(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
                        "(", "category", "c255", ")",
                        "(", "categoryorder", "(", "c0", "c255", ")", ")",
                        "(", "categoryrange", "range", "(", "c255", "c0", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	cil_resolve_catorder(test_db->ast->root->cl_head->next->next, args);
	__cil_verify_order(test_db->catorder, test_db->ast->root, CIL_CAT);

	args->pass = CIL_PASS_MLS;

	int rc = cil_resolve_catrange(test_db->ast->root->cl_head->next->next->next, (struct cil_catrange*)test_db->ast->root->cl_head->next->next->next->data, args);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
}

void test_cil_resolve_catrange_cat1_neg(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
                        "(", "category", "c255", ")",
                        "(", "categoryorder", "(", "c0", "c255", ")", ")",
                        "(", "categoryrange", "range", "(", "c12", "c255", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	cil_resolve_catorder(test_db->ast->root->cl_head->next->next, args);
	__cil_verify_order(test_db->catorder, test_db->ast->root, CIL_CAT);

	args->pass = CIL_PASS_MLS;

	int rc = cil_resolve_catrange(test_db->ast->root->cl_head->next->next->next, (struct cil_catrange*)test_db->ast->root->cl_head->next->next->next->data, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_catrange_cat2_neg(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
                        "(", "category", "c255", ")",
                        "(", "categoryorder", "(", "c0", "c255", ")", ")",
                        "(", "categoryrange", "range", "(", "c0", "c23", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	cil_resolve_catorder(test_db->ast->root->cl_head->next->next, args);
	__cil_verify_order(test_db->catorder, test_db->ast->root, CIL_CAT);

	args->pass = CIL_PASS_MLS;

	int rc = cil_resolve_catrange(test_db->ast->root->cl_head->next->next->next, (struct cil_catrange*)test_db->ast->root->cl_head->next->next->next->data, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_senscat(CuTest *tc) {
	char *line[] = {"(", "sensitivity", "s0", ")",
                        "(", "sensitivity", "s1", ")",
                        "(", "dominance", "(", "s0", "s1", ")", ")",
                        "(", "category", "c0", ")",
                        "(", "category", "c255", ")",
                        "(", "categoryorder", "(", "c0", "c255", ")", ")",
                        "(", "sensitivitycategory", "s1", "(", "c0", "c255", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MLS, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_senscat_catrange_neg(CuTest *tc) {
	char *line[] = {"(", "sensitivity", "s0", ")",
                        "(", "sensitivity", "s1", ")",
                        "(", "dominance", "(", "s0", "s1", ")", ")",
                        "(", "category", "c0", ")",
                        "(", "category", "c255", ")",
                        "(", "category", "c500", ")",
                        "(", "categoryorder", "(", "c0", "c255", "c500", ")", ")",
                        "(", "sensitivitycategory", "s1", "(", "c0", "(", "c255", "c5", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_catorder(test_db->ast->root->cl_head->next->next->next->next->next->next, args);

	args->pass = CIL_PASS_MLS;

	int rc = cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
}

void test_cil_resolve_senscat_catsetname(CuTest *tc) {
	char *line[] = {"(", "sensitivity", "s0", ")",
                        "(", "sensitivity", "s1", ")",
                        "(", "category", "c0", ")",
                        "(", "category", "c255", ")",
                        "(", "category", "c500", ")",
			"(", "categoryset", "foo", "(", "c0", "c255", "c500", ")", ")",
                        "(", "categoryorder", "(", "c0", "c255", "c500", ")", ")",
                        "(", "sensitivitycategory", "s1", "foo", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MLS, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	struct cil_catset *test_catset = (struct cil_catset *)test_db->ast->root->cl_head->next->next->next->next->next->data;
	cil_resolve_catset(test_db->ast->root->cl_head->next->next->next->next->next, test_catset, args);

	args->pass = CIL_PASS_MISC2;

	int rc = cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_senscat_catsetname_neg(CuTest *tc) {
	char *line[] = {"(", "sensitivity", "s0", ")",
                        "(", "sensitivity", "s1", ")",
                        "(", "category", "c0", ")",
                        "(", "category", "c255", ")",
                        "(", "category", "c500", ")",
                        "(", "sensitivitycategory", "s1", "foo", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_senscat_sublist(CuTest *tc) {
      char *line[] = {"(", "sensitivity", "s0", ")",
                        "(", "sensitivity", "s1", ")",
                        "(", "dominance", "(", "s0", "s1", ")", ")",
                        "(", "category", "c0", ")",
                        "(", "category", "c1", ")",
                        "(", "category", "c255", ")",
                        "(", "categoryorder", "(", "c0", "c1", "c255", ")", ")",
                        "(", "sensitivitycategory", "s1", "(", "c0", "(", "c1", "c255", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC1, &changed, NULL, NULL, NULL);

	cil_tree_walk(test_db->ast->root, __cil_resolve_ast_node_helper, NULL, NULL, args);
	__cil_verify_order(test_db->catorder, test_db->ast->root, CIL_CAT);

	int rc = cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_senscat_missingsens_neg(CuTest *tc) {
      char *line[] = {"(", "sensitivity", "s0", ")",
                        "(", "dominance", "(", "s0", "s1", ")", ")",
                        "(", "category", "c0", ")",
                        "(", "category", "c255", ")",
                        "(", "categoryorder", "(", "c0", "c255", ")", ")",
                        "(", "sensitivitycategory", "s1", "(", "c0", "c255", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MLS, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_senscat_category_neg(CuTest *tc) {
      char *line[] = {"(", "sensitivity", "s0", ")",
                        "(", "sensitivity", "s1", ")",
                        "(", "dominance", "(", "s0", "s1", ")", ")",
                        "(", "category", "c0", ")",
                        "(", "category", "c255", ")",
                        "(", "categoryorder", "(", "c0", "c255", ")", ")",
                        "(", "sensitivitycategory", "s1", "(", "c5", "c255", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MLS, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_senscat_currrangecat(CuTest *tc) {
      char *line[] = {"(", "sensitivity", "s0", ")",
                        "(", "sensitivity", "s1", ")",
                        "(", "dominance", "(", "s0", "s1", ")", ")",
                        "(", "category", "c0", ")",
                        "(", "category", "c1", ")",
                        "(", "category", "c255", ")",
                        "(", "categoryorder", "(", "c0", "c1", "c255", ")", ")",
                        "(", "sensitivitycategory", "s1", "(", "c0", "(", "c1", "c255", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC1, &changed, NULL, NULL, NULL);

	cil_tree_walk(test_db->ast->root, __cil_resolve_ast_node_helper, NULL, NULL, args);
	__cil_verify_order(test_db->catorder, test_db->ast->root, CIL_CAT);
	__cil_verify_order(test_db->dominance, test_db->ast->root, CIL_SENS);

	args->pass = CIL_PASS_MISC2;

	int rc = cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_level(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "categoryorder", "(", "c0", ")", ")",
			"(", "sensitivity", "s0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "type", "blah_t", ")",
			"(", "role", "blah_r", ")",
			"(", "user", "blah_u", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "sidcontext", "test", "(", "blah_u", "blah_r", "blah_t", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next, args);
	
	args->pass = CIL_PASS_MISC3;

	struct cil_tree_node *level = test_db->ast->root->cl_head->next->next->next->next->next->next->next;
	int rc = cil_resolve_level(level, (struct cil_level*)level->data, args);
	int rc2 = cil_resolve_level(level->next, (struct cil_level*)level->next->data, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, SEPOL_OK, rc2);
}

void test_cil_resolve_level_catlist(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "category", "c1", ")",
			"(", "categoryorder", "(", "c0", "c1", ")", ")",
			"(", "sensitivity", "s0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", "c1", ")", ")",
			"(", "type", "blah_t", ")",
			"(", "role", "blah_r", ")",
			"(", "user", "blah_u", ")",
			"(", "level", "low", "(", "s0", "(", "c0", "c1", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", "c1", ")", ")", ")",
			"(", "sidcontext", "test", "(", "blah_u", "blah_r", "blah_t", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next->next, args);
	
	args->pass = CIL_PASS_MISC3;

	struct cil_tree_node *level = test_db->ast->root->cl_head->next->next->next->next->next->next->next->next;
	int rc = cil_resolve_level(level, (struct cil_level*)level->data, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	rc = cil_resolve_level(level, (struct cil_level*)level->data, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_level_catset(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "category", "c1", ")",
			"(", "category", "c2", ")",
			"(", "categoryset", "cats", "(", "c0", "c1", "c2", ")", ")",	
			"(", "categoryorder", "(", "c0", "c1", "c2", ")", ")",
			"(", "sensitivity", "s0", ")",
			"(", "sensitivitycategory", "s0", "cats", ")",
			"(", "type", "blah_t", ")",
			"(", "role", "blah_r", ")",
			"(", "user", "blah_u", ")",
			"(", "level", "low", "(", "s0", "cats", ")", ")",
			"(", "level", "high", "(", "s0", "(", "cats", ")", ")", ")",
			"(", "sidcontext", "test", "(", "blah_u", "blah_r", "blah_t", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC1, &changed, NULL, NULL, NULL);

	struct cil_catset *cs = (struct cil_catset *)test_db->ast->root->cl_head->next->next->next->data;

	cil_resolve_catorder(test_db->ast->root->cl_head->next->next->next->next, args);

	args->pass = CIL_PASS_MLS;

	cil_resolve_catset(test_db->ast->root->cl_head->next->next->next, cs, args);

	args->pass = CIL_PASS_MISC2;

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next->next->next->next, args);

	args->pass = CIL_PASS_MISC3;
	
	struct cil_tree_node *level = test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next->next;
	int rc = cil_resolve_level(level, (struct cil_level*)level->data, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_level_catset_name_neg(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "category", "c1", ")",
			"(", "category", "c2", ")",
			"(", "categoryset", "cats", "(", "c0", "c1", "c2", ")", ")",	
			"(", "categoryorder", "(", "c0", "c1", "c2", ")", ")",
			"(", "sensitivity", "s0", ")",
			"(", "sensitivitycategory", "s0", "cats", ")",
			"(", "type", "blah_t", ")",
			"(", "role", "blah_r", ")",
			"(", "user", "blah_u", ")",
			"(", "level", "low", "(", "s0", "dne", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "sidcontext", "test", "(", "blah_u", "blah_r", "blah_t", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_MISC3;
	
	struct cil_tree_node *level = test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next->next;
	int rc = cil_resolve_level(level, (struct cil_level*)level->data, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_level_sens_neg(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "categoryorder", "(", "c0", ")", ")",
			"(", "sensitivity", "s0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "type", "blah_t", ")",
			"(", "role", "blah_r", ")",
			"(", "user", "blah_u", ")",
			"(", "level", "low", "(", "s1", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s1", "(", "c0", ")", ")", ")",
			"(", "sid", "test", "(", "blah_u", "blah_r", "blah_t", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next, args);
	struct cil_tree_node *level = test_db->ast->root->cl_head->next->next->next->next->next->next->next;

	args->pass = CIL_PASS_MISC3;

	int rc = cil_resolve_level(level, (struct cil_level*)level->data, args);
	int rc2 = cil_resolve_level(level->next, (struct cil_level*)level->next->data, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc2);
}

void test_cil_resolve_level_cat_neg(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "categoryorder", "(", "c0", ")", ")",
			"(", "sensitivity", "s0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "type", "blah_t", ")",
			"(", "role", "blah_r", ")",
			"(", "user", "blah_u", ")",
			"(", "level", "low", "(", "s0", "(", "c1", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c1", ")", ")", ")",
			"(", "sid", "test", "(", "blah_u", "blah_r", "blah_t", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next, args);
	struct cil_tree_node *level = test_db->ast->root->cl_head->next->next->next->next->next->next->next;

	args->pass = CIL_PASS_MISC3;
	int rc = cil_resolve_level(level, (struct cil_level*)level->data, args);
	int rc2 = cil_resolve_level(level->next, (struct cil_level*)level->next->data, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc2);
}

void test_cil_resolve_level_senscat_neg(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "categoryorder", "(", "c0", ")", ")",
			"(", "sensitivity", "s0", ")",
			"(", "sensitivitycategory", "s1", "(", "c0", ")", ")",
			"(", "type", "blah_t", ")",
			"(", "role", "blah_r", ")",
			"(", "user", "blah_u", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "sid", "test", "(", "blah_u", "blah_r", "blah_t", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next, args);
	struct cil_tree_node *level = test_db->ast->root->cl_head->next->next->next->next->next->next->next;

	args->pass = CIL_PASS_MISC3;
	int rc = cil_resolve_level(level, (struct cil_level*)level->data, args);
	int rc2 = cil_resolve_level(level->next, (struct cil_level*)level->next->data, args);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
	CuAssertIntEquals(tc, SEPOL_ERR, rc2);
}

void test_cil_resolve_levelrange_namedlvl(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "levelrange", "range", "(", "low", "high", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next, args);

	args->pass = CIL_PASS_MISC3;

	struct cil_levelrange *lvlrange = (struct cil_levelrange *)test_db->ast->root->cl_head->next->next->next->next->next->data;

	int rc = cil_resolve_levelrange(test_db->ast->root->cl_head->next->next->next->next->next, lvlrange, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_levelrange_namedlvl_low_neg(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "levelrange", "range", "(", "DNE", "high", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next, args);

	args->pass = CIL_PASS_MISC3;

	struct cil_levelrange *lvlrange = (struct cil_levelrange *)test_db->ast->root->cl_head->next->next->next->next->next->data;
	
	int rc = cil_resolve_levelrange(test_db->ast->root->cl_head->next->next->next->next->next, lvlrange, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_levelrange_namedlvl_high_neg(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "levelrange", "range", "(", "low", "DNE", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next, args);

	args->pass = CIL_PASS_MISC3;

	struct cil_levelrange *lvlrange = (struct cil_levelrange *)test_db->ast->root->cl_head->next->next->next->next->next->data;
	
	int rc = cil_resolve_levelrange(test_db->ast->root->cl_head->next->next->next->next->next, lvlrange, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_levelrange_anonlvl(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "levelrange", "range", "(", "(", "s0", "(", "c0", ")", ")", "(", "s0", "(", "c0", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next, args);

	args->pass = CIL_PASS_MISC3;

	struct cil_levelrange *lvlrange = (struct cil_levelrange *)test_db->ast->root->cl_head->next->next->next->data;
	
	int rc = cil_resolve_levelrange(test_db->ast->root->cl_head->next->next->next, lvlrange, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_levelrange_anonlvl_low_neg(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "levelrange", "range", "(", "(", "DNE", "(", "c0", ")", ")", "(", "s0", "(", "c0", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next, args);

	struct cil_levelrange *lvlrange = (struct cil_levelrange *)test_db->ast->root->cl_head->next->next->next->data;
	
	args->pass = CIL_PASS_MISC3;

	int rc = cil_resolve_levelrange(test_db->ast->root->cl_head->next->next->next, lvlrange, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_levelrange_anonlvl_high_neg(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "levelrange", "range", "(", "(", "s0", "(", "c0", ")", ")", "(", "dne", "(", "c0", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next, args);

	struct cil_levelrange *lvlrange = (struct cil_levelrange *)test_db->ast->root->cl_head->next->next->next->data;
	
	args->pass = CIL_PASS_MISC3;

	int rc = cil_resolve_levelrange(test_db->ast->root->cl_head->next->next->next, lvlrange, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_constrain(CuTest *tc) {
        char *line[] = {"(", "class", "file", "(", "create", "relabelto", ")", ")",
			"(", "class", "dir", "(", "create", "relabelto", ")", ")",
			"(", "sensitivity", "s0", ")",
			"(", "category", "c1", ")",
			"(", "level", "l2", "(", "s0", "(", "c1", ")", ")", ")",
			"(", "level", "h2", "(", "s0", "(", "c1", ")", ")", ")",
			"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "l2", "h2", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	int rc = cil_resolve_constrain(test_db->ast->root->cl_head->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_constrain_class_neg(CuTest *tc) {
        char *line[] = {"(", "class", "file", "(", "create", "relabelto", ")", ")",
			"(", "sensitivity", "s0", ")",
			"(", "category", "c1", ")",
			"(", "level", "l2", "(", "s0", "(", "c1", ")", ")", ")",
			"(", "level", "h2", "(", "s0", "(", "c1", ")", ")", ")",
			"(", "mlsconstrain", "(", "foo", "(", "create", "relabelto", ")", ")", "(", "eq", "l2", "h2", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_constrain(test_db->ast->root->cl_head->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_constrain_perm_neg(CuTest *tc) {
        char *line[] = {"(", "class", "file", "(", "create", ")", ")",
			"(", "class", "dir", "(", "create", "relabelto", ")", ")",
			"(", "sensitivity", "s0", ")",
			"(", "category", "c1", ")",
			"(", "level", "l2", "(", "s0", "(", "c1", ")", ")", ")",
			"(", "level", "h2", "(", "s0", "(", "c1", ")", ")", ")",
			"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "l2", "h2", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_constrain(test_db->ast->root->cl_head->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_constrain_perm_resolve_neg(CuTest *tc) {
        char *line[] = {"(", "sensitivity", "s0", ")",
			"(", "category", "c1", ")",
			"(", "level", "l2", "(", "s0", "(", "c1", ")", ")", ")",
			"(", "level", "h2", "(", "s0", "(", "c1", ")", ")", ")",
			"(", "mlsconstrain", "(", "file", "(", "foo", ")", ")", "(", "eq", "l2", "h2", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_constrain(test_db->ast->root->cl_head->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_context(CuTest *tc) {
	char *line[] = {"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "user", "system_u", ")",
			"(", "role", "object_r", ")",
			"(", "type", "netif_t", ")",
			"(", "context", "con",
                        "(", "system_u", "object_r", "netif_t", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	struct cil_context *test_context = (struct cil_context*)test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->data;

	int rc = cil_resolve_context(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, test_context, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_context_macro(CuTest *tc) {
	char *line[] = {"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "user", "system_u", ")",
			"(", "role", "object_r", ")",
			"(", "type", "netif_t", ")",
			"(", "macro", "mm", "(", "(", "levelrange", "range", ")", ")",
				"(", "context", "con",
					"(", "system_u", "object_r", "netif_t", "range", ")", ")", ")", 
			"(", "call", "mm", "(", "(", "(", "s0", "(", "c0", ")", ")", "(", "s0", "(", "c0", ")", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);
	
	struct cil_context *test_context = (struct cil_context*)test_db->ast->root->cl_head->next->next->next->next->next->next->next->cl_head->data;

	int rc2 = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	int rc3 = cil_resolve_call2(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);

	args->pass = CIL_PASS_MISC2;

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next, args);

	args->pass = CIL_PASS_MISC3;
	args->callstack = test_db->ast->root->cl_head->next->next->next->next->next->next->next->next;

	int rc = cil_resolve_context(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->cl_head, test_context,  args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, SEPOL_OK, rc2);
	CuAssertIntEquals(tc, SEPOL_OK, rc3);
}

void test_cil_resolve_context_macro_neg(CuTest *tc) {
	char *line[] = {"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "user", "system_u", ")",
			"(", "role", "object_r", ")",
			"(", "type", "netif_t", ")",
			"(", "macro", "mm", "(", "(", "levelrange", "range", ")", ")",
				"(", "context", "con",
					"(", "system_u", "object_r", "netif_t", "range", ")", ")", ")", 
			"(", "call", "mm", "(", "(", "(", "s0", "(", "c0", ")", ")", "(", "s0", "(", "DNE", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	struct cil_context *test_context = (struct cil_context*)test_db->ast->root->cl_head->next->next->next->next->next->next->next->cl_head->data;

	int rc2 = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	int rc3 = cil_resolve_call2(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next, args);

	args->pass = CIL_PASS_MISC3;
	args->callstack = test_db->ast->root->cl_head->next->next->next->next->next->next->next->next;

	int rc = cil_resolve_context(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->cl_head, test_context, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, SEPOL_OK, rc2);
	CuAssertIntEquals(tc, SEPOL_OK, rc3);
}

void test_cil_resolve_context_namedrange(CuTest *tc) {
	char *line[] = {"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "levelrange", "range", "(", "low", "high", ")", ")",
			"(", "user", "system_u", ")",
			"(", "role", "object_r", ")",
			"(", "type", "netif_t", ")",
			"(", "context", "con",
                        "(", "system_u", "object_r", "netif_t", "range", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	struct cil_context *test_context = (struct cil_context*)test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next->data;

	int rc = cil_resolve_context(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next, test_context, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_context_namedrange_neg(CuTest *tc) {
	char *line[] = {"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "levelrange", "range", "(", "low", "high", ")", ")",
			"(", "user", "system_u", ")",
			"(", "role", "object_r", ")",
			"(", "type", "netif_t", ")",
			"(", "context", "con",
                        "(", "system_u", "object_r", "netif_t", "DNE", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	struct cil_context *test_context = (struct cil_context*)test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next->data;

	int rc = cil_resolve_context(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next, test_context, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_context_user_neg(CuTest *tc) {
	char *line[] = {"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "role", "object_r", ")",
			"(", "type", "netif_t", ")",
			"(", "context", "con",
                        "(", "system_u", "object_r", "netif_t", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	struct cil_context *test_context = (struct cil_context*)test_db->ast->root->cl_head->next->next->next->next->next->next->next->data;

	int rc = cil_resolve_context(test_db->ast->root->cl_head->next->next->next->next->next->next->next, test_context, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_context_role_neg(CuTest *tc) {
	char *line[] = {"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "user", "system_u", ")",
			"(", "type", "netif_t", ")",
			"(", "context", "con",
                        "(", "system_u", "object_r", "netif_t", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	struct cil_context *test_context = (struct cil_context*)test_db->ast->root->cl_head->next->next->next->next->next->next->next->data;

	int rc = cil_resolve_context(test_db->ast->root->cl_head->next->next->next->next->next->next->next, test_context, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_context_type_neg(CuTest *tc) {
	char *line[] = {"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "user", "system_u", ")",
			"(", "role", "object_r", ")",
			"(", "context", "con",
                        "(", "system_u", "object_r", "netif_t", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	struct cil_context *test_context = (struct cil_context*)test_db->ast->root->cl_head->next->next->next->next->next->next->next->data;

	int rc = cil_resolve_context(test_db->ast->root->cl_head->next->next->next->next->next->next->next, test_context, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_context_anon_level_neg(CuTest *tc) {
	char *line[] = {"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "user", "system_u", ")",
			"(", "role", "object_r", ")",
			"(", "type", "netif_t", ")",
			"(", "context", "con",
                        "(", "system_u", "object_r", "netif_t", "(", "DNE", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next, args);

	args->pass = CIL_PASS_MISC3;

	struct cil_context *test_context = (struct cil_context*)test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->data;

	int rc = cil_resolve_context(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, test_context, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_roletransition(CuTest *tc) {
	char *line[] = {"(", "role", "foo_r", ")",
			"(", "type", "bar_t", ")",
			"(", "role", "foobar_r", ")",
			"(", "class", "process", "(", "transition", ")", ")",
			"(", "roletransition", "foo_r", "bar_t", "process", "foobar_r", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_roletransition(test_db->ast->root->cl_head->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_roletransition_srcdecl_neg(CuTest *tc) {
	char *line[] = {"(", "type", "bar_t", ")",
			"(", "role", "foobar_r", ")", 
			"(", "class", "process", "(", "transition", ")", ")",
			"(", "roletransition", "foo_r", "bar_t", "process", "foobar_r", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_roletransition(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_roletransition_tgtdecl_neg(CuTest *tc) {
	char *line[] = {"(", "role", "foo_r", ")",
			"(", "role", "foobar_r", ")", 
			"(", "class", "process", "(", "transition", ")", ")",
			"(", "roletransition", "foo_r", "bar_t", "process", "foobar_r", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_roletransition(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_roletransition_resultdecl_neg(CuTest *tc) {
	char *line[] = {"(", "role", "foo_r", ")",
			"(", "type", "bar_t", ")", 
			"(", "class", "process", "(", "transition", ")", ")",
			"(", "roletransition", "foo_r", "bar_t", "process", "foobar_r", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_roletransition(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_typeattributeset_type_in_multiple_attrs(CuTest *tc) {
	char *line[] = {"(", "typeattribute", "attrs", ")",
			"(", "typeattribute", "attrs2", ")",
			"(", "type", "type_t", ")",
			"(", "typeattributeset", "attrs2", "type_t", ")",
			"(", "typeattributeset", "attrs", "type_t", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	int rc = cil_resolve_typeattributeset(test_db->ast->root->cl_head->next->next->next->next, args);
	int rc2 = cil_resolve_typeattributeset(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, SEPOL_OK, rc2);
}

void test_cil_resolve_typeattributeset_multiple_excludes_with_not(CuTest *tc) {
	char *line[] = {"(", "typeattribute", "attrs", ")",
			"(", "typeattribute", "attrs2", ")",
			"(", "type", "type_t", ")",
			"(", "type", "type_b", ")",
			"(", "type", "type_a", ")",
			"(", "typeattributeset", "attrs", "(", "and", "type_a", "type_b", ")", ")", 
			"(", "typeattributeset", "attrs2", "(", "not", "attrs", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_typeattributeset(test_db->ast->root->cl_head->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_typeattributeset_multiple_types_with_and(CuTest *tc) {
	char *line[] = {"(", "typeattribute", "attrs", ")",
			"(", "type", "type_t", ")",
			"(", "type", "type_tt", ")",
			"(", "typeattributeset", "attrs", "(", "and", "type_t", "type_tt", ")", ")", NULL}; 

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_typeattributeset(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_typeattributeset_using_attr(CuTest *tc) {
	char *line[] = {"(", "typeattribute", "attrs", ")",
			"(", "typeattribute", "attr_a", ")",
			"(", "typeattributeset", "attrs", "attr_a", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_typeattributeset(test_db->ast->root->cl_head->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_typeattributeset_name_neg(CuTest *tc) {
	char *line[] = {"(", "type", "type_t", ")",
			"(", "typeattributeset", "attrs", "type_t", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_typeattributeset(test_db->ast->root->cl_head->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_typeattributeset_undef_type_neg(CuTest *tc) {
	char *line[] = {"(", "typeattribute", "attrs", ")",
			"(", "typeattributeset", "attrs", "type_t", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_typeattributeset(test_db->ast->root->cl_head->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_typeattributeset_not(CuTest *tc) {
	char *line[] = {"(", "typeattribute", "attrs", ")",
			"(", "type", "type_t", ")",
			"(", "type", "t_t", ")",
			"(", "typeattributeset", "attrs", "(", "not", "t_t", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	int rc = cil_resolve_typeattributeset(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_typeattributeset_undef_type_not_neg(CuTest *tc) {
	char *line[] = {"(", "typeattribute", "attrs", ")",
			"(", "type", "type_t", ")",
			"(", "typeattributeset", "attrs", "(", "not", "t_t", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	int rc = cil_resolve_typeattributeset(test_db->ast->root->cl_head->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_typealias(CuTest *tc) {
	char *line[] = {"(", "block", "foo", 
				"(", "typealias", ".foo.test", "type_t", ")", 
				"(", "type", "test", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_typealias(test_db->ast->root->cl_head->cl_head, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_typealias_neg(CuTest *tc) {
	char *line[] = {"(", "block", "foo", 
				"(", "typealias", ".foo", "apache_alias", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_typealias(test_db->ast->root->cl_head->cl_head, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_typebounds(CuTest *tc) {
	char *line[] = {"(", "type", "type_a", ")",
			"(", "type", "type_b", ")",
			"(", "typebounds", "type_a", "type_b", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_typebounds(test_db->ast->root->cl_head->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_typebounds_repeatbind_neg(CuTest *tc) {
	char *line[] = {"(", "type", "type_a", ")",
			"(", "type", "type_b", ")",
			"(", "typebounds", "type_a", "type_b", ")",
			"(", "typebounds", "type_a", "type_b", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_typebounds(test_db->ast->root->cl_head->next->next, args);
	int rc2 = cil_resolve_typebounds(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, SEPOL_ERR, rc2);
}

void test_cil_resolve_typebounds_type1_neg(CuTest *tc) {
	char *line[] = {"(", "type", "type_b", ")",
			"(", "typebounds", "type_a", "type_b", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_typebounds(test_db->ast->root->cl_head->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_typebounds_type2_neg(CuTest *tc) {
	char *line[] = {"(", "type", "type_a", ")",
			"(", "typebounds", "type_a", "type_b", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_typebounds(test_db->ast->root->cl_head->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_typepermissive(CuTest *tc) {
	char *line[] = {"(", "type", "type_a", ")",
			"(", "typepermissive", "type_a", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_typepermissive(test_db->ast->root->cl_head->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_typepermissive_neg(CuTest *tc) {
	char *line[] = {"(", "type", "type_a", ")",
			"(", "typepermissive", "type_b", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_typepermissive(test_db->ast->root->cl_head->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_nametypetransition(CuTest *tc) {
	char *line[] = {"(", "type", "foo", ")",
			"(", "type", "bar", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "type", "foobar", ")",
			"(", "nametypetransition", "str", "foo", "bar", "file", "foobar", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_nametypetransition(test_db->ast->root->cl_head->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_nametypetransition_src_neg(CuTest *tc) {
	char *line[] = {"(", "type", "foo", ")",
			"(", "type", "bar", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "type", "foobar", ")",
			"(", "nametypetransition", "str", "wrong", "bar", "file", "foobar", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_nametypetransition(test_db->ast->root->cl_head->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_nametypetransition_tgt_neg(CuTest *tc) {
	char *line[] = {"(", "type", "foo", ")",
			"(", "type", "bar", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "type", "foobar", ")",
			"(", "nametypetransition", "str", "foo", "wrong", "file", "foobar", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_nametypetransition(test_db->ast->root->cl_head->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_nametypetransition_class_neg(CuTest *tc) {
	char *line[] = {"(", "type", "foo", ")",
			"(", "type", "bar", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "type", "foobar", ")",
			"(", "nametypetransition", "str", "foo", "bar", "wrong", "foobar", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
 
	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_nametypetransition(test_db->ast->root->cl_head->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_nametypetransition_dest_neg(CuTest *tc) {
	char *line[] = {"(", "type", "foo", ")",
			"(", "type", "bar", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "type", "foobar", ")",
			"(", "nametypetransition", "str", "foo", "bar", "file", "wrong", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_nametypetransition(test_db->ast->root->cl_head->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_rangetransition(CuTest *tc) {
	char *line[] = {"(", "class", "class_", "(", "read", ")", ")",
			"(", "type", "type_a", ")",
			"(", "type", "type_b", ")",
			"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "rangetransition", "type_a", "type_b", "class_", "(", "low", "high", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_rangetransition(test_db->ast->root->cl_head->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_rangetransition_namedrange_anon(CuTest *tc) {
	char *line[] = {"(", "class", "class_", "(", "read", ")", ")",
			"(", "type", "type_a", ")",
			"(", "type", "type_b", ")",
			"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "macro", "mm", "(", "(", "levelrange", "l", ")", ")",
				"(", "rangetransition", "type_a", "type_b", "class_", "l", ")", ")",
			"(", "call", "mm", "(", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	int rc2 = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	int rc3 = cil_resolve_call2(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next, args);

	args->pass = CIL_PASS_MISC2;

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next->next->next->next, args);

	args->pass = CIL_PASS_MISC3;
	args->callstack = test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next;

	int rc = cil_resolve_rangetransition(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next->cl_head, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, SEPOL_OK, rc2);
	CuAssertIntEquals(tc, SEPOL_OK, rc3);
}

void test_cil_resolve_rangetransition_namedrange_anon_neg(CuTest *tc) {
	char *line[] = {"(", "class", "class_", "(", "read", ")", ")",
			"(", "type", "type_a", ")",
			"(", "type", "type_b", ")",
			"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "macro", "mm", "(", "(", "levelrange", "l", ")", ")",
				"(", "rangetransition", "type_a", "type_b", "class_", "l", ")", ")",
			"(", "call", "mm", "(", "(", "DNE", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	int rc2 = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	int rc3 = cil_resolve_call2(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next, args);

	args->pass = CIL_PASS_MISC2;

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next->next->next->next, args);

	args->pass = CIL_PASS_MISC3;
	args->callstack = test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next;

	int rc = cil_resolve_rangetransition(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next->cl_head,  args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, SEPOL_OK, rc2);
	CuAssertIntEquals(tc, SEPOL_OK, rc3);
}

void test_cil_resolve_rangetransition_namedrange(CuTest *tc) {
	char *line[] = {"(", "class", "class_", "(", "read", ")", ")",
			"(", "type", "type_a", ")",
			"(", "type", "type_b", ")",
			"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "levelrange", "foo_range", "(", "low", "high", ")", ")",
			"(", "rangetransition", "type_a", "type_b", "class_", "foo_range", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_rangetransition(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_rangetransition_namedrange_neg(CuTest *tc) {
	char *line[] = {"(", "class", "class_", "(", "read", ")", ")",
			"(", "type", "type_a", ")",
			"(", "type", "type_b", ")",
			"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "levelrange", "foo_range", "(", "low", "high", ")", ")",
			"(", "rangetransition", "type_a", "type_b", "class_", "DNE", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_rangetransition(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_rangetransition_type1_neg(CuTest *tc) {
	char *line[] = {"(", "class", "class_", "(", "read", ")", ")",
			"(", "type", "type_a", ")",
			"(", "type", "type_b", ")",
			"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "rangetransition", "type_DNE", "type_b", "class_", "(", "low", "high", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_rangetransition(test_db->ast->root->cl_head->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_rangetransition_type2_neg(CuTest *tc) {
	char *line[] = {"(", "class", "class_", "(", "read", ")", ")",
			"(", "type", "type_a", ")",
			"(", "type", "type_b", ")",
			"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "rangetransition", "type_a", "type_DNE", "class_", "(", "low", "high", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_rangetransition(test_db->ast->root->cl_head->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_rangetransition_class_neg(CuTest *tc) {
	char *line[] = {"(", "class", "class_", "(", "read", ")", ")",
			"(", "type", "type_a", ")",
			"(", "type", "type_b", ")",
			"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "rangetransition", "type_a", "type_b", "class_DNE", "(", "low", "high", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_rangetransition(test_db->ast->root->cl_head->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_rangetransition_call_level_l_anon(CuTest *tc) {
	char *line[] = {"(", "class", "class_", "(", "read", ")", ")",
			"(", "type", "type_a", ")",
			"(", "type", "type_b", ")",
			"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "macro", "mm", "(", "(", "level", "l", ")", ")",
				"(", "rangetransition", "type_a", "type_b", "class_", "(", "l", "high", ")", ")", ")",
			"(", "call", "mm", "(", "(", "s0", "(", "c0", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	int rc2 = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	int rc3 = cil_resolve_call2(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);

	args->pass = CIL_PASS_MISC2;

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next->next->next, args);

	args->pass = CIL_PASS_MISC3;
	args->callstack = test_db->ast->root->cl_head->next->next->next->next->next->next->next->next;

	int rc = cil_resolve_rangetransition(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->cl_head, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, SEPOL_OK, rc2);
	CuAssertIntEquals(tc, SEPOL_OK, rc3);
}

void test_cil_resolve_rangetransition_call_level_l_anon_neg(CuTest *tc) {
	char *line[] = {"(", "class", "class_", "(", "read", ")", ")",
			"(", "type", "type_a", ")",
			"(", "type", "type_b", ")",
			"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "macro", "mm", "(", "(", "level", "l", ")", ")",
				"(", "rangetransition", "type_a", "type_b", "class_", "(", "l", "high", ")", ")", ")",
			"(", "call", "mm", "(", "(", "s0", "(", "c4", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	int rc2 = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	int rc3 = cil_resolve_call2(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);

	args->pass = CIL_PASS_MISC2;

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next->next->next, args);

	args->pass = CIL_PASS_MISC3;
	args->callstack = test_db->ast->root->cl_head->next->next->next->next->next->next->next->next;

	int rc = cil_resolve_rangetransition(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->cl_head, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, SEPOL_OK, rc2);
	CuAssertIntEquals(tc, SEPOL_OK, rc3);
}

void test_cil_resolve_rangetransition_call_level_h_anon(CuTest *tc) {
	char *line[] = {"(", "class", "class_", "(", "read", ")", ")",
			"(", "type", "type_a", ")",
			"(", "type", "type_b", ")",
			"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "macro", "mm", "(", "(", "level", "h", ")", ")",
				"(", "rangetransition", "type_a", "type_b", "class_", "(", "low", "h", ")", ")", ")",
			"(", "call", "mm", "(", "(", "s0", "(", "c0", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	int rc2 = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	int rc3 = cil_resolve_call2(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);

	args->pass = CIL_PASS_MISC2;

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next->next->next, args);

	args->pass = CIL_PASS_MISC3;
	args->callstack = test_db->ast->root->cl_head->next->next->next->next->next->next->next->next;

	int rc = cil_resolve_rangetransition(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->cl_head, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, SEPOL_OK, rc2);
	CuAssertIntEquals(tc, SEPOL_OK, rc3);
}

void test_cil_resolve_rangetransition_call_level_h_anon_neg(CuTest *tc) {
	char *line[] = {"(", "class", "class_", "(", "read", ")", ")",
			"(", "type", "type_a", ")",
			"(", "type", "type_b", ")",
			"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "macro", "mm", "(", "(", "level", "h", ")", ")",
				"(", "rangetransition", "type_a", "type_b", "class_", "(", "low", "h", ")", ")", ")",
			"(", "call", "mm", "(", "(", "s0", "(", "c4", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	int rc2 = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	int rc3 = cil_resolve_call2(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);

	args->pass = CIL_PASS_MISC2;

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next->next->next, args);

	args->pass = CIL_PASS_MISC3;
	args->callstack = test_db->ast->root->cl_head->next->next->next->next->next->next->next->next;

	int rc = cil_resolve_rangetransition(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->cl_head, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, SEPOL_OK, rc2);
	CuAssertIntEquals(tc, SEPOL_OK, rc3);
}

void test_cil_resolve_rangetransition_level_l_neg(CuTest *tc) {
	char *line[] = {"(", "class", "class_", "(", "read", ")", ")",
			"(", "type", "type_a", ")",
			"(", "type", "type_b", ")",
			"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "rangetransition", "type_a", "type_b", "class_", "(", "low_DNE", "high", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_rangetransition(test_db->ast->root->cl_head->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_rangetransition_level_h_neg(CuTest *tc) {
	char *line[] = {"(", "class", "class_", "(", "read", ")", ")",
			"(", "type", "type_a", ")",
			"(", "type", "type_b", ")",
			"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "rangetransition", "type_a", "type_b", "class_", "(", "low", "high_DNE", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_rangetransition(test_db->ast->root->cl_head->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_rangetransition_anon_level_l(CuTest *tc) {
	char *line[] = {"(", "class", "class_", "(", "read", ")", ")",
			"(", "type", "type_a", ")",
			"(", "type", "type_b", ")",
			"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "rangetransition", "type_a", "type_b", "class_", "(", "(", "s0", "(", "c0", ")", ")", "high", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next->next->next, args);

	args->pass = CIL_PASS_MISC3;

	int rc = cil_resolve_rangetransition(test_db->ast->root->cl_head->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_rangetransition_anon_level_l_neg(CuTest *tc) {
	char *line[] = {"(", "class", "class_", "(", "read", ")", ")",
			"(", "type", "type_a", ")",
			"(", "type", "type_b", ")",
			"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "rangetransition", "type_a", "type_b", "class_", "(", "(", "s0", "(", "c_DNE", ")", ")", "high", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next->next->next, args);

	args->pass = CIL_PASS_MISC3;

	int rc = cil_resolve_rangetransition(test_db->ast->root->cl_head->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_rangetransition_anon_level_h(CuTest *tc) {
	char *line[] = {"(", "class", "class_", "(", "read", ")", ")",
			"(", "type", "type_a", ")",
			"(", "type", "type_b", ")",
			"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "rangetransition", "type_a", "type_b", "class_", "(", "low", "(", "s0", "(", "c0", ")",  ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next->next->next, args);

	args->pass = CIL_PASS_MISC3;

	int rc = cil_resolve_rangetransition(test_db->ast->root->cl_head->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_rangetransition_anon_level_h_neg(CuTest *tc) {
	char *line[] = {"(", "class", "class_", "(", "read", ")", ")",
			"(", "type", "type_a", ")",
			"(", "type", "type_b", ")",
			"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "rangetransition", "type_a", "type_b", "class_", "(", "low", "(", "s_DNE", "(", "c0", ")",  ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next->next->next, args);

	args->pass = CIL_PASS_MISC3;

	int rc = cil_resolve_rangetransition(test_db->ast->root->cl_head->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_classcommon(CuTest *tc) {
	char *line[] = {"(", "class", "file", "(", "read", ")", ")",
			"(", "common", "file", "(", "write", ")", ")",	
			"(", "classcommon", "file", "file", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_classcommon(test_db->ast->root->cl_head->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_classcommon_no_class_neg(CuTest *tc) {
	char *line[] = {"(", "class", "foo", "(", "read", ")", ")",
			"(", "classcommon", "foo", "foo", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_classcommon(test_db->ast->root->cl_head->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_classcommon_no_common_neg(CuTest *tc) {
	char *line[] = {"(", "common", "foo", "(", "read", ")", ")",
			"(", "classcommon", "foo", "foo", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_classcommon(test_db->ast->root->cl_head->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_classpermset_named(CuTest *tc) {
	char *line[] = {"(", "classmap", "files", "(", "read", ")", ")",
			"(", "class", "char", "(", "read", ")", ")",
			"(", "classpermissionset", "char_w", "(", "char", "(", "read", ")", ")", ")",
			"(", "classmapping", "files", "read", "char_w", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	struct cil_classpermset *cps = test_db->ast->root->cl_head->next->next->data;

	int rc = cil_resolve_classpermset(test_db->ast->root->cl_head->next->next->next, cps, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_classpermset_named_namedpermlist(CuTest *tc) {
	char *line[] = {"(", "classmap", "files", "(", "read", ")", ")",
			"(", "class", "char", "(", "read", ")", ")",
			"(", "classpermissionset", "char_w", "(", "char", "baz", ")", ")",
			"(", "permissionset", "baz", "(", "read", ")", ")",
			"(", "classmapping", "files", "read", "char_w", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	struct cil_classpermset *cps = test_db->ast->root->cl_head->next->next->data;

	int rc = cil_resolve_classpermset(test_db->ast->root->cl_head->next->next->next, cps, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_classpermset_named_permlist_neg(CuTest *tc) {
	char *line[] = {"(", "classmap", "files", "(", "read", ")", ")",
			"(", "class", "char", "(", "read", ")", ")",
			"(", "classpermissionset", "char_w", "(", "dne", "(", "read", ")", ")", ")",
			"(", "classmapping", "files", "read", "char_w", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	struct cil_classpermset *cps = test_db->ast->root->cl_head->next->next->data;

	int rc = cil_resolve_classpermset(test_db->ast->root->cl_head->next->next->next, cps, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_classpermset_named_unnamedcps_neg(CuTest *tc) {
	char *line[] = {"(", "classmap", "files", "(", "read", ")", ")",
			"(", "class", "char", "(", "read", ")", ")",
			"(", "classpermissionset", "char_w", "(", "char", "(", "read", ")", ")", ")",
			"(", "classmapping", "files", "read", "char_w", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	struct cil_classpermset *cps;
	cil_classpermset_init(&cps);

	int rc = cil_resolve_classpermset(test_db->ast->root->cl_head->next->next->next, cps, args);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
}

void test_cil_resolve_classpermset_anon(CuTest *tc) {
	char *line[] = {"(", "classmap", "files", "(", "read", ")", ")",
			"(", "classmapping", "files", "read", "(", "char", "(", "read", ")", ")", ")", 
			"(", "class", "char", "(", "read", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	struct cil_classpermset *cps = ((struct cil_classmapping*)test_db->ast->root->cl_head->next->data)->classpermsets_str->head->data;

	int rc = cil_resolve_classpermset(test_db->ast->root->cl_head->next, cps, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_classpermset_anon_namedpermlist(CuTest *tc) {
	char *line[] = {"(", "classmap", "files", "(", "read", ")", ")",
			"(", "classmapping", "files", "read", "(", "char", "baz", ")", ")",
			"(", "permissionset", "baz", "(", "read", ")", ")",
			"(", "class", "char", "(", "read", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	struct cil_classpermset *cps = ((struct cil_classmapping*)test_db->ast->root->cl_head->next->data)->classpermsets_str->head->data;

	int rc = cil_resolve_classpermset(test_db->ast->root->cl_head->next, cps, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_classpermset_anon_permlist_neg(CuTest *tc) {
	char *line[] = {"(", "classmap", "files", "(", "read", ")", ")",
			"(", "classmapping", "files", "read", "(", "char", "(", "dne", ")", ")", ")", 
			"(", "class", "char", "(", "read", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	struct cil_classpermset *cps = ((struct cil_classmapping*)test_db->ast->root->cl_head->next->data)->classpermsets_str->head->data;

	int rc = cil_resolve_classpermset(test_db->ast->root->cl_head->next, cps, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_avrule(CuTest *tc) {
	char *line[] = {"(", "class", "bar", "(", "read", "write", "open", ")", ")", 
	                "(", "type", "test", ")", 
			"(", "type", "foo", ")", 
	                "(", "allow", "test", "foo", "(", "bar", "(", "read", "write", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_avrule(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_avrule_permset(CuTest *tc) {
	char *line[] = {"(", "class", "bar", "(", "read", "write", "open", ")", ")", 
	                "(", "type", "test", ")", 
			"(", "type", "foo", ")",
			"(", "permissionset", "baz", "(", "open", "write", ")", ")",
	                "(", "allow", "test", "foo", "(", "bar", "baz", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_avrule(test_db->ast->root->cl_head->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_avrule_permset_neg(CuTest *tc) {
	char *line[] = {"(", "class", "bar", "(", "read", "write", "open", ")", ")", 
	                "(", "type", "test", ")", 
			"(", "type", "foo", ")",
			"(", "permissionset", "baz", "(", "open", "close", ")", ")",
	                "(", "allow", "test", "foo", "(", "bar", "dne", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_avrule(test_db->ast->root->cl_head->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_avrule_permset_permdne_neg(CuTest *tc) {
	char *line[] = {"(", "class", "bar", "(", "read", "write", "open", ")", ")", 
	                "(", "type", "test", ")", 
			"(", "type", "foo", ")",
			"(", "permissionset", "baz", "(", "open", "dne", ")", ")",
	                "(", "allow", "test", "foo", "(", "bar", "baz", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_avrule(test_db->ast->root->cl_head->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_avrule_firsttype_neg(CuTest *tc) {
	char *line[] = {"(", "class", "bar", "(", "read", "write", "open", ")", ")", 
	                "(", "type", "test", ")", 
			"(", "type", "foo", ")", 
	                "(", "allow", "fail1", "foo", "(", "bar", "(", "read", "write", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_avrule(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_avrule_secondtype_neg(CuTest *tc) {
	char *line[] = {"(", "class", "bar", "(", "read", "write", "open", ")", ")", 
	                "(", "type", "test", ")", 
			"(", "type", "foo", ")", 
	                "(", "allow", "test", "fail2", "(", "bar", "(", "read", "write", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_avrule(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_avrule_class_neg(CuTest *tc) {
	char *line[] = {"(", "class", "bar", "(", "read", "write", "open", ")", ")", 
	                "(", "type", "test", ")", 
			"(", "type", "foo", ")", 
	                "(", "allow", "test", "foo", "(", "fail3", "(", "read", "write", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_avrule(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_avrule_perm_neg(CuTest *tc) {
	char *line[] = {"(", "class", "bar", "(", "read", "write", "open", ")", ")", 
	                "(", "type", "test", ")", 
			"(", "type", "foo", ")", 
	                "(", "allow", "test", "foo", "(", "bar", "(", "execute", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_avrule(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_type_rule_transition(CuTest *tc) {
	char *line[] = {"(", "type", "foo", ")",
			"(", "type", "bar", ")",
			"(", "class", "file", "(", "write", ")", ")",
			"(", "type", "foobar", ")", 
			"(", "typetransition", "foo", "bar", "file", "foobar", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_type_rule(test_db->ast->root->cl_head->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_type_rule_transition_srcdecl_neg(CuTest *tc) {
	char *line[] = {"(", "type", "bar", ")",
			"(", "class", "file", "(", "write", ")", ")",
			"(", "type", "foobar", ")", 
			"(", "typetransition", "foo", "bar", "file", "foobar", ")", NULL};
	
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_type_rule(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_type_rule_transition_tgtdecl_neg(CuTest *tc) {
	char *line[] = {"(", "type", "foo", ")",
			"(", "class", "file", "(", "write", ")", ")",
			"(", "type", "foobar", ")", 
			"(", "typetransition", "foo", "bar", "file", "foobar", ")", NULL};
	
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_type_rule(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_type_rule_transition_objdecl_neg(CuTest *tc) {
	char *line[] = {"(", "type", "foo", ")",
			"(", "type", "bar", ")",
			"(", "type", "foobar", ")", 
			"(", "typetransition", "foo", "bar", "file", "foobar", ")", NULL};
	
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_type_rule(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_type_rule_transition_resultdecl_neg(CuTest *tc) {
	char *line[] = {"(", "type", "foo", ")",
			"(", "type", "bar", ")",
			"(", "class", "file", "(", "write", ")", ")",
			"(", "typetransition", "foo", "bar", "file", "foobar", ")", NULL};
	
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_type_rule(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_type_rule_change(CuTest *tc) {
	char *line[] = {"(", "type", "foo", ")",
			"(", "type", "bar", ")",
			"(", "class", "file", "(", "write", ")", ")",
			"(", "type", "foobar", ")", 
			"(", "typechange", "foo", "bar", "file", "foobar", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_type_rule(test_db->ast->root->cl_head->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_type_rule_change_srcdecl_neg(CuTest *tc) {
	char *line[] = {"(", "type", "bar", ")",
			"(", "class", "file", "(", "write", ")", ")",
			"(", "type", "foobar", ")", 
			"(", "typechange", "foo", "bar", "file", "foobar", ")", NULL};
	
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_type_rule(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_type_rule_change_tgtdecl_neg(CuTest *tc) {
	char *line[] = {"(", "type", "foo", ")",
			"(", "class", "file", "(", "write", ")", ")",
			"(", "type", "foobar", ")", 
			"(", "typechange", "foo", "bar", "file", "foobar", ")", NULL};
	
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_type_rule(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_type_rule_change_objdecl_neg(CuTest *tc) {
	char *line[] = {"(", "type", "foo", ")",
			"(", "type", "bar", ")",
			"(", "type", "foobar", ")", 
			"(", "typechange", "foo", "bar", "file", "foobar", ")", NULL};
	
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_type_rule(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_type_rule_change_resultdecl_neg(CuTest *tc) {
	char *line[] = {"(", "type", "foo", ")",
			"(", "type", "bar", ")",
			"(", "class", "file", "(", "write", ")", ")",
			"(", "typechange", "foo", "bar", "file", "foobar", ")", NULL};
	
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_type_rule(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_type_rule_member(CuTest *tc) {
	char *line[] = {"(", "type", "foo", ")",
			"(", "type", "bar", ")",
			"(", "class", "file", "(", "write", ")", ")",
			"(", "type", "foobar", ")", 
			"(", "typemember", "foo", "bar", "file", "foobar", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_type_rule(test_db->ast->root->cl_head->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_type_rule_member_srcdecl_neg(CuTest *tc) {
	char *line[] = {"(", "type", "bar", ")",
			"(", "class", "file", "(", "write", ")", ")",
			"(", "type", "foobar", ")", 
			"(", "typemember", "foo", "bar", "file", "foobar", ")", NULL};
	
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_type_rule(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_type_rule_member_tgtdecl_neg(CuTest *tc) {
	char *line[] = {"(", "type", "foo", ")",
			"(", "class", "file", "(", "write", ")", ")",
			"(", "type", "foobar", ")", 
			"(", "typemember", "foo", "bar", "file", "foobar", ")", NULL};
	
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_type_rule(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_type_rule_member_objdecl_neg(CuTest *tc) {
	char *line[] = {"(", "type", "foo", ")",
			"(", "type", "bar", ")",
			"(", "type", "foobar", ")", 
			"(", "typemember", "foo", "bar", "file", "foobar", ")", NULL};
	
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_type_rule(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_type_rule_member_resultdecl_neg(CuTest *tc) {
	char *line[] = {"(", "type", "foo", ")",
			"(", "type", "bar", ")",
			"(", "class", "file", "(", "write", ")", ")",
			"(", "typemember", "foo", "bar", "file", "foobar", ")", NULL};
	
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_type_rule(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_filecon(CuTest *tc) {
	char *line[] = {"(", "user", "user_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "context", "con", "(", "user_u", "role_r", "type_t", "(", "low", "high", ")", ")", ")",
			"(", "filecon", "root", "path", "file", "con", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_filecon(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_filecon_neg(CuTest *tc) {
	char *line[] = {"(", "user", "user_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "context", "con", "(", "user_u", "role_r", "type_t", "(", "low", "high", ")", ")", ")",
			"(", "filecon", "root", "path", "file", "conn", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_filecon(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_filecon_anon_context(CuTest *tc) {
	char *line[] = {"(", "user", "user_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "filecon", "root", "path", "file", "(", "user_u", "role_r", "type_t", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_filecon(test_db->ast->root->cl_head->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_filecon_anon_context_neg(CuTest *tc) {
	char *line[] = {"(", "user", "system_u", ")",
			"(", "type", "type_t", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "filecon", "root", "path", "file", "(", "user_u", "role_r", "type_t", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	int rc = cil_resolve_filecon(test_db->ast->root->cl_head->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_portcon(CuTest *tc) {
	char *line[] = {"(", "user", "user_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "context", "con", "(", "user_u", "role_r", "type_t", "(", "low", "high", ")", ")", ")",
			"(", "portcon", "udp", "25", "con", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_portcon(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_portcon_neg(CuTest *tc) {
	char *line[] = {"(", "user", "user_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "context", "con", "(", "user_u", "role_r", "type_t", "(", "low", "high", ")", ")", ")",
			"(", "portcon", "udp", "25", "conn", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_portcon(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_portcon_anon_context(CuTest *tc) {
	char *line[] = {"(", "user", "user_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "portcon", "udp", "25", "(", "user_u", "role_r", "type_t", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_portcon(test_db->ast->root->cl_head->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_portcon_anon_context_neg(CuTest *tc) {
	char *line[] = {"(", "user", "system_u", ")",
			"(", "type", "type_t", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "portcon", "udp", "25", "(", "user_u", "role_r", "type_t", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_portcon(test_db->ast->root->cl_head->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_genfscon(CuTest *tc) {
	char *line[] = {"(", "user", "user_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "context", "con", "(", "user_u", "role_r", "type_t", "(", "low", "high", ")", ")", ")",
			"(", "genfscon", "type", "path", "con", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_genfscon(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_genfscon_neg(CuTest *tc) {
	char *line[] = {"(", "user", "user_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "context", "con", "(", "user_u", "role_r", "type_t", "(", "low", "high", ")", ")", ")",
			"(", "genfscon", "type", "path", "conn", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_genfscon(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_genfscon_anon_context(CuTest *tc) {
	char *line[] = {"(", "user", "user_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "genfscon", "type", "path", "(", "user_u", "role_r", "type_t", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_genfscon(test_db->ast->root->cl_head->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_genfscon_anon_context_neg(CuTest *tc) {
	char *line[] = {"(", "user", "system_u", ")",
			"(", "type", "type_t", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "genfscon", "type", "path", "(", "user_u", "role_r", "type_t", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_genfscon(test_db->ast->root->cl_head->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_nodecon_ipv4(CuTest *tc) {
	char *line[] = {"(", "user", "user_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "context", "con", "(", "user_u", "role_r", "type_t", "(", "low", "high", ")", ")", ")",
			"(", "ipaddr", "ip", "192.168.1.1", ")",
			"(", "ipaddr", "netmask", "192.168.1.1", ")",
			"(", "nodecon", "ip", "netmask", "con", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_nodecon(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_nodecon_ipv6(CuTest *tc) {
	char *line[] = {"(", "user", "user_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "context", "con", "(", "user_u", "role_r", "type_t", "(", "low", "high", ")", ")", ")",
			"(", "ipaddr", "ip", "2001:0DB8:AC10:FE01::", ")",
			"(", "ipaddr", "netmask", "2001:0DB8:AC10:FE01::", ")",
			"(", "nodecon", "ip", "netmask", "con", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_nodecon(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_nodecon_anonipaddr_ipv4(CuTest *tc) {
	char *line[] = {"(", "user", "user_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "context", "con", "(", "user_u", "role_r", "type_t", "(", "low", "high", ")", ")", ")",
			"(", "ipaddr", "netmask", "192.168.1.1", ")",
			"(", "nodecon", "(", "192.168.1.1", ")", "netmask", "con", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_nodecon(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_nodecon_anonnetmask_ipv4(CuTest *tc) {
	char *line[] = {"(", "user", "user_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "context", "con", "(", "user_u", "role_r", "type_t", "(", "low", "high", ")", ")", ")",
			"(", "ipaddr", "ip", "192.168.1.1", ")",
			"(", "nodecon", "ip", "(", "192.168.1.1", ")", "con", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_nodecon(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_nodecon_anonipaddr_ipv6(CuTest *tc) {
	char *line[] = {"(", "user", "user_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "context", "con", "(", "user_u", "role_r", "type_t", "(", "low", "high", ")", ")", ")",
			"(", "ipaddr", "netmask", "2001:0DB8:AC10:FE01::", ")",
			"(", "nodecon", "(", "2001:0DB8:AC10:FE01::", ")", "netmask", "con", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_nodecon(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_nodecon_anonnetmask_ipv6(CuTest *tc) {
	char *line[] = {"(", "user", "user_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "context", "con", "(", "user_u", "role_r", "type_t", "(", "low", "high", ")", ")", ")",
			"(", "ipaddr", "ip", "2001:0DB8:AC10:FE01::", ")",
			"(", "nodecon", "ip", "(", "2001:0DB8:AC10:FE01::", ")", "con", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_nodecon(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_nodecon_diffipfam_neg(CuTest *tc) {
	char *line[] = {"(", "user", "user_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "context", "con", "(", "user_u", "role_r", "type_t", "(", "low", "high", ")", ")", ")",
			"(", "ipaddr", "ip", "2001:0DB8:AC10:FE01::", ")",
			"(", "nodecon", "ip", "(", "192.168.1.1", ")", "con", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_nodecon(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
}

void test_cil_resolve_nodecon_context_neg(CuTest *tc) {
	char *line[] = {"(", "user", "user_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "context", "con", "(", "user_u", "role_r", "type_t", "(", "low", "high", ")", ")", ")",
			"(", "ipaddr", "ip", "192.168.1.1", ")",
			"(", "ipaddr", "netmask", "192.168.1.1", ")",
			"(", "nodecon", "n", "netmask", "con", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_nodecon(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_nodecon_ipaddr_neg(CuTest *tc) {
	char *line[] = {"(", "user", "user_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "context", "con", "(", "user_u", "role_r", "type_t", "(", "low", "high", ")", ")", ")",
			"(", "ipaddr", "ip", "192.168.1.1", ")",
			"(", "ipaddr", "netmask", "192.168.1.1", ")",
			"(", "nodecon", "ip", "n", "con", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_nodecon(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_nodecon_netmask_neg(CuTest *tc) {
	char *line[] = {"(", "user", "user_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "context", "con", "(", "user_u", "role_r", "type_t", "(", "low", "high", ")", ")", ")",
			"(", "ipaddr", "ip", "192.168.1.1", ")",
			"(", "nodecon", "ip", "ip", "conn", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_nodecon(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_nodecon_anon_context(CuTest *tc) {
	char *line[] = {"(", "user", "user_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "ipaddr", "ip", "192.168.1.1", ")",
			"(", "nodecon", "ip", "ip", "(", "user_u", "role_r", "type_t", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_nodecon(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_nodecon_anon_context_neg(CuTest *tc) {
	char *line[] = {"(", "user", "system_u", ")",
			"(", "type", "type_t", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "ipaddr", "ip", "192.168.1.1", ")",
			"(", "nodecon", "ip", "ip", "(", "user_u", "role_r", "type_t", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_nodecon(test_db->ast->root->cl_head->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_netifcon(CuTest *tc) {
	char *line[] = {"(", "context", "if_default", "(", "system_u", "object_r", "etc_t", "(", "low", "high", ")", ")", ")",
			"(", "context", "packet_default", "(", "system_u", "object_r", "etc_t", "(", "low", "high", ")", ")", ")", 
			"(", "netifcon", "eth0", "if_default", "packet_default", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_netifcon(test_db->ast->root->cl_head->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_netifcon_otf_neg(CuTest *tc) {
	char *line[] = {"(", "context", "if_default", "(", "system_u", "object_r", "etc_t", "(", "low", "high", ")", ")", ")",
			"(", "netifcon", "eth0", "if_default", "packet_default", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_netifcon(test_db->ast->root->cl_head->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_netifcon_interface_neg(CuTest *tc) {
	char *line[] = {"(", "context", "packet_default", "(", "system_u", "object_r", "etc_t", "(", "low", "high", ")", ")", ")", 
			"(", "netifcon", "eth0", "if_default", "packet_default", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_netifcon(test_db->ast->root->cl_head->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_netifcon_unnamed(CuTest *tc) {
	char *line[] = {"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")", 
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "user", "system_u", ")",
			"(", "role", "object_r", ")",
			"(", "type", "netif_t", ")",
			"(", "netifcon", "eth1",
                        "(", "system_u", "object_r", "netif_t", "(", "low", "high", ")", ")",
                        "(", "system_u", "object_r", "netif_t", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_netifcon(test_db->ast->root->cl_head->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_netifcon_unnamed_packet_neg(CuTest *tc) {
	char *line[] = {"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")", 
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "role", "object_r", ")",
			"(", "type", "netif_t", ")",
			"(", "netifcon", "eth1",
                        "(", "system_u", "object_r", "netif_t", "(", "low", "high", ")", ")",
                        "(", "system_u", "object_r", "netif_t", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_netifcon(test_db->ast->root->cl_head->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_netifcon_unnamed_otf_neg(CuTest *tc) {
	char *line[] = {"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")", 
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "user", "system_u", ")",
			"(", "role", "object_r", ")",
			"(", "type", "netif_t", ")",
			"(", "netifcon", "eth1",
                        "(", "system_u", "object_r", "netif_t", "(", "low", "high", ")", ")", 
                        "(", "system_u", "foo_r", "netif_t", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_netifcon(test_db->ast->root->cl_head->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_netifcon_sublist_secondlist_missing_neg(CuTest *tc) {
	char *line[] = {"(", "netifcon", "eth1",
                        "(", "system_u", "object_r", "netif_t", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_netifcon(test_db->ast->root->cl_head, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_pirqcon(CuTest *tc) {
	char *line[] = {"(", "context", "con", "(", "system_u", "object_r", "etc_t", "(", "low", "high", ")", ")", ")",
			"(", "pirqcon", "1", "con", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_pirqcon(test_db->ast->root->cl_head->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_pirqcon_context_neg(CuTest *tc) {
	char *line[] = {"(", "context", "con", "(", "system_u", "object_r", "etc_t", "(", "low", "high", ")", ")", ")",
			"(", "pirqcon", "1", "dne", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_pirqcon(test_db->ast->root->cl_head->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_pirqcon_anon_context(CuTest *tc) {
	char *line[] = {"(", "user", "system_u", ")",
			"(", "role", "object_r", ")",
			"(", "type", "etc_t", ")",
			"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "pirqcon", "1", "(", "system_u", "object_r", "etc_t", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next->next->next, args);

	args->pass = CIL_PASS_MISC3;

	int rc = cil_resolve_pirqcon(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_pirqcon_anon_context_neg(CuTest *tc) {
	char *line[] = {"(", "pirqcon", "1", "(", "system_u", "object_r", "etc_t", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_pirqcon(test_db->ast->root->cl_head, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_iomemcon(CuTest *tc) {
	char *line[] = {"(", "context", "con", "(", "system_u", "object_r", "etc_t", "(", "low", "high", ")", ")", ")",
			"(", "iomemcon", "1", "con", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_iomemcon(test_db->ast->root->cl_head->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_iomemcon_context_neg(CuTest *tc) {
	char *line[] = {"(", "context", "con", "(", "system_u", "object_r", "etc_t", "(", "low", "high", ")", ")", ")",
			"(", "iomemcon", "1", "dne", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_iomemcon(test_db->ast->root->cl_head->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_iomemcon_anon_context(CuTest *tc) {
	char *line[] = {"(", "user", "system_u", ")",
			"(", "role", "object_r", ")",
			"(", "type", "etc_t", ")",
			"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "iomemcon", "1", "(", "system_u", "object_r", "etc_t", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next->next->next, args);

	args->pass = CIL_PASS_MISC3;

	int rc = cil_resolve_iomemcon(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_iomemcon_anon_context_neg(CuTest *tc) {
	char *line[] = {"(", "iomemcon", "1", "(", "system_u", "object_r", "etc_t", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_iomemcon(test_db->ast->root->cl_head, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_ioportcon(CuTest *tc) {
	char *line[] = {"(", "context", "con", "(", "system_u", "object_r", "etc_t", "(", "low", "high", ")", ")", ")",
			"(", "ioportcon", "1", "con", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_ioportcon(test_db->ast->root->cl_head->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_ioportcon_context_neg(CuTest *tc) {
	char *line[] = {"(", "context", "con", "(", "system_u", "object_r", "etc_t", "(", "low", "high", ")", ")", ")",
			"(", "ioportcon", "1", "dne", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_ioportcon(test_db->ast->root->cl_head->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_ioportcon_anon_context(CuTest *tc) {
	char *line[] = {"(", "user", "system_u", ")",
			"(", "role", "object_r", ")",
			"(", "type", "etc_t", ")",
			"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "ioportcon", "1", "(", "system_u", "object_r", "etc_t", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next->next->next, args);

	args->pass = CIL_PASS_MISC3;

	int rc = cil_resolve_ioportcon(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_ioportcon_anon_context_neg(CuTest *tc) {
	char *line[] = {"(", "ioportcon", "1", "(", "system_u", "object_r", "etc_t", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_ioportcon(test_db->ast->root->cl_head, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_pcidevicecon(CuTest *tc) {
	char *line[] = {"(", "context", "con", "(", "system_u", "object_r", "etc_t", "(", "low", "high", ")", ")", ")",
			"(", "pcidevicecon", "1", "con", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_pcidevicecon(test_db->ast->root->cl_head->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_pcidevicecon_context_neg(CuTest *tc) {
	char *line[] = {"(", "context", "con", "(", "system_u", "object_r", "etc_t", "(", "low", "high", ")", ")", ")",
			"(", "pcidevicecon", "1", "dne", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_pcidevicecon(test_db->ast->root->cl_head->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_pcidevicecon_anon_context(CuTest *tc) {
	char *line[] = {"(", "user", "system_u", ")",
			"(", "role", "object_r", ")",
			"(", "type", "etc_t", ")",
			"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "pcidevicecon", "1", "(", "system_u", "object_r", "etc_t", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next->next->next, args);

	args->pass = CIL_PASS_MISC3;

	int rc = cil_resolve_pcidevicecon(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_pcidevicecon_anon_context_neg(CuTest *tc) {
	char *line[] = {"(", "pcidevicecon", "1", "(", "system_u", "object_r", "etc_t", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_pcidevicecon(test_db->ast->root->cl_head, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_fsuse(CuTest *tc) {
	char *line[] = {"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "user", "system_u", ")",
			"(", "role", "object_r", ")",
			"(", "type", "netif_t", ")",
			"(", "context", "con", "(", "system_u", "object_r", "netif_t", "(", "low", "high", ")", ")", ")",
			"(", "fsuse", "xattr", "ext3", "con", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_fsuse(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_fsuse_nocontext_neg(CuTest *tc) {
	char *line[] = {"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "user", "system_u", ")",
			"(", "role", "object_r", ")",
			"(", "type", "netif_t", ")",
			"(", "context", "con", "(", "system_u", "object_r", "netif_t", "(", "low", "high", ")", ")", ")",
			"(", "fsuse", "xattr", "ext3", "(", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_fsuse(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
}

void test_cil_resolve_fsuse_neg(CuTest *tc) {
	char *line[] = {"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "user", "system_u", ")",
			"(", "role", "object_r", ")",
			"(", "type", "netif_t", ")",
			"(", "context", "con", "(", "system_u", "object_r", "netif_t", "(", "low", "high", ")", ")", ")",
			"(", "fsuse", "xattr", "ext3", "conn", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_fsuse(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_fsuse_anon(CuTest *tc) {
	char *line[] = {"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "user", "system_u", ")",
			"(", "role", "object_r", ")",
			"(", "type", "netif_t", ")",
			"(", "fsuse", "xattr", "ext3", "(", "system_u", "object_r", "netif_t", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_fsuse(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_fsuse_anon_neg(CuTest *tc) {
	char *line[] = {"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "user", "system_u", ")",
			"(", "role", "object_r", ")",
			"(", "type", "netif_t", ")",
			"(", "fsuse", "xattr", "ext3", "(", "system_uu", "object_r", "netif_t", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_fsuse(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_sidcontext(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "categoryorder", "(", "c0", ")", ")",
			"(", "sensitivity", "s0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "type", "blah_t", ")",
			"(", "role", "blah_r", ")",
			"(", "user", "blah_u", ")",
			"(", "sid", "test", ")",
			"(", "sidcontext", "test", "(", "blah_u", "blah_r", "blah_t", "(", "(", "s0", "(", "c0", ")", ")", "(", "s0", "(", "c0", ")", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_MISC3;
	
	int rc = cil_resolve_sidcontext(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_sidcontext_named_levels(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "categoryorder", "(", "c0", ")", ")",
			"(", "sensitivity", "s0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "type", "blah_t", ")",
			"(", "role", "blah_r", ")",
			"(", "user", "blah_u", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "sid", "test", ")",
			"(", "sidcontext", "test", "(", "blah_u", "blah_r", "blah_t", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_MISC3;

	struct cil_tree_node *level = test_db->ast->root->cl_head->next->next->next->next->next->next->next;
	cil_resolve_level(level, (struct cil_level*)level->data, args);
	cil_resolve_level(level->next, (struct cil_level*)level->next->data, args);
	int rc = cil_resolve_sidcontext(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_sidcontext_named_context(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "categoryorder", "(", "c0", ")", ")",
			"(", "sensitivity", "s0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "type", "blah_t", ")",
			"(", "role", "blah_r", ")",
			"(", "user", "blah_u", ")",
			"(", "context", "con", "(", "blah_u", "blah_r", "blah_t", "(", "(", "s0", "(", "c0", ")", ")", "(", "s0", "(", "c0", ")", ")", ")", ")", ")",
			"(", "sid", "test", ")",
			"(", "sidcontext", "test", "con", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_MISC3;

	struct cil_tree_node *context = test_db->ast->root->cl_head->next->next->next->next->next->next->next;
	cil_resolve_context(context, (struct cil_context*)context->data, args);

	int rc = cil_resolve_sidcontext(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_sidcontext_named_context_wrongname_neg(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "categoryorder", "(", "c0", ")", ")",
			"(", "sensitivity", "s0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "type", "blah_t", ")",
			"(", "role", "blah_r", ")",
			"(", "user", "blah_u", ")",
			"(", "context", "con", "(", "blah_u", "blah_r", "blah_t", "(", "(", "s0", "(", "c0", ")", ")", "(", "s0", "(", "c0", ")", ")", ")", ")", ")",
			"(", "sid", "test", ")",
			"(", "sidcontext", "test", "foo", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_MISC3;

	struct cil_tree_node *context = test_db->ast->root->cl_head->next->next->next->next->next->next->next;
	cil_resolve_context(context, (struct cil_context*)context->data, args);
	
	int rc = cil_resolve_sidcontext(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_sidcontext_named_context_invaliduser_neg(CuTest *tc) {
           char *line[] = {"(", "category", "c0", ")",
                        "(", "categoryorder", "(", "c0", ")", ")",
                        "(", "sensitivity", "s0", ")",
                        "(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
                        "(", "type", "blah_t", ")",
                        "(", "role", "blah_r", ")",
                        "(", "user", "blah_u", ")",
			"(", "sid", "test", ")",
                        "(", "sidcontext", "test", "(", "", "blah_r", "blah_t", "(", "(", "s0", "(", "c0", ")", ")", "(", "s0", "(", "c0", ")", ")", ")", ")", ")", NULL};

        struct cil_tree *test_tree;
        gen_test_tree(&test_tree, line);

        struct cil_db *test_db;
        cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

        cil_build_ast(test_db, test_tree->root, test_db->ast->root);

        cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next, args);

        int rc = cil_resolve_sidcontext(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);
        CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_blockinherit(CuTest *tc) {
	char *line[] = {"(", "block", "baz", "(", "type", "b", ")", ")",
			"(", "block", "foo", "(", "type", "a", ")", 
				"(", "blockinherit", "baz", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_blockinherit(test_db->ast->root->cl_head->next->cl_head->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_blockinherit_blockstrdne_neg(CuTest *tc) {
	char *line[] = {"(", "block", "baz", "(", "type", "b", ")", ")",
			"(", "block", "foo", "(", "type", "a", ")", 
				"(", "blockinherit", "dne", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_blockinherit(test_db->ast->root->cl_head->next->cl_head->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_in_block(CuTest *tc) {
	char *line[] = {"(", "class", "char", "(", "read", ")", ")",
			"(", "block", "foo", "(", "type", "a", ")", ")",
			"(", "in", "foo", "(", "allow", "test", "baz", "(", "char", "(", "read", ")", ")", ")", ")", NULL}; 

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_in(test_db->ast->root->cl_head->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_in_blockstrdne_neg(CuTest *tc) {
	char *line[] = {"(", "class", "char", "(", "read", ")", ")",
			"(", "in", "foo", "(", "allow", "test", "baz", "(", "char", "(", "read", ")", ")", ")", ")", NULL}; 

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_in(test_db->ast->root->cl_head->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_in_macro(CuTest *tc) {
	char *line[] = {"(", "class", "char", "(", "read", "write", ")", ")",
			"(", "macro", "mm", "(", "(", "class", "a", ")", ")", 
				"(", "allow", "foo", "bar", "(", "file", "(", "write", ")", ")", ")", ")",
			"(", "in", "mm", "(", "allow", "test", "baz", "(", "char", "(", "read", ")", ")", ")", ")", NULL}; 

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_in(test_db->ast->root->cl_head->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_in_optional(CuTest *tc) {
	char *line[] = {"(", "class", "char", "(", "read", "write", ")", ")",
			"(", "optional", "opt", "(", "allow", "foo", "bar", "(", "baz", "(", "read", ")", ")", ")", ")",
			"(", "in", "opt", "(", "allow", "test", "baz", "(", "char", "(", "read", ")", ")", ")", ")", NULL}; 

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_in(test_db->ast->root->cl_head->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_call1_noparam(CuTest *tc) {
	char *line[] = {"(", "type", "qaz", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "macro", "mm", "(", "(", "type", ")", ")",
				"(", "type", "b", ")",
				"(", "allow", "qaz", "b", "file", "(", "read", ")", ")", ")",
			"(", "call", "mm", "(", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_call1_type(CuTest *tc) {
	char *line[] = {"(", "type", "qaz", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "macro", "mm", "(", "(", "type", "a", ")", ")",
				"(", "type", "b", ")",
				"(", "allow", "a", "b", "(", "file", "(", "read", ")", ")", ")", ")",
			"(", "call", "mm", "(", "qaz", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_call1_role(CuTest *tc) {
	char *line[] = {"(", "role", "role_r", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "macro", "mm", "(", "(", "role", "a", ")", ")",
				"(", "role", "b", ")",
				"(", "allow", "a", "b", "(", "file", "(", "read", ")", ")", ")", ")",
			"(", "call", "mm", "(", "role_r", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_call1_user(CuTest *tc) {
	char *line[] = {"(", "user", "user_u", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "macro", "mm", "(", "(", "user", "a", ")", ")",
				"(", "user", "b", ")",
				"(", "allow", "a", "b", "(", "file", "(", "read", ")", ")", ")", ")",
			"(", "call", "mm", "(", "user_u", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_call1_sens(CuTest *tc) {
	char *line[] = {"(", "sensitivity", "sens", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "macro", "mm", "(", "(", "sensitivity", "a", ")", ")",
				"(", "sensitivity", "b", ")",
				"(", "allow", "a", "b", "(", "file", "(", "read", ")", ")", ")", ")",
			"(", "call", "mm", "(", "sens", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_call1_cat(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "macro", "mm", "(", "(", "category", "a", ")", ")",
				"(", "category", "b", ")",
				"(", "allow", "a", "b", "(", "file", "(", "read", ")", ")", ")", ")",
			"(", "call", "mm", "(", "c0", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_call1_catset(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "category", "c1", ")",
			"(", "category", "c2", ")",
			"(", "categoryset", "somecats", "(", "c0", "c1", "c2", ")", ")",
			"(", "macro", "mm", "(", "(", "categoryset",  "foo", ")", ")",
				"(", "level", "bar", "(", "s0", "foo", ")", ")", ")",
			"(", "call", "mm", "(", "somecats", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_call1_catset_anon(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "category", "c1", ")",
			"(", "category", "c2", ")",
			"(", "macro", "mm", "(", "(", "categoryset",  "foo", ")", ")",
				"(", "level", "bar", "(", "s0", "foo", ")", ")", ")",
			"(", "call", "mm", "(", "(", "c0", "c1", "c2", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_call1_catset_anon_neg(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "category", "c1", ")",
			"(", "category", "c2", ")",
			"(", "macro", "mm", "(", "(", "categoryset",  "foo", ")", ")",
				"(", "level", "bar", "(", "s0", "foo", ")", ")", ")",
			"(", "call", "mm", "(", "(", "c5", "(", "c2", ")", "c4", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
}

void test_cil_resolve_call1_level(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "user", "system_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "level", "l", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "h", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "macro", "mm", "(", "(", "level", "lvl_l", ")", "(", "level", "lvl_h", ")", ")",
				"(", "context", "foo", "(", "system_u", "role_r", "type_t", "(", "lvl_l", "lvl_h", ")", ")", ")", ")",
			"(", "call", "mm", "(", "l", "h", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_call1_level_anon(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "user", "system_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "level", "l", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "h", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "macro", "mm", "(", "(", "level", "lvl_l", ")", ")",
				"(", "context", "foo", "(", "system_u", "role_r", "type_t", "(", "lvl_l", "h", ")", ")", ")", ")",
			"(", "call", "mm", "(", "(", "s0", "(", "c0", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_call1_level_anon_neg(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "user", "system_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "level", "l", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "h", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "macro", "mm", "(", "(", "level", "lvl_l", ")", ")",
				"(", "context", "foo", "(", "system_u", "role_r", "type_t", "(", "lvl_l", "h", ")", ")", ")", ")",
			"(", "call", "mm", "(", "(", "s0", "(", "c0", "(", "c5", ")", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
}

void test_cil_resolve_call1_ipaddr(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "user", "system_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "level", "lvl_l", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "lvl_h", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "context", "con", "(", "system_u", "role_r", "type_t", "(", "lvl_l", "lvl_h", ")", ")", ")",
			"(", "ipaddr", "netmask", "192.168.0.1", ")",
			"(", "ipaddr", "ip", "192.168.0.1", ")",
			"(", "macro", "mm", "(", "(", "ipaddr", "addr", ")", ")",
				"(", "nodecon", "addr", "netmask", "con", ")", ")",
			"(", "call", "mm", "(", "ip", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_call1_ipaddr_anon(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "user", "system_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "level", "lvl_l", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "lvl_h", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "context", "con", "(", "system_u", "role_r", "type_t", "(", "lvl_l", "lvl_h", ")", ")", ")",
			"(", "ipaddr", "netmask", "192.168.0.1", ")",
			"(", "macro", "mm", "(", "(", "ipaddr", "addr", ")", ")",
				"(", "nodecon", "addr", "netmask", "con", ")", ")",
			"(", "call", "mm", "(", "(", "192.168.1.1", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_call1_ipaddr_anon_neg(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "user", "system_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "level", "lvl_l", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "lvl_h", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "context", "con", "(", "system_u", "role_r", "type_t", "(", "lvl_l", "lvl_h", ")", ")", ")",
			"(", "ipaddr", "netmask", "192.168.0.1", ")",
			"(", "macro", "mm", "(", "(", "ipaddr", "addr", ")", ")",
				"(", "nodecon", "addr", "netmask", "con", ")", ")",
			"(", "call", "mm", "(", "(", "192.1.1", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
}

void test_cil_resolve_call1_class(CuTest *tc) {
	char *line[] = {"(", "class", "foo", "(", "read", ")", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "macro", "mm", "(", "(", "class", "a", ")", ")",
				"(", "class", "b", "(", "read", ")", ")",
				"(", "allow", "a", "b", "(", "file", "(", "read", ")", ")", ")", ")",
			"(", "call", "mm", "(", "foo", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_call1_classmap(CuTest *tc) {
	char *line[] = {"(", "class", "file", "(", "open", ")", ")",
			"(", "macro", "mm", "(", "(", "classmap", "a", ")", ")", 
				"(", "classmapping", "a", "read", "(", "file", "(", "open", ")", ")", ")", ")",
			"(", "call", "mm", "(", "(", "read", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_call1(test_db->ast->root->cl_head->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_call1_permset(CuTest *tc) {
	char *line[] = {"(", "permissionset", "foo", "(", "read", "open", ")", ")",
			"(", "type", "dead", ")",
			"(", "type", "bar", ")",
			"(", "class", "baz", "(", "close", "read", "open", ")", ")",
			"(", "macro", "mm", "(", "(", "permissionset", "a", ")", ")", 
				"(", "allow", "dead", "bar", "(", "baz", "a", ")", ")", ")",
			"(", "call", "mm", "(", "foo", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_call1_permset_anon(CuTest *tc) {
	char *line[] = {"(", "type", "dead", ")",
			"(", "type", "bar", ")",
			"(", "class", "baz", "(", "close", "read", "open", ")", ")",
			"(", "macro", "mm", "(", "(", "permissionset", "a", ")", ")", 
				"(", "allow", "dead", "bar", "(", "baz", "a", ")", ")", ")",
			"(", "call", "mm", "(", "(", "read", "open", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_call1_classpermset_named(CuTest *tc) {
	char *line[] = {"(", "classmap", "files", "(", "read", ")", ")",
			"(", "class", "file", "(", "open", ")", ")",
			"(", "classpermissionset", "char_w", "(", "file", "(", "open", ")", ")", ")",
			"(", "macro", "mm", "(", "(", "classpermissionset", "a", ")", ")", 
				"(", "classmapping", "files", "read", "a", ")", ")",
			"(", "call", "mm", "(", "char_w", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_call1_classpermset_anon(CuTest *tc) {
	char *line[] = {"(", "classmap", "files", "(", "read", ")", ")",
			"(", "class", "file", "(", "open", ")", ")",
			"(", "macro", "mm", "(", "(", "classpermissionset", "a", ")", ")", 
				"(", "classmapping", "files", "read", "a", ")", ")",
			"(", "call", "mm", "(", "(", "file", "(", "open", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_call1_classpermset_anon_neg(CuTest *tc) {
	char *line[] = {"(", "classmap", "files", "(", "read", ")", ")",
			"(", "class", "file", "(", "open", ")", ")",
			"(", "macro", "mm", "(", "(", "classpermissionset", "a", ")", ")", 
				"(", "classmapping", "files", "read", "a", ")", ")",
			"(", "call", "mm", "(", "(", "file", "(", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
}

void test_cil_resolve_call1_unknown_neg(CuTest *tc) {
	char *line[] = {"(", "class", "foo", "(", "read", ")", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "macro", "mm", "(", "(", "class", "a", ")", ")",
				"(", "class", "b", "(", "read", ")", ")",
				"(", "allow", "a", "b", "(", "file", "(", "read", ")", ")", ")", ")",
			"(", "call", "mm", "(", "foo", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	struct cil_tree_node *macro_node = NULL;
	cil_resolve_name(test_db->ast->root->cl_head->next->next->next, ((struct cil_call*)test_db->ast->root->cl_head->next->next->next->data)->macro_str, CIL_SYM_BLOCKS, args, &macro_node);
	((struct cil_call*)test_db->ast->root->cl_head->next->next->next->data)->macro = (struct cil_macro*)macro_node->data;
	free(((struct cil_call*)test_db->ast->root->cl_head->next->next->next->data)->macro_str);
	((struct cil_call*)test_db->ast->root->cl_head->next->next->next->data)->macro_str = NULL;

	((struct cil_call*)test_db->ast->root->cl_head->next->next->next->data)->macro->params->head->flavor = CIL_NETIFCON;

	int rc = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
}

void test_cil_resolve_call1_unknowncall_neg(CuTest *tc) {
	char *line[] = {"(", "class", "foo", "(", "read", ")", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "macro", "mm", "(", "(", "class", "a", ")", ")",
				"(", "class", "b", "(", "read", ")", ")",
				"(", "allow", "a", "b", "(", "file", "(", "read", ")", ")", ")", ")",
			"(", "call", "m", "(", "foo", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_call1_extraargs_neg(CuTest *tc) {
	char *line[] = {"(", "class", "foo", "(", "read", ")", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "macro", "mm", "(", "(", "class", "a", ")", ")",
				"(", "class", "b", "(", "read", ")", ")",
				"(", "allow", "a", "b", "(", "file", "(", "read", ")", ")", ")", ")",
			"(", "call", "mm", "(", "foo", "bar", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
}

void test_cil_resolve_call1_copy_dup(CuTest *tc) {
	char *line[] = {"(", "type", "qaz", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "macro", "mm", "(", "(", "type", "a", ")", ")",
				"(", "type", "qaz", ")",
				"(", "allow", "a", "b", "(", "file", "(", "read", ")", ")", ")", ")",
			"(", "call", "mm", "(", "qaz", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_call1_missing_arg_neg(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "user", "system_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "level", "l", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "h", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "macro", "mm", "(", "(", "level", "lvl_l", ")", "(", "level", "lvl_h", ")", ")",
				"(", "context", "foo", "(", "system_u", "role_r", "type_t", "(", "lvl_l", "lvl_h", ")", ")", ")", ")",
			"(", "call", "mm", "(", "l", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
}

void test_cil_resolve_call1_paramsflavor_neg(CuTest *tc) {
	char *line[] = {"(", "type", "qaz", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "macro", "mm", "(", "(", "type", "a", ")", ")",
				"(", "type", "b", ")",
				"(", "allow", "a", "b", "(", "file", "(", "read", ")", ")", ")", ")",
			"(", "call", "mm", "(", "qaz", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	struct cil_tree_node *macro_node = NULL;

	struct cil_call *new_call = ((struct cil_call*)test_db->ast->root->cl_head->next->next->next->data);
	cil_resolve_name(test_db->ast->root->cl_head->next->next->next, new_call->macro_str, CIL_SYM_BLOCKS, args, &macro_node);
	new_call->macro = (struct cil_macro*)macro_node->data;
	struct cil_list_item *item = new_call->macro->params->head;
	item->flavor = CIL_CONTEXT;

	int rc = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
}

void test_cil_resolve_call1_unknownflavor_neg(CuTest *tc) {
	char *line[] = {"(", "type", "qaz", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "macro", "mm", "(", "(", "type", "a", ")", ")",
				"(", "type", "b", ")",
				"(", "allow", "a", "b", "(", "file", "(", "read", ")", ")", ")", ")",
			"(", "call", "mm", "(", "qaz", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	struct cil_tree_node *macro_node = NULL;

	struct cil_call *new_call = ((struct cil_call*)test_db->ast->root->cl_head->next->next->next->data);
	cil_resolve_name(test_db->ast->root->cl_head->next->next->next, new_call->macro_str, CIL_SYM_BLOCKS, args, &macro_node);
	new_call->macro = (struct cil_macro*)macro_node->data;
	struct cil_list_item *item = new_call->macro->params->head;
	((struct cil_param*)item->data)->flavor = CIL_CONTEXT;

	int rc = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
}

void test_cil_resolve_call2_type(CuTest *tc) {
	char *line[] = {"(", "type", "qaz", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "macro", "mm", "(", "(", "type", "a", ")", ")",
				"(", "type", "b", ")",
				"(", "allow", "a", "b", "(", "file", "(", "read", ")", ")", ")", ")",
			"(", "call", "mm", "(", "qaz", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_call1(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	int rc = cil_resolve_call2(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_call2_role(CuTest *tc) {
	char *line[] = {"(", "role", "role_r", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "macro", "mm", "(", "(", "role", "a", ")", ")",
				"(", "role", "b", ")",
				"(", "allow", "a", "b", "(", "file", "(", "read", ")", ")", ")", ")",
			"(", "call", "mm", "(", "role_r", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_call1(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	int rc = cil_resolve_call2(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_call2_user(CuTest *tc) {
	char *line[] = {"(", "user", "user_u", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "macro", "mm", "(", "(", "user", "a", ")", ")",
				"(", "user", "b", ")",
				"(", "allow", "a", "b", "(", "file", "(", "read", ")", ")", ")", ")",
			"(", "call", "mm", "(", "user_u", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_call1(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	int rc = cil_resolve_call2(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_call2_sens(CuTest *tc) {
	char *line[] = {"(", "sensitivity", "sens", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "macro", "mm", "(", "(", "sensitivity", "a", ")", ")",
				"(", "sensitivity", "b", ")",
				"(", "allow", "a", "b", "(", "file", "(", "read", ")", ")", ")", ")",
			"(", "call", "mm", "(", "sens", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_call1(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	int rc = cil_resolve_call2(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_call2_cat(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "macro", "mm", "(", "(", "category", "a", ")", ")",
				"(", "category", "b", ")",
				"(", "allow", "a", "b", "(", "file", "(", "read", ")", ")", ")", ")",
			"(", "call", "mm", "(", "c0", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_call1(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	int rc = cil_resolve_call2(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_call2_catset(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "category", "c1", ")",
			"(", "category", "c2", ")",
			"(", "categoryset", "somecats", "(", "c0", "c1", "c2", ")", ")",
			"(", "macro", "mm", "(", "(", "categoryset",  "foo", ")", ")",
				"(", "level", "bar", "(", "s0", "foo", ")", ")", ")",
			"(", "call", "mm", "(", "somecats", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_call1(test_db->ast->root->cl_head->next->next->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	int rc = cil_resolve_call2(test_db->ast->root->cl_head->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_call2_catset_anon(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "category", "c1", ")",
			"(", "category", "c2", ")",
			"(", "macro", "mm", "(", "(", "categoryset",  "foo", ")", ")",
				"(", "level", "bar", "(", "s0", "foo", ")", ")", ")",
			"(", "call", "mm", "(", "(", "c0", "c1", "c2", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_call1(test_db->ast->root->cl_head->next->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	int rc = cil_resolve_call2(test_db->ast->root->cl_head->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_call2_permset(CuTest *tc) {
	char *line[] = {"(", "permissionset", "foo", "(", "read", "open", ")", ")",
			"(", "class", "dead", "(", "close", ")", ")",
			"(", "class", "bar", "(", "close", ")", ")",
			"(", "class", "baz", "(", "close", ")", ")",
			"(", "macro", "mm", "(", "(", "permissionset", "a", ")", ")", 
				"(", "allow", "dead", "bar", "(", "baz", "a", ")", ")", ")",
			"(", "call", "mm", "(", "foo", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_call1(test_db->ast->root->cl_head->next->next->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	int rc = cil_resolve_call2(test_db->ast->root->cl_head->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_call2_permset_anon(CuTest *tc) {
	char *line[] = {"(", "class", "dead", "(", "close", ")", ")",
			"(", "class", "bar", "(", "close", ")", ")",
			"(", "class", "baz", "(", "close", ")", ")",
			"(", "macro", "mm", "(", "(", "permissionset", "a", ")", ")", 
				"(", "allow", "dead", "bar", "(", "baz", "a", ")", ")", ")",
			"(", "call", "mm", "(", "(", "read", "open", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_call1(test_db->ast->root->cl_head->next->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	int rc = cil_resolve_call2(test_db->ast->root->cl_head->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_call2_classpermset_named(CuTest *tc) {
	char *line[] = {"(", "classmap", "files", "(", "read", ")", ")",
			"(", "class", "file", "(", "open", ")", ")",
			"(", "classpermissionset", "char_w", "(", "file", "(", "open", ")", ")", ")",
			"(", "macro", "mm", "(", "(", "classpermissionset", "a", ")", ")", 
				"(", "classmapping", "files", "read", "a", ")", ")",
			"(", "call", "mm", "(", "char_w", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_call1(test_db->ast->root->cl_head->next->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	int rc = cil_resolve_call2(test_db->ast->root->cl_head->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_call2_classpermset_anon(CuTest *tc) {
	char *line[] = {"(", "classmap", "files", "(", "read", ")", ")",
			"(", "class", "file", "(", "open", ")", ")",
			"(", "macro", "mm", "(", "(", "classpermissionset", "a", ")", ")", 
				"(", "classmapping", "files", "read", "a", ")", ")",
			"(", "call", "mm", "(", "(", "file", "(", "open", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_call1(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	int rc = cil_resolve_call2(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_call2_class(CuTest *tc) {
	char *line[] = {"(", "class", "foo", "(", "read", ")", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "macro", "mm", "(", "(", "class", "a", ")", ")",
				"(", "class", "b", "(", "read", ")", ")",
				"(", "allow", "a", "b", "(", "file", "(", "read", ")", ")", ")", ")",
			"(", "call", "mm", "(", "foo", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_call1(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	int rc = cil_resolve_call2(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_call2_classmap(CuTest *tc) {
	char *line[] = {"(", "class", "file", "(", "open", ")", ")",
			"(", "classmap", "files", "(", "read", ")", ")",	
			"(", "macro", "mm", "(", "(", "classmap", "a", ")", ")", 
				"(", "classmapping", "a", "read", "(", "file", "(", "open", ")", ")", ")", ")",
			"(", "call", "mm", "(", "files", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc2 = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	int rc = cil_resolve_call2(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, SEPOL_OK, rc2);
}

void test_cil_resolve_call2_level(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "user", "system_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "level", "l", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "h", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "macro", "mm", "(", "(", "level", "lvl_l", ")", "(", "level", "lvl_h", ")", ")",
				"(", "context", "foo", "(", "system_u", "role_r", "type_t", "(", "lvl_l", "lvl_h", ")", ")", ")", ")",
			"(", "call", "mm", "(", "l", "h", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_call1(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	int rc = cil_resolve_call2(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_call2_level_anon(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "user", "system_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "level", "l", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "h", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "macro", "mm", "(", "(", "level", "lvl_l", ")", ")",
				"(", "context", "foo", "(", "system_u", "role_r", "type_t", "(", "lvl_l", "h", ")", ")", ")", ")",
			"(", "call", "mm", "(", "(", "s0", "(", "c0", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_call1(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	int rc = cil_resolve_call2(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_call2_ipaddr(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "user", "system_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "level", "lvl_l", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "lvl_h", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "context", "con", "(", "system_u", "role_r", "type_t", "(", "lvl_l", "lvl_h", ")", ")", ")",
			"(", "ipaddr", "netmask", "192.168.0.1", ")",
			"(", "ipaddr", "ip", "192.168.0.1", ")",
			"(", "macro", "mm", "(", "(", "ipaddr", "addr", ")", ")",
				"(", "nodecon", "addr", "netmask", "con", ")", ")",
			"(", "call", "mm", "(", "ip", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_call1(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	int rc = cil_resolve_call2(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_call2_ipaddr_anon(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "user", "system_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "level", "lvl_l", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "lvl_h", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "context", "con", "(", "system_u", "role_r", "type_t", "(", "lvl_l", "lvl_h", ")", ")", ")",
			"(", "ipaddr", "netmask", "192.168.0.1", ")",
			"(", "macro", "mm", "(", "(", "ipaddr", "addr", ")", ")",
				"(", "nodecon", "addr", "netmask", "con", ")", ")",
			"(", "call", "mm", "(", "(", "192.168.1.1", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_call1(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	int rc = cil_resolve_call2(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_call2_unknown_neg(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "user", "system_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "level", "l", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "h", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "macro", "mm", "(", "(", "level", "lvl_l", ")", "(", "level", "lvl_h", ")", ")",
				"(", "context", "foo", "(", "system_u", "role_r", "type_t", "(", "lvl_l", "lvl_h", ")", ")", ")", ")",
			"(", "call", "mm", "(", "l", "h", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_call1(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);
	((struct cil_args*)((struct cil_list_item *)((struct cil_call *)test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->data)->args->head)->data)->flavor = CIL_SYM_UNKNOWN;

	args->pass = CIL_PASS_CALL2;

	int rc = cil_resolve_call2(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
}

void test_cil_resolve_call2_name_neg(CuTest *tc) {
	char *line[] = {"(", "class", "foo", "(", "read", ")", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "macro", "mm", "(", "(", "class", "a", ")", ")",
				"(", "class", "b", "(", "read", ")", ")",
				"(", "allow", "a", "b", "(", "file", "(", "read", ")", ")", ")", ")",
			"(", "call", "mm", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_call1(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	int rc = cil_resolve_call2(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
}

void test_cil_resolve_name_call_args(CuTest *tc) {
	char *line[] = {"(", "type", "qaz", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "macro", "mm", "(", "(", "type", "a", ")", ")",
				"(", "type", "b", ")",
				"(", "allow", "a", "b", "(", "file", "(", "read", ")", ")", ")", ")",
			"(", "call", "mm", "(", "qaz", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	struct cil_tree_node *test_node;
	cil_tree_node_init(&test_node);

	cil_resolve_call1(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	cil_resolve_call2(test_db->ast->root->cl_head->next->next->next, args);
	int rc = cil_resolve_name_call_args((struct cil_call *)test_db->ast->root->cl_head->next->next->next->data, "a", CIL_SYM_TYPES, &test_node);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_name_call_args_multipleparams(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "user", "system_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "level", "l", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "h", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "macro", "mm", "(", "(", "level", "lvl_l", ")", "(", "level", "lvl_h", ")", ")",
				"(", "context", "foo", "(", "system_u", "role_r", "type_t", "(", "lvl_l", "lvl_h", ")", ")", ")", ")",
			"(", "call", "mm", "(", "l", "h", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	struct cil_tree_node *test_node;
	cil_tree_node_init(&test_node);

	cil_resolve_call1(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	cil_resolve_call2(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, args);
	int rc = cil_resolve_name_call_args((struct cil_call *)test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->data, "lvl_h", CIL_SYM_LEVELS, &test_node);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_name_call_args_diffflavor(CuTest *tc) {
	char *line[] = {"(", "type", "qaz", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "macro", "mm", "(", "(", "type", "a", ")", ")",
				"(", "type", "b", ")",
				"(", "allow", "a", "b", "(", "file", "(", "read", ")", ")", ")", ")",
			"(", "call", "mm", "(", "qaz", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	struct cil_tree_node *test_node;
	cil_tree_node_init(&test_node);

	cil_resolve_call1(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	cil_resolve_call2(test_db->ast->root->cl_head->next->next->next, args);
	int rc = cil_resolve_name_call_args((struct cil_call *)test_db->ast->root->cl_head->next->next->next->data, "qaz", CIL_LEVEL, &test_node);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
}

void test_cil_resolve_name_call_args_callnull_neg(CuTest *tc) {
	char *line[] = {"(", "type", "qaz", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "macro", "mm", "(", "(", "type", "a", ")", ")",
				"(", "type", "b", ")",
				"(", "allow", "a", "b", "(", "file", "(", "read", ")", ")", ")", ")",
			"(", "call", "mm", "(", "qaz", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	struct cil_tree_node *test_node;
	cil_tree_node_init(&test_node);

	cil_resolve_call1(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	cil_resolve_call2(test_db->ast->root->cl_head->next->next->next, args);
	int rc = cil_resolve_name_call_args(NULL, "qaz", CIL_LEVEL, &test_node);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
}

void test_cil_resolve_name_call_args_namenull_neg(CuTest *tc) {
	char *line[] = {"(", "type", "qaz", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "macro", "mm", "(", "(", "type", "a", ")", ")",
				"(", "type", "b", ")",
				"(", "allow", "a", "b", "(", "file", "(", "read", ")", ")", ")", ")",
			"(", "call", "mm", "(", "qaz", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	struct cil_tree_node *test_node;
	cil_tree_node_init(&test_node);

	cil_resolve_call1(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	cil_resolve_call2(test_db->ast->root->cl_head->next->next->next, args);
	int rc = cil_resolve_name_call_args((struct cil_call *)test_db->ast->root->cl_head->next->next->next->data, NULL, CIL_LEVEL, &test_node);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
}

void test_cil_resolve_name_call_args_callargsnull_neg(CuTest *tc) {
	char *line[] = {"(", "type", "qaz", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "macro", "mm", "(", "(", "type", "a", ")", ")",
				"(", "type", "b", ")",
				"(", "allow", "a", "b", "(", "file", "(", "read", ")", ")", ")", ")",
			"(", "call", "mm", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	struct cil_tree_node *test_node;
	cil_tree_node_init(&test_node);

	cil_resolve_call1(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	cil_resolve_call2(test_db->ast->root->cl_head->next->next->next, args);
	int rc = cil_resolve_name_call_args((struct cil_call *)test_db->ast->root->cl_head->next->next->next->data, "qas", CIL_LEVEL, &test_node);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
}

void test_cil_resolve_name_call_args_name_neg(CuTest *tc) {
	char *line[] = {"(", "type", "qaz", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "macro", "mm", "(", "(", "type", "a", ")", ")",
				"(", "type", "b", ")",
				"(", "allow", "a", "b", "(", "file", "(", "read", ")", ")", ")", ")",
			"(", "call", "mm", "(", "baz", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	struct cil_tree_node *test_node = NULL;
	//cil_tree_node_init(&test_node);

	cil_resolve_call1(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	cil_resolve_call2(test_db->ast->root->cl_head->next->next->next, args);
	int rc = cil_resolve_name_call_args((struct cil_call *)test_db->ast->root->cl_head->next->next->next->data, "qas", CIL_TYPE, &test_node);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
}

void test_cil_resolve_expr_stack_bools(CuTest *tc) {
	char *line[] = {"(", "boolean", "foo", "true", ")",
			"(", "boolean", "bar", "false", ")",
			"(", "class", "baz", "(", "read", ")", ")",
			"(", "booleanif", "(", "and", "foo", "bar", ")",
			"(", "allow", "foo", "bar", "(", "baz", "(", "read", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	struct cil_booleanif *bif = (struct cil_booleanif*)test_db->ast->root->cl_head->next->next->next->data; 

	int rc = cil_resolve_expr_stack(bif->expr_stack, test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_expr_stack_tunables(CuTest *tc) {
	char *line[] = {"(", "tunable", "foo", "true", ")",
			"(", "tunable", "bar", "false", ")",
			"(", "class", "baz", "(", "read", ")", ")",
			"(", "tunableif", "(", "and", "foo", "bar", ")",
			"(", "true",
			"(", "allow", "foo", "bar", "(", "baz", "(", "read", ")", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_TIF, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	struct cil_tunableif *tif = (struct cil_tunableif*)test_db->ast->root->cl_head->next->next->next->data; 

	int rc = cil_resolve_expr_stack(tif->expr_stack, test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_expr_stack_type(CuTest *tc) {
        char *line[] = {"(", "class", "file", "(", "create", "relabelto", ")", ")",
			"(", "class", "dir", "(", "create", "relabelto", ")", ")",
			"(", "type", "t1", ")",
			"(", "type", "type_t", ")",
			"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "t1", "type_t", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	struct cil_constrain *cons = (struct cil_constrain*)test_db->ast->root->cl_head->next->next->next->next->data; 

	int rc = cil_resolve_expr_stack(cons->expr, test_db->ast->root->cl_head->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_expr_stack_role(CuTest *tc) {
        char *line[] = {"(", "class", "file", "(", "create", "relabelto", ")", ")",
			"(", "class", "dir", "(", "create", "relabelto", ")", ")",
			"(", "role", "r1", ")",
			"(", "role", "role_r", ")",
			"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "r1", "role_r", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	struct cil_constrain *cons = (struct cil_constrain*)test_db->ast->root->cl_head->next->next->next->next->data; 

	int rc = cil_resolve_expr_stack(cons->expr, test_db->ast->root->cl_head->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_expr_stack_user(CuTest *tc) {
        char *line[] = {"(", "class", "file", "(", "create", "relabelto", ")", ")",
			"(", "class", "dir", "(", "create", "relabelto", ")", ")",
			"(", "user", "u1", ")",
			"(", "user", "user_u", ")",
			"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "u1", "user_u", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	struct cil_constrain *cons = (struct cil_constrain*)test_db->ast->root->cl_head->next->next->next->next->data; 

	int rc = cil_resolve_expr_stack(cons->expr, test_db->ast->root->cl_head->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_expr_stack_neg(CuTest *tc) {
	char *line[] = {"(", "boolean", "foo", "true", ")",
			"(", "boolean", "bar", "false", ")",
			"(", "class", "baz", "(", "read", ")", ")",
			"(", "booleanif", "(", "and", "beef", "baf", ")",
			"(", "true",
			"(", "allow", "foo", "bar", "(", "baz", "(", "read", ")", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	struct cil_booleanif *bif = (struct cil_booleanif*)test_db->ast->root->cl_head->next->next->next->data; 

	int rc = cil_resolve_expr_stack(bif->expr_stack,test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_expr_stack_emptystr_neg(CuTest *tc) {
	char *line[] = {"(", "boolean", "foo", "true", ")",
			"(", "boolean", "bar", "false", ")",
			"(", "class", "baz", "(", "read", ")", ")",
			"(", "booleanif", "(", "and", "foo", "bar", ")",
			"(", "true",
			"(", "allow", "foo", "bar", "(", "baz", "(", "read", ")", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	struct cil_booleanif *bif = (struct cil_booleanif*)test_db->ast->root->cl_head->next->next->next->data;
	((struct cil_conditional*)bif->expr_stack->head->data)->str = NULL;

	int rc = cil_resolve_expr_stack(bif->expr_stack,test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
}

void test_cil_resolve_boolif(CuTest *tc) {
	char *line[] = {"(", "boolean", "foo", "true", ")",
			"(", "boolean", "bar", "false", ")",
			"(", "class", "baz", "(", "read", ")", ")",
			"(", "booleanif", "(", "and", "foo", "bar", ")",
			"(", "true",
			"(", "allow", "foo", "bar", "(", "baz", "(", "read", ")", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	int rc = cil_resolve_boolif(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_boolif_neg(CuTest *tc) {
	char *line[] = {"(", "boolean", "foo", "true", ")",
			"(", "boolean", "bar", "false", ")",
			"(", "class", "baz", "(", "read", ")", ")",
			"(", "booleanif", "(", "and", "dne", "N/A", ")",
			"(", "true",
			"(", "allow", "foo", "bar", "(", "baz", "(", "read", ")", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	int rc = cil_resolve_boolif(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_evaluate_expr_stack_and(CuTest *tc) {
	char *line[] = {"(", "tunable", "foo", "true", ")",
			"(", "tunable", "bar", "false", ")",
			"(", "class", "baz", "(", "read", ")", ")",
			"(", "tunableif", "(", "and", "foo", "bar", ")",
			"(", "true",
			"(", "allow", "foo", "bar", "(", "baz", "(", "read", ")", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint16_t result = CIL_FALSE;
	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_TIF, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	struct cil_tunableif *tif = (struct cil_tunableif*)test_db->ast->root->cl_head->next->next->next->data;

	cil_resolve_expr_stack(tif->expr_stack, test_db->ast->root->cl_head->next->next->next, args);
	int rc = cil_evaluate_expr_stack(tif->expr_stack, &result);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_evaluate_expr_stack_not(CuTest *tc) {
	char *line[] = {"(", "tunable", "foo", "true", ")",
			"(", "tunable", "bar", "false", ")",
			"(", "class", "baz", "(", "read", ")", ")",
			"(", "tunableif", "(", "not", "bar", ")",
			"(", "true",
			"(", "allow", "foo", "bar", "(", "baz", "(", "read", ")", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint16_t result = CIL_FALSE;
	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_TIF, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	struct cil_tunableif *tif = (struct cil_tunableif*)test_db->ast->root->cl_head->next->next->next->data;

	cil_resolve_expr_stack(tif->expr_stack, test_db->ast->root->cl_head->next->next->next, args);
	int rc = cil_evaluate_expr_stack(tif->expr_stack, &result);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_evaluate_expr_stack_or(CuTest *tc) {
	char *line[] = {"(", "tunable", "foo", "true", ")",
			"(", "tunable", "bar", "false", ")",
			"(", "class", "baz", "(", "read", ")", ")",
			"(", "tunableif", "(", "or", "foo", "bar", ")",
			"(", "true",
			"(", "allow", "foo", "bar", "(", "baz", "(", "read", ")", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint16_t result = CIL_FALSE;
	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_TIF, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	struct cil_tunableif *tif = (struct cil_tunableif*)test_db->ast->root->cl_head->next->next->next->data;

	cil_resolve_expr_stack(tif->expr_stack, test_db->ast->root->cl_head->next->next->next, args);
	int rc = cil_evaluate_expr_stack(tif->expr_stack, &result);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_evaluate_expr_stack_xor(CuTest *tc) {
	char *line[] = {"(", "tunable", "foo", "true", ")",
			"(", "tunable", "bar", "false", ")",
			"(", "class", "baz", "(", "read", ")", ")",
			"(", "tunableif", "(", "xor", "foo", "bar", ")",
			"(", "true",
			"(", "allow", "foo", "bar", "(", "baz", "(", "read", ")", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint16_t result = CIL_FALSE;
	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_TIF, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	struct cil_tunableif *tif = (struct cil_tunableif*)test_db->ast->root->cl_head->next->next->next->data;

	cil_resolve_expr_stack(tif->expr_stack, test_db->ast->root->cl_head->next->next->next, args);
	int rc = cil_evaluate_expr_stack(tif->expr_stack, &result);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_evaluate_expr_stack_eq(CuTest *tc) {
	char *line[] = {"(", "tunable", "foo", "true", ")",
			"(", "tunable", "bar", "false", ")",
			"(", "class", "baz", "(", "read", ")", ")",
			"(", "tunableif", "(", "eq", "foo", "bar", ")",
			"(", "true",
			"(", "allow", "foo", "bar", "(", "baz", "(", "read", ")", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint16_t result = CIL_FALSE;
	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_TIF, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	struct cil_tunableif *tif = (struct cil_tunableif*)test_db->ast->root->cl_head->next->next->next->data;

	cil_resolve_expr_stack(tif->expr_stack, test_db->ast->root->cl_head->next->next->next, args);
	int rc = cil_evaluate_expr_stack(tif->expr_stack, &result);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_evaluate_expr_stack_neq(CuTest *tc) {
	char *line[] = {"(", "tunable", "foo", "true", ")",
			"(", "tunable", "bar", "false", ")",
			"(", "class", "baz", "(", "read", ")", ")",
			"(", "tunableif", "(", "neq", "foo", "bar", ")",
			"(", "true",
			"(", "allow", "foo", "bar", "(", "baz", "(", "read", ")", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint16_t result = CIL_FALSE;
	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_TIF, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	struct cil_tunableif *tif = (struct cil_tunableif*)test_db->ast->root->cl_head->next->next->next->data;

	cil_resolve_expr_stack(tif->expr_stack, test_db->ast->root->cl_head->next->next->next, args);
	int rc = cil_evaluate_expr_stack(tif->expr_stack, &result);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_evaluate_expr_stack_oper1(CuTest *tc) {
	char *line[] = {"(", "tunable", "foo", "true", ")",
			"(", "tunable", "bar", "false", ")",
			"(", "tunable", "baz", "false", ")",
			"(", "class", "baz", "(", "read", ")", ")",
			"(", "tunableif", "(", "and", "(", "or", "foo", "bar", ")", "baz", ")",
			"(", "true",
			"(", "allow", "foo", "bar", "(", "jaz", "(", "read", ")", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint16_t result = CIL_FALSE;
	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_TIF, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	struct cil_tunableif *tif = (struct cil_tunableif*)test_db->ast->root->cl_head->next->next->next->next->data;

	cil_resolve_expr_stack(tif->expr_stack, test_db->ast->root->cl_head->next->next->next->next, args);
	int rc = cil_evaluate_expr_stack(tif->expr_stack, &result);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_evaluate_expr_stack_oper2(CuTest *tc) {
	char *line[] = {"(", "tunable", "foo", "true", ")",
			"(", "tunable", "bar", "false", ")",
			"(", "tunable", "baz", "false", ")",
			"(", "class", "baz", "(", "read", ")", ")",
			"(", "tunableif", "(", "and", "baz", "(", "or", "foo", "bar", ")", ")",
			"(", "true",
			"(", "allow", "foo", "bar", "(", "jaz", "(", "read", ")", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint16_t result = CIL_FALSE;
	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_TIF, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	struct cil_tunableif *tif = (struct cil_tunableif*)test_db->ast->root->cl_head->next->next->next->next->data;

	cil_resolve_expr_stack(tif->expr_stack, test_db->ast->root->cl_head->next->next->next->next, args);
	int rc = cil_evaluate_expr_stack(tif->expr_stack, &result);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}
/*
void test_cil_evaluate_expr_stack_neg(CuTest *tc) {
	char *line[] = {"(", "tunable", "foo", "true", ")",
			"(", "tunable", "bar", "false", ")",
			"(", "class", "baz", "(", "read", ")", ")",
			"(", "tunableif", "(", "neq", "foo", "bar", ")",
			"(", "allow", "foo", "bar", "(", "baz", "(", "read", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint16_t result = CIL_FALSE;

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	struct cil_tree_node *test_node;
	cil_tree_node_init(&test_node);

	struct cil_conditional *new_cond;
	cil_conditional_init(&new_cond);
	new_cond->flavor = CIL_COND;
	char *baz = "baz";
	new_cond->str = baz;
	new_cond->flavor = CIL_TUNABLE;

	struct cil_tunableif *tif = test_db->ast->root->cl_head->next->next->next->next->data;

	test_node->data = new_cond;	
	test_node->cl_head = tif->expr_stack;
	tif->expr_stack->parent = test_node;

	cil_resolve_expr_stack(test_db, tif->expr_stack, test_db->ast->root->cl_head->next->next->next, NULL);
	int rc = cil_evaluate_expr_stack(tif->expr_stack, &result);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
}
*/
void test_cil_resolve_tunif_false(CuTest *tc) {
	char *line[] = {"(", "tunable", "foo", "true", ")",
			"(", "tunable", "bar", "false", ")",
			"(", "class", "baz", "(", "read", ")", ")",
			"(", "tunableif", "(", "and", "foo", "bar", ")",
			"(", "false",
			"(", "allow", "foo", "bar", "(", "baz", "(", "read", ")", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_TIF, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	int rc = cil_resolve_tunif(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_tunif_true(CuTest *tc) {
	char *line[] = {"(", "tunable", "foo", "true", ")",
			"(", "tunable", "bar", "true", ")",
			"(", "class", "baz", "(", "read", ")", ")",
			"(", "tunableif", "(", "and", "foo", "bar", ")",
			"(", "true",
			"(", "allow", "foo", "bar", "(", "baz", "(", "read", ")", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_TIF, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	int rc = cil_resolve_tunif(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_tunif_resolveexpr_neg(CuTest *tc) {
	char *line[] = {"(", "tunable", "foo", "true", ")",
			"(", "tunable", "bar", "false", ")",
			"(", "class", "baz", "(", "read", ")", ")",
			"(", "tunableif", "(", "and", "dne", "N/A", ")",
			"(", "true",
			"(", "allow", "foo", "bar", "(", "baz", "(", "read", ")", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_TIF, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	int rc = cil_resolve_tunif(test_db->ast->root->cl_head->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}
/*
void test_cil_resolve_tunif_evaluateexpr_neg(CuTest *tc) {
	char *line[] = {"(", "tunable", "foo", "true", ")",
			"(", "tunable", "bar", "false", ")",
			"(", "class", "baz", "(", "read", ")", ")",
			"(", "tunableif", "(", "and", "foo", "bar", ")",
			"(", "allow", "foo", "bar", "(", "baz", "(", "read", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	struct cil_tree_node *test_node;
	cil_tree_node_init(&test_node);

	struct cil_conditional *new_cond;
	cil_conditional_init(&new_cond);
	new_cond->flavor = CIL_COND;
	char *baz = "baz";
	new_cond->str = baz;
	new_cond->flavor = CIL_TUNABLE;

	struct tunableif *tif = test_db->ast->root->cl_head->next->next->next->data;

	test_node->data = new_cond;	
	test_node->cl_head = tif->expr_stack;
	tif->expr_stack->parent = test_node;

	int rc = cil_resolve_tunif(test_db, test_db->ast->root->cl_head->next->next->next, NULL);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
}
*/
void test_cil_resolve_userbounds(CuTest *tc) {
	char *line[] = {"(", "user", "user1", ")", 
			"(", "user", "user2", ")", 
			"(", "userbounds", "user1", "user2", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_userbounds(test_db->ast->root->cl_head->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_userbounds_exists_neg(CuTest *tc) {
	char *line[] = {"(", "user", "user1", ")", 
			"(", "user", "user2", ")", 
			"(", "userbounds", "user1", "user2", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_userbounds(test_db->ast->root->cl_head->next->next, args);
	int rc = cil_resolve_userbounds(test_db->ast->root->cl_head->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
}

void test_cil_resolve_userbounds_user1_neg(CuTest *tc) {
	char *line[] = {"(", "user", "user1", ")", 
			"(", "user", "user2", ")", 
			"(", "userbounds", "user_DNE", "user2", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_userbounds(test_db->ast->root->cl_head->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_userbounds_user2_neg(CuTest *tc) {
	char *line[] = {"(", "user", "user1", ")", 
			"(", "user", "user2", ")", 
			"(", "userbounds", "user1", "user_DNE", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_userbounds(test_db->ast->root->cl_head->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_roletype(CuTest *tc) {
	char *line[] = {"(", "role",  "admin_r", ")",
			"(", "type", "admin_t", ")",
			"(", "roletype", "admin_r", "admin_t", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_roletype(test_db->ast->root->cl_head->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_roletype_type_neg(CuTest *tc) {
	char *line[] = {"(", "role",  "admin_r", ")",
			"(", "roletype", "admin_r", "admin_t", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_roletype(test_db->ast->root->cl_head->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_roletype_role_neg(CuTest *tc) {
	char *line[] = {"(", "type", "admin_t", ")",
			"(", "roletype", "admin_r", "admin_t", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_roletype(test_db->ast->root->cl_head->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_userrole(CuTest *tc) {
	char *line[] = {"(", "role",  "staff_r", ")",
			"(", "user", "staff_u", ")",
			"(", "userrole", "staff_u", "staff_r", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	int rc = cil_resolve_userrole(test_db->ast->root->cl_head->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_userrole_user_neg(CuTest *tc) {
	char *line[] = {"(", "role",  "staff_r", ")",
			"(", "userrole", "staff_u", "staff_r", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_userrole(test_db->ast->root->cl_head->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_userrole_role_neg(CuTest *tc) {
	char *line[] = {"(", "user", "staff_u", ")",
			"(", "userrole", "staff_u", "staff_r", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = cil_resolve_userrole(test_db->ast->root->cl_head->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_userlevel(CuTest *tc) {
	char *line[] = {"(", "user",  "foo_u", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "userlevel", "foo_u", "low", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_MISC3;

	int rc = cil_resolve_userlevel(test_db->ast->root->cl_head->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_userlevel_macro(CuTest *tc) {
	char *line[] = {"(", "user",  "foo_u", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "macro", "mm", "(", "(", "level", "l", ")", ")",
				"(", "userlevel", "foo_u", "l", ")", ")",
			"(", "call", "mm", "(", "(", "s0", "(", "c0", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);


	args->pass = CIL_PASS_CALL1;

	int rc2 = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	int rc3 = cil_resolve_call2(test_db->ast->root->cl_head->next->next->next->next->next, args);

	args->pass = CIL_PASS_MISC2;

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_MISC3;
	args->callstack = test_db->ast->root->cl_head->next->next->next->next->next;

	int rc = cil_resolve_userlevel(test_db->ast->root->cl_head->next->next->next->next->next->cl_head, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, SEPOL_OK, rc2);
	CuAssertIntEquals(tc, SEPOL_OK, rc3);
}

void test_cil_resolve_userlevel_macro_neg(CuTest *tc) {
	char *line[] = {"(", "user",  "foo_u", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "macro", "mm", "(", "(", "level", "l", ")", ")",
				"(", "userlevel", "foo_u", "l", ")", ")",
			"(", "call", "mm", "(", "(", "DNE", "(", "c0", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc2 = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	int rc3 = cil_resolve_call2(test_db->ast->root->cl_head->next->next->next->next->next, args);

	args->pass = CIL_PASS_MISC2;

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_MISC3;
	args->callstack = test_db->ast->root->cl_head->next->next->next->next->next;

	int rc = cil_resolve_userlevel(test_db->ast->root->cl_head->next->next->next->next->next->cl_head, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, SEPOL_OK, rc2);
	CuAssertIntEquals(tc, SEPOL_OK, rc3);
}

void test_cil_resolve_userlevel_level_anon(CuTest *tc) {
	char *line[] = {"(", "user",  "foo_u", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "userlevel", "foo_u", "(", "s0", "(", "c0", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_MISC3;

	int rc = cil_resolve_userlevel(test_db->ast->root->cl_head->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_userlevel_level_anon_neg(CuTest *tc) {
	char *line[] = {"(", "user",  "foo_u", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "userlevel", "foo_u", "(", "s0", "(", "DNE", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_MISC3;

	int rc = cil_resolve_userlevel(test_db->ast->root->cl_head->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_userlevel_user_neg(CuTest *tc) {
	char *line[] = {"(", "user",  "foo_u", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "userlevel", "DNE", "low", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_MISC3;

	int rc = cil_resolve_userlevel(test_db->ast->root->cl_head->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_userlevel_level_neg(CuTest *tc) {
	char *line[] = {"(", "user",  "foo_u", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "userlevel", "foo_u", "DNE", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_MISC3;

	int rc = cil_resolve_userlevel(test_db->ast->root->cl_head->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_userrange(CuTest *tc) {
	char *line[] = {"(", "user",  "foo_u", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "levelrange", "range", "(", "(", "s0", "(", "c0", ")", ")", "(", "s0", "(", "c0", ")", ")", ")", ")",
			"(", "userrange", "foo_u", "range", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next, args);
	int rc = cil_resolve_userrange(test_db->ast->root->cl_head->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_userrange_macro(CuTest *tc) {
	char *line[] = {"(", "user",  "foo_u", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "macro", "mm", "(", "(", "levelrange", "range", ")", ")",
				"(", "userrange", "foo_u", "range", ")", ")",
			"(", "call", "mm", "(", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc2 = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next->next->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	int rc3 = cil_resolve_call2(test_db->ast->root->cl_head->next->next->next->next->next->next->next, args);

	args->pass = CIL_PASS_MISC2;

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_MISC3;
	args->callstack = test_db->ast->root->cl_head->next->next->next->next->next->next->next;

	int rc = cil_resolve_userrange(test_db->ast->root->cl_head->next->next->next->next->next->next->next->cl_head, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, SEPOL_OK, rc2);
	CuAssertIntEquals(tc, SEPOL_OK, rc3);
}

void test_cil_resolve_userrange_macro_neg(CuTest *tc) {
	char *line[] = {"(", "user",  "foo_u", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "macro", "mm", "(", "(", "levelrange", "range", ")", ")",
				"(", "userrange", "foo_u", "range", ")", ")",
			"(", "call", "mm", "(", "(", "DNE", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc2 = cil_resolve_call1(test_db->ast->root->cl_head->next->next->next->next->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	int rc3 = cil_resolve_call2(test_db->ast->root->cl_head->next->next->next->next->next->next->next, args);

	args->pass = CIL_PASS_MISC2;

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_MISC3;
	args->callstack = test_db->ast->root->cl_head->next->next->next->next->next->next->next;

	int rc = cil_resolve_userrange(test_db->ast->root->cl_head->next->next->next->next->next->next->next->cl_head, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, SEPOL_OK, rc2);
	CuAssertIntEquals(tc, SEPOL_OK, rc3);
}

void test_cil_resolve_userrange_range_anon(CuTest *tc) {
	char *line[] = {"(", "user",  "foo_u", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "userrange", "foo_u", "(", "low", "high", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_MISC3;

	int rc = cil_resolve_userrange(test_db->ast->root->cl_head->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_userrange_range_anon_neg(CuTest *tc) {
	char *line[] = {"(", "user",  "foo_u", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "userrange", "foo_u", "(", "DNE", "high", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_MISC3;

	int rc = cil_resolve_userrange(test_db->ast->root->cl_head->next->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_userrange_user_neg(CuTest *tc) {
	char *line[] = {"(", "user",  "foo_u", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "levelrange", "range", "(", "(", "s0", "(", "c0", ")", ")", "(", "s0", "(", "c0", ")", ")", ")", ")",
			"(", "userrange", "DNE", "range", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_MISC3;

	int rc = cil_resolve_userrange(test_db->ast->root->cl_head->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_userrange_range_neg(CuTest *tc) {
	char *line[] = {"(", "user",  "foo_u", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "levelrange", "range", "(", "(", "s0", "(", "c0", ")", ")", "(", "s0", "(", "c0", ")", ")", ")", ")",
			"(", "userrange", "foo_u", "DNE", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_senscat(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_MISC3;

	int rc = cil_resolve_userrange(test_db->ast->root->cl_head->next->next->next->next->next, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_disable_children_helper_optional_enabled(CuTest *tc) {
	char *line[] = {"(", "optional", "opt", "(", "allow", "foo", "bar", "(", "baz", "file", "(", "read", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	uint32_t finished = 0;

	int rc = __cil_disable_children_helper(test_db->ast->root->cl_head, &finished, NULL);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_disable_children_helper_optional_disabled(CuTest *tc) {
	char *line[] = {"(", "optional", "opt", "(", "allow", "foo", "bar", "(", "baz", "file", "(", "read", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	uint32_t finished = 0;

	((struct cil_optional *)test_db->ast->root->cl_head->data)->datum.state = CIL_STATE_DISABLED;
	
	int rc = __cil_disable_children_helper(test_db->ast->root->cl_head, &finished, NULL);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_disable_children_helper_block(CuTest *tc) {
	char *line[] = {"(", "block", "a", "(", "type", "log", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	uint32_t finished = 0;

	int rc = __cil_disable_children_helper(test_db->ast->root->cl_head, &finished, NULL);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_disable_children_helper_user(CuTest *tc) {
	char *line[] = {"(", "user", "staff_u", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	uint32_t finished = 0;

	int rc = __cil_disable_children_helper(test_db->ast->root->cl_head, &finished, NULL);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_disable_children_helper_role(CuTest *tc) {
	char *line[] = {"(", "role", "role_r", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	uint32_t finished = 0;

	int rc = __cil_disable_children_helper(test_db->ast->root->cl_head, &finished, NULL);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_disable_children_helper_type(CuTest *tc) {
	char *line[] = {"(", "type", "type_t", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	uint32_t finished = 0;

	int rc = __cil_disable_children_helper(test_db->ast->root->cl_head, &finished, NULL);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_disable_children_helper_typealias(CuTest *tc) {
	char *line[] = {"(", "typealias", ".test.type", "type_t", ")", "(", "type", "test", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	uint32_t finished = 0;

	int rc = __cil_disable_children_helper(test_db->ast->root->cl_head, &finished, NULL);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_disable_children_helper_common(CuTest *tc) {
	char *line[] = {"(", "common", "foo", "(", "read", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	uint32_t finished = 0;

	int rc = __cil_disable_children_helper(test_db->ast->root->cl_head, &finished, NULL);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_disable_children_helper_class(CuTest *tc) {
	char *line[] = {"(", "class", "foo", "(", "read", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	uint32_t finished = 0;

	int rc = __cil_disable_children_helper(test_db->ast->root->cl_head, &finished, NULL);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_disable_children_helper_bool(CuTest *tc) {
	char *line[] = {"(", "boolean", "foo", "true", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	uint32_t finished = 0;

	int rc = __cil_disable_children_helper(test_db->ast->root->cl_head, &finished, NULL);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_disable_children_helper_sens(CuTest *tc) {
	char *line[] = {"(", "sensitivity", "s0", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	uint32_t finished = 0;

	int rc = __cil_disable_children_helper(test_db->ast->root->cl_head, &finished, NULL);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_disable_children_helper_cat(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	uint32_t finished = 0;

	int rc = __cil_disable_children_helper(test_db->ast->root->cl_head, &finished, NULL);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_disable_children_helper_catset(CuTest *tc) {
	char *line[] = {"(", "categoryset", "somecats", "(", "c0", "c1", "c2", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	uint32_t finished = 0;

	int rc = __cil_disable_children_helper(test_db->ast->root->cl_head, &finished, NULL);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_disable_children_helper_sid(CuTest *tc) {
	char *line[] = {"(", "sid", "foo", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	uint32_t finished = 0;

	int rc = __cil_disable_children_helper(test_db->ast->root->cl_head, &finished, NULL);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_disable_children_helper_macro(CuTest *tc) {
	char *line[] = {"(", "macro", "mm", "(", "(", "type", "a", ")", ")",
				"(", "type", "b", ")",
				"(", "allow", "a", "b", "(", "file", "(", "read", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	uint32_t finished = 0;

	int rc = __cil_disable_children_helper(test_db->ast->root->cl_head, &finished, NULL);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_disable_children_helper_context(CuTest *tc) {
	char *line[] = {"(", "context", "con",
                        "(", "system_u", "object_r", "netif_t", "(", "low", "high", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	uint32_t finished = 0;

	int rc = __cil_disable_children_helper(test_db->ast->root->cl_head, &finished, NULL);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_disable_children_helper_level(CuTest *tc) {
	char *line[] = {"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	uint32_t finished = 0;

	int rc = __cil_disable_children_helper(test_db->ast->root->cl_head, &finished, NULL);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_disable_children_helper_policycap(CuTest *tc) {
	char *line[] = {"(", "policycap", "foo", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	uint32_t finished = 0;

	int rc = __cil_disable_children_helper(test_db->ast->root->cl_head, &finished, NULL);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_disable_children_helper_perm(CuTest *tc) {
	char *line[] = {"(", "class", "foo", "(", "read", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	uint32_t finished = 0;

	int rc = __cil_disable_children_helper(test_db->ast->root->cl_head->cl_head, &finished, NULL);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_disable_children_helper_catalias(CuTest *tc) {
	char *line[] = {"(", "categoryalias", "c0", "red", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	uint32_t finished = 0;

	int rc = __cil_disable_children_helper(test_db->ast->root->cl_head, &finished, NULL);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_disable_children_helper_sensalias(CuTest *tc) {
	char *line[] = {"(", "sensitivityalias", "s0", "red", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	uint32_t finished = 0;

	int rc = __cil_disable_children_helper(test_db->ast->root->cl_head, &finished, NULL);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_disable_children_helper_tunable(CuTest *tc) {
	char *line[] = {"(", "tunable", "foo", "false", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	uint32_t finished = 0;

	int rc = __cil_disable_children_helper(test_db->ast->root->cl_head, &finished, NULL);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_disable_children_helper_unknown(CuTest *tc) {
	char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "l2", "h2", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	uint32_t finished = 0;

	int rc = __cil_disable_children_helper(test_db->ast->root->cl_head, &finished, NULL);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}


/*
	__cil_resolve_ast_node_helper test cases
*/

void test_cil_resolve_ast_node_helper_call1(CuTest *tc) {
	char *line[] = {"(", "type", "qaz", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "macro", "mm", "(", "(", "type", "a", ")", ")",
				"(", "type", "b", ")",
				"(", "allow", "a", "b", "(", "file", "(", "read", ")", ")", ")", ")",
			"(", "call", "mm", "(", "qaz", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_call1_neg(CuTest *tc) {
	char *line[] = {"(", "type", "qaz", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "macro", "mm", "(", "(", "type", "a", ")", ")",
				"(", "type", "b", ")",
				"(", "allow", "a", "b", "(", "file", "(", "read", ")", ")", ")", ")",
			"(", "call", "m", "(", "qaz", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_call2(CuTest *tc) {
	char *line[] = {"(", "type", "qaz", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "macro", "mm", "(", "(", "type", "a", ")", ")",
				"(", "type", "b", ")",
				"(", "allow", "a", "b", "(", "file", "(", "read", ")", ")", ")", ")",
			"(", "call", "mm", "(", "qaz", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_call1(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_call2_neg(CuTest *tc) {
	char *line[] = {"(", "type", "qaz", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "macro", "mm", "(", "(", "type", "a", ")", ")",
				"(", "type", "b", ")",
				"(", "allow", "a", "b", "(", "file", "(", "read", ")", ")", ")", ")",
			"(", "call", "mm", "(", "foo", "extra", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, NULL, NULL);
	uint32_t finished = 0;

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_call1(test_db->ast->root->cl_head->next->next->next, args);

	args->pass = CIL_PASS_CALL2;

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_ast_node_helper_boolif(CuTest *tc) {
	char *line[] = {"(", "boolean", "foo", "true", ")",
			"(", "boolean", "bar", "false", ")",
			"(", "class", "baz", "(", "read", ")", ")",
			"(", "booleanif", "(", "and", "foo", "bar", ")",
			"(", "true",
			"(", "allow", "foo", "bar", "(", "baz", "(", "read", ")", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC1, &changed, NULL, NULL, NULL);
	uint32_t finished = 0;

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_boolif_neg(CuTest *tc) {
	char *line[] = {"(", "boolean", "foo", "true", ")",
			"(", "boolean", "bar", "false", ")",
			"(", "class", "baz", "(", "read", ")", ")",
			"(", "booleanif", "(", "and", "dne", "N/A", ")",
			"(", "true",
			"(", "allow", "foo", "bar", "(", "baz", "(", "read", ")", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC1, &changed, NULL, NULL, NULL);
	uint32_t finished = 0;

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_tunif(CuTest *tc) {
	char *line[] = {"(", "tunable", "foo", "true", ")",
			"(", "tunable", "bar", "false", ")",
			"(", "class", "baz", "(", "read", ")", ")",
			"(", "tunableif", "(", "and", "foo", "bar", ")",
			"(", "false",
			"(", "allow", "foo", "bar", "(", "baz", "(", "read", ")", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_TIF, &changed, NULL, NULL, NULL);
	uint32_t finished = 0;

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_tunif_neg(CuTest *tc) {
	char *line[] = {"(", "tunable", "foo", "true", ")",
			"(", "tunable", "bar", "false", ")",
			"(", "class", "baz", "(", "read", ")", ")",
			"(", "tunableif", "(", "and", "dne", "N/A", ")",
			"(", "true",
			"(", "allow", "foo", "bar", "(", "baz", "(", "read", ")", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE; 
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_TIF, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_catorder(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")", 
			"(", "category", "c1", ")",
			"(", "category", "c2", ")",
			"(", "categoryorder", "(", "c0", "c1", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC1, &changed, NULL, NULL, NULL);
	uint32_t finished = 0;

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_catorder_neg(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")", 
			"(", "category", "c1", ")",
			"(", "category", "c2", ")",
			"(", "categoryorder", "(", "c8", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC1, &changed, NULL, NULL, NULL);
	uint32_t finished = 0;

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_dominance(CuTest *tc) {
	char *line[] = {"(", "sensitivity", "s0", ")", 
			"(", "sensitivity", "s1", ")",
			"(", "sensitivity", "s2", ")",
			"(", "dominance", "(", "s0", "s1", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC1, &changed, NULL, NULL, NULL);
	uint32_t finished = 0;

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_dominance_neg(CuTest *tc) {
	char *line[] = {"(", "sensitivity", "s0", ")", 
			"(", "sensitivity", "s1", ")",
			"(", "sensitivity", "s2", ")",
			"(", "dominance", "(", "s0", "s6", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC1, &changed, NULL, NULL, NULL);
	uint32_t finished = 0;

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_roleallow(CuTest *tc) {
	char *line[] = {"(", "role", "foo", ")", \
			"(", "role", "bar", ")", \
			"(", "roleallow", "foo", "bar", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next, &finished, args);	
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_roleallow_neg(CuTest *tc) {
	char *line[] = {"(", "role", "foo", ")", \
			"(", "roleallow", "foo", "bar", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_sensalias(CuTest *tc) {
	char *line[] = {"(", "sensitivity", "s0", ")",
			"(", "sensitivityalias", "s0", "alias", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MLS, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_sensalias_neg(CuTest *tc) {
	char *line[] = {"(", "sensitivityalias", "s0", "alias", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MLS, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_catalias(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")", 
			"(", "categoryalias", "c0", "red", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MLS, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_catalias_neg(CuTest *tc) {
	char *line[] = {"(", "categoryalias", "c0", "red", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	uint32_t finished = 0;

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_catset(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "category", "c1", ")",
			"(", "category", "c2", ")",
			"(", "categoryset", "somecats", "(", "c0", "c1", "c2", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MLS, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_catset_catlist_neg(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "category", "c1", ")",
			"(", "categoryset", "somecats", "(", "c0", "c1", "c2", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MLS, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_catrange(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
                        "(", "category", "c255", ")",
                        "(", "categoryorder", "(", "c0", "c255", ")", ")",
                        "(", "categoryrange", "range", "(", "c0", "c255", ")", ")", NULL};


	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC1, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	cil_resolve_catorder(test_db->ast->root->cl_head->next->next, args);
	__cil_verify_order(test_db->catorder, test_db->ast->root, CIL_CAT);

	args->pass = CIL_PASS_MLS;

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_catrange_neg(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
                        "(", "category", "c255", ")",
                        "(", "categoryorder", "(", "c0", "c255", ")", ")",
                        "(", "categoryrange", "range", "(", "c255", "c0", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MLS, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_level(CuTest *tc) {
        char *line[] = {"(", "sensitivity", "s0", ")",
			"(", "category", "c1", ")",
			"(", "sensitivitycategory", "s0", "(", "c1", ")", ")",
			"(", "level", "l2", "(", "s0", "(", "c1", ")", ")", ")",  NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC1, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_tree_walk(test_db->ast->root,  __cil_resolve_ast_node_helper, NULL, NULL, args);
	__cil_verify_order(test_db->catorder, test_db->ast->root, CIL_CAT);

	__cil_verify_order(test_db->dominance, test_db->ast->root, CIL_SENS);

	args->pass = CIL_PASS_MLS;
	cil_tree_walk(test_db->ast->root, __cil_resolve_ast_node_helper, NULL, NULL, args);

	args->pass = CIL_PASS_MISC2;
	cil_tree_walk(test_db->ast->root, __cil_resolve_ast_node_helper, NULL, NULL, args);

	args->pass = CIL_PASS_MISC3;
	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, finished, 0);
}

void test_cil_resolve_ast_node_helper_level_neg(CuTest *tc) {
        char *line[] = {"(", "sensitivity", "s0", ")",
			"(", "category", "c1", ")",
			"(", "sensitivitycategory", "s0", "(", "c1", ")", ")",
			"(", "level", "l2", "(", "s8", "(", "c1", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC1, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_tree_walk(test_db->ast->root,  __cil_resolve_ast_node_helper, NULL, NULL, args);
	__cil_verify_order(test_db->catorder, test_db->ast->root, CIL_CAT);

	__cil_verify_order(test_db->dominance, test_db->ast->root, CIL_SENS);

	args->pass = CIL_PASS_MLS;
	cil_tree_walk(test_db->ast->root, __cil_resolve_ast_node_helper, NULL, NULL, args);

	args->pass = CIL_PASS_MISC3;

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, finished, 0);
}

void test_cil_resolve_ast_node_helper_levelrange(CuTest *tc) {
        char *line[] = {"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "categoryorder", "(", "c0", ")", ")",
			"(", "dominance", "(", "s0", ")", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "levelrange", "range", "(", "(", "s0", "(", "c0", ")", ")", "(", "s0", "(", "c0", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC1, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	cil_tree_walk(test_db->ast->root,  __cil_resolve_ast_node_helper, NULL, NULL, args);

	__cil_verify_order(test_db->catorder, test_db->ast->root, CIL_CAT);

	__cil_verify_order(test_db->dominance, test_db->ast->root, CIL_SENS);

	args->pass = CIL_PASS_MLS;
	cil_tree_walk(test_db->ast->root, __cil_resolve_ast_node_helper, NULL, NULL, args);

	args->pass = CIL_PASS_MISC2;
	cil_tree_walk(test_db->ast->root, __cil_resolve_ast_node_helper, NULL, NULL, args);

	args->pass = CIL_PASS_MISC3;
	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, finished, 0);
}

void test_cil_resolve_ast_node_helper_levelrange_neg(CuTest *tc) {
        char *line[] = {"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "categoryorder", "(", "c0", ")", ")",
			"(", "dominance", "(", "s0", ")", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "levelrange", "range", "(", "(", "DNE", "(", "c0", ")", ")", "(", "s0", "(", "c0", ")", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC1, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_tree_walk(test_db->ast->root,  __cil_resolve_ast_node_helper, NULL, NULL, args);
	__cil_verify_order(test_db->catorder, test_db->ast->root, CIL_CAT);

	__cil_verify_order(test_db->dominance, test_db->ast->root, CIL_SENS);

	args->pass = CIL_PASS_MLS;
	cil_tree_walk(test_db->ast->root, __cil_resolve_ast_node_helper, NULL, NULL, args);

	args->pass = CIL_PASS_MISC3;

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, finished, 0);
}

void test_cil_resolve_ast_node_helper_constrain(CuTest *tc) {
        char *line[] = {"(", "class", "file", "(", "create", "relabelto", ")", ")",
			"(", "class", "dir", "(", "create", "relabelto", ")", ")",
			"(", "sensitivity", "s0", ")",
			"(", "category", "c1", ")",
			"(", "role", "r1", ")",
			"(", "role", "r2", ")",
			"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "r1", "r2", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_constrain_neg(CuTest *tc) {
        char *line[] = {"(", "class", "file", "(", "create", ")", ")",
			"(", "class", "dir", "(", "create", ")", ")",
			"(", "sensitivity", "s0", ")",
			"(", "category", "c1", ")",
			"(", "role", "r1", ")",
			"(", "role", "r2", ")",
			"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "r1", "r2", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_mlsconstrain(CuTest *tc) {
        char *line[] = {"(", "class", "file", "(", "create", "relabelto", ")", ")",
			"(", "class", "dir", "(", "create", "relabelto", ")", ")",
			"(", "sensitivity", "s0", ")",
			"(", "category", "c1", ")",
			"(", "level", "l2", "(", "s0", "(", "c1", ")", ")", ")",
			"(", "level", "h2", "(", "s0", "(", "c1", ")", ")", ")",
			"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "l2", "h2", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_mlsconstrain_neg(CuTest *tc) {
        char *line[] = {"(", "class", "file", "(", "read", ")", ")",
			"(", "class", "dir", "(", "read", ")", ")",
			"(", "sensitivity", "s0", ")",
			"(", "category", "c1", ")",
			"(", "level", "l2", "(", "s0", "(", "c1", ")", ")", ")",
			"(", "level", "h2", "(", "s0", "(", "c1", ")", ")", ")",
			"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "l2", "h2", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_context(CuTest *tc) {
	char *line[] = {"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "user", "system_u", ")",
			"(", "role", "object_r", ")",
			"(", "type", "netif_t", ")",
			"(", "context", "con",
                        "(", "system_u", "object_r", "netif_t", "(", "low", "high", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC1, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_tree_walk(test_db->ast->root,  __cil_resolve_ast_node_helper, NULL, NULL, args);
	__cil_verify_order(test_db->catorder, test_db->ast->root, CIL_CAT);

	__cil_verify_order(test_db->dominance, test_db->ast->root, CIL_SENS);

	args->pass = CIL_PASS_MLS;
	cil_tree_walk(test_db->ast->root, __cil_resolve_ast_node_helper, NULL, NULL, args);

	args->pass = CIL_PASS_MISC3;

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, finished, 0);
}

void test_cil_resolve_ast_node_helper_context_neg(CuTest *tc) {
	char *line[] = {"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "user", "system_u", ")",
			"(", "role", "object_r", ")",
			"(", "type", "netif_t", ")",
			"(", "context", "con",
                        "(", "system_u", "object_r", "netif_t", "DNE", "high", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC1, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_tree_walk(test_db->ast->root,  __cil_resolve_ast_node_helper, NULL, NULL, args);
	__cil_verify_order(test_db->catorder, test_db->ast->root, CIL_CAT);

	__cil_verify_order(test_db->dominance, test_db->ast->root, CIL_SENS);

	args->pass = CIL_PASS_MLS;
	cil_tree_walk(test_db->ast->root, __cil_resolve_ast_node_helper, NULL, NULL, args);

	args->pass = CIL_PASS_MISC3;

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
	CuAssertIntEquals(tc, finished, 0);
}

void test_cil_resolve_ast_node_helper_senscat(CuTest *tc) {
	char *line[] = {"(", "sensitivity", "s0", ")",
                        "(", "sensitivity", "s1", ")",
                        "(", "dominance", "(", "s0", "s1", ")", ")",
                        "(", "category", "c0", ")",
                        "(", "category", "c255", ")",
                        "(", "categoryorder", "(", "c0", "c255", ")", ")",
                        "(", "sensitivitycategory", "s1", "(", "c0", "c255", ")", ")", NULL};
	
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_senscat_neg(CuTest *tc) {
	char *line[] = {"(", "sensitivity", "s0", ")",
                        "(", "sensitivity", "s1", ")",
                        "(", "dominance", "(", "s0", "s1", ")", ")",
                        "(", "category", "c0", ")",
                        "(", "category", "c255", ")",
                        "(", "categoryorder", "(", "c0", "c255", ")", ")",
                        "(", "sensitivitycategory", "s5", "foo", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_roletransition(CuTest *tc) {
	char *line[] = {"(", "role", "foo_r", ")",
			"(", "type", "bar_t", ")",
			"(", "role", "foobar_r", ")", 
			"(", "class", "process", "(", "transition", ")", ")",
			"(", "roletransition", "foo_r", "bar_t", "process", "foobar_r", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_roletransition_srcdecl_neg(CuTest *tc) {
	char *line[] = {"(", "type", "bar_t", ")",
			"(", "role", "foobar_r", ")", 
			"(", "class", "process", "(", "transition", ")", ")",
			"(", "roletransition", "foo_r", "bar_t", "process", "foobar_r", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_roletransition_tgtdecl_neg(CuTest *tc) {
	char *line[] = {"(", "role", "foo_r", ")",
			"(", "role", "foobar_r", ")", 
			"(", "class", "process", "(", "transition", ")", ")",
			"(", "roletransition", "foo_r", "bar_t", "process", "foobar_r", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_roletransition_resultdecl_neg(CuTest *tc) {
	char *line[] = {"(", "role", "foo_r", ")",
			"(", "type", "bar_t", ")",
			"(", "class", "process", "(", "transition", ")", ")",
			"(", "roletransition", "foo_r", "bar_t", "process", "foobar_r", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_typeattributeset(CuTest *tc) {
	char *line[] = {"(", "typeattribute", "attrs", ")",
			"(", "type", "type_t", ")",
			"(", "type", "type_tt", ")",
			"(", "typeattributeset", "attrs", "(", "type_t", "type_tt", ")", ")", NULL}; 

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_typeattributeset_undef_type_neg(CuTest *tc) {
	char *line[] = {"(", "typeattribute", "attrs", ")",
			"(", "type", "type_t", ")",
			"(", "typeattributeset", "attrs", "(", "not", "t_t", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_typealias(CuTest *tc) {
	char *line[] = {"(", "block", "foo", 
				"(", "typealias", ".foo.test", "type_t", ")", 
				"(", "type", "test", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->cl_head, &finished, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_typealias_notype_neg(CuTest *tc) {
	char *line[] = {"(", "block", "bar", 
				"(", "typealias", ".bar.test", "type_t", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->cl_head, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_typebounds(CuTest *tc) {
	char *line[] = {"(", "type", "type_a", ")",
			"(", "type", "type_b", ")",
			"(", "typebounds", "type_a", "type_b", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_typebounds_neg(CuTest *tc) {
	char *line[] = {"(", "type", "type_b", ")",
			"(", "typebounds", "type_a", "type_b", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_typepermissive(CuTest *tc) {
	char *line[] = {"(", "type", "type_a", ")",
			"(", "typepermissive", "type_a", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);
	uint32_t finished = 0;
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_typepermissive_neg(CuTest *tc) {
	char *line[] = {"(", "type", "type_b", ")",
			"(", "typepermissive", "type_a", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_rangetransition(CuTest *tc) {
	char *line[] = {"(", "class", "class_", "(", "read", ")", ")",
			"(", "type", "type_a", ")",
			"(", "type", "type_b", ")",
			"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "rangetransition", "type_a", "type_b", "class_", "(", "low", "high", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next->next->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_rangetransition_neg(CuTest *tc) {
	char *line[] = {"(", "class", "class_", "(", "read", ")", ")",
			"(", "type", "type_a", ")",
			"(", "type", "type_b", ")",
			"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "rangetransition", "type_DNE", "type_b", "class_", "(", "low", "high", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next->next->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_nametypetransition(CuTest *tc) {
	char *line[] = {"(", "type", "foo", ")",
			"(", "type", "bar", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "type", "foobar", ")",
			"(", "nametypetransition", "str", "foo", "bar", "file", "foobar", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_nametypetransition_neg(CuTest *tc) {
	char *line[] = {"(", "type", "foo", ")",
			"(", "type", "bar", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "type", "foobar", ")",
			"(", "nametypetransition", "str", "foo", "bar", "file", "foobarrr", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_avrule(CuTest *tc) {
	char *line[] = {"(", "class", "bar", "(", "read", "write", "open", ")", ")", 
	                "(", "type", "test", ")", 
			"(", "type", "foo", ")", 
	                "(", "allow", "test", "foo", "(", "bar", "(", "read", "write", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_avrule_src_nores_neg(CuTest *tc) {
	char *line[] = {"(", "allow", "test", "foo", "(", "bar", "(", "read", "write", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_avrule_tgt_nores_neg(CuTest *tc) {
	char *line[] = {"(", "type", "test", ")", 
			"(", "allow", "test", "foo", "(", "bar", "(", "read", "write", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_avrule_class_nores_neg(CuTest *tc) {
	char *line[] = {"(", "type", "test", ")", 
			"(", "type", "foo", ")", 
			"(", "allow", "test", "foo", "(", "bar", "(", "read", "write", ")", ")", ")", NULL};
	
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_avrule_datum_null_neg(CuTest *tc) {
	char *line[] = {"(", "class", "bar", "(", "read", "write", "open", ")", ")",
	                "(", "type", "test", ")", "(", "type", "foo", ")",
	                "(", "allow", "test", "foo", "(", "bar", "(","fake", ")", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_type_rule_transition(CuTest *tc) {
	char *line[] = {"(", "type", "foo", ")",
			"(", "type", "bar", ")",
			"(", "class", "file", "(", "write", ")", ")",
			"(", "type", "foobar", ")",
			"(", "typetransition", "foo", "bar", "file", "foobar", ")", NULL};
	
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_type_rule_transition_neg(CuTest *tc) {
	char *line[] = {"(", "type", "foo", ")",
			"(", "class", "file", "(", "write", ")", ")",
			"(", "type", "foobar", ")",
			"(", "typetransition", "foo", "bar", "file", "foobar", ")", NULL};
	
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_type_rule_change(CuTest *tc) {
	char *line[] = {"(", "type", "foo", ")",
			"(", "type", "bar", ")",
			"(", "class", "file", "(", "write", ")", ")",
			"(", "type", "foobar", ")",
			"(", "typechange", "foo", "bar", "file", "foobar", ")", NULL};
	
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_type_rule_change_neg(CuTest *tc) {
	char *line[] = {"(", "type", "foo", ")",
			"(", "class", "file", "(", "write", ")", ")",
			"(", "type", "foobar", ")",
			"(", "typechange", "foo", "bar", "file", "foobar", ")", NULL};
	
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_type_rule_member(CuTest *tc) {
	char *line[] = {"(", "type", "foo", ")",
			"(", "type", "bar", ")",
			"(", "class", "file", "(", "write", ")", ")",
			"(", "type", "foobar", ")",
			"(", "typemember", "foo", "bar", "file", "foobar", ")", NULL};
	
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_type_rule_member_neg(CuTest *tc) {
	char *line[] = {"(", "type", "foo", ")",
			"(", "class", "file", "(", "write", ")", ")",
			"(", "type", "foobar", ")",
			"(", "typemember", "foo", "bar", "file", "foobar", ")", NULL};
	
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;
	
	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_userbounds(CuTest *tc) {
	char *line[] = {"(", "user", "user1", ")",
			"(", "user", "user2", ")",
			"(", "userbounds", "user1", "user2", ")", NULL};
		
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	struct cil_tree_node *test_ast_node;
	cil_tree_node_init(&test_ast_node);

	uint32_t finished = 0;

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next, &finished, args);
	CuAssertIntEquals(tc, 0, finished);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_ast_node_helper_userbounds_neg(CuTest *tc) {
	char *line[] = {"(", "user", "user1", ")",
			"(", "userbounds", "user1", "user2", ")", NULL};
		
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	struct cil_tree_node *test_ast_node;
	cil_tree_node_init(&test_ast_node);

	uint32_t finished = 0;

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next, &finished, args);
	CuAssertIntEquals(tc, 0, finished);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_ast_node_helper_roletype(CuTest *tc) {
	char *line[] = {"(", "role",  "admin_r", ")",
			"(", "type", "admin_t", ")",
			"(", "roletype", "admin_r", "admin_t", ")", NULL};
		
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	struct cil_tree_node *test_ast_node;
	cil_tree_node_init(&test_ast_node);

	uint32_t finished = 0;

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next, &finished, args);
	CuAssertIntEquals(tc, 0, finished);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_ast_node_helper_roletype_role_neg(CuTest *tc) {
	char *line[] = {"(", "type", "admin_t", ")",
			"(", "roletype", "admin_r", "admin_t", ")", NULL};
		
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	struct cil_tree_node *test_ast_node;
	cil_tree_node_init(&test_ast_node);

	uint32_t finished = 0;

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next, &finished, args);
	CuAssertIntEquals(tc, 0, finished);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_ast_node_helper_roletype_type_neg(CuTest *tc) {
	char *line[] = {"(", "role", "admin_r", ")",
			"(", "roletype", "admin_r", "admin_t", ")", NULL};
		
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	struct cil_tree_node *test_ast_node;
	cil_tree_node_init(&test_ast_node);

	uint32_t finished = 0;

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next, &finished, args);
	CuAssertIntEquals(tc, 0, finished);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_ast_node_helper_userrole(CuTest *tc) {
	char *line[] = {"(", "role",  "staff_r", ")",
			"(", "user", "staff_u", ")",
			"(", "userrole", "staff_u", "staff_r", ")", NULL};
		
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	struct cil_tree_node *test_ast_node;
	cil_tree_node_init(&test_ast_node);

	uint32_t finished = 0;

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next, &finished, args);
	CuAssertIntEquals(tc, 0, finished);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_ast_node_helper_userrole_user_neg(CuTest *tc) {
	char *line[] = {"(", "role",  "staff_r", ")",
			"(", "userrole", "staff_u", "staff_r", ")", NULL};
		
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	struct cil_tree_node *test_ast_node;
	cil_tree_node_init(&test_ast_node);

	uint32_t finished = 0;

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next, &finished, args);
	CuAssertIntEquals(tc, 0, finished);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_ast_node_helper_userrole_role_neg(CuTest *tc) {
	char *line[] = {"(", "user",  "staff_u", ")",
			"(", "userrole", "staff_u", "staff_r", ")", NULL};
		
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	struct cil_tree_node *test_ast_node;
	cil_tree_node_init(&test_ast_node);

	uint32_t finished = 0;

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next, &finished, args);
	CuAssertIntEquals(tc, 0, finished);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_ast_node_helper_userlevel(CuTest *tc) {
	char *line[] = {"(", "user",  "foo_u", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "userlevel", "foo_u", "low", ")", NULL};
		
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	struct cil_tree_node *test_ast_node;
	cil_tree_node_init(&test_ast_node);

	uint32_t finished = 0;

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next->next->next, &finished, args);
	CuAssertIntEquals(tc, 0, finished);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_ast_node_helper_userlevel_neg(CuTest *tc) {
	char *line[] = {"(", "user",  "foo_u", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "userlevel", "DNE", "low", ")", NULL};
		
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	struct cil_tree_node *test_ast_node;
	cil_tree_node_init(&test_ast_node);

	uint32_t finished = 0;

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next->next->next, &finished, args);
	CuAssertIntEquals(tc, 0, finished);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_ast_node_helper_userrange(CuTest *tc) {
	char *line[] = {"(", "user",  "foo_u", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "levelrange", "range", "(", "(", "s0", "(", "c0", ")", ")", "(", "s0", "(", "c0", ")", ")", ")", ")",
			"(", "userrange", "foo_u", "range", ")", NULL};
		
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	struct cil_tree_node *test_ast_node;
	cil_tree_node_init(&test_ast_node);

	uint32_t finished = 0;

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next->next->next, &finished, args);
	CuAssertIntEquals(tc, 0, finished);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_ast_node_helper_userrange_neg(CuTest *tc) {
	char *line[] = {"(", "user",  "foo_u", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "levelrange", "range", "(", "(", "s0", "(", "c0", ")", ")", "(", "s0", "(", "c0", ")", ")", ")", ")",
			"(", "userrange", "DNE", "range", ")", NULL};
		
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	struct cil_tree_node *test_ast_node;
	cil_tree_node_init(&test_ast_node);

	uint32_t finished = 0;

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next->next->next, &finished, args);
	CuAssertIntEquals(tc, 0, finished);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}

void test_cil_resolve_ast_node_helper_filecon(CuTest *tc) {
	char *line[] = {"(", "user", "user_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "context", "con", "(", "user_u", "role_r", "type_t", "(", "low", "high", ")", ")", ")",
			"(", "filecon", "root", "path", "file", "con", ")", NULL};
        
	struct cil_tree *test_tree;
        gen_test_tree(&test_tree, line);

        struct cil_db *test_db;
        cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

        uint32_t finished = 0;

        cil_build_ast(test_db, test_tree->root, test_db->ast->root);

        int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, &finished, args);
        CuAssertIntEquals(tc, SEPOL_OK, rc);
        CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_filecon_neg(CuTest *tc) {
	char *line[] = {"(", "user", "user_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "context", "con", "(", "user_u", "role_r", "type_t", "(", "low", "high", ")", ")", ")",
			"(", "filecon", "root", "path", "file", "foo", ")", NULL};
 
        struct cil_tree *test_tree;
        gen_test_tree(&test_tree, line);

        struct cil_db *test_db;
        cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

        uint32_t finished = 0;

        cil_build_ast(test_db, test_tree->root, test_db->ast->root);

        int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, &finished, args);
        CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
        CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_portcon(CuTest *tc) {
	char *line[] = {"(", "user", "user_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "context", "con", "(", "user_u", "role_r", "type_t", "(", "low", "high", ")", ")", ")",
			"(", "portcon", "udp", "25", "con", ")", NULL};
        
	struct cil_tree *test_tree;
        gen_test_tree(&test_tree, line);

        struct cil_db *test_db;
        cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

        uint32_t finished = 0;

        cil_build_ast(test_db, test_tree->root, test_db->ast->root);

        int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, &finished, args);
        CuAssertIntEquals(tc, SEPOL_OK, rc);
        CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_portcon_neg(CuTest *tc) {
	char *line[] = {"(", "user", "user_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "context", "con", "(", "user_u", "role_r", "type_t", "(", "low", "high", ")", ")", ")",
			"(", "portcon", "udp", "25", "foo", ")", NULL};
 
        struct cil_tree *test_tree;
        gen_test_tree(&test_tree, line);

        struct cil_db *test_db;
        cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

        uint32_t finished = 0;

        cil_build_ast(test_db, test_tree->root, test_db->ast->root);

        int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, &finished, args);
        CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
        CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_genfscon(CuTest *tc) {
	char *line[] = {"(", "user", "user_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "context", "con", "(", "user_u", "role_r", "type_t", "(", "low", "high", ")", ")", ")",
			"(", "genfscon", "type", "path", "con", ")", NULL};
        
	struct cil_tree *test_tree;
        gen_test_tree(&test_tree, line);

        struct cil_db *test_db;
        cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

        uint32_t finished = 0;

        cil_build_ast(test_db, test_tree->root, test_db->ast->root);

        int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, &finished, args);
        CuAssertIntEquals(tc, SEPOL_OK, rc);
        CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_genfscon_neg(CuTest *tc) {
	char *line[] = {"(", "user", "user_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "context", "con", "(", "user_u", "role_r", "type_t", "(", "low", "high", ")", ")", ")",
			"(", "genfscon", "type", "path", "foo", ")", NULL};
 
        struct cil_tree *test_tree;
        gen_test_tree(&test_tree, line);

        struct cil_db *test_db;
        cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

        uint32_t finished = 0;

        cil_build_ast(test_db, test_tree->root, test_db->ast->root);

        int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next, &finished, args);
        CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
        CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_nodecon(CuTest *tc) {
	char *line[] = {"(", "user", "user_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "context", "con", "(", "user_u", "role_r", "type_t", "(", "low", "high", ")", ")", ")",
			"(", "ipaddr", "ip", "192.168.1.1", ")",
			"(", "nodecon", "ip", "ip", "con", ")", NULL};
        
	struct cil_tree *test_tree;
        gen_test_tree(&test_tree, line);

        struct cil_db *test_db;
        cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

        uint32_t finished = 0;

        cil_build_ast(test_db, test_tree->root, test_db->ast->root);

        int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next, &finished, args);
        CuAssertIntEquals(tc, SEPOL_OK, rc);
        CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_nodecon_ipaddr_neg(CuTest *tc) {
	char *line[] = {"(", "user", "user_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "context", "con", "(", "user_u", "role_r", "type_t", "(", "low", "high", ")", ")", ")",
			"(", "ipaddr", "ip", "192.168.1.1", ")",
			"(", "ipaddr", "netmask", "192.168.1.1", ")",
			"(", "nodecon", "ipp", "netmask", "foo", ")", NULL};
 
        struct cil_tree *test_tree;
        gen_test_tree(&test_tree, line);

        struct cil_db *test_db;
        cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

        uint32_t finished = 0;

        cil_build_ast(test_db, test_tree->root, test_db->ast->root);

        int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next->next, &finished, args);
        CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
        CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_nodecon_netmask_neg(CuTest *tc) {
	char *line[] = {"(", "user", "user_u", ")",
			"(", "role", "role_r", ")",
			"(", "type", "type_t", ")",
			"(", "category", "c0", ")",
			"(", "sensitivity", "s0", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "context", "con", "(", "user_u", "role_r", "type_t", "(", "low", "high", ")", ")", ")",
			"(", "ipaddr", "ip", "192.168.1.1", ")",
			"(", "ipaddr", "netmask", "192.168.1.1", ")",
			"(", "nodecon", "ip", "nnetmask", "foo", ")", NULL};
 
        struct cil_tree *test_tree;
        gen_test_tree(&test_tree, line);

        struct cil_db *test_db;
        cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

        uint32_t finished = 0;

        cil_build_ast(test_db, test_tree->root, test_db->ast->root);

        int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next->next, &finished, args);
        CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
        CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_netifcon(CuTest *tc) {
	char *line[] = {"(", "context", "if_default", "(", "system_u", "object_r", "etc_t", "(", "low", "high", ")", ")", ")",
			"(", "context", "packet_default", "(", "system_u", "object_r", "etc_t", "(", "low", "high", ")", ")", ")", 
			"(", "netifcon", "eth0", "if_default", "packet_default", ")", NULL};
        
	struct cil_tree *test_tree;
        gen_test_tree(&test_tree, line);

        struct cil_db *test_db;
        cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

        uint32_t finished = 0;

        cil_build_ast(test_db, test_tree->root, test_db->ast->root);

        int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next, &finished, args);
        CuAssertIntEquals(tc, SEPOL_OK, rc);
        CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_netifcon_neg(CuTest *tc) {
	char *line[] = {"(", "context", "if_default", "(", "system_u", "object_r", "etc_t", "(", "low", "high", ")", ")", ")",
			"(", "netifcon", "eth0", "if_default", "packet_default", ")", NULL};
 
        struct cil_tree *test_tree;
        gen_test_tree(&test_tree, line);

        struct cil_db *test_db;
        cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

        uint32_t finished = 0;

        cil_build_ast(test_db, test_tree->root, test_db->ast->root);

        int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next, &finished, args);
        CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
        CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_pirqcon(CuTest *tc) {
	char *line[] = {"(", "context", "con", "(", "system_u", "object_r", "etc_t", "(", "low", "high", ")", ")", ")",
			"(", "pirqcon", "1", "con", ")", NULL};
        
	struct cil_tree *test_tree;
        gen_test_tree(&test_tree, line);

        struct cil_db *test_db;
        cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

        uint32_t finished = 0;

        cil_build_ast(test_db, test_tree->root, test_db->ast->root);

        int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next, &finished, args);
        CuAssertIntEquals(tc, SEPOL_OK, rc);
        CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_pirqcon_neg(CuTest *tc) {
	char *line[] = {"(", "context", "con", "(", "system_u", "object_r", "etc_t", "(", "low", "high", ")", ")", ")",
			"(", "pirqcon", "1", "dne", ")", NULL};
        
        struct cil_tree *test_tree;
        gen_test_tree(&test_tree, line);

        struct cil_db *test_db;
        cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

        uint32_t finished = 0;

        cil_build_ast(test_db, test_tree->root, test_db->ast->root);

        int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next, &finished, args);
        CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
        CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_iomemcon(CuTest *tc) {
	char *line[] = {"(", "context", "con", "(", "system_u", "object_r", "etc_t", "(", "low", "high", ")", ")", ")",
			"(", "iomemcon", "1", "con", ")", NULL};
        
	struct cil_tree *test_tree;
        gen_test_tree(&test_tree, line);

        struct cil_db *test_db;
        cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

        uint32_t finished = 0;

        cil_build_ast(test_db, test_tree->root, test_db->ast->root);

        int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next, &finished, args);
        CuAssertIntEquals(tc, SEPOL_OK, rc);
        CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_iomemcon_neg(CuTest *tc) {
	char *line[] = {"(", "context", "con", "(", "system_u", "object_r", "etc_t", "(", "low", "high", ")", ")", ")",
			"(", "iomemcon", "1", "dne", ")", NULL};
        
        struct cil_tree *test_tree;
        gen_test_tree(&test_tree, line);

        struct cil_db *test_db;
        cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

        uint32_t finished = 0;

        cil_build_ast(test_db, test_tree->root, test_db->ast->root);

        int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next, &finished, args);
        CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
        CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_ioportcon(CuTest *tc) {
	char *line[] = {"(", "context", "con", "(", "system_u", "object_r", "etc_t", "(", "low", "high", ")", ")", ")",
			"(", "ioportcon", "1", "con", ")", NULL};
        
	struct cil_tree *test_tree;
        gen_test_tree(&test_tree, line);

        struct cil_db *test_db;
        cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

        uint32_t finished = 0;

        cil_build_ast(test_db, test_tree->root, test_db->ast->root);

        int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next, &finished, args);
        CuAssertIntEquals(tc, SEPOL_OK, rc);
        CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_ioportcon_neg(CuTest *tc) {
	char *line[] = {"(", "context", "con", "(", "system_u", "object_r", "etc_t", "(", "low", "high", ")", ")", ")",
			"(", "ioportcon", "1", "dne", ")", NULL};
        
        struct cil_tree *test_tree;
        gen_test_tree(&test_tree, line);

        struct cil_db *test_db;
        cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

        uint32_t finished = 0;

        cil_build_ast(test_db, test_tree->root, test_db->ast->root);

        int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next, &finished, args);
        CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
        CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_pcidevicecon(CuTest *tc) {
	char *line[] = {"(", "context", "con", "(", "system_u", "object_r", "etc_t", "(", "low", "high", ")", ")", ")",
			"(", "pcidevicecon", "1", "con", ")", NULL};
        
	struct cil_tree *test_tree;
        gen_test_tree(&test_tree, line);

        struct cil_db *test_db;
        cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

        uint32_t finished = 0;

        cil_build_ast(test_db, test_tree->root, test_db->ast->root);

        int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next, &finished, args);
        CuAssertIntEquals(tc, SEPOL_OK, rc);
        CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_pcidevicecon_neg(CuTest *tc) {
	char *line[] = {"(", "context", "con", "(", "system_u", "object_r", "etc_t", "(", "low", "high", ")", ")", ")",
			"(", "pcidevicecon", "1", "dne", ")", NULL};
        
        struct cil_tree *test_tree;
        gen_test_tree(&test_tree, line);

        struct cil_db *test_db;
        cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

        uint32_t finished = 0;

        cil_build_ast(test_db, test_tree->root, test_db->ast->root);

        int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next, &finished, args);
        CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
        CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_fsuse(CuTest *tc) {
	char *line[] = {"(", "sensitivity", "s0", ")",
			"(", "category", "c0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "user", "system_u", ")",
			"(", "role", "object_r", ")",
			"(", "type", "netif_t", ")",
			"(", "context", "con", "(", "system_u", "object_r", "netif_t", "(", "low", "high", ")", ")", ")",
			"(", "fsuse", "xattr", "ext3", "con", ")", NULL};
        
	struct cil_tree *test_tree;
        gen_test_tree(&test_tree, line);

        struct cil_db *test_db;
        cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

        uint32_t finished = 0;

        cil_build_ast(test_db, test_tree->root, test_db->ast->root);

        int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next, &finished, args);
        CuAssertIntEquals(tc, SEPOL_OK, rc);
        CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_fsuse_neg(CuTest *tc) {
	char *line[] = {"(", "context", "if_default", "(", "system_u", "object_r", "etc_t", "(", "low", "high", ")", ")", ")",
			"(", "netifcon", "eth0", "if_default", "packet_default", ")", NULL};
 
        struct cil_tree *test_tree;
        gen_test_tree(&test_tree, line);

        struct cil_db *test_db;
        cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

        uint32_t finished = 0;

        cil_build_ast(test_db, test_tree->root, test_db->ast->root);

        int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next, &finished, args);
        CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
        CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_sidcontext(CuTest *tc) {
	char *line[] = {"(", "category", "c0", ")",
			"(", "categoryorder", "(", "c0", ")", ")",
			"(", "sensitivity", "s0", ")",
			"(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
			"(", "type", "blah_t", ")",
			"(", "role", "blah_r", ")",
			"(", "user", "blah_u", ")",
			"(", "level", "low", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "level", "high", "(", "s0", "(", "c0", ")", ")", ")",
			"(", "sid", "test", "(", "blah_u", "blah_r", "blah_t", "(", "low", "high", ")", ")", ")", NULL};
        
	struct cil_tree *test_tree;
        gen_test_tree(&test_tree, line);

        struct cil_db *test_db;
        cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

        uint32_t finished = 0;

        cil_build_ast(test_db, test_tree->root, test_db->ast->root);

        int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next->next->next->next->next->next->next, &finished, args);
        CuAssertIntEquals(tc, SEPOL_OK, rc);
        CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_sidcontext_neg(CuTest *tc) {
       	char *line[] = {"(", "category", "c0", ")",
                        "(", "categoryorder", "(", "c0", ")", ")",
                        "(", "sensitivity", "s0", ")",
                        "(", "sensitivitycategory", "s0", "(", "c0", ")", ")",
                        "(", "type", "blah_t", ")",
                        "(", "role", "blah_r", ")",
                        "(", "user", "blah_u", ")",
                        "(", "sidcontext", "test", "(", "", "blah_r", "blah_t", "(", "(", "s0", "(", "c0", ")", ")", "(", "s0", "(", "c0", ")", ")", ")", ")", ")", NULL};
 
        struct cil_tree *test_tree;
        gen_test_tree(&test_tree, line);

        struct cil_db *test_db;
        cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

        uint32_t finished = 0;

        cil_build_ast(test_db, test_tree->root, test_db->ast->root);

        int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next->next->next->next->next, &finished, args);
        CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
        CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_blockinherit(CuTest *tc) {
	char *line[] = {"(", "block", "baz", "(", "type", "foo", ")", ")",
			"(", "block", "bar", "(", "type", "a", ")",
				"(", "blockinherit", "baz", ")", ")", NULL};
        
	struct cil_tree *test_tree;
        gen_test_tree(&test_tree, line);

        struct cil_db *test_db;
        cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_BLKIN, &changed, NULL, NULL, NULL);

        uint32_t finished = 0;

        cil_build_ast(test_db, test_tree->root, test_db->ast->root);

        int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->cl_head->next, &finished, args);
        CuAssertIntEquals(tc, SEPOL_OK, rc);
        CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_classcommon(CuTest *tc) {
	char *line[] = {"(", "class", "file", "(", "read", ")", ")",
			"(", "common", "file", "(", "write", ")", ")",	
			"(", "classcommon", "file", "file", ")", NULL};
        
	struct cil_tree *test_tree;
        gen_test_tree(&test_tree, line);

        struct cil_db *test_db;
        cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

        uint32_t finished = 0;

        cil_build_ast(test_db, test_tree->root, test_db->ast->root);

        int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next, &finished, args);
        CuAssertIntEquals(tc, SEPOL_OK, rc);
        CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_classcommon_neg(CuTest *tc) {
	char *line[] = {"(", "class", "file", "(", "read", ")", ")",
			"(", "classcommon", "file", "file", ")", NULL};
        
	struct cil_tree *test_tree;
        gen_test_tree(&test_tree, line);

        struct cil_db *test_db;
        cil_db_init(&test_db);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, NULL, NULL);

        uint32_t finished = 0;

        cil_build_ast(test_db, test_tree->root, test_db->ast->root);

        int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next, &finished, args);
        CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
        CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_rolebounds(CuTest *tc) {
	char *line[] = {"(", "role", "role1", ")",
			"(", "role", "role2", ")",
			"(", "rolebounds", "role1", "role2", ")", NULL};
		
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	struct cil_tree_node *test_ast_node;
	cil_tree_node_init(&test_ast_node);

	uint32_t finished = 0;

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next, &finished, args);
	CuAssertIntEquals(tc, 0, finished);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_ast_node_helper_rolebounds_neg(CuTest *tc) {
	char *line[] = {"(", "role", "role1", ")",
			"(", "rolebounds", "role1", "role2", ")", NULL};
		
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	struct cil_tree_node *test_ast_node;
	cil_tree_node_init(&test_ast_node);

	uint32_t finished = 0;

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next, &finished, args);
	CuAssertIntEquals(tc, 0, finished);
	CuAssertIntEquals(tc, SEPOL_ENOENT, rc);
}


void test_cil_resolve_ast_node_helper_callstack(CuTest *tc) {
	char *line[] = {"(", "call", "mm", "(", "foo", ")", ")", NULL};
		
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	struct cil_tree_node *test_ast_node;
	cil_tree_node_init(&test_ast_node);

	struct cil_tree_node *test_ast_node_call;
	cil_tree_node_init(&test_ast_node_call);
	test_ast_node_call->flavor = CIL_CALL;

	uint32_t finished = 0;

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	__cil_resolve_ast_node_helper(test_db->ast->root->cl_head, &finished, args);
	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head, &finished, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_ast_node_helper_call(CuTest *tc) {
	char *line[] = {"(", "call", "mm", "(", "foo", ")", ")", NULL};
		
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	struct cil_tree_node *test_ast_node;
	cil_tree_node_init(&test_ast_node);

	struct cil_tree_node *test_ast_node_call;
	cil_tree_node_init(&test_ast_node_call);
	test_ast_node_call->flavor = CIL_CALL;

	uint32_t finished = 0;

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head, &finished, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_ast_node_helper_optional(CuTest *tc) {
	char *line[] = {"(", "optional", "opt", "(", "allow", "foo", "bar", "(", "file", "(", "read", ")", ")", ")", ")", NULL};
		
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	struct cil_tree_node *test_ast_node;
	cil_tree_node_init(&test_ast_node);

	struct cil_tree_node *test_ast_node_opt;
	cil_tree_node_init(&test_ast_node_opt);
	test_ast_node_opt->flavor = CIL_OPTIONAL;

	uint32_t finished = 0;

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	// set optional to disabled
	((struct cil_symtab_datum *)test_db->ast->root->cl_head->data)->state = CIL_STATE_DISABLED;

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head, &finished, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_ast_node_helper_macro(CuTest *tc) {
	char *line[] = {"(", "macro", "mm", "(", "(", "type", "a", ")", ")",
				"(", "type", "b", ")",
				"(", "allow", "a", "b", "(", "file", "(", "read", ")", ")", ")", ")", NULL};
		
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	struct cil_tree_node *test_ast_node;
	cil_tree_node_init(&test_ast_node);

	uint32_t finished = 0;

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head, &finished, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_ast_node_helper_optstack(CuTest *tc) {
	char *line[] = {"(", "class", "baz", "(", "read", ")", ")",
			"(", "type", "foo", ")",
			"(", "type", "bar", ")",
			"(", "optional", "opt", "(", "allow", "foo", "bar", "(", "baz", "(", "read", ")", ")", ")", ")", NULL};
		
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	struct cil_tree_node *test_ast_node;
	cil_tree_node_init(&test_ast_node);

	struct cil_tree_node *test_ast_node_opt;
	cil_tree_node_init(&test_ast_node_opt);
	test_ast_node_opt->flavor = CIL_OPTIONAL;

	uint32_t finished = 0;

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	__cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next, &finished, args);
	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_OK, rc);
}

void test_cil_resolve_ast_node_helper_optstack_tunable_neg(CuTest *tc) {
	char *line[] = {"(", "tunable", "foo", "true", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	struct cil_tree_node *test_ast_node_opt;
	cil_tree_node_init(&test_ast_node_opt);
	test_ast_node_opt->flavor = CIL_OPTIONAL;

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_TIF, &changed, NULL, test_ast_node_opt, NULL);

	uint32_t finished = 0;

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
}

void test_cil_resolve_ast_node_helper_optstack_macro_neg(CuTest *tc) {
	char *line[] = {"(", "type", "qaz", ")",
			"(", "class", "file", "(", "read", ")", ")",
			"(", "macro", "mm", "(", "(", "type", "a", ")", ")",
				"(", "type", "b", ")",
				"(", "allow", "a", "b", "(", "file", "(", "read", ")", ")", ")", ")",
			"(", "call", "mm", "(", "qaz", ")", ")", NULL};

	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);

	struct cil_tree_node *test_ast_node_opt;
	cil_tree_node_init(&test_ast_node_opt);
	test_ast_node_opt->flavor = CIL_OPTIONAL;

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_CALL1, &changed, NULL, test_ast_node_opt, NULL);

	uint32_t finished = 0;

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);

	cil_resolve_call1(test_db->ast->root->cl_head->next->next, args);

	args->pass = CIL_PASS_CALL2;

	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
	CuAssertIntEquals(tc, 0, finished);
}

void test_cil_resolve_ast_node_helper_nodenull_neg(CuTest *tc) {
	char *line[] = {"(", "role",  "staff_r", ")",
			"(", "user", "staff_u", ")",
			"(", "userrole", "staff_u", "staff_r", ")", NULL};
		
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	struct cil_tree_node *test_ast_node;
	cil_tree_node_init(&test_ast_node);

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_TIF, &changed, NULL, NULL, NULL);

	uint32_t finished = 0;

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	int rc = __cil_resolve_ast_node_helper(NULL, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
}

void test_cil_resolve_ast_node_helper_extraargsnull_neg(CuTest *tc) {
	char *line[] = {"(", "role",  "staff_r", ")",
			"(", "user", "staff_u", ")",
			"(", "userrole", "staff_u", "staff_r", ")", NULL};
		
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	struct cil_tree_node *test_ast_node;
	cil_tree_node_init(&test_ast_node);

	uint32_t finished = 0;

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next, &finished, NULL);
	CuAssertIntEquals(tc, 0, finished);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
}

void test_cil_resolve_ast_node_helper_dbflavor_neg(CuTest *tc) {
	char *line[] = {"(", "role",  "staff_r", ")",
			"(", "user", "staff_u", ")",
			"(", "userrole", "staff_u", "staff_r", ")", NULL};
		
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	struct cil_tree_node *test_ast_node;
	cil_tree_node_init(&test_ast_node);

	uint32_t finished = 0;

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
}

void test_cil_resolve_ast_node_helper_pass_neg(CuTest *tc) {
	char *line[] = {"(", "role",  "staff_r", ")",
			"(", "user", "staff_u", ")",
			"(", "userrole", "staff_u", "staff_r", ")", NULL};
		
	struct cil_tree *test_tree;
	gen_test_tree(&test_tree, line);

	struct cil_db *test_db;
	cil_db_init(&test_db);
	
	struct cil_tree_node *test_ast_node;
	cil_tree_node_init(&test_ast_node);

	uint32_t finished = 0;

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC3, &changed, NULL, NULL, NULL);

	cil_build_ast(test_db, test_tree->root, test_db->ast->root);
	
	int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next->next, &finished, args);
	CuAssertIntEquals(tc, SEPOL_ERR, rc);
}

void test_cil_resolve_ast_node_helper_optfailedtoresolve(CuTest *tc) {
	char *line[] = {"(", "class", "file", "(", "read", ")", ")",
			"(", "classcommon", "file", "file", ")", NULL};
        
	struct cil_tree *test_tree;
        gen_test_tree(&test_tree, line);

        struct cil_db *test_db;
        cil_db_init(&test_db);

	struct cil_optional *opt;
	cil_optional_init(&opt);

	struct cil_tree_node *test_ast_node_opt;
	cil_tree_node_init(&test_ast_node_opt);
	test_ast_node_opt->flavor = CIL_OPTIONAL;
	test_ast_node_opt->data = opt;

	uint32_t changed = CIL_FALSE;
	struct cil_args_resolve *args = gen_resolve_args(test_db, CIL_PASS_MISC2, &changed, NULL, test_ast_node_opt, NULL);

        uint32_t finished = 0;

        cil_build_ast(test_db, test_tree->root, test_db->ast->root);

        int rc = __cil_resolve_ast_node_helper(test_db->ast->root->cl_head->next, &finished, args);
        CuAssertIntEquals(tc, SEPOL_OK, rc);
        CuAssertIntEquals(tc, 0, finished);
}