1 /* 2 * Copyright 2011 Tresys Technology, LLC. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions are met: 6 * 7 * 1. Redistributions of source code must retain the above copyright notice, 8 * this list of conditions and the following disclaimer. 9 * 10 * 2. Redistributions in binary form must reproduce the above copyright notice, 11 * this list of conditions and the following disclaimer in the documentation 12 * and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY TRESYS TECHNOLOGY, LLC ``AS IS'' AND ANY EXPRESS 15 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 16 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 17 * EVENT SHALL TRESYS TECHNOLOGY, LLC OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 18 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 19 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 21 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 22 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 23 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 24 * 25 * The views and conclusions contained in the software and documentation are those 26 * of the authors and should not be interpreted as representing official policies, 27 * either expressed or implied, of Tresys Technology, LLC. 28 */ 29 30 #include <sepol/policydb/policydb.h> 31 32 #include "CuTest.h" 33 #include "CilTest.h" 34 #include "test_cil_build_ast.h" 35 36 #include "../../src/cil_build_ast.h" 37 38 #include "../../src/cil_tree.h" 39 40 int __cil_build_ast_node_helper(struct cil_tree_node *, uint32_t *, void *); 41 int __cil_build_ast_last_child_helper(__attribute__((unused)) struct cil_tree_node *parse_current, void *); 42 //int __cil_build_constrain_tree(struct cil_tree_node *parse_current, struct cil_tree_node *expr_root); 43 44 struct cil_args_build { 45 struct cil_tree_node *ast; 46 struct cil_db *db; 47 struct cil_tree_node *macro; 48 struct cil_tree_node *tifstack; 49 }; 50 51 struct cil_args_build *gen_build_args(struct cil_tree_node *node, struct cil_db *db, struct cil_tree_node * macro, struct cil_tree_node *tifstack) 52 { 53 struct cil_args_build *args = cil_malloc(sizeof(*args)); 54 args->ast = node; 55 args->db = db; 56 args->macro = macro; 57 args->tifstack = tifstack; 58 59 return args; 60 } 61 62 // First seen in cil_gen_common 63 void test_cil_parse_to_list(CuTest *tc) { 64 char *line[] = {"(", "allow", "test", "foo", "(", "bar", "(", "read", "write", ")", ")", ")", NULL}; 65 66 struct cil_tree *test_tree; 67 gen_test_tree(&test_tree, line); 68 69 struct cil_tree_node *test_current; 70 test_current = test_tree->root->cl_head->cl_head; 71 72 struct cil_avrule *test_avrule; 73 cil_avrule_init(&test_avrule); 74 test_avrule->rule_kind = CIL_AVRULE_ALLOWED; 75 test_avrule->src_str = cil_strdup(test_current->next->data); 76 test_avrule->tgt_str = cil_strdup(test_current->next->next->data); 77 78 cil_classpermset_init(&test_avrule->classpermset); 79 80 test_avrule->classpermset->class_str = cil_strdup(test_current->next->next->next->cl_head->data); 81 82 cil_permset_init(&test_avrule->classpermset->permset); 83 84 cil_list_init(&test_avrule->classpermset->permset->perms_list_str); 85 86 test_current = test_current->next->next->next->cl_head->next->cl_head; 87 88 int rc = cil_parse_to_list(test_current, test_avrule->classpermset->permset->perms_list_str, CIL_AST_STR); 89 CuAssertIntEquals(tc, SEPOL_OK, rc); 90 91 cil_destroy_avrule(test_avrule); 92 } 93 94 void test_cil_parse_to_list_currnull_neg(CuTest *tc) { 95 char *line[] = {"(", "allow", "test", "foo", "(", "bar", "(", "read", "write", ")", ")", ")", NULL}; 96 97 struct cil_tree *test_tree; 98 gen_test_tree(&test_tree, line); 99 100 struct cil_tree_node *test_current; 101 test_current = test_tree->root->cl_head->cl_head; 102 103 struct cil_avrule *test_avrule; 104 cil_avrule_init(&test_avrule); 105 test_avrule->rule_kind = CIL_AVRULE_ALLOWED; 106 test_avrule->src_str = cil_strdup(test_current->next->data); 107 test_avrule->tgt_str = cil_strdup(test_current->next->next->data); 108 109 cil_classpermset_init(&test_avrule->classpermset); 110 111 test_avrule->classpermset->class_str = cil_strdup(test_current->next->next->next->cl_head->data); 112 113 cil_permset_init(&test_avrule->classpermset->permset); 114 115 cil_list_init(&test_avrule->classpermset->permset->perms_list_str); 116 117 test_current = NULL; 118 119 int rc = cil_parse_to_list(test_current, test_avrule->classpermset->permset->perms_list_str, CIL_AST_STR); 120 CuAssertIntEquals(tc, SEPOL_ERR, rc); 121 122 cil_destroy_avrule(test_avrule); 123 } 124 125 void test_cil_parse_to_list_listnull_neg(CuTest *tc) { 126 char *line[] = {"(", "allow", "test", "foo", "(", "bar", "(", "read", "write", ")", ")", ")", NULL}; 127 128 struct cil_tree *test_tree; 129 gen_test_tree(&test_tree, line); 130 131 struct cil_tree_node *test_current; 132 test_current = test_tree->root->cl_head->cl_head; 133 134 struct cil_avrule *test_avrule; 135 cil_avrule_init(&test_avrule); 136 test_avrule->rule_kind = CIL_AVRULE_ALLOWED; 137 test_avrule->src_str = cil_strdup(test_current->next->data); 138 test_avrule->tgt_str = cil_strdup(test_current->next->next->data); 139 140 cil_classpermset_init(&test_avrule->classpermset); 141 142 test_avrule->classpermset->class_str = cil_strdup(test_current->next->next->next->cl_head->data); 143 144 cil_permset_init(&test_avrule->classpermset->permset); 145 146 test_current = test_current->next->next->next->cl_head->next->cl_head; 147 148 int rc = cil_parse_to_list(test_current, test_avrule->classpermset->permset->perms_list_str, CIL_AST_STR); 149 CuAssertIntEquals(tc, SEPOL_ERR, rc); 150 151 cil_destroy_avrule(test_avrule); 152 } 153 154 void test_cil_set_to_list(CuTest *tc) { 155 char *line[] = {"(", "foo1", "foo2", "(", "foo3", ")", ")", NULL}; 156 157 struct cil_tree *test_tree; 158 struct cil_list *cil_l = NULL; 159 struct cil_list *sub_list = NULL; 160 161 gen_test_tree(&test_tree, line); 162 cil_list_init(&cil_l); 163 164 int rc = cil_set_to_list(test_tree->root->cl_head, cil_l, 1); 165 sub_list = (struct cil_list *)cil_l->head->next->next->data; 166 167 CuAssertIntEquals(tc, SEPOL_OK, rc); 168 CuAssertStrEquals(tc, "foo1", (char*)cil_l->head->data); 169 CuAssertStrEquals(tc, "foo2", (char*)cil_l->head->next->data); 170 CuAssertStrEquals(tc, "foo3", (char*)sub_list->head->data); 171 } 172 173 void test_cil_set_to_list_tree_node_null_neg(CuTest *tc) { 174 struct cil_list *cil_l = NULL; 175 int rc = cil_set_to_list(NULL, cil_l, 1); 176 177 CuAssertIntEquals(tc, SEPOL_ERR, rc); 178 } 179 180 void test_cil_set_to_list_cl_head_null_neg(CuTest *tc) { 181 char *line[] = {"(", "foo", "bar", ")", NULL}; 182 183 struct cil_list *cil_l; 184 struct cil_tree *test_tree = NULL; 185 186 cil_list_init(&cil_l); 187 gen_test_tree(&test_tree, line); 188 test_tree->root->cl_head = NULL; 189 190 int rc = cil_set_to_list(test_tree->root, cil_l, 1); 191 192 CuAssertIntEquals(tc, SEPOL_ERR, rc); 193 } 194 195 void test_cil_set_to_list_listnull_neg(CuTest *tc) { 196 char *line[] = {"(", "foo1", "foo2", "foo3", ")", NULL}; 197 198 struct cil_tree *test_tree = NULL; 199 gen_test_tree(&test_tree, line); 200 201 int rc = cil_set_to_list(test_tree->root, NULL, 1); 202 203 CuAssertIntEquals(tc, SEPOL_ERR, rc); 204 } 205 206 void test_cil_gen_block(CuTest *tc) { 207 char *line[] = {"(", "block", "a", "(", "type", "log", ")", ")", NULL}; 208 209 struct cil_tree *test_tree; 210 gen_test_tree(&test_tree, line); 211 212 struct cil_tree_node *test_ast_node; 213 cil_tree_node_init(&test_ast_node); 214 215 struct cil_db *test_db; 216 cil_db_init(&test_db); 217 218 test_ast_node->parent = test_db->ast->root; 219 test_ast_node->line = 1; 220 221 int rc = cil_gen_block(test_db, test_tree->root->cl_head->cl_head, test_ast_node, 0); 222 CuAssertIntEquals(tc, SEPOL_OK, rc); 223 CuAssertPtrNotNull(tc, test_ast_node->data); 224 CuAssertIntEquals(tc, ((struct cil_block*)test_ast_node->data)->is_abstract, 0); 225 CuAssertIntEquals(tc, test_ast_node->flavor, CIL_BLOCK); 226 } 227 228 void test_cil_gen_block_justblock_neg(CuTest *tc) { 229 char *line[] = {"(", "block", ")", NULL}; 230 231 struct cil_tree *test_tree; 232 gen_test_tree(&test_tree, line); 233 234 struct cil_tree_node *test_ast_node; 235 cil_tree_node_init(&test_ast_node); 236 237 struct cil_db *test_db; 238 cil_db_init(&test_db); 239 240 test_ast_node->parent = test_db->ast->root; 241 test_ast_node->line = 1; 242 243 int rc = cil_gen_block(test_db, test_tree->root->cl_head->cl_head, test_ast_node, 0); 244 CuAssertIntEquals(tc, SEPOL_ERR, rc); 245 } 246 247 void test_cil_gen_block_noname_neg(CuTest *tc) { 248 char *line[] = {"(", "block", "(", "type", "log", ")", ")", NULL}; 249 250 struct cil_tree *test_tree; 251 gen_test_tree(&test_tree, line); 252 253 struct cil_tree_node *test_ast_node; 254 cil_tree_node_init(&test_ast_node); 255 256 struct cil_db *test_db; 257 cil_db_init(&test_db); 258 259 test_ast_node->parent = test_db->ast->root; 260 test_ast_node->line = 1; 261 262 int rc = cil_gen_block(test_db, test_tree->root->cl_head->cl_head, test_ast_node, 0); 263 CuAssertIntEquals(tc, SEPOL_ERR, rc); 264 } 265 266 void test_cil_gen_block_dbnull_neg(CuTest *tc) { 267 char *line[] = {"(", "block", "foo", "(", "type", "log", ")", ")", NULL}; 268 269 struct cil_tree *test_tree; 270 gen_test_tree(&test_tree, line); 271 272 struct cil_tree_node *test_ast_node; 273 cil_tree_node_init(&test_ast_node); 274 275 struct cil_db *test_db = NULL; 276 277 int rc = cil_gen_block(test_db, test_tree->root->cl_head->cl_head, test_ast_node, 0); 278 CuAssertIntEquals(tc, SEPOL_ERR, rc); 279 } 280 281 void test_cil_gen_block_treenull_neg(CuTest *tc) { 282 char *line[] = {"(", "block", "foo", "(", "type", "log", ")", ")", NULL}; 283 284 struct cil_tree *test_tree; 285 gen_test_tree(&test_tree, line); 286 287 struct cil_tree_node *test_ast_node; 288 cil_tree_node_init(&test_ast_node); 289 290 test_tree->root->cl_head->cl_head = NULL; 291 292 struct cil_db *test_db; 293 cil_db_init(&test_db); 294 295 test_ast_node->parent = test_db->ast->root; 296 test_ast_node->line = 1; 297 298 int rc = cil_gen_block(test_db, test_tree->root->cl_head->cl_head, test_ast_node, 0); 299 CuAssertIntEquals(tc, SEPOL_ERR, rc); 300 } 301 302 void test_cil_gen_block_nodenull_neg(CuTest *tc) { 303 char *line[] = {"(", "block", "foo", "(", "type", "log", ")", ")", NULL}; 304 305 struct cil_tree *test_tree; 306 gen_test_tree(&test_tree, line); 307 308 struct cil_tree_node *test_ast_node = NULL; 309 310 struct cil_db *test_db; 311 cil_db_init(&test_db); 312 313 int rc = cil_gen_block(test_db, test_tree->root->cl_head->cl_head, test_ast_node, 0); 314 CuAssertIntEquals(tc, SEPOL_ERR, rc); 315 } 316 317 void test_cil_gen_block_nodeparentnull_neg(CuTest *tc) { 318 char *line[] = {"(", "block", "foo", "(", "type", "log", ")", ")", NULL}; 319 320 struct cil_tree *test_tree; 321 gen_test_tree(&test_tree, line); 322 323 struct cil_tree_node *test_ast_node; 324 cil_tree_node_init(&test_ast_node); 325 326 struct cil_db *test_db; 327 cil_db_init(&test_db); 328 329 test_ast_node->parent = NULL; 330 test_ast_node->line = 1; 331 332 int rc = cil_gen_block(test_db, test_tree->root->cl_head->cl_head, test_ast_node, 0); 333 CuAssertIntEquals(tc, SEPOL_ERR, rc); 334 } 335 336 void test_cil_destroy_block(CuTest *tc) { 337 char *line[] = {"(", "block", "a", "(", "type", "log", ")", ")", NULL}; 338 339 struct cil_tree *test_tree; 340 gen_test_tree(&test_tree, line); 341 342 struct cil_tree_node *test_ast_node; 343 cil_tree_node_init(&test_ast_node); 344 345 struct cil_db *test_db; 346 cil_db_init(&test_db); 347 348 test_ast_node->parent = test_db->ast->root; 349 test_ast_node->line = 1; 350 351 cil_gen_block(test_db, test_tree->root->cl_head->cl_head, test_ast_node, 0); 352 353 cil_destroy_block((struct cil_block*)test_ast_node->data); 354 CuAssertPtrEquals(tc, NULL,test_ast_node->data); 355 } 356 357 void test_cil_gen_blockinherit(CuTest *tc) { 358 char *line[] = {"(", "blockinherit", "foo", ")", NULL}; 359 360 struct cil_tree *test_tree; 361 gen_test_tree(&test_tree, line); 362 363 struct cil_tree_node *test_ast_node; 364 cil_tree_node_init(&test_ast_node); 365 366 struct cil_db *test_db; 367 cil_db_init(&test_db); 368 369 test_ast_node->parent = test_db->ast->root; 370 test_ast_node->line = 1; 371 372 int rc = cil_gen_blockinherit(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 373 CuAssertIntEquals(tc, SEPOL_OK, rc); 374 } 375 376 void test_cil_gen_blockinherit_namelist_neg(CuTest *tc) { 377 char *line[] = {"(", "blockinherit", "(", "foo", ")", ")", NULL}; 378 379 struct cil_tree *test_tree; 380 gen_test_tree(&test_tree, line); 381 382 struct cil_tree_node *test_ast_node; 383 cil_tree_node_init(&test_ast_node); 384 385 struct cil_db *test_db; 386 cil_db_init(&test_db); 387 388 test_ast_node->parent = test_db->ast->root; 389 test_ast_node->line = 1; 390 391 int rc = cil_gen_blockinherit(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 392 CuAssertIntEquals(tc, SEPOL_ERR, rc); 393 } 394 395 void test_cil_gen_blockinherit_namenull_neg(CuTest *tc) { 396 char *line[] = {"(", "blockinherit", ")", NULL}; 397 398 struct cil_tree *test_tree; 399 gen_test_tree(&test_tree, line); 400 401 struct cil_tree_node *test_ast_node; 402 cil_tree_node_init(&test_ast_node); 403 404 struct cil_db *test_db; 405 cil_db_init(&test_db); 406 407 test_ast_node->parent = test_db->ast->root; 408 test_ast_node->line = 1; 409 410 int rc = cil_gen_blockinherit(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 411 CuAssertIntEquals(tc, SEPOL_ERR, rc); 412 } 413 414 void test_cil_gen_blockinherit_extra_neg(CuTest *tc) { 415 char *line[] = {"(", "blockinherit", "foo", "extra", ")", NULL}; 416 417 struct cil_tree *test_tree; 418 gen_test_tree(&test_tree, line); 419 420 struct cil_tree_node *test_ast_node; 421 cil_tree_node_init(&test_ast_node); 422 423 struct cil_db *test_db; 424 cil_db_init(&test_db); 425 426 test_ast_node->parent = test_db->ast->root; 427 test_ast_node->line = 1; 428 429 int rc = cil_gen_blockinherit(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 430 CuAssertIntEquals(tc, SEPOL_ERR, rc); 431 } 432 433 void test_cil_gen_blockinherit_dbnull_neg(CuTest *tc) { 434 char *line[] = {"(", "blockinherit", "foo", "extra", ")", NULL}; 435 436 struct cil_tree *test_tree; 437 gen_test_tree(&test_tree, line); 438 439 struct cil_tree_node *test_ast_node; 440 cil_tree_node_init(&test_ast_node); 441 442 struct cil_db *test_db = NULL; 443 444 int rc = cil_gen_blockinherit(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 445 CuAssertIntEquals(tc, SEPOL_ERR, rc); 446 } 447 448 void test_cil_gen_blockinherit_currnull_neg(CuTest *tc) { 449 char *line[] = {"(", ")", NULL}; 450 451 struct cil_tree *test_tree; 452 gen_test_tree(&test_tree, line); 453 454 struct cil_tree_node *test_ast_node; 455 cil_tree_node_init(&test_ast_node); 456 457 struct cil_db *test_db; 458 cil_db_init(&test_db); 459 460 test_ast_node->parent = test_db->ast->root; 461 test_ast_node->line = 1; 462 463 int rc = cil_gen_blockinherit(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 464 CuAssertIntEquals(tc, SEPOL_ERR, rc); 465 } 466 467 void test_cil_gen_blockinherit_astnull_neg(CuTest *tc) { 468 char *line[] = {"(", "blockinherit", "foo", "extra", ")", NULL}; 469 470 struct cil_tree *test_tree; 471 gen_test_tree(&test_tree, line); 472 473 struct cil_tree_node *test_ast_node = NULL; 474 475 struct cil_db *test_db; 476 cil_db_init(&test_db); 477 478 int rc = cil_gen_blockinherit(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 479 CuAssertIntEquals(tc, SEPOL_ERR, rc); 480 } 481 482 void test_cil_gen_perm(CuTest *tc) { 483 char *line[] = {"(", "class", "foo", "(", "read", "write", "open", ")", ")", NULL}; 484 485 struct cil_tree *test_tree; 486 gen_test_tree(&test_tree, line); 487 488 struct cil_tree_node *test_ast_node; 489 cil_tree_node_init(&test_ast_node); 490 491 struct cil_db *test_db; 492 cil_db_init(&test_db); 493 494 struct cil_class *new_node; 495 cil_class_init(&new_node); 496 497 struct cil_tree_node *new_tree_node; 498 cil_tree_node_init(&new_tree_node); 499 new_tree_node->data = new_node; 500 new_tree_node->flavor = CIL_CLASS; 501 502 test_ast_node->parent = new_tree_node; 503 test_ast_node->line = 1; 504 505 int rc = cil_gen_perm(test_db, test_tree->root->cl_head->cl_head->next->next->cl_head, test_ast_node); 506 int rc1 = cil_gen_perm(test_db, test_tree->root->cl_head->cl_head->next->next->cl_head->next, test_ast_node); 507 int rc2 = cil_gen_perm(test_db, test_tree->root->cl_head->cl_head->next->next->cl_head->next->next, test_ast_node); 508 CuAssertIntEquals(tc, SEPOL_OK, rc); 509 CuAssertIntEquals(tc, SEPOL_OK, rc1); 510 CuAssertIntEquals(tc, SEPOL_OK, rc2); 511 } 512 513 void test_cil_gen_perm_dbnull_neg(CuTest *tc) { 514 char *line[] = {"(", "class", "file", "(", "read", "write", "open", ")", ")", NULL}; 515 516 int rc = 0; 517 struct cil_tree *test_tree; 518 gen_test_tree(&test_tree, line); 519 520 struct cil_tree_node *test_current_perm = NULL; 521 struct cil_tree_node *test_new_ast = NULL; 522 struct cil_tree_node *test_ast_node; 523 cil_tree_node_init(&test_ast_node); 524 525 struct cil_db *test_db = NULL; 526 527 test_current_perm = test_tree->root->cl_head->cl_head->next->next->cl_head; 528 529 cil_tree_node_init(&test_new_ast); 530 test_new_ast->parent = test_ast_node; 531 test_new_ast->line = test_current_perm->line; 532 533 rc = cil_gen_perm(test_db, test_current_perm, test_new_ast); 534 CuAssertIntEquals(tc, SEPOL_ERR, rc); 535 } 536 537 void test_cil_gen_perm_currnull_neg(CuTest *tc) { 538 char *line[] = {"(", "class", "file", "(", "read", "write", "open", ")", ")", NULL}; 539 540 int rc = 0; 541 struct cil_tree *test_tree; 542 gen_test_tree(&test_tree, line); 543 544 struct cil_tree_node *test_current_perm = NULL; 545 struct cil_tree_node *test_new_ast = NULL; 546 struct cil_tree_node *test_ast_node; 547 cil_tree_node_init(&test_ast_node); 548 549 struct cil_db *test_db; 550 cil_db_init(&test_db); 551 552 test_ast_node->parent = test_db->ast->root; 553 test_ast_node->line = 1; 554 555 test_current_perm = NULL; 556 557 cil_tree_node_init(&test_new_ast); 558 test_new_ast->parent = test_ast_node; 559 560 rc = cil_gen_perm(test_db, test_current_perm, test_new_ast); 561 CuAssertIntEquals(tc, SEPOL_ERR, rc); 562 } 563 564 void test_cil_gen_perm_astnull_neg(CuTest *tc) { 565 char *line[] = {"(", "class", "foo", "(", "read", "write", "open", ")", ")", NULL}; 566 567 struct cil_tree *test_tree; 568 gen_test_tree(&test_tree, line); 569 570 struct cil_tree_node *test_ast_node = NULL; 571 572 struct cil_db *test_db; 573 cil_db_init(&test_db); 574 575 struct cil_class *new_node; 576 cil_class_init(&new_node); 577 578 struct cil_tree_node *new_tree_node; 579 cil_tree_node_init(&new_tree_node); 580 new_tree_node->data = new_node; 581 new_tree_node->flavor = CIL_CLASS; 582 583 int rc = cil_gen_perm(test_db, test_tree->root->cl_head->cl_head->next->next->cl_head, test_ast_node); 584 CuAssertIntEquals(tc, SEPOL_ERR, rc); 585 } 586 587 void test_cil_gen_perm_nodenull_neg(CuTest *tc) { 588 char *line[] = {"(", "class", "file", "(", "read", "write", "open", ")", ")", NULL}; 589 590 int rc = 0; 591 struct cil_tree *test_tree; 592 gen_test_tree(&test_tree, line); 593 594 struct cil_tree_node *test_current_perm = NULL; 595 struct cil_tree_node *test_new_ast = NULL; 596 struct cil_tree_node *test_ast_node = NULL; 597 598 struct cil_db *test_db; 599 cil_db_init(&test_db); 600 601 test_current_perm = test_tree->root->cl_head->cl_head->next->next->cl_head; 602 603 cil_tree_node_init(&test_new_ast); 604 test_new_ast->parent = test_ast_node; 605 test_new_ast->line = test_current_perm->line; 606 607 rc = cil_gen_perm(test_db, test_current_perm, test_new_ast); 608 CuAssertIntEquals(tc, SEPOL_ERR, rc); 609 } 610 611 void test_cil_gen_permset(CuTest *tc) { 612 char *line[] = {"(", "permissionset", "foo", "(", "read", "write", ")", ")", NULL}; 613 614 struct cil_tree *test_tree; 615 gen_test_tree(&test_tree, line); 616 617 struct cil_tree_node *test_ast_node; 618 cil_tree_node_init(&test_ast_node); 619 620 struct cil_db *test_db; 621 cil_db_init(&test_db); 622 623 test_ast_node->parent = test_db->ast->root; 624 test_ast_node->line = 1; 625 626 int rc = cil_gen_permset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 627 CuAssertIntEquals(tc, SEPOL_OK, rc); 628 } 629 630 void test_cil_gen_permset_noname_neg(CuTest *tc) { 631 char *line[] = {"(", "permissionset", ")", NULL}; 632 633 struct cil_tree *test_tree; 634 gen_test_tree(&test_tree, line); 635 636 struct cil_tree_node *test_ast_node; 637 cil_tree_node_init(&test_ast_node); 638 639 struct cil_db *test_db; 640 cil_db_init(&test_db); 641 642 test_ast_node->parent = test_db->ast->root; 643 test_ast_node->line = 1; 644 645 int rc = cil_gen_permset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 646 CuAssertIntEquals(tc, SEPOL_ERR, rc); 647 } 648 649 void test_cil_gen_permset_nameinparens_neg(CuTest *tc) { 650 char *line[] = {"(", "permissionset", "(", "foo", ")", "(", "read", "write", ")", ")", NULL}; 651 652 struct cil_tree *test_tree; 653 gen_test_tree(&test_tree, line); 654 655 struct cil_tree_node *test_ast_node; 656 cil_tree_node_init(&test_ast_node); 657 658 struct cil_db *test_db; 659 cil_db_init(&test_db); 660 661 test_ast_node->parent = test_db->ast->root; 662 test_ast_node->line = 1; 663 664 int rc = cil_gen_permset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 665 CuAssertIntEquals(tc, SEPOL_ERR, rc); 666 } 667 668 void test_cil_gen_permset_noperms_neg(CuTest *tc) { 669 char *line[] = {"(", "permissionset", "foo", ")", NULL}; 670 671 struct cil_tree *test_tree; 672 gen_test_tree(&test_tree, line); 673 674 struct cil_tree_node *test_ast_node; 675 cil_tree_node_init(&test_ast_node); 676 677 struct cil_db *test_db; 678 cil_db_init(&test_db); 679 680 test_ast_node->parent = test_db->ast->root; 681 test_ast_node->line = 1; 682 683 int rc = cil_gen_permset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 684 CuAssertIntEquals(tc, SEPOL_ERR, rc); 685 } 686 687 void test_cil_gen_permset_emptyperms_neg(CuTest *tc) { 688 char *line[] = {"(", "permissionset", "foo", "(", ")", ")", NULL}; 689 690 struct cil_tree *test_tree; 691 gen_test_tree(&test_tree, line); 692 693 struct cil_tree_node *test_ast_node; 694 cil_tree_node_init(&test_ast_node); 695 696 struct cil_db *test_db; 697 cil_db_init(&test_db); 698 699 test_ast_node->parent = test_db->ast->root; 700 test_ast_node->line = 1; 701 702 int rc = cil_gen_permset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 703 CuAssertIntEquals(tc, SEPOL_ERR, rc); 704 } 705 706 void test_cil_gen_permset_extra_neg(CuTest *tc) { 707 char *line[] = {"(", "permissionset", "foo", "(", "read", "write", ")", "extra", ")", NULL}; 708 709 struct cil_tree *test_tree; 710 gen_test_tree(&test_tree, line); 711 712 struct cil_tree_node *test_ast_node; 713 cil_tree_node_init(&test_ast_node); 714 715 struct cil_db *test_db; 716 cil_db_init(&test_db); 717 718 test_ast_node->parent = test_db->ast->root; 719 test_ast_node->line = 1; 720 721 int rc = cil_gen_permset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 722 CuAssertIntEquals(tc, SEPOL_ERR, rc); 723 } 724 725 void test_cil_gen_permset_dbnull_neg(CuTest *tc) { 726 char *line[] = {"(", "permissionset", "foo", "(", "read", "write", ")", ")", NULL}; 727 728 struct cil_tree *test_tree; 729 gen_test_tree(&test_tree, line); 730 731 struct cil_tree_node *test_ast_node; 732 cil_tree_node_init(&test_ast_node); 733 734 struct cil_db *test_db = NULL; 735 736 int rc = cil_gen_permset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 737 CuAssertIntEquals(tc, SEPOL_ERR, rc); 738 } 739 740 void test_cil_gen_permset_currnull_neg(CuTest *tc) { 741 char *line[] = {"(", ")", NULL}; 742 743 struct cil_tree *test_tree; 744 gen_test_tree(&test_tree, line); 745 746 struct cil_tree_node *test_ast_node; 747 cil_tree_node_init(&test_ast_node); 748 749 struct cil_db *test_db; 750 cil_db_init(&test_db); 751 752 test_ast_node->parent = test_db->ast->root; 753 test_ast_node->line = 1; 754 755 int rc = cil_gen_permset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 756 CuAssertIntEquals(tc, SEPOL_ERR, rc); 757 } 758 759 void test_cil_gen_permset_astnull_neg(CuTest *tc) { 760 char *line[] = {"(", "permissionset", "foo", "(", "read", "write", ")", ")", NULL}; 761 762 struct cil_tree *test_tree; 763 gen_test_tree(&test_tree, line); 764 765 struct cil_tree_node *test_ast_node = NULL; 766 767 struct cil_db *test_db; 768 cil_db_init(&test_db); 769 770 int rc = cil_gen_permset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 771 CuAssertIntEquals(tc, SEPOL_ERR, rc); 772 } 773 774 void test_cil_gen_perm_nodes(CuTest *tc) { 775 char *line[] = {"(", "class", "file", "(", "read", "write", "open", ")", ")", NULL}; 776 777 struct cil_tree *test_tree; 778 gen_test_tree(&test_tree, line); 779 780 struct cil_tree_node *test_ast_node; 781 cil_tree_node_init(&test_ast_node); 782 783 struct cil_db *test_db; 784 cil_db_init(&test_db); 785 786 char *test_key = test_tree->root->cl_head->cl_head->next->data; 787 struct cil_class *test_cls; 788 cil_class_init(&test_cls); 789 790 test_ast_node->parent = test_db->ast->root; 791 test_ast_node->line = 1; 792 793 cil_symtab_insert(&test_db->symtab[CIL_SYM_CLASSES], (hashtab_key_t)test_key, (struct cil_symtab_datum*)test_cls, test_ast_node); 794 795 test_ast_node->data = test_cls; 796 test_ast_node->flavor = CIL_CLASS; 797 798 int rc = cil_gen_perm_nodes(test_db, test_tree->root->cl_head->cl_head->next->next->cl_head, test_ast_node, CIL_PERM); 799 CuAssertIntEquals(tc, SEPOL_OK, rc); 800 } 801 802 void test_cil_gen_perm_nodes_failgen_neg(CuTest *tc) { 803 char *line[] = {"(", "class", "file", "(", "read", "write", "open", ")", ")", NULL}; 804 805 struct cil_tree *test_tree; 806 gen_test_tree(&test_tree, line); 807 808 struct cil_tree_node *test_ast_node; 809 cil_tree_node_init(&test_ast_node); 810 811 struct cil_db *test_db; 812 cil_db_init(&test_db); 813 814 char *test_key = test_tree->root->cl_head->cl_head->next->data; 815 struct cil_class *test_cls; 816 cil_class_init(&test_cls); 817 818 cil_symtab_destroy(&test_cls->perms); 819 820 test_ast_node->parent = test_db->ast->root; 821 test_ast_node->line = 1; 822 823 cil_symtab_insert(&test_db->symtab[CIL_SYM_CLASSES], (hashtab_key_t)test_key, (struct cil_symtab_datum*)test_cls, test_ast_node); 824 825 test_ast_node->data = test_cls; 826 test_ast_node->flavor = CIL_CLASS; 827 828 int rc = cil_gen_perm_nodes(test_db, test_tree->root->cl_head->cl_head->next->next->cl_head, test_ast_node, CIL_PERM); 829 CuAssertIntEquals(tc, SEPOL_ENOMEM, rc); 830 } 831 832 void test_cil_gen_perm_nodes_inval_perm_neg(CuTest *tc) { 833 char *line[] = {"(", "class", "file", "(", "read", "(", "write", "open", ")", ")", NULL}; 834 835 struct cil_tree *test_tree; 836 gen_test_tree(&test_tree, line); 837 838 struct cil_tree_node *test_ast_node; 839 cil_tree_node_init(&test_ast_node); 840 841 struct cil_db *test_db; 842 cil_db_init(&test_db); 843 844 char *test_key = test_tree->root->cl_head->cl_head->next->data; 845 struct cil_class *test_cls; 846 cil_class_init(&test_cls); 847 848 test_ast_node->parent = test_db->ast->root; 849 test_ast_node->line = 1; 850 851 cil_symtab_insert(&test_db->symtab[CIL_SYM_CLASSES], (hashtab_key_t)test_key, (struct cil_symtab_datum*)test_cls, test_ast_node); 852 853 test_ast_node->data = test_cls; 854 test_ast_node->flavor = CIL_CLASS; 855 856 int rc = cil_gen_perm_nodes(test_db, test_tree->root->cl_head->cl_head->next->next->cl_head, test_ast_node, CIL_PERM); 857 CuAssertIntEquals(tc, SEPOL_ERR, rc); 858 } 859 860 void test_cil_fill_permset(CuTest *tc) { 861 char *line[] = {"(", "permissionset", "foo", "(", "read", "write", ")", ")", NULL}; 862 863 struct cil_tree *test_tree; 864 gen_test_tree(&test_tree, line); 865 866 struct cil_tree_node *test_ast_node; 867 cil_tree_node_init(&test_ast_node); 868 869 struct cil_permset *permset; 870 cil_permset_init(&permset); 871 872 int rc = cil_fill_permset(test_tree->root->cl_head->cl_head->next->next->cl_head, permset); 873 CuAssertIntEquals(tc, SEPOL_OK, rc); 874 } 875 876 void test_cil_fill_permset_sublist_neg(CuTest *tc) { 877 char *line[] = {"(", "permissionset", "foo", "(", "read", "(", "write", ")", ")", ")", NULL}; 878 879 struct cil_tree *test_tree; 880 gen_test_tree(&test_tree, line); 881 882 struct cil_tree_node *test_ast_node; 883 cil_tree_node_init(&test_ast_node); 884 885 struct cil_permset *permset; 886 cil_permset_init(&permset); 887 888 int rc = cil_fill_permset(test_tree->root->cl_head->cl_head->next->next->cl_head, permset); 889 CuAssertIntEquals(tc, SEPOL_ERR, rc); 890 } 891 892 void test_cil_fill_permset_startpermnull_neg(CuTest *tc) { 893 char *line[] = {"(", "permissionset", "foo", "(", ")", ")", NULL}; 894 895 struct cil_tree *test_tree; 896 gen_test_tree(&test_tree, line); 897 898 struct cil_tree_node *test_ast_node; 899 cil_tree_node_init(&test_ast_node); 900 901 struct cil_permset *permset; 902 cil_permset_init(&permset); 903 904 int rc = cil_fill_permset(test_tree->root->cl_head->cl_head->next->next->cl_head, permset); 905 CuAssertIntEquals(tc, SEPOL_ERR, rc); 906 } 907 908 void test_cil_fill_permset_permsetnull_neg(CuTest *tc) { 909 char *line[] = {"(", "permissionset", "foo", "(", "read", "write", ")", ")", NULL}; 910 911 struct cil_tree *test_tree; 912 gen_test_tree(&test_tree, line); 913 914 struct cil_tree_node *test_ast_node; 915 cil_tree_node_init(&test_ast_node); 916 917 struct cil_permset *permset = NULL; 918 919 int rc = cil_fill_permset(test_tree->root->cl_head->cl_head->next->next->cl_head, permset); 920 CuAssertIntEquals(tc, SEPOL_ERR, rc); 921 } 922 923 void test_cil_gen_in(CuTest *tc) { 924 char *line[] = {"(", "in", "foo", "(", "allow", "test", "baz", "(", "char", "(", "read", ")", ")", ")", ")", NULL}; 925 926 struct cil_tree *test_tree; 927 gen_test_tree(&test_tree, line); 928 929 struct cil_tree_node *test_ast_node; 930 cil_tree_node_init(&test_ast_node); 931 932 struct cil_db *test_db; 933 cil_db_init(&test_db); 934 935 test_ast_node->parent = test_db->ast->root; 936 test_ast_node->line = 1; 937 938 int rc = cil_gen_in(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 939 CuAssertIntEquals(tc, SEPOL_OK, rc); 940 } 941 942 void test_cil_gen_in_blockstrnull_neg(CuTest *tc) { 943 char *line[] = {"(", "in", ")", NULL}; 944 945 struct cil_tree *test_tree; 946 gen_test_tree(&test_tree, line); 947 948 struct cil_tree_node *test_ast_node; 949 cil_tree_node_init(&test_ast_node); 950 951 struct cil_db *test_db; 952 cil_db_init(&test_db); 953 954 test_ast_node->parent = test_db->ast->root; 955 test_ast_node->line = 1; 956 957 int rc = cil_gen_in(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 958 CuAssertIntEquals(tc, SEPOL_ERR, rc); 959 } 960 961 void test_cil_gen_in_extra_neg(CuTest *tc) { 962 char *line[] = {"(", "in", "foo", "(", "allow", "test", "baz", "(", "char", "(", "read", ")", ")", ")", "extra", ")", NULL}; 963 964 struct cil_tree *test_tree; 965 gen_test_tree(&test_tree, line); 966 967 struct cil_tree_node *test_ast_node; 968 cil_tree_node_init(&test_ast_node); 969 970 struct cil_db *test_db; 971 cil_db_init(&test_db); 972 973 test_ast_node->parent = test_db->ast->root; 974 test_ast_node->line = 1; 975 976 int rc = cil_gen_in(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 977 CuAssertIntEquals(tc, SEPOL_ERR, rc); 978 } 979 980 void test_cil_gen_in_dbnull_neg(CuTest *tc) { 981 char *line[] = {"(", "in", "foo", "(", "allow", "test", "baz", "(", "char", "(", "read", ")", ")", ")", ")", NULL}; 982 983 struct cil_tree *test_tree; 984 gen_test_tree(&test_tree, line); 985 986 struct cil_tree_node *test_ast_node; 987 cil_tree_node_init(&test_ast_node); 988 989 struct cil_db *test_db = NULL; 990 991 int rc = cil_gen_in(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 992 CuAssertIntEquals(tc, SEPOL_ERR, rc); 993 } 994 995 void test_cil_gen_in_currnull_neg(CuTest *tc) { 996 char *line[] = {"(", ")", NULL}; 997 998 struct cil_tree *test_tree; 999 gen_test_tree(&test_tree, line); 1000 1001 struct cil_tree_node *test_ast_node; 1002 cil_tree_node_init(&test_ast_node); 1003 1004 struct cil_db *test_db; 1005 cil_db_init(&test_db); 1006 1007 test_ast_node->parent = test_db->ast->root; 1008 test_ast_node->line = 1; 1009 1010 int rc = cil_gen_in(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1011 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1012 } 1013 1014 void test_cil_gen_in_astnull_neg(CuTest *tc) { 1015 char *line[] = {"(", "in", "foo", "(", "allow", "test", "baz", "(", "char", "(", "read", ")", ")", ")", ")", NULL}; 1016 1017 struct cil_tree *test_tree; 1018 gen_test_tree(&test_tree, line); 1019 1020 struct cil_tree_node *test_ast_node = NULL; 1021 1022 struct cil_db *test_db; 1023 cil_db_init(&test_db); 1024 1025 int rc = cil_gen_in(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1026 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1027 } 1028 1029 void test_cil_gen_class(CuTest *tc) { 1030 char *line[] = {"(", "class", "file", "(", "read", "write", "open", ")", ")", NULL}; 1031 1032 struct cil_tree *test_tree; 1033 gen_test_tree(&test_tree, line); 1034 1035 struct cil_tree_node *test_ast_node; 1036 cil_tree_node_init(&test_ast_node); 1037 1038 struct cil_db *test_db; 1039 cil_db_init(&test_db); 1040 1041 test_ast_node->parent = test_db->ast->root; 1042 test_ast_node->line = 1; 1043 1044 int rc = cil_gen_class(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1045 CuAssertIntEquals(tc, SEPOL_OK, rc); 1046 CuAssertPtrNotNull(tc, test_ast_node->cl_tail); 1047 CuAssertPtrNotNull(tc, test_ast_node->data); 1048 CuAssertIntEquals(tc, test_ast_node->flavor, CIL_CLASS); 1049 } 1050 1051 void test_cil_gen_class_noname_neg(CuTest *tc) { 1052 char *line[] = {"(", "class", "(", "read", "write", "open", ")", ")", NULL}; 1053 1054 struct cil_tree *test_tree; 1055 gen_test_tree(&test_tree, line); 1056 1057 struct cil_tree_node *test_ast_node; 1058 cil_tree_node_init(&test_ast_node); 1059 1060 struct cil_db *test_db; 1061 cil_db_init(&test_db); 1062 1063 test_ast_node->parent = test_db->ast->root; 1064 test_ast_node->line = 1; 1065 1066 int rc = cil_gen_class(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1067 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1068 } 1069 1070 void test_cil_gen_class_nodenull_neg(CuTest *tc) { 1071 char *line[] = {"(", "class", "(", "read", "write", "open", ")", ")", NULL}; 1072 1073 struct cil_tree *test_tree; 1074 gen_test_tree(&test_tree, line); 1075 1076 struct cil_tree_node *test_ast_node = NULL; 1077 1078 struct cil_db *test_db; 1079 cil_db_init(&test_db); 1080 1081 int rc = cil_gen_class(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1082 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1083 } 1084 1085 void test_cil_gen_class_dbnull_neg(CuTest *tc) { 1086 char *line[] = {"(", "class", "(", "read", "write", "open", ")", ")", NULL}; 1087 1088 struct cil_tree *test_tree; 1089 gen_test_tree(&test_tree, line); 1090 1091 struct cil_tree_node *test_ast_node; 1092 cil_tree_node_init(&test_ast_node); 1093 1094 struct cil_db *test_db = NULL; 1095 1096 int rc = cil_gen_class(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1097 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1098 } 1099 1100 void test_cil_gen_class_currnull_neg(CuTest *tc) { 1101 char *line[] = {"(", "class", "(", "read", "write", "open", ")", ")", NULL}; 1102 1103 struct cil_tree *test_tree; 1104 gen_test_tree(&test_tree, line); 1105 1106 struct cil_tree_node *test_ast_node; 1107 cil_tree_node_init(&test_ast_node); 1108 1109 struct cil_db *test_db; 1110 cil_db_init(&test_db); 1111 1112 test_tree->root->cl_head->cl_head = NULL; 1113 1114 int rc = cil_gen_class(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1115 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1116 } 1117 1118 void test_cil_gen_class_noclass_neg(CuTest *tc) { 1119 char *line[] = {"(", "test", "read", "write", "open", ")", ")", NULL}; 1120 1121 struct cil_tree *test_tree; 1122 gen_test_tree(&test_tree, line); 1123 1124 struct cil_tree_node *test_ast_node; 1125 cil_tree_node_init(&test_ast_node); 1126 1127 struct cil_db *test_db; 1128 cil_db_init(&test_db); 1129 1130 test_ast_node->parent = test_db->ast->root; 1131 test_ast_node->line = 1; 1132 1133 int rc = cil_gen_class(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1134 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1135 } 1136 1137 void test_cil_gen_class_noclassname_neg(CuTest *tc) { 1138 char *line[] = {"(", "class", ")", NULL}; 1139 1140 struct cil_tree *test_tree; 1141 gen_test_tree(&test_tree, line); 1142 1143 struct cil_tree_node *test_ast_node; 1144 cil_tree_node_init(&test_ast_node); 1145 1146 struct cil_db *test_db; 1147 cil_db_init(&test_db); 1148 1149 test_ast_node->parent = test_db->ast->root; 1150 test_ast_node->line = 1; 1151 1152 int rc = cil_gen_class(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1153 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1154 } 1155 1156 void test_cil_gen_class_namesublist_neg(CuTest *tc) { 1157 char *line[] = {"(", "class", "(", "foo", ")", ")", NULL}; 1158 1159 struct cil_tree *test_tree; 1160 gen_test_tree(&test_tree, line); 1161 1162 struct cil_tree_node *test_ast_node; 1163 cil_tree_node_init(&test_ast_node); 1164 1165 struct cil_db *test_db; 1166 cil_db_init(&test_db); 1167 1168 test_ast_node->parent = test_db->ast->root; 1169 test_ast_node->line = 1; 1170 1171 int rc = cil_gen_class(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1172 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1173 } 1174 1175 void test_cil_gen_class_noperms(CuTest *tc) { 1176 char *line[] = {"(", "class", "foo", ")", NULL}; 1177 1178 struct cil_tree *test_tree; 1179 gen_test_tree(&test_tree, line); 1180 1181 struct cil_tree_node *test_ast_node; 1182 cil_tree_node_init(&test_ast_node); 1183 1184 struct cil_db *test_db; 1185 cil_db_init(&test_db); 1186 1187 test_ast_node->parent = test_db->ast->root; 1188 test_ast_node->line = 1; 1189 1190 int rc = cil_gen_class(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1191 CuAssertIntEquals(tc, SEPOL_OK, rc); 1192 } 1193 1194 void test_cil_gen_class_permsnotinlist_neg(CuTest *tc) { 1195 char *line[] = {"(", "class", "foo", "read", "write", ")", NULL}; 1196 1197 struct cil_tree *test_tree; 1198 gen_test_tree(&test_tree, line); 1199 1200 struct cil_tree_node *test_ast_node; 1201 cil_tree_node_init(&test_ast_node); 1202 1203 struct cil_db *test_db; 1204 cil_db_init(&test_db); 1205 1206 test_ast_node->parent = test_db->ast->root; 1207 test_ast_node->line = 1; 1208 1209 int rc = cil_gen_class(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1210 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1211 } 1212 1213 void test_cil_gen_class_extrapermlist_neg(CuTest *tc) { 1214 char *line[] = {"(", "class", "foo", "(", "read", ")", "(", "write", ")", ")", NULL}; 1215 1216 struct cil_tree *test_tree; 1217 gen_test_tree(&test_tree, line); 1218 1219 struct cil_tree_node *test_ast_node; 1220 cil_tree_node_init(&test_ast_node); 1221 1222 struct cil_db *test_db; 1223 cil_db_init(&test_db); 1224 1225 test_ast_node->parent = test_db->ast->root; 1226 test_ast_node->line = 1; 1227 1228 int rc = cil_gen_class(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1229 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1230 } 1231 1232 void test_cil_gen_class_listinlist_neg(CuTest *tc) { 1233 char *line[] = {"(", "class", "test", "(", "read", "(", "write", ")", ")", ")", NULL}; 1234 1235 struct cil_tree *test_tree; 1236 gen_test_tree(&test_tree, line); 1237 1238 struct cil_tree_node *test_ast_node; 1239 cil_tree_node_init(&test_ast_node); 1240 1241 struct cil_db *test_db; 1242 cil_db_init(&test_db); 1243 1244 test_ast_node->parent = test_db->ast->root; 1245 test_ast_node->line = 1; 1246 1247 int rc = cil_gen_class(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1248 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1249 } 1250 1251 void test_cil_fill_classpermset_anonperms(CuTest *tc) { 1252 char *line[] = {"(", "classpermissionset", "char_w", "(", "char", "(", "write", ")", ")", ")", NULL}; 1253 1254 struct cil_tree *test_tree; 1255 gen_test_tree(&test_tree, line); 1256 1257 struct cil_tree_node *test_ast_node; 1258 cil_tree_node_init(&test_ast_node); 1259 1260 struct cil_classpermset *cps; 1261 cil_classpermset_init(&cps); 1262 1263 int rc = cil_fill_classpermset(test_tree->root->cl_head->cl_head->next->next->cl_head, cps); 1264 CuAssertIntEquals(tc, SEPOL_OK, rc); 1265 } 1266 1267 void test_cil_fill_classpermset_anonperms_neg(CuTest *tc) { 1268 char *line[] = {"(", "classpermissionset", "char_w", "(", "char", "(", "write", "(", "extra", ")", ")", ")", ")", NULL}; 1269 1270 struct cil_tree *test_tree; 1271 gen_test_tree(&test_tree, line); 1272 1273 struct cil_tree_node *test_ast_node; 1274 cil_tree_node_init(&test_ast_node); 1275 1276 struct cil_classpermset *cps; 1277 cil_classpermset_init(&cps); 1278 1279 int rc = cil_fill_classpermset(test_tree->root->cl_head->cl_head->next->next->cl_head, cps); 1280 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1281 } 1282 1283 void test_cil_fill_classpermset_namedperms(CuTest *tc) { 1284 char *line[] = {"(", "classpermissionset", "char_w", "(", "char", "perms", ")", ")", NULL}; 1285 1286 struct cil_tree *test_tree; 1287 gen_test_tree(&test_tree, line); 1288 1289 struct cil_tree_node *test_ast_node; 1290 cil_tree_node_init(&test_ast_node); 1291 1292 struct cil_classpermset *cps; 1293 cil_classpermset_init(&cps); 1294 1295 int rc = cil_fill_classpermset(test_tree->root->cl_head->cl_head->next->next->cl_head, cps); 1296 CuAssertIntEquals(tc, SEPOL_OK, rc); 1297 } 1298 1299 void test_cil_fill_classpermset_extra_neg(CuTest *tc) { 1300 char *line[] = {"(", "classpermissionset", "char_w", "(", "char", "(", "write", ")", "extra", ")", ")", NULL}; 1301 1302 struct cil_tree *test_tree; 1303 gen_test_tree(&test_tree, line); 1304 1305 struct cil_tree_node *test_ast_node; 1306 cil_tree_node_init(&test_ast_node); 1307 1308 struct cil_classpermset *cps; 1309 cil_classpermset_init(&cps); 1310 1311 int rc = cil_fill_classpermset(test_tree->root->cl_head->cl_head->next->next->cl_head, cps); 1312 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1313 } 1314 1315 void test_cil_fill_classpermset_emptypermslist_neg(CuTest *tc) { 1316 char *line[] = {"(", "classpermissionset", "char_w", "(", "char", "(", ")", ")", ")", NULL}; 1317 1318 struct cil_tree *test_tree; 1319 gen_test_tree(&test_tree, line); 1320 1321 struct cil_tree_node *test_ast_node; 1322 cil_tree_node_init(&test_ast_node); 1323 1324 struct cil_classpermset *cps; 1325 cil_classpermset_init(&cps); 1326 1327 int rc = cil_fill_classpermset(test_tree->root->cl_head->cl_head->next->next->cl_head, cps); 1328 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1329 } 1330 1331 void test_cil_fill_classpermset_noperms_neg(CuTest *tc) { 1332 char *line[] = {"(", "classpermissionset", "char_w", "(", "char", ")", ")", NULL}; 1333 1334 struct cil_tree *test_tree; 1335 gen_test_tree(&test_tree, line); 1336 1337 struct cil_tree_node *test_ast_node; 1338 cil_tree_node_init(&test_ast_node); 1339 1340 struct cil_classpermset *cps; 1341 cil_classpermset_init(&cps); 1342 1343 int rc = cil_fill_classpermset(test_tree->root->cl_head->cl_head->next->next->cl_head, cps); 1344 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1345 } 1346 1347 void test_cil_fill_classpermset_noclass_neg(CuTest *tc) { 1348 char *line[] = {"(", "classpermissionset", "char_w", "(", "(", "write", ")", ")", ")", NULL}; 1349 1350 struct cil_tree *test_tree; 1351 gen_test_tree(&test_tree, line); 1352 1353 struct cil_tree_node *test_ast_node; 1354 cil_tree_node_init(&test_ast_node); 1355 1356 struct cil_classpermset *cps; 1357 cil_classpermset_init(&cps); 1358 1359 int rc = cil_fill_classpermset(test_tree->root->cl_head->cl_head->next->next->cl_head, cps); 1360 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1361 } 1362 1363 void test_cil_fill_classpermset_classnodenull_neg(CuTest *tc) { 1364 char *line[] = {"(", "classpermissionset", "char_w", "(", ")", ")", NULL}; 1365 1366 struct cil_tree *test_tree; 1367 gen_test_tree(&test_tree, line); 1368 1369 struct cil_tree_node *test_ast_node; 1370 cil_tree_node_init(&test_ast_node); 1371 1372 struct cil_classpermset *cps; 1373 cil_classpermset_init(&cps); 1374 1375 int rc = cil_fill_classpermset(test_tree->root->cl_head->cl_head->next->next->cl_head, cps); 1376 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1377 } 1378 1379 void test_cil_fill_classpermset_cpsnull_neg(CuTest *tc) { 1380 char *line[] = {"(", "classpermissionset", "char_w", "(", "char", "(", "read", ")", ")", ")", NULL}; 1381 1382 struct cil_tree *test_tree; 1383 gen_test_tree(&test_tree, line); 1384 1385 struct cil_tree_node *test_ast_node; 1386 cil_tree_node_init(&test_ast_node); 1387 1388 struct cil_classpermset *cps = NULL; 1389 1390 int rc = cil_fill_classpermset(test_tree->root->cl_head->cl_head->next->next->cl_head, cps); 1391 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1392 } 1393 1394 void test_cil_gen_classpermset(CuTest *tc) { 1395 char *line[] = {"(", "classpermissionset", "char_w", "(", "char", "(", "write", ")", ")", ")", NULL}; 1396 1397 struct cil_tree *test_tree; 1398 gen_test_tree(&test_tree, line); 1399 1400 struct cil_tree_node *test_ast_node; 1401 cil_tree_node_init(&test_ast_node); 1402 1403 struct cil_db *test_db; 1404 cil_db_init(&test_db); 1405 1406 test_ast_node->parent = test_db->ast->root; 1407 test_ast_node->line = 1; 1408 1409 int rc = cil_gen_classpermset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1410 CuAssertIntEquals(tc, SEPOL_OK, rc); 1411 } 1412 1413 void test_cil_gen_classpermset_noname_neg(CuTest *tc) { 1414 char *line[] = {"(", "classpermissionset", ")", NULL}; 1415 1416 struct cil_tree *test_tree; 1417 gen_test_tree(&test_tree, line); 1418 1419 struct cil_tree_node *test_ast_node; 1420 cil_tree_node_init(&test_ast_node); 1421 1422 struct cil_db *test_db; 1423 cil_db_init(&test_db); 1424 1425 test_ast_node->parent = test_db->ast->root; 1426 test_ast_node->line = 1; 1427 1428 int rc = cil_gen_classpermset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1429 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1430 } 1431 1432 void test_cil_gen_classpermset_nameinparens_neg(CuTest *tc) { 1433 char *line[] = {"(", "classpermissionset", "(", "foo", ")", "(", "read", "(", "write", ")", ")", ")", NULL}; 1434 1435 struct cil_tree *test_tree; 1436 gen_test_tree(&test_tree, line); 1437 1438 struct cil_tree_node *test_ast_node; 1439 cil_tree_node_init(&test_ast_node); 1440 1441 struct cil_db *test_db; 1442 cil_db_init(&test_db); 1443 1444 test_ast_node->parent = test_db->ast->root; 1445 test_ast_node->line = 1; 1446 1447 int rc = cil_gen_classpermset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1448 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1449 } 1450 1451 void test_cil_gen_classpermset_noclass_neg(CuTest *tc) { 1452 char *line[] = {"(", "classpermissionset", "foo", ")", NULL}; 1453 1454 struct cil_tree *test_tree; 1455 gen_test_tree(&test_tree, line); 1456 1457 struct cil_tree_node *test_ast_node; 1458 cil_tree_node_init(&test_ast_node); 1459 1460 struct cil_db *test_db; 1461 cil_db_init(&test_db); 1462 1463 test_ast_node->parent = test_db->ast->root; 1464 test_ast_node->line = 1; 1465 1466 int rc = cil_gen_classpermset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1467 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1468 } 1469 1470 void test_cil_gen_classpermset_noperms_neg(CuTest *tc) { 1471 char *line[] = {"(", "classpermissionset", "foo", "(", "char", ")", ")", ")", NULL}; 1472 1473 struct cil_tree *test_tree; 1474 gen_test_tree(&test_tree, line); 1475 1476 struct cil_tree_node *test_ast_node; 1477 cil_tree_node_init(&test_ast_node); 1478 1479 struct cil_db *test_db; 1480 cil_db_init(&test_db); 1481 1482 test_ast_node->parent = test_db->ast->root; 1483 test_ast_node->line = 1; 1484 1485 int rc = cil_gen_classpermset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1486 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1487 } 1488 1489 void test_cil_gen_classpermset_emptyperms_neg(CuTest *tc) { 1490 char *line[] = {"(", "classpermissionset", "foo", "(", ")", ")", NULL}; 1491 1492 struct cil_tree *test_tree; 1493 gen_test_tree(&test_tree, line); 1494 1495 struct cil_tree_node *test_ast_node; 1496 cil_tree_node_init(&test_ast_node); 1497 1498 struct cil_db *test_db; 1499 cil_db_init(&test_db); 1500 1501 test_ast_node->parent = test_db->ast->root; 1502 test_ast_node->line = 1; 1503 1504 int rc = cil_gen_classpermset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1505 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1506 } 1507 1508 void test_cil_gen_classpermset_extra_neg(CuTest *tc) { 1509 char *line[] = {"(", "classpermissionset", "foo", "(", "read", "(", "write", ")", ")", "extra", ")", NULL}; 1510 1511 struct cil_tree *test_tree; 1512 gen_test_tree(&test_tree, line); 1513 1514 struct cil_tree_node *test_ast_node; 1515 cil_tree_node_init(&test_ast_node); 1516 1517 struct cil_db *test_db; 1518 cil_db_init(&test_db); 1519 1520 test_ast_node->parent = test_db->ast->root; 1521 test_ast_node->line = 1; 1522 1523 int rc = cil_gen_classpermset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1524 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1525 } 1526 1527 void test_cil_gen_classpermset_dbnull_neg(CuTest *tc) { 1528 char *line[] = {"(", "classpermissionset", "foo", "(", "read", "(", "write", ")", ")", ")", NULL}; 1529 1530 struct cil_tree *test_tree; 1531 gen_test_tree(&test_tree, line); 1532 1533 struct cil_tree_node *test_ast_node; 1534 cil_tree_node_init(&test_ast_node); 1535 1536 struct cil_db *test_db = NULL; 1537 1538 int rc = cil_gen_classpermset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1539 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1540 } 1541 1542 void test_cil_gen_classpermset_currnull_neg(CuTest *tc) { 1543 char *line[] = {"(", ")", NULL}; 1544 1545 struct cil_tree *test_tree; 1546 gen_test_tree(&test_tree, line); 1547 1548 struct cil_tree_node *test_ast_node; 1549 cil_tree_node_init(&test_ast_node); 1550 1551 struct cil_db *test_db; 1552 cil_db_init(&test_db); 1553 1554 test_ast_node->parent = test_db->ast->root; 1555 test_ast_node->line = 1; 1556 1557 int rc = cil_gen_classpermset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1558 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1559 } 1560 1561 void test_cil_gen_classpermset_astnull_neg(CuTest *tc) { 1562 char *line[] = {"(", "classpermissionset", "foo", "(", "read", "(", "write", ")", ")", ")", NULL}; 1563 1564 struct cil_tree *test_tree; 1565 gen_test_tree(&test_tree, line); 1566 1567 struct cil_tree_node *test_ast_node = NULL; 1568 1569 struct cil_db *test_db; 1570 cil_db_init(&test_db); 1571 1572 int rc = cil_gen_classpermset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1573 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1574 } 1575 1576 void test_cil_gen_classmap_perm(CuTest *tc) { 1577 char *line[] = {"(", "classmap", "files", "(", "read", ")", ")", NULL}; 1578 1579 struct cil_tree *test_tree; 1580 gen_test_tree(&test_tree, line); 1581 1582 struct cil_tree_node *test_ast_node; 1583 cil_tree_node_init(&test_ast_node); 1584 1585 struct cil_db *test_db; 1586 cil_db_init(&test_db); 1587 1588 test_ast_node->parent = test_db->ast->root; 1589 test_ast_node->line = 1; 1590 1591 struct cil_classmap *map = NULL; 1592 cil_classmap_init(&map); 1593 1594 test_ast_node->flavor = CIL_CLASSMAP; 1595 test_ast_node->data = map; 1596 1597 struct cil_tree_node *test_ast_node_a; 1598 cil_tree_node_init(&test_ast_node_a); 1599 1600 test_ast_node_a->parent = test_ast_node; 1601 test_ast_node_a->line = test_tree->root->cl_head->cl_head->next->next->cl_head->line; 1602 test_ast_node_a->path = test_tree->root->cl_head->cl_head->next->next->cl_head->path; 1603 1604 int rc = cil_gen_classmap_perm(test_db, test_tree->root->cl_head->cl_head->next->next->cl_head, test_ast_node_a); 1605 CuAssertIntEquals(tc, SEPOL_OK, rc); 1606 } 1607 1608 void test_cil_gen_classmap_perm_dupeperm_neg(CuTest *tc) { 1609 char *line[] = {"(", "classmap", "files", "(", "read", ")", ")", NULL}; 1610 1611 struct cil_tree *test_tree; 1612 gen_test_tree(&test_tree, line); 1613 1614 struct cil_tree_node *test_ast_node; 1615 cil_tree_node_init(&test_ast_node); 1616 1617 struct cil_db *test_db; 1618 cil_db_init(&test_db); 1619 1620 test_ast_node->parent = test_db->ast->root; 1621 test_ast_node->line = 1; 1622 1623 cil_gen_classmap(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1624 1625 struct cil_tree_node *test_ast_node_a; 1626 cil_tree_node_init(&test_ast_node_a); 1627 1628 test_ast_node_a->parent = test_ast_node; 1629 test_ast_node_a->line = test_tree->root->cl_head->cl_head->next->next->cl_head->line; 1630 test_ast_node_a->path = test_tree->root->cl_head->cl_head->next->next->cl_head->path; 1631 1632 int rc = cil_gen_classmap_perm(test_db, test_tree->root->cl_head->cl_head->next->next->cl_head, test_ast_node_a); 1633 CuAssertIntEquals(tc, SEPOL_EEXIST, rc); 1634 } 1635 1636 void test_cil_gen_classmap_perm_dbnull_neg(CuTest *tc) { 1637 char *line[] = {"(", "classmap", "files", "(", "read", ")", ")", NULL}; 1638 1639 struct cil_tree *test_tree; 1640 gen_test_tree(&test_tree, line); 1641 1642 struct cil_tree_node *test_ast_node; 1643 cil_tree_node_init(&test_ast_node); 1644 1645 struct cil_db *test_db; 1646 cil_db_init(&test_db); 1647 1648 test_ast_node->parent = test_db->ast->root; 1649 test_ast_node->line = 1; 1650 1651 cil_gen_classmap(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1652 1653 struct cil_tree_node *test_ast_node_a; 1654 cil_tree_node_init(&test_ast_node_a); 1655 1656 test_ast_node_a->parent = test_ast_node; 1657 test_ast_node_a->line = test_tree->root->cl_head->cl_head->line; 1658 test_ast_node_a->path = test_tree->root->cl_head->cl_head->path; 1659 1660 test_db = NULL; 1661 1662 int rc = cil_gen_classmap_perm(test_db, test_tree->root->cl_head->cl_head->next->next->cl_head, test_ast_node_a); 1663 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1664 } 1665 1666 void test_cil_gen_classmap_perm_currnull_neg(CuTest *tc) { 1667 char *line[] = {"(", "classmap", "files", "(", ")", ")", NULL}; 1668 1669 struct cil_tree *test_tree; 1670 gen_test_tree(&test_tree, line); 1671 1672 struct cil_tree_node *test_ast_node; 1673 cil_tree_node_init(&test_ast_node); 1674 1675 struct cil_db *test_db; 1676 cil_db_init(&test_db); 1677 1678 test_ast_node->parent = test_db->ast->root; 1679 test_ast_node->line = 1; 1680 1681 cil_gen_classmap(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1682 1683 struct cil_tree_node *test_ast_node_a; 1684 cil_tree_node_init(&test_ast_node_a); 1685 1686 test_ast_node_a->parent = test_ast_node; 1687 test_ast_node_a->line = test_tree->root->cl_head->cl_head->line; 1688 test_ast_node_a->path = test_tree->root->cl_head->cl_head->path; 1689 1690 int rc = cil_gen_classmap_perm(test_db, test_tree->root->cl_head->cl_head->next->next->cl_head, test_ast_node_a); 1691 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1692 } 1693 1694 void test_cil_gen_classmap_perm_astnull_neg(CuTest *tc) { 1695 char *line[] = {"(", "classmap", "files", "(", "read", ")", ")", NULL}; 1696 1697 struct cil_tree *test_tree; 1698 gen_test_tree(&test_tree, line); 1699 1700 struct cil_tree_node *test_ast_node; 1701 cil_tree_node_init(&test_ast_node); 1702 1703 struct cil_db *test_db; 1704 cil_db_init(&test_db); 1705 1706 test_ast_node->parent = test_db->ast->root; 1707 test_ast_node->line = 1; 1708 1709 cil_gen_classmap(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1710 1711 struct cil_tree_node *test_ast_node_a = NULL; 1712 1713 int rc = cil_gen_classmap_perm(test_db, test_tree->root->cl_head->cl_head->next->next->cl_head, test_ast_node_a); 1714 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1715 } 1716 1717 void test_cil_gen_classmap(CuTest *tc) { 1718 char *line[] = {"(", "classmap", "files", "(", "read", ")", ")", NULL}; 1719 1720 struct cil_tree *test_tree; 1721 gen_test_tree(&test_tree, line); 1722 1723 struct cil_tree_node *test_ast_node; 1724 cil_tree_node_init(&test_ast_node); 1725 1726 struct cil_db *test_db; 1727 cil_db_init(&test_db); 1728 1729 test_ast_node->parent = test_db->ast->root; 1730 test_ast_node->line = 1; 1731 1732 int rc = cil_gen_classmap(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1733 CuAssertIntEquals(tc, SEPOL_OK, rc); 1734 } 1735 1736 void test_cil_gen_classmap_extra_neg(CuTest *tc) { 1737 char *line[] = {"(", "classmap", "files", "(", "read", ")", "extra", ")", NULL}; 1738 1739 struct cil_tree *test_tree; 1740 gen_test_tree(&test_tree, line); 1741 1742 struct cil_tree_node *test_ast_node; 1743 cil_tree_node_init(&test_ast_node); 1744 1745 struct cil_db *test_db; 1746 cil_db_init(&test_db); 1747 1748 test_ast_node->parent = test_db->ast->root; 1749 test_ast_node->line = 1; 1750 1751 int rc = cil_gen_classmap(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1752 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1753 } 1754 1755 void test_cil_gen_classmap_noname_neg(CuTest *tc) { 1756 char *line[] = {"(", "classmap", ")", NULL}; 1757 1758 struct cil_tree *test_tree; 1759 gen_test_tree(&test_tree, line); 1760 1761 struct cil_tree_node *test_ast_node; 1762 cil_tree_node_init(&test_ast_node); 1763 1764 struct cil_db *test_db; 1765 cil_db_init(&test_db); 1766 1767 test_ast_node->parent = test_db->ast->root; 1768 test_ast_node->line = 1; 1769 1770 int rc = cil_gen_classmap(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1771 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1772 } 1773 1774 void test_cil_gen_classmap_emptyperms_neg(CuTest *tc) { 1775 char *line[] = {"(", "classmap", "files", "(", ")", ")", NULL}; 1776 1777 struct cil_tree *test_tree; 1778 gen_test_tree(&test_tree, line); 1779 1780 struct cil_tree_node *test_ast_node; 1781 cil_tree_node_init(&test_ast_node); 1782 1783 struct cil_db *test_db; 1784 cil_db_init(&test_db); 1785 1786 test_ast_node->parent = test_db->ast->root; 1787 test_ast_node->line = 1; 1788 1789 int rc = cil_gen_classmap(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1790 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1791 } 1792 1793 void test_cil_gen_classmap_dbnull_neg(CuTest *tc) { 1794 char *line[] = {"(", "classmap", "files", "(", "read", ")", ")", NULL}; 1795 1796 struct cil_tree *test_tree; 1797 gen_test_tree(&test_tree, line); 1798 1799 struct cil_tree_node *test_ast_node; 1800 cil_tree_node_init(&test_ast_node); 1801 1802 struct cil_db *test_db = NULL; 1803 1804 int rc = cil_gen_classmap(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1805 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1806 } 1807 1808 void test_cil_gen_classmap_currnull_neg(CuTest *tc) { 1809 char *line[] = {"(", ")", NULL}; 1810 1811 struct cil_tree *test_tree; 1812 gen_test_tree(&test_tree, line); 1813 1814 struct cil_tree_node *test_ast_node; 1815 cil_tree_node_init(&test_ast_node); 1816 1817 struct cil_db *test_db; 1818 cil_db_init(&test_db); 1819 1820 test_ast_node->parent = test_db->ast->root; 1821 test_ast_node->line = 1; 1822 1823 int rc = cil_gen_classmap(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1824 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1825 } 1826 1827 void test_cil_gen_classmap_astnull_neg(CuTest *tc) { 1828 char *line[] = {"(", "classmap", "files", "(", "read", ")", ")", NULL}; 1829 1830 struct cil_tree *test_tree; 1831 gen_test_tree(&test_tree, line); 1832 1833 struct cil_tree_node *test_ast_node = NULL; 1834 1835 struct cil_db *test_db; 1836 cil_db_init(&test_db); 1837 1838 int rc = cil_gen_classmap(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1839 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1840 } 1841 1842 void test_cil_gen_classmapping_anonpermset(CuTest *tc) { 1843 char *line[] = {"(", "classmapping", "files", "read", 1844 "(", "file", "(", "open", "read", "getattr", ")", ")", NULL}; 1845 1846 struct cil_tree *test_tree; 1847 gen_test_tree(&test_tree, line); 1848 1849 struct cil_tree_node *test_ast_node; 1850 cil_tree_node_init(&test_ast_node); 1851 1852 struct cil_db *test_db; 1853 cil_db_init(&test_db); 1854 1855 test_ast_node->parent = test_db->ast->root; 1856 test_ast_node->line = 1; 1857 1858 int rc = cil_gen_classmapping(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1859 CuAssertIntEquals(tc, SEPOL_OK, rc); 1860 } 1861 1862 void test_cil_gen_classmapping_anonpermset_neg(CuTest *tc) { 1863 char *line[] = {"(", "classmapping", "files", "read", 1864 "(", "file", "(", ")", ")", ")", NULL}; 1865 1866 struct cil_tree *test_tree; 1867 gen_test_tree(&test_tree, line); 1868 1869 struct cil_tree_node *test_ast_node; 1870 cil_tree_node_init(&test_ast_node); 1871 1872 struct cil_db *test_db; 1873 cil_db_init(&test_db); 1874 1875 test_ast_node->parent = test_db->ast->root; 1876 test_ast_node->line = 1; 1877 1878 int rc = cil_gen_classmapping(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1879 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1880 } 1881 1882 void test_cil_gen_classmapping_namedpermset(CuTest *tc) { 1883 char *line[] = {"(", "classmapping", "files", "read", "char_w", ")", NULL}; 1884 1885 struct cil_tree *test_tree; 1886 gen_test_tree(&test_tree, line); 1887 1888 struct cil_tree_node *test_ast_node; 1889 cil_tree_node_init(&test_ast_node); 1890 1891 struct cil_db *test_db; 1892 cil_db_init(&test_db); 1893 1894 test_ast_node->parent = test_db->ast->root; 1895 test_ast_node->line = 1; 1896 1897 int rc = cil_gen_classmapping(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1898 CuAssertIntEquals(tc, SEPOL_OK, rc); 1899 } 1900 1901 void test_cil_gen_classmapping_noclassmapname_neg(CuTest *tc) { 1902 char *line[] = {"(", "classmapping", ")", NULL}; 1903 1904 struct cil_tree *test_tree; 1905 gen_test_tree(&test_tree, line); 1906 1907 struct cil_tree_node *test_ast_node; 1908 cil_tree_node_init(&test_ast_node); 1909 1910 struct cil_db *test_db; 1911 cil_db_init(&test_db); 1912 1913 test_ast_node->parent = test_db->ast->root; 1914 test_ast_node->line = 1; 1915 1916 int rc = cil_gen_classmapping(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1917 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1918 } 1919 1920 void test_cil_gen_classmapping_noclassmapperm_neg(CuTest *tc) { 1921 char *line[] = {"(", "classmapping", "files", ")", NULL}; 1922 1923 struct cil_tree *test_tree; 1924 gen_test_tree(&test_tree, line); 1925 1926 struct cil_tree_node *test_ast_node; 1927 cil_tree_node_init(&test_ast_node); 1928 1929 struct cil_db *test_db; 1930 cil_db_init(&test_db); 1931 1932 test_ast_node->parent = test_db->ast->root; 1933 test_ast_node->line = 1; 1934 1935 int rc = cil_gen_classmapping(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1936 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1937 } 1938 1939 void test_cil_gen_classmapping_nopermissionsets_neg(CuTest *tc) { 1940 char *line[] = {"(", "classmapping", "files", "read", ")", NULL}; 1941 1942 struct cil_tree *test_tree; 1943 gen_test_tree(&test_tree, line); 1944 1945 struct cil_tree_node *test_ast_node; 1946 cil_tree_node_init(&test_ast_node); 1947 1948 struct cil_db *test_db; 1949 cil_db_init(&test_db); 1950 1951 test_ast_node->parent = test_db->ast->root; 1952 test_ast_node->line = 1; 1953 1954 int rc = cil_gen_classmapping(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1955 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1956 } 1957 1958 void test_cil_gen_classmapping_dbnull_neg(CuTest *tc) { 1959 char *line[] = {"(", "classmapping", "files", "read", 1960 "(", "file", "(", "open", "read", "getattr", ")", ")", NULL}; 1961 1962 struct cil_tree *test_tree; 1963 gen_test_tree(&test_tree, line); 1964 1965 struct cil_tree_node *test_ast_node; 1966 cil_tree_node_init(&test_ast_node); 1967 1968 struct cil_db *test_db = NULL; 1969 1970 int rc = cil_gen_classmapping(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1971 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1972 } 1973 1974 void test_cil_gen_classmapping_currnull_neg(CuTest *tc) { 1975 char *line[] = {"(", ")", NULL}; 1976 1977 struct cil_tree *test_tree; 1978 gen_test_tree(&test_tree, line); 1979 1980 struct cil_tree_node *test_ast_node; 1981 cil_tree_node_init(&test_ast_node); 1982 1983 struct cil_db *test_db; 1984 cil_db_init(&test_db); 1985 1986 test_ast_node->parent = test_db->ast->root; 1987 test_ast_node->line = 1; 1988 1989 int rc = cil_gen_classmapping(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 1990 CuAssertIntEquals(tc, SEPOL_ERR, rc); 1991 } 1992 1993 void test_cil_gen_classmapping_astnull_neg(CuTest *tc) { 1994 char *line[] = {"(", "classmapping", "files", "read", 1995 "(", "file", "(", "open", "read", "getattr", ")", ")", NULL}; 1996 1997 struct cil_tree *test_tree; 1998 gen_test_tree(&test_tree, line); 1999 2000 struct cil_tree_node *test_ast_node = NULL; 2001 2002 struct cil_db *test_db; 2003 cil_db_init(&test_db); 2004 2005 int rc = cil_gen_classmapping(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2006 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2007 } 2008 2009 void test_cil_gen_common(CuTest *tc) { 2010 char *line[] = {"(", "common", "test", "(", "read", "write", ")", ")", NULL}; 2011 2012 struct cil_tree *test_tree; 2013 gen_test_tree(&test_tree, line); 2014 2015 struct cil_tree_node *test_ast_node; 2016 cil_tree_node_init(&test_ast_node); 2017 2018 struct cil_db *test_db; 2019 cil_db_init(&test_db); 2020 2021 test_ast_node->parent = test_db->ast->root; 2022 test_ast_node->line = 1; 2023 2024 int rc = cil_gen_common(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2025 CuAssertIntEquals(tc, SEPOL_OK, rc); 2026 CuAssertPtrNotNull(tc, test_ast_node->data); 2027 CuAssertIntEquals(tc, test_ast_node->flavor, CIL_COMMON); 2028 } 2029 2030 void test_cil_gen_common_dbnull_neg(CuTest *tc) { 2031 char *line[] = {"(", "common", "test", "(", "read", "write", ")", ")", NULL}; 2032 2033 struct cil_tree *test_tree; 2034 gen_test_tree(&test_tree, line); 2035 2036 struct cil_tree_node *test_ast_node; 2037 cil_tree_node_init(&test_ast_node); 2038 2039 struct cil_db *test_db = NULL; 2040 2041 int rc = cil_gen_common(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2042 2043 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2044 } 2045 2046 void test_cil_gen_common_currnull_neg(CuTest *tc) { 2047 char *line[] = {"(", ")", NULL}; 2048 2049 struct cil_tree *test_tree; 2050 gen_test_tree(&test_tree, line); 2051 2052 struct cil_tree_node *test_ast_node; 2053 cil_tree_node_init(&test_ast_node); 2054 2055 struct cil_db *test_db; 2056 cil_db_init(&test_db); 2057 2058 int rc = cil_gen_common(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2059 2060 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2061 } 2062 2063 void test_cil_gen_common_astnull_neg(CuTest *tc) { 2064 char *line[] = {"(", "common", "test", "(", "read", "write", ")", ")", NULL}; 2065 2066 struct cil_tree *test_tree; 2067 gen_test_tree(&test_tree, line); 2068 2069 struct cil_tree_node *test_ast_node = NULL; 2070 2071 struct cil_db *test_db; 2072 cil_db_init(&test_db); 2073 2074 int rc = cil_gen_common(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2075 2076 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2077 } 2078 2079 void test_cil_gen_common_noname_neg(CuTest *tc) { 2080 char *line[] = {"(", "common", ")", NULL}; 2081 2082 struct cil_tree *test_tree; 2083 gen_test_tree(&test_tree, line); 2084 2085 struct cil_tree_node *test_ast_node; 2086 cil_tree_node_init(&test_ast_node); 2087 2088 struct cil_db *test_db; 2089 cil_db_init(&test_db); 2090 2091 test_ast_node->parent = test_db->ast->root; 2092 test_ast_node->line = 1; 2093 2094 int rc = cil_gen_common(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2095 2096 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2097 } 2098 2099 void test_cil_gen_common_twoperms_neg(CuTest *tc) { 2100 char *line[] = {"(", "common", "foo", "(", "write", ")", "(", "read", ")", ")", NULL}; 2101 2102 struct cil_tree *test_tree; 2103 gen_test_tree(&test_tree, line); 2104 2105 struct cil_tree_node *test_ast_node; 2106 cil_tree_node_init(&test_ast_node); 2107 2108 struct cil_db *test_db; 2109 cil_db_init(&test_db); 2110 2111 test_ast_node->parent = test_db->ast->root; 2112 test_ast_node->line = 1; 2113 2114 int rc = cil_gen_common(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2115 2116 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2117 } 2118 2119 void test_cil_gen_common_permsublist_neg(CuTest *tc) { 2120 char *line[] = {"(", "common", "test", "(", "read", "(", "write", ")", ")", ")", NULL}; 2121 2122 struct cil_tree *test_tree; 2123 gen_test_tree(&test_tree, line); 2124 2125 struct cil_tree_node *test_ast_node; 2126 cil_tree_node_init(&test_ast_node); 2127 2128 struct cil_db *test_db; 2129 cil_db_init(&test_db); 2130 2131 test_ast_node->parent = test_db->ast->root; 2132 test_ast_node->line = 1; 2133 2134 int rc = cil_gen_common(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2135 2136 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2137 } 2138 2139 void test_cil_gen_common_noperms_neg(CuTest *tc) { 2140 char *line[] = {"(", "common", "test", "(", ")", ")", NULL}; 2141 2142 struct cil_tree *test_tree; 2143 gen_test_tree(&test_tree, line); 2144 2145 struct cil_tree_node *test_ast_node; 2146 cil_tree_node_init(&test_ast_node); 2147 2148 struct cil_db *test_db; 2149 cil_db_init(&test_db); 2150 2151 test_ast_node->parent = test_db->ast->root; 2152 test_ast_node->line = 1; 2153 2154 int rc = cil_gen_common(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2155 2156 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2157 } 2158 2159 void test_cil_gen_sid(CuTest *tc) { 2160 char *line[] = {"(", "sid", "foo", ")", NULL}; 2161 2162 struct cil_tree *test_tree; 2163 gen_test_tree(&test_tree, line); 2164 2165 struct cil_tree_node *test_ast_node; 2166 cil_tree_node_init(&test_ast_node); 2167 2168 struct cil_db *test_db; 2169 cil_db_init(&test_db); 2170 2171 test_ast_node->parent = test_db->ast->root; 2172 test_ast_node->line = 1; 2173 2174 int rc = cil_gen_sid(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2175 CuAssertIntEquals(tc, SEPOL_OK, rc); 2176 } 2177 2178 void test_cil_gen_sid_noname_neg(CuTest *tc) { 2179 char *line[] = {"(", "sid", ")", NULL}; 2180 2181 struct cil_tree *test_tree; 2182 gen_test_tree(&test_tree, line); 2183 2184 struct cil_tree_node *test_ast_node; 2185 cil_tree_node_init(&test_ast_node); 2186 2187 struct cil_db *test_db; 2188 cil_db_init(&test_db); 2189 2190 test_ast_node->parent = test_db->ast->root; 2191 test_ast_node->line = 1; 2192 2193 int rc = cil_gen_sid(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2194 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2195 } 2196 2197 void test_cil_gen_sid_nameinparens_neg(CuTest *tc) { 2198 char *line[] = {"(", "sid", "(", "foo", ")", ")", NULL}; 2199 2200 struct cil_tree *test_tree; 2201 gen_test_tree(&test_tree, line); 2202 2203 struct cil_tree_node *test_ast_node; 2204 cil_tree_node_init(&test_ast_node); 2205 2206 struct cil_db *test_db; 2207 cil_db_init(&test_db); 2208 2209 test_ast_node->parent = test_db->ast->root; 2210 test_ast_node->line = 1; 2211 2212 int rc = cil_gen_sid(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2213 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2214 } 2215 2216 void test_cil_gen_sid_extra_neg(CuTest *tc) { 2217 char *line[] = {"(", "sid", "foo", "extra", ")", NULL}; 2218 2219 struct cil_tree *test_tree; 2220 gen_test_tree(&test_tree, line); 2221 2222 struct cil_tree_node *test_ast_node; 2223 cil_tree_node_init(&test_ast_node); 2224 2225 struct cil_db *test_db; 2226 cil_db_init(&test_db); 2227 2228 test_ast_node->parent = test_db->ast->root; 2229 test_ast_node->line = 1; 2230 2231 int rc = cil_gen_sid(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2232 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2233 } 2234 2235 void test_cil_gen_sid_dbnull_neg(CuTest *tc) { 2236 char *line[] = {"(", "sid", "foo", ")", NULL}; 2237 2238 struct cil_tree *test_tree; 2239 gen_test_tree(&test_tree, line); 2240 2241 struct cil_tree_node *test_ast_node; 2242 cil_tree_node_init(&test_ast_node); 2243 2244 struct cil_db *test_db = NULL; 2245 2246 int rc = cil_gen_sid(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2247 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2248 } 2249 2250 void test_cil_gen_sid_currnull_neg(CuTest *tc) { 2251 char *line[] = {"(", ")", NULL}; 2252 2253 struct cil_tree *test_tree; 2254 gen_test_tree(&test_tree, line); 2255 2256 struct cil_tree_node *test_ast_node; 2257 cil_tree_node_init(&test_ast_node); 2258 2259 struct cil_db *test_db; 2260 cil_db_init(&test_db); 2261 2262 test_ast_node->parent = test_db->ast->root; 2263 test_ast_node->line = 1; 2264 2265 int rc = cil_gen_sid(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2266 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2267 } 2268 2269 void test_cil_gen_sid_astnull_neg(CuTest *tc) { 2270 char *line[] = {"(", "sid", "foo", ")", NULL}; 2271 2272 struct cil_tree *test_tree; 2273 gen_test_tree(&test_tree, line); 2274 2275 struct cil_tree_node *test_ast_node = NULL; 2276 2277 struct cil_db *test_db; 2278 cil_db_init(&test_db); 2279 2280 int rc = cil_gen_sid(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2281 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2282 } 2283 2284 void test_cil_gen_sidcontext(CuTest *tc) { 2285 char *line[] = {"(", "sidcontext", "test", "(", "blah", "blah", "blah", "(", "(", "s0", "(", "c0", ")", ")", "(", "s0", "(", "c0", ")", ")", ")", ")", ")", NULL}; 2286 2287 struct cil_tree *test_tree; 2288 gen_test_tree(&test_tree, line); 2289 2290 struct cil_tree_node *test_ast_node; 2291 cil_tree_node_init(&test_ast_node); 2292 2293 struct cil_db *test_db; 2294 cil_db_init(&test_db); 2295 2296 2297 test_ast_node->parent = test_db->ast->root; 2298 test_ast_node->line = 1; 2299 2300 int rc = cil_gen_sidcontext(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2301 CuAssertIntEquals(tc, SEPOL_OK, rc); 2302 CuAssertPtrNotNull(tc, test_ast_node->data); 2303 CuAssertIntEquals(tc, test_ast_node->flavor, CIL_SIDCONTEXT); 2304 } 2305 2306 void test_cil_gen_sidcontext_namedcontext(CuTest *tc) { 2307 char *line[] = {"(", "sidcontext", "test", "something", ")", NULL}; 2308 2309 struct cil_tree *test_tree; 2310 gen_test_tree(&test_tree, line); 2311 2312 struct cil_tree_node *test_ast_node; 2313 cil_tree_node_init(&test_ast_node); 2314 2315 struct cil_db *test_db; 2316 cil_db_init(&test_db); 2317 2318 test_ast_node->parent = test_db->ast->root; 2319 test_ast_node->line = 1; 2320 2321 int rc = cil_gen_sidcontext(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2322 CuAssertIntEquals(tc, SEPOL_OK, rc); 2323 CuAssertPtrNotNull(tc, test_ast_node->data); 2324 CuAssertIntEquals(tc, test_ast_node->flavor, CIL_SIDCONTEXT); 2325 } 2326 2327 void test_cil_gen_sidcontext_halfcontext_neg(CuTest *tc) { 2328 char *line[] = {"(", "sidcontext", "test", "(", "blah", "blah", "blah", "(", "(", "s0", "(", "c0", ")", ")", ")", ")", ")", NULL}; 2329 2330 struct cil_tree *test_tree; 2331 gen_test_tree(&test_tree, line); 2332 2333 struct cil_tree_node *test_ast_node; 2334 cil_tree_node_init(&test_ast_node); 2335 2336 struct cil_db *test_db; 2337 cil_db_init(&test_db); 2338 2339 test_ast_node->parent = test_db->ast->root; 2340 test_ast_node->line = 1; 2341 2342 int rc = cil_gen_sidcontext(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2343 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2344 } 2345 2346 void test_cil_gen_sidcontext_noname_neg(CuTest *tc) { 2347 char *line[] = {"(", "sidcontext", "(", "blah", "blah", "blah", "(", "s0", "(", "c0", ")", ")", "(", "s0", "(", "c0", ")", ")", ")", ")", NULL}; 2348 2349 struct cil_tree *test_tree; 2350 gen_test_tree(&test_tree, line); 2351 2352 struct cil_tree_node *test_ast_node; 2353 cil_tree_node_init(&test_ast_node); 2354 2355 struct cil_db *test_db; 2356 cil_db_init(&test_db); 2357 2358 test_ast_node->parent = test_db->ast->root; 2359 test_ast_node->line = 1; 2360 2361 int rc = cil_gen_sidcontext(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2362 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2363 } 2364 2365 void test_cil_gen_sidcontext_empty_neg(CuTest *tc) { 2366 char *line[] = {"(", "sidcontext", ")", NULL}; 2367 2368 struct cil_tree *test_tree; 2369 gen_test_tree(&test_tree, line); 2370 2371 struct cil_tree_node *test_ast_node; 2372 cil_tree_node_init(&test_ast_node); 2373 2374 struct cil_db *test_db; 2375 cil_db_init(&test_db); 2376 2377 test_ast_node->parent = test_db->ast->root; 2378 test_ast_node->line = 1; 2379 2380 int rc = cil_gen_sidcontext(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2381 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2382 } 2383 2384 void test_cil_gen_sidcontext_nocontext_neg(CuTest *tc) { 2385 char *line[] = {"(", "sidcontext", "test", ")", NULL}; 2386 2387 struct cil_tree *test_tree; 2388 gen_test_tree(&test_tree, line); 2389 2390 struct cil_tree_node *test_ast_node; 2391 cil_tree_node_init(&test_ast_node); 2392 2393 struct cil_db *test_db; 2394 cil_db_init(&test_db); 2395 2396 test_ast_node->parent = test_db->ast->root; 2397 test_ast_node->line = 1; 2398 2399 int rc = cil_gen_sidcontext(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2400 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2401 } 2402 2403 void test_cil_gen_sidcontext_dblname_neg(CuTest *tc) { 2404 char *line[] = {"(", "sidcontext", "test", "test2", "(", "blah", "blah", "blah", "(", "s0", "(", "c0", ")", ")", "(", "s0", "(", "c0", ")", ")", ")", ")", NULL}; 2405 2406 struct cil_tree *test_tree; 2407 gen_test_tree(&test_tree, line); 2408 2409 struct cil_tree_node *test_ast_node; 2410 cil_tree_node_init(&test_ast_node); 2411 2412 struct cil_db *test_db; 2413 cil_db_init(&test_db); 2414 2415 test_ast_node->parent = test_db->ast->root; 2416 test_ast_node->line = 1; 2417 2418 int rc = cil_gen_sidcontext(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2419 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2420 } 2421 2422 void test_cil_gen_sidcontext_dbnull_neg(CuTest *tc) { 2423 char *line[] = {"(", "sidcontext", "test", "(", "blah", "blah", "blah", "(", "s0", "(", "c0", ")", ")", "(", "s0", "(", "c0", ")", ")", ")", ")", NULL}; 2424 2425 struct cil_tree *test_tree; 2426 gen_test_tree(&test_tree, line); 2427 2428 struct cil_tree_node *test_ast_node; 2429 cil_tree_node_init(&test_ast_node); 2430 2431 struct cil_db *test_db = NULL; 2432 2433 int rc = cil_gen_sidcontext(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2434 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2435 } 2436 2437 void test_cil_gen_sidcontext_pcurrnull_neg(CuTest *tc) { 2438 struct cil_tree_node *test_ast_node; 2439 cil_tree_node_init(&test_ast_node); 2440 2441 struct cil_db *test_db; 2442 cil_db_init(&test_db); 2443 2444 test_ast_node->parent = test_db->ast->root; 2445 test_ast_node->line = 1; 2446 2447 int rc = cil_gen_sidcontext(test_db, NULL, test_ast_node); 2448 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2449 } 2450 2451 void test_cil_gen_sidcontext_astnodenull_neg(CuTest *tc) { 2452 char *line[] = {"(", "sidcontext", "test", "(", "blah", "blah", "blah", "(", "s0", "(", "c0", ")", ")", "(", "s0", "(", "c0", ")", ")", ")", ")", NULL}; 2453 2454 struct cil_tree *test_tree; 2455 gen_test_tree(&test_tree, line); 2456 2457 struct cil_tree_node *test_ast_node; 2458 cil_tree_node_init(&test_ast_node); 2459 2460 struct cil_db *test_db; 2461 cil_db_init(&test_db); 2462 2463 test_ast_node->parent = test_db->ast->root; 2464 test_ast_node->line = 1; 2465 2466 int rc = cil_gen_sidcontext(test_db, test_tree->root->cl_head->cl_head, NULL); 2467 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2468 } 2469 2470 void test_cil_gen_type(CuTest *tc) { 2471 char *line[] = {"(", "type", "test", ")", NULL}; 2472 2473 struct cil_tree *test_tree; 2474 gen_test_tree(&test_tree, line); 2475 2476 struct cil_tree_node *test_ast_node; 2477 cil_tree_node_init(&test_ast_node); 2478 2479 struct cil_db *test_db; 2480 cil_db_init(&test_db); 2481 2482 test_ast_node->parent = test_db->ast->root; 2483 test_ast_node->line = 1; 2484 2485 int rc = cil_gen_type(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2486 CuAssertIntEquals(tc, SEPOL_OK, rc); 2487 CuAssertPtrNotNull(tc, test_ast_node->data); 2488 CuAssertIntEquals(tc, test_ast_node->flavor, CIL_TYPE); 2489 } 2490 2491 void test_cil_gen_type_dbnull_neg(CuTest *tc) { 2492 char *line[] = {"(", "type", "test", ")", NULL}; 2493 2494 struct cil_tree *test_tree; 2495 gen_test_tree(&test_tree, line); 2496 2497 struct cil_tree_node *test_ast_node; 2498 cil_tree_node_init(&test_ast_node); 2499 2500 struct cil_db *test_db = NULL; 2501 2502 int rc = cil_gen_type(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2503 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2504 } 2505 2506 void test_cil_gen_type_currnull_neg(CuTest *tc) { 2507 char *line[] = {"(", ")", NULL}; 2508 2509 struct cil_tree *test_tree; 2510 gen_test_tree(&test_tree, line); 2511 2512 struct cil_tree_node *test_ast_node; 2513 cil_tree_node_init(&test_ast_node); 2514 2515 struct cil_db *test_db; 2516 cil_db_init(&test_db); 2517 2518 test_ast_node->parent = test_db->ast->root; 2519 test_ast_node->line = 1; 2520 2521 int rc = cil_gen_type(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2522 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2523 } 2524 2525 void test_cil_gen_type_astnull_neg(CuTest *tc) { 2526 char *line[] = {"(", "type", "test", ")", NULL}; 2527 2528 struct cil_tree *test_tree; 2529 gen_test_tree(&test_tree, line); 2530 2531 struct cil_tree_node *test_ast_node = NULL; 2532 2533 struct cil_db *test_db; 2534 cil_db_init(&test_db); 2535 2536 int rc = cil_gen_type(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2537 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2538 } 2539 2540 void test_cil_gen_type_extra_neg(CuTest *tc) { 2541 char *line[] = {"(", "type", "foo", "bar," ")", NULL}; 2542 2543 struct cil_tree *test_tree; 2544 gen_test_tree(&test_tree, line); 2545 2546 struct cil_tree_node *test_ast_node; 2547 cil_tree_node_init(&test_ast_node); 2548 2549 struct cil_db *test_db; 2550 cil_db_init(&test_db); 2551 2552 test_ast_node->parent = test_db->ast->root; 2553 test_ast_node->line = 1; 2554 2555 int rc = cil_gen_type(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2556 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2557 } 2558 2559 void test_cil_gen_typeattribute(CuTest *tc) { 2560 char *line[] = {"(", "typeattribute", "test", NULL}; 2561 2562 struct cil_tree *test_tree; 2563 gen_test_tree(&test_tree, line); 2564 2565 struct cil_tree_node *test_ast_node; 2566 cil_tree_node_init(&test_ast_node); 2567 2568 struct cil_db *test_db; 2569 cil_db_init(&test_db); 2570 2571 test_ast_node->parent = test_db->ast->root; 2572 test_ast_node->line = 1; 2573 2574 int rc = cil_gen_typeattribute(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2575 CuAssertIntEquals(tc, SEPOL_OK, rc); 2576 CuAssertPtrNotNull(tc, test_ast_node->data); 2577 CuAssertIntEquals(tc, test_ast_node->flavor, CIL_TYPEATTRIBUTE); 2578 } 2579 2580 void test_cil_gen_typeattribute_dbnull_neg(CuTest *tc) { 2581 char *line[] = {"(", "typeattribute", "test", ")", NULL}; 2582 2583 struct cil_tree *test_tree; 2584 gen_test_tree(&test_tree, line); 2585 2586 struct cil_tree_node *test_ast_node; 2587 cil_tree_node_init(&test_ast_node); 2588 2589 struct cil_db *test_db = NULL; 2590 2591 int rc = cil_gen_typeattribute(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2592 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2593 } 2594 2595 2596 void test_cil_gen_typeattribute_currnull_neg(CuTest *tc) { 2597 char *line[] = {"(", ")", NULL}; 2598 2599 struct cil_tree *test_tree; 2600 gen_test_tree(&test_tree, line); 2601 2602 struct cil_tree_node *test_ast_node; 2603 cil_tree_node_init(&test_ast_node); 2604 2605 struct cil_db *test_db; 2606 cil_db_init(&test_db); 2607 2608 test_ast_node->parent = test_db->ast->root; 2609 test_ast_node->line = 1; 2610 2611 int rc = cil_gen_typeattribute(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2612 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2613 } 2614 2615 2616 void test_cil_gen_typeattribute_astnull_neg(CuTest *tc) { 2617 char *line[] = {"(", "typeattribute", "test", ")", NULL}; 2618 2619 struct cil_tree *test_tree; 2620 gen_test_tree(&test_tree, line); 2621 2622 struct cil_tree_node *test_ast_node = NULL; 2623 2624 struct cil_db *test_db; 2625 cil_db_init(&test_db); 2626 2627 int rc = cil_gen_typeattribute(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2628 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2629 } 2630 2631 void test_cil_gen_typeattribute_extra_neg(CuTest *tc) { 2632 char *line[] = {"(", "typeattribute", "foo", "bar," ")", NULL}; 2633 2634 struct cil_tree *test_tree; 2635 gen_test_tree(&test_tree, line); 2636 2637 struct cil_tree_node *test_ast_node; 2638 cil_tree_node_init(&test_ast_node); 2639 2640 struct cil_db *test_db; 2641 cil_db_init(&test_db); 2642 2643 test_ast_node->parent = test_db->ast->root; 2644 test_ast_node->line = 1; 2645 2646 int rc = cil_gen_typeattribute(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2647 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2648 } 2649 2650 void test_cil_gen_typebounds(CuTest *tc) { 2651 char *line[] = {"(", "typebounds", "type_a", "type_b", ")", NULL}; 2652 2653 struct cil_tree *test_tree; 2654 gen_test_tree(&test_tree, line); 2655 2656 struct cil_tree_node *test_ast_node; 2657 cil_tree_node_init(&test_ast_node); 2658 2659 struct cil_db *test_db; 2660 cil_db_init(&test_db); 2661 2662 test_ast_node->parent = test_db->ast->root; 2663 test_ast_node->line = 1; 2664 2665 int rc = cil_gen_typebounds(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2666 CuAssertIntEquals(tc, SEPOL_OK, rc); 2667 } 2668 2669 void test_cil_gen_typebounds_notype1_neg(CuTest *tc) { 2670 char *line[] = {"(", "typebounds", ")", NULL}; 2671 2672 struct cil_tree *test_tree; 2673 gen_test_tree(&test_tree, line); 2674 2675 struct cil_tree_node *test_ast_node; 2676 cil_tree_node_init(&test_ast_node); 2677 2678 struct cil_db *test_db; 2679 cil_db_init(&test_db); 2680 2681 test_ast_node->parent = test_db->ast->root; 2682 test_ast_node->line = 1; 2683 2684 int rc = cil_gen_typebounds(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2685 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2686 } 2687 2688 void test_cil_gen_typebounds_type1inparens_neg(CuTest *tc) { 2689 char *line[] = {"(", "typebounds", "(", "type_a", ")", "type_b", ")", NULL}; 2690 2691 struct cil_tree *test_tree; 2692 gen_test_tree(&test_tree, line); 2693 2694 struct cil_tree_node *test_ast_node; 2695 cil_tree_node_init(&test_ast_node); 2696 2697 struct cil_db *test_db; 2698 cil_db_init(&test_db); 2699 2700 test_ast_node->parent = test_db->ast->root; 2701 test_ast_node->line = 1; 2702 2703 int rc = cil_gen_typebounds(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2704 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2705 } 2706 2707 void test_cil_gen_typebounds_notype2_neg(CuTest *tc) { 2708 char *line[] = {"(", "typebounds", "type_a", ")", NULL}; 2709 2710 struct cil_tree *test_tree; 2711 gen_test_tree(&test_tree, line); 2712 2713 struct cil_tree_node *test_ast_node; 2714 cil_tree_node_init(&test_ast_node); 2715 2716 struct cil_db *test_db; 2717 cil_db_init(&test_db); 2718 2719 test_ast_node->parent = test_db->ast->root; 2720 test_ast_node->line = 1; 2721 2722 int rc = cil_gen_typebounds(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2723 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2724 } 2725 2726 void test_cil_gen_typebounds_type2inparens_neg(CuTest *tc) { 2727 char *line[] = {"(", "typebounds", "type_a", "(", "type_b", ")", ")", NULL}; 2728 2729 struct cil_tree *test_tree; 2730 gen_test_tree(&test_tree, line); 2731 2732 struct cil_tree_node *test_ast_node; 2733 cil_tree_node_init(&test_ast_node); 2734 2735 struct cil_db *test_db; 2736 cil_db_init(&test_db); 2737 2738 test_ast_node->parent = test_db->ast->root; 2739 test_ast_node->line = 1; 2740 2741 int rc = cil_gen_typebounds(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2742 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2743 } 2744 2745 void test_cil_gen_typebounds_extra_neg(CuTest *tc) { 2746 char *line[] = {"(", "typebounds", "type_a", "type_b", "extra", ")", NULL}; 2747 2748 struct cil_tree *test_tree; 2749 gen_test_tree(&test_tree, line); 2750 2751 struct cil_tree_node *test_ast_node; 2752 cil_tree_node_init(&test_ast_node); 2753 2754 struct cil_db *test_db; 2755 cil_db_init(&test_db); 2756 2757 test_ast_node->parent = test_db->ast->root; 2758 test_ast_node->line = 1; 2759 2760 int rc = cil_gen_typebounds(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2761 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2762 } 2763 2764 void test_cil_gen_typebounds_dbnull_neg(CuTest *tc) { 2765 char *line[] = {"(", "typebounds", "type_a", "type_b", ")", NULL}; 2766 2767 struct cil_tree *test_tree; 2768 gen_test_tree(&test_tree, line); 2769 2770 struct cil_tree_node *test_ast_node; 2771 cil_tree_node_init(&test_ast_node); 2772 2773 struct cil_db *test_db = NULL; 2774 2775 int rc = cil_gen_typebounds(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2776 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2777 } 2778 2779 void test_cil_gen_typebounds_currnull_neg(CuTest *tc) { 2780 char *line[] = {"(", ")", NULL}; 2781 2782 struct cil_tree *test_tree; 2783 gen_test_tree(&test_tree, line); 2784 2785 struct cil_tree_node *test_ast_node; 2786 cil_tree_node_init(&test_ast_node); 2787 2788 struct cil_db *test_db; 2789 cil_db_init(&test_db); 2790 2791 test_ast_node->parent = test_db->ast->root; 2792 test_ast_node->line = 1; 2793 2794 int rc = cil_gen_typebounds(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2795 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2796 } 2797 2798 void test_cil_gen_typebounds_astnull_neg(CuTest *tc) { 2799 char *line[] = {"(", "typebounds", "type_a", "type_b", ")", NULL}; 2800 2801 struct cil_tree *test_tree; 2802 gen_test_tree(&test_tree, line); 2803 2804 struct cil_tree_node *test_ast_node = NULL; 2805 2806 struct cil_db *test_db; 2807 cil_db_init(&test_db); 2808 2809 int rc = cil_gen_typebounds(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2810 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2811 } 2812 2813 void test_cil_gen_typepermissive(CuTest *tc) { 2814 char *line[] = {"(", "typepermissive", "type_a", ")", NULL}; 2815 2816 struct cil_tree *test_tree; 2817 gen_test_tree(&test_tree, line); 2818 2819 struct cil_tree_node *test_ast_node; 2820 cil_tree_node_init(&test_ast_node); 2821 2822 struct cil_db *test_db; 2823 cil_db_init(&test_db); 2824 2825 test_ast_node->parent = test_db->ast->root; 2826 test_ast_node->line = 1; 2827 2828 int rc = cil_gen_typepermissive(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2829 CuAssertIntEquals(tc, SEPOL_OK, rc); 2830 } 2831 2832 void test_cil_gen_typepermissive_noname_neg(CuTest *tc) { 2833 char *line[] = {"(", "typepermissive", ")", NULL}; 2834 2835 struct cil_tree *test_tree; 2836 gen_test_tree(&test_tree, line); 2837 2838 struct cil_tree_node *test_ast_node; 2839 cil_tree_node_init(&test_ast_node); 2840 2841 struct cil_db *test_db; 2842 cil_db_init(&test_db); 2843 2844 test_ast_node->parent = test_db->ast->root; 2845 test_ast_node->line = 1; 2846 2847 int rc = cil_gen_typepermissive(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2848 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2849 } 2850 2851 void test_cil_gen_typepermissive_typeinparens_neg(CuTest *tc) { 2852 char *line[] = {"(", "typepermissive", "(", "type_a", ")", ")", NULL}; 2853 2854 struct cil_tree *test_tree; 2855 gen_test_tree(&test_tree, line); 2856 2857 struct cil_tree_node *test_ast_node; 2858 cil_tree_node_init(&test_ast_node); 2859 2860 struct cil_db *test_db; 2861 cil_db_init(&test_db); 2862 2863 test_ast_node->parent = test_db->ast->root; 2864 test_ast_node->line = 1; 2865 2866 int rc = cil_gen_typepermissive(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2867 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2868 } 2869 2870 void test_cil_gen_typepermissive_extra_neg(CuTest *tc) { 2871 char *line[] = {"(", "typepermissive", "type_a", "extra", ")", NULL}; 2872 2873 struct cil_tree *test_tree; 2874 gen_test_tree(&test_tree, line); 2875 2876 struct cil_tree_node *test_ast_node; 2877 cil_tree_node_init(&test_ast_node); 2878 2879 struct cil_db *test_db; 2880 cil_db_init(&test_db); 2881 2882 test_ast_node->parent = test_db->ast->root; 2883 test_ast_node->line = 1; 2884 2885 int rc = cil_gen_typepermissive(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2886 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2887 } 2888 2889 void test_cil_gen_typepermissive_dbnull_neg(CuTest *tc) { 2890 char *line[] = {"(", "typepermissive", "type_a", ")", NULL}; 2891 2892 struct cil_tree *test_tree; 2893 gen_test_tree(&test_tree, line); 2894 2895 struct cil_tree_node *test_ast_node; 2896 cil_tree_node_init(&test_ast_node); 2897 2898 struct cil_db *test_db = NULL; 2899 2900 int rc = cil_gen_typepermissive(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2901 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2902 } 2903 2904 void test_cil_gen_typepermissive_currnull_neg(CuTest *tc) { 2905 char *line[] = {"(", ")", NULL}; 2906 2907 struct cil_tree *test_tree; 2908 gen_test_tree(&test_tree, line); 2909 2910 struct cil_tree_node *test_ast_node; 2911 cil_tree_node_init(&test_ast_node); 2912 2913 struct cil_db *test_db; 2914 cil_db_init(&test_db); 2915 2916 test_ast_node->parent = test_db->ast->root; 2917 test_ast_node->line = 1; 2918 2919 int rc = cil_gen_typepermissive(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2920 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2921 } 2922 2923 void test_cil_gen_typepermissive_astnull_neg(CuTest *tc) { 2924 char *line[] = {"(", "typepermissive", "type_a", ")", NULL}; 2925 2926 struct cil_tree *test_tree; 2927 gen_test_tree(&test_tree, line); 2928 2929 struct cil_tree_node *test_ast_node = NULL; 2930 2931 struct cil_db *test_db; 2932 cil_db_init(&test_db); 2933 2934 int rc = cil_gen_typepermissive(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2935 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2936 } 2937 2938 void test_cil_gen_nametypetransition(CuTest *tc) { 2939 char *line[] = {"(", "nametypetransition", "str", "foo", "bar", "file", "foobar", ")", NULL}; 2940 2941 struct cil_tree *test_tree; 2942 gen_test_tree(&test_tree, line); 2943 2944 struct cil_tree_node *test_ast_node; 2945 cil_tree_node_init(&test_ast_node); 2946 2947 struct cil_db *test_db; 2948 cil_db_init(&test_db); 2949 2950 test_ast_node->parent = test_db->ast->root; 2951 test_ast_node->line = 1; 2952 2953 int rc = cil_gen_nametypetransition(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2954 CuAssertIntEquals(tc, SEPOL_OK, rc); 2955 } 2956 2957 void test_cil_gen_nametypetransition_strinparens_neg(CuTest *tc) { 2958 char *line[] = {"(", "nametypetransition", "(", "str", ")", "foo", "bar", "file", "foobar", ")", NULL}; 2959 2960 struct cil_tree *test_tree; 2961 gen_test_tree(&test_tree, line); 2962 2963 struct cil_tree_node *test_ast_node; 2964 cil_tree_node_init(&test_ast_node); 2965 2966 struct cil_db *test_db; 2967 cil_db_init(&test_db); 2968 2969 test_ast_node->parent = test_db->ast->root; 2970 test_ast_node->line = 1; 2971 2972 int rc = cil_gen_nametypetransition(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2973 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2974 } 2975 2976 void test_cil_gen_nametypetransition_nostr_neg(CuTest *tc) { 2977 char *line[] = {"(", "nametypetransition", ")", NULL}; 2978 2979 struct cil_tree *test_tree; 2980 gen_test_tree(&test_tree, line); 2981 2982 struct cil_tree_node *test_ast_node; 2983 cil_tree_node_init(&test_ast_node); 2984 2985 struct cil_db *test_db; 2986 cil_db_init(&test_db); 2987 2988 test_ast_node->parent = test_db->ast->root; 2989 test_ast_node->line = 1; 2990 2991 int rc = cil_gen_nametypetransition(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 2992 CuAssertIntEquals(tc, SEPOL_ERR, rc); 2993 } 2994 2995 void test_cil_gen_nametypetransition_srcinparens_neg(CuTest *tc) { 2996 char *line[] = {"(", "nametypetransition", "str", "(", "foo", ")", "bar", "file", "foobar", ")", NULL}; 2997 2998 struct cil_tree *test_tree; 2999 gen_test_tree(&test_tree, line); 3000 3001 struct cil_tree_node *test_ast_node; 3002 cil_tree_node_init(&test_ast_node); 3003 3004 struct cil_db *test_db; 3005 cil_db_init(&test_db); 3006 3007 test_ast_node->parent = test_db->ast->root; 3008 test_ast_node->line = 1; 3009 3010 int rc = cil_gen_nametypetransition(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 3011 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3012 } 3013 3014 void test_cil_gen_nametypetransition_nosrc_neg(CuTest *tc) { 3015 char *line[] = {"(", "nametypetransition", "str", ")", NULL}; 3016 3017 struct cil_tree *test_tree; 3018 gen_test_tree(&test_tree, line); 3019 3020 struct cil_tree_node *test_ast_node; 3021 cil_tree_node_init(&test_ast_node); 3022 3023 struct cil_db *test_db; 3024 cil_db_init(&test_db); 3025 3026 test_ast_node->parent = test_db->ast->root; 3027 test_ast_node->line = 1; 3028 3029 int rc = cil_gen_nametypetransition(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 3030 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3031 } 3032 3033 void test_cil_gen_nametypetransition_tgtinparens_neg(CuTest *tc) { 3034 char *line[] = {"(", "nametypetransition", "str", "foo", "(", "bar", ")", "file", "foobar", ")", NULL}; 3035 3036 struct cil_tree *test_tree; 3037 gen_test_tree(&test_tree, line); 3038 3039 struct cil_tree_node *test_ast_node; 3040 cil_tree_node_init(&test_ast_node); 3041 3042 struct cil_db *test_db; 3043 cil_db_init(&test_db); 3044 3045 test_ast_node->parent = test_db->ast->root; 3046 test_ast_node->line = 1; 3047 3048 int rc = cil_gen_nametypetransition(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 3049 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3050 } 3051 3052 void test_cil_gen_nametypetransition_notgt_neg(CuTest *tc) { 3053 char *line[] = {"(", "nametypetransition", "str", "foo", ")", NULL}; 3054 3055 struct cil_tree *test_tree; 3056 gen_test_tree(&test_tree, line); 3057 3058 struct cil_tree_node *test_ast_node; 3059 cil_tree_node_init(&test_ast_node); 3060 3061 struct cil_db *test_db; 3062 cil_db_init(&test_db); 3063 3064 test_ast_node->parent = test_db->ast->root; 3065 test_ast_node->line = 1; 3066 3067 int rc = cil_gen_nametypetransition(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 3068 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3069 } 3070 3071 void test_cil_gen_nametypetransition_classinparens_neg(CuTest *tc) { 3072 char *line[] = {"(", "nametypetransition", "str", "foo", "bar", "(", "file", ")", "foobar", ")", NULL}; 3073 3074 struct cil_tree *test_tree; 3075 gen_test_tree(&test_tree, line); 3076 3077 struct cil_tree_node *test_ast_node; 3078 cil_tree_node_init(&test_ast_node); 3079 3080 struct cil_db *test_db; 3081 cil_db_init(&test_db); 3082 3083 test_ast_node->parent = test_db->ast->root; 3084 test_ast_node->line = 1; 3085 3086 int rc = cil_gen_nametypetransition(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 3087 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3088 } 3089 3090 void test_cil_gen_nametypetransition_noclass_neg(CuTest *tc) { 3091 char *line[] = {"(", "nametypetransition", "str", "foo", "bar", ")", NULL}; 3092 3093 struct cil_tree *test_tree; 3094 gen_test_tree(&test_tree, line); 3095 3096 struct cil_tree_node *test_ast_node; 3097 cil_tree_node_init(&test_ast_node); 3098 3099 struct cil_db *test_db; 3100 cil_db_init(&test_db); 3101 3102 test_ast_node->parent = test_db->ast->root; 3103 test_ast_node->line = 1; 3104 3105 int rc = cil_gen_nametypetransition(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 3106 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3107 } 3108 3109 void test_cil_gen_nametypetransition_destinparens_neg(CuTest *tc) { 3110 char *line[] = {"(", "nametypetransition", "str", "foo", "bar", "file", "(", "foobar", ")", ")", NULL}; 3111 3112 struct cil_tree *test_tree; 3113 gen_test_tree(&test_tree, line); 3114 3115 struct cil_tree_node *test_ast_node; 3116 cil_tree_node_init(&test_ast_node); 3117 3118 struct cil_db *test_db; 3119 cil_db_init(&test_db); 3120 3121 test_ast_node->parent = test_db->ast->root; 3122 test_ast_node->line = 1; 3123 3124 int rc = cil_gen_nametypetransition(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 3125 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3126 } 3127 3128 void test_cil_gen_nametypetransition_nodest_neg(CuTest *tc) { 3129 char *line[] = {"(", "nametypetransition", "str", "foo", "bar", "file", ")", NULL}; 3130 3131 struct cil_tree *test_tree; 3132 gen_test_tree(&test_tree, line); 3133 3134 struct cil_tree_node *test_ast_node; 3135 cil_tree_node_init(&test_ast_node); 3136 3137 struct cil_db *test_db; 3138 cil_db_init(&test_db); 3139 3140 test_ast_node->parent = test_db->ast->root; 3141 test_ast_node->line = 1; 3142 3143 int rc = cil_gen_nametypetransition(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 3144 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3145 } 3146 3147 3148 void test_cil_gen_nametypetransition_extra_neg(CuTest *tc) { 3149 char *line[] = {"(", "nametypetransition", "str", "foo", "bar", "file", "foobar", "extra", ")", NULL}; 3150 3151 struct cil_tree *test_tree; 3152 gen_test_tree(&test_tree, line); 3153 3154 struct cil_tree_node *test_ast_node; 3155 cil_tree_node_init(&test_ast_node); 3156 3157 struct cil_db *test_db; 3158 cil_db_init(&test_db); 3159 3160 test_ast_node->parent = test_db->ast->root; 3161 test_ast_node->line = 1; 3162 3163 int rc = cil_gen_nametypetransition(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 3164 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3165 } 3166 3167 void test_cil_gen_nametypetransition_dbnull_neg(CuTest *tc) { 3168 char *line[] = {"(", "nametypetransition", "str", "foo", "bar", "file", "foobar", "extra", ")", NULL}; 3169 3170 struct cil_tree *test_tree; 3171 gen_test_tree(&test_tree, line); 3172 3173 struct cil_tree_node *test_ast_node; 3174 cil_tree_node_init(&test_ast_node); 3175 3176 struct cil_db *test_db = NULL; 3177 3178 int rc = cil_gen_nametypetransition(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 3179 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3180 } 3181 3182 void test_cil_gen_nametypetransition_currnull_neg(CuTest *tc) { 3183 char *line[] = {"(", ")", NULL}; 3184 3185 struct cil_tree *test_tree; 3186 gen_test_tree(&test_tree, line); 3187 3188 struct cil_tree_node *test_ast_node; 3189 cil_tree_node_init(&test_ast_node); 3190 3191 struct cil_db *test_db; 3192 cil_db_init(&test_db); 3193 3194 test_ast_node->parent = test_db->ast->root; 3195 test_ast_node->line = 1; 3196 3197 int rc = cil_gen_nametypetransition(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 3198 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3199 } 3200 3201 void test_cil_gen_nametypetransition_astnull_neg(CuTest *tc) { 3202 char *line[] = {"(", "nametypetransition", "str", "foo", "bar", "file", "foobar", ")", NULL}; 3203 3204 struct cil_tree *test_tree; 3205 gen_test_tree(&test_tree, line); 3206 3207 struct cil_tree_node *test_ast_node = NULL; 3208 3209 struct cil_db *test_db; 3210 cil_db_init(&test_db); 3211 3212 int rc = cil_gen_nametypetransition(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 3213 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3214 } 3215 3216 void test_cil_gen_rangetransition(CuTest *tc) { 3217 char *line[] = {"(", "rangetransition", "type_a_t", "type_b_t", "class", "(", "low_l", "high_l", ")", ")", NULL}; 3218 3219 struct cil_tree *test_tree; 3220 gen_test_tree(&test_tree, line); 3221 3222 struct cil_tree_node *test_ast_node; 3223 cil_tree_node_init(&test_ast_node); 3224 3225 struct cil_db *test_db; 3226 cil_db_init(&test_db); 3227 3228 test_ast_node->parent = test_db->ast->root; 3229 test_ast_node->line = 1; 3230 3231 int rc = cil_gen_rangetransition(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 3232 CuAssertIntEquals(tc, SEPOL_OK, rc); 3233 } 3234 3235 void test_cil_gen_rangetransition_namedtransition(CuTest *tc) { 3236 char *line[] = {"(", "rangetransition", "type_a_t", "type_b_t", "class", "namedtrans", ")", NULL}; 3237 3238 struct cil_tree *test_tree; 3239 gen_test_tree(&test_tree, line); 3240 3241 struct cil_tree_node *test_ast_node; 3242 cil_tree_node_init(&test_ast_node); 3243 3244 struct cil_db *test_db; 3245 cil_db_init(&test_db); 3246 3247 test_ast_node->parent = test_db->ast->root; 3248 test_ast_node->line = 1; 3249 3250 int rc = cil_gen_rangetransition(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 3251 CuAssertIntEquals(tc, SEPOL_OK, rc); 3252 } 3253 3254 void test_cil_gen_rangetransition_anon_low_l(CuTest *tc) { 3255 char *line[] = {"(", "rangetransition", "type_a_t", "type_b_t", "class", "(", "(", "s0", "(", "c0", ")", ")", "high_l", ")", ")", NULL}; 3256 3257 struct cil_tree *test_tree; 3258 gen_test_tree(&test_tree, line); 3259 3260 struct cil_tree_node *test_ast_node; 3261 cil_tree_node_init(&test_ast_node); 3262 3263 struct cil_db *test_db; 3264 cil_db_init(&test_db); 3265 3266 test_ast_node->parent = test_db->ast->root; 3267 test_ast_node->line = 1; 3268 3269 int rc = cil_gen_rangetransition(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 3270 CuAssertIntEquals(tc, SEPOL_OK, rc); 3271 } 3272 3273 void test_cil_gen_rangetransition_anon_low_l_neg(CuTest *tc) { 3274 char *line[] = {"(", "rangetransition", "type_a_t", "type_b_t", "class", "(", "(", "s0", "(", ")", ")", "high_l", ")", ")", NULL}; 3275 3276 struct cil_tree *test_tree; 3277 gen_test_tree(&test_tree, line); 3278 3279 struct cil_tree_node *test_ast_node; 3280 cil_tree_node_init(&test_ast_node); 3281 3282 struct cil_db *test_db; 3283 cil_db_init(&test_db); 3284 3285 test_ast_node->parent = test_db->ast->root; 3286 test_ast_node->line = 1; 3287 3288 int rc = cil_gen_rangetransition(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 3289 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3290 } 3291 3292 void test_cil_gen_rangetransition_anon_high_l(CuTest *tc) { 3293 char *line[] = {"(", "rangetransition", "type_a_t", "type_b_t", "class", "(", "low_l", "(", "s0", "(", "c0", ")", ")", ")", ")", NULL}; 3294 3295 struct cil_tree *test_tree; 3296 gen_test_tree(&test_tree, line); 3297 3298 struct cil_tree_node *test_ast_node; 3299 cil_tree_node_init(&test_ast_node); 3300 3301 struct cil_db *test_db; 3302 cil_db_init(&test_db); 3303 3304 test_ast_node->parent = test_db->ast->root; 3305 test_ast_node->line = 1; 3306 3307 int rc = cil_gen_rangetransition(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 3308 CuAssertIntEquals(tc, SEPOL_OK, rc); 3309 } 3310 3311 void test_cil_gen_rangetransition_anon_high_l_neg(CuTest *tc) { 3312 char *line[] = {"(", "rangetransition", "type_a_t", "type_b_t", "class", "(", "low_l", "(", "s0", "(", ")", ")", ")", ")", NULL}; 3313 3314 struct cil_tree *test_tree; 3315 gen_test_tree(&test_tree, line); 3316 3317 struct cil_tree_node *test_ast_node; 3318 cil_tree_node_init(&test_ast_node); 3319 3320 struct cil_db *test_db; 3321 cil_db_init(&test_db); 3322 3323 test_ast_node->parent = test_db->ast->root; 3324 test_ast_node->line = 1; 3325 3326 int rc = cil_gen_rangetransition(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 3327 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3328 } 3329 3330 void test_cil_gen_rangetransition_dbnull_neg(CuTest *tc) { 3331 char *line[] = {"(", "rangetransition", "type_a_t", "type_b_t", "class", "(", "low_l", "high_l", ")", ")", NULL}; 3332 3333 struct cil_tree *test_tree; 3334 gen_test_tree(&test_tree, line); 3335 3336 struct cil_tree_node *test_ast_node; 3337 cil_tree_node_init(&test_ast_node); 3338 3339 struct cil_db *test_db = NULL; 3340 3341 int rc = cil_gen_rangetransition(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 3342 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3343 } 3344 3345 void test_cil_gen_rangetransition_currnull_neg(CuTest *tc) { 3346 char *line[] = {"(", ")", NULL}; 3347 3348 struct cil_tree *test_tree; 3349 gen_test_tree(&test_tree, line); 3350 3351 struct cil_tree_node *test_ast_node; 3352 cil_tree_node_init(&test_ast_node); 3353 3354 struct cil_db *test_db; 3355 cil_db_init(&test_db); 3356 3357 test_ast_node->parent = test_db->ast->root; 3358 test_ast_node->line = 1; 3359 3360 int rc = cil_gen_rangetransition(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 3361 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3362 } 3363 3364 void test_cil_gen_rangetransition_astnull_neg(CuTest *tc) { 3365 char *line[] = {"(", "rangetransition", "type_a_t", "type_b_t", "class", "(", "low_l", "high_l", ")", ")", NULL}; 3366 3367 struct cil_tree *test_tree; 3368 gen_test_tree(&test_tree, line); 3369 3370 struct cil_tree_node *test_ast_node = NULL; 3371 3372 struct cil_db *test_db; 3373 cil_db_init(&test_db); 3374 3375 int rc = cil_gen_rangetransition(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 3376 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3377 } 3378 3379 void test_cil_gen_rangetransition_nofirsttype_neg(CuTest *tc) { 3380 char *line[] = {"(", "rangetransition", ")", NULL}; 3381 3382 struct cil_tree *test_tree; 3383 gen_test_tree(&test_tree, line); 3384 3385 struct cil_tree_node *test_ast_node; 3386 cil_tree_node_init(&test_ast_node); 3387 3388 struct cil_db *test_db; 3389 cil_db_init(&test_db); 3390 3391 test_ast_node->parent = test_db->ast->root; 3392 test_ast_node->line = 1; 3393 3394 int rc = cil_gen_rangetransition(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 3395 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3396 } 3397 3398 void test_cil_gen_rangetransition_firsttype_inparens_neg(CuTest *tc) { 3399 char *line[] = {"(", "rangetransition", "(", "type_a_t", ")", "type_b_t", "class", "(", "low_l", "high_l", ")", ")", NULL}; 3400 3401 struct cil_tree *test_tree; 3402 gen_test_tree(&test_tree, line); 3403 3404 struct cil_tree_node *test_ast_node; 3405 cil_tree_node_init(&test_ast_node); 3406 3407 struct cil_db *test_db; 3408 cil_db_init(&test_db); 3409 3410 test_ast_node->parent = test_db->ast->root; 3411 test_ast_node->line = 1; 3412 3413 int rc = cil_gen_rangetransition(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 3414 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3415 } 3416 3417 void test_cil_gen_rangetransition_nosecondtype_neg(CuTest *tc) { 3418 char *line[] = {"(", "rangetransition", "type_a_t", ")", NULL}; 3419 3420 struct cil_tree *test_tree; 3421 gen_test_tree(&test_tree, line); 3422 3423 struct cil_tree_node *test_ast_node; 3424 cil_tree_node_init(&test_ast_node); 3425 3426 struct cil_db *test_db; 3427 cil_db_init(&test_db); 3428 3429 test_ast_node->parent = test_db->ast->root; 3430 test_ast_node->line = 1; 3431 3432 int rc = cil_gen_rangetransition(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 3433 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3434 } 3435 3436 void test_cil_gen_rangetransition_secondtype_inparens_neg(CuTest *tc) { 3437 char *line[] = {"(", "rangetransition", "type_a_t", "(", "type_b_t", ")", "class", "(", "low_l", "high_l", ")", ")", NULL}; 3438 3439 struct cil_tree *test_tree; 3440 gen_test_tree(&test_tree, line); 3441 3442 struct cil_tree_node *test_ast_node; 3443 cil_tree_node_init(&test_ast_node); 3444 3445 struct cil_db *test_db; 3446 cil_db_init(&test_db); 3447 3448 test_ast_node->parent = test_db->ast->root; 3449 test_ast_node->line = 1; 3450 3451 int rc = cil_gen_rangetransition(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 3452 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3453 } 3454 3455 void test_cil_gen_rangetransition_noclass_neg(CuTest *tc) { 3456 char *line[] = {"(", "rangetransition", "type_a_t", "type_b_t", ")", NULL}; 3457 3458 struct cil_tree *test_tree; 3459 gen_test_tree(&test_tree, line); 3460 3461 struct cil_tree_node *test_ast_node; 3462 cil_tree_node_init(&test_ast_node); 3463 3464 struct cil_db *test_db; 3465 cil_db_init(&test_db); 3466 3467 test_ast_node->parent = test_db->ast->root; 3468 test_ast_node->line = 1; 3469 3470 int rc = cil_gen_rangetransition(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 3471 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3472 } 3473 3474 void test_cil_gen_rangetransition_class_inparens_neg(CuTest *tc) { 3475 char *line[] = {"(", "rangetransition", "type_a_t", "type_b_t", "(", "class", ")", "(", "low_l", "high_l", ")", ")", NULL}; 3476 3477 struct cil_tree *test_tree; 3478 gen_test_tree(&test_tree, line); 3479 3480 struct cil_tree_node *test_ast_node; 3481 cil_tree_node_init(&test_ast_node); 3482 3483 struct cil_db *test_db; 3484 cil_db_init(&test_db); 3485 3486 test_ast_node->parent = test_db->ast->root; 3487 test_ast_node->line = 1; 3488 3489 int rc = cil_gen_rangetransition(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 3490 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3491 } 3492 3493 void test_cil_gen_rangetransition_nolevel_l_neg(CuTest *tc) { 3494 char *line[] = {"(", "rangetransition", "type_a_t", "type_b_t", "class", ")", NULL}; 3495 3496 struct cil_tree *test_tree; 3497 gen_test_tree(&test_tree, line); 3498 3499 struct cil_tree_node *test_ast_node; 3500 cil_tree_node_init(&test_ast_node); 3501 3502 struct cil_db *test_db; 3503 cil_db_init(&test_db); 3504 3505 test_ast_node->parent = test_db->ast->root; 3506 test_ast_node->line = 1; 3507 3508 int rc = cil_gen_rangetransition(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 3509 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3510 } 3511 3512 void test_cil_gen_rangetransition_nolevel_h_neg(CuTest *tc) { 3513 char *line[] = {"(", "rangetransition", "type_a_t", "type_b_t", "class", "(", "low_l", ")", ")", NULL}; 3514 3515 struct cil_tree *test_tree; 3516 gen_test_tree(&test_tree, line); 3517 3518 struct cil_tree_node *test_ast_node; 3519 cil_tree_node_init(&test_ast_node); 3520 3521 struct cil_db *test_db; 3522 cil_db_init(&test_db); 3523 3524 test_ast_node->parent = test_db->ast->root; 3525 test_ast_node->line = 1; 3526 3527 int rc = cil_gen_rangetransition(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 3528 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3529 } 3530 3531 void test_cil_gen_rangetransition_extra_neg(CuTest *tc) { 3532 char *line[] = {"(", "rangetransition", "type_a_t", "type_b_t", "class", "(", "low_l", "high_l", ")", "extra", ")", NULL}; 3533 3534 struct cil_tree *test_tree; 3535 gen_test_tree(&test_tree, line); 3536 3537 struct cil_tree_node *test_ast_node; 3538 cil_tree_node_init(&test_ast_node); 3539 3540 struct cil_db *test_db; 3541 cil_db_init(&test_db); 3542 3543 test_ast_node->parent = test_db->ast->root; 3544 test_ast_node->line = 1; 3545 3546 int rc = cil_gen_rangetransition(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 3547 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3548 } 3549 3550 void test_cil_gen_expr_stack_and(CuTest *tc) { 3551 char *line[] = {"(", "booleanif", "(", "and", "foo", "bar", ")", 3552 "(", "true", "(", "allow", "foo", "bar", "baz", "(", "read", ")", ")", ")", ")", NULL}; 3553 3554 struct cil_tree *test_tree; 3555 gen_test_tree(&test_tree, line); 3556 3557 struct cil_tree_node *test_ast_node; 3558 cil_tree_node_init(&test_ast_node); 3559 3560 struct cil_db *test_db; 3561 cil_db_init(&test_db); 3562 3563 test_ast_node->parent = test_db->ast->root; 3564 test_ast_node->line = 1; 3565 3566 struct cil_booleanif *bif; 3567 cil_boolif_init(&bif); 3568 3569 int rc = cil_gen_expr_stack(test_tree->root->cl_head->cl_head->next, CIL_BOOL, &bif->expr_stack); 3570 CuAssertIntEquals(tc, SEPOL_OK, rc); 3571 } 3572 3573 void test_cil_gen_expr_stack_or(CuTest *tc) { 3574 char *line[] = {"(", "booleanif", "(", "or", "foo", "bar", ")", 3575 "(", "true", "(", "allow", "foo", "bar", "baz", "(", "read", ")", ")", ")", NULL}; 3576 3577 struct cil_tree *test_tree; 3578 gen_test_tree(&test_tree, line); 3579 3580 struct cil_tree_node *test_ast_node; 3581 cil_tree_node_init(&test_ast_node); 3582 3583 struct cil_db *test_db; 3584 cil_db_init(&test_db); 3585 3586 test_ast_node->parent = test_db->ast->root; 3587 test_ast_node->line = 1; 3588 3589 struct cil_booleanif *bif; 3590 cil_boolif_init(&bif); 3591 3592 int rc = cil_gen_expr_stack(test_tree->root->cl_head->cl_head->next, CIL_BOOL, &bif->expr_stack); 3593 CuAssertIntEquals(tc, SEPOL_OK, rc); 3594 } 3595 3596 void test_cil_gen_expr_stack_xor(CuTest *tc) { 3597 char *line[] = {"(", "booleanif", "(", "xor", "foo", "bar", ")", 3598 "(", "true", "(", "allow", "foo", "bar", "baz", "(", "read", ")", ")", ")", ")", NULL}; 3599 3600 struct cil_tree *test_tree; 3601 gen_test_tree(&test_tree, line); 3602 3603 struct cil_tree_node *test_ast_node; 3604 cil_tree_node_init(&test_ast_node); 3605 3606 struct cil_db *test_db; 3607 cil_db_init(&test_db); 3608 3609 test_ast_node->parent = test_db->ast->root; 3610 test_ast_node->line = 1; 3611 3612 struct cil_booleanif *bif; 3613 cil_boolif_init(&bif); 3614 3615 int rc = cil_gen_expr_stack(test_tree->root->cl_head->cl_head->next, CIL_BOOL, &bif->expr_stack); 3616 CuAssertIntEquals(tc, SEPOL_OK, rc); 3617 } 3618 3619 void test_cil_gen_expr_stack_not(CuTest *tc) { 3620 char *line[] = {"(", "booleanif", "(", "not", "foo", ")", 3621 "(", "true", "(", "allow", "foo", "bar", "baz", "(", "read", ")", ")", ")", ")", NULL}; 3622 3623 struct cil_tree *test_tree; 3624 gen_test_tree(&test_tree, line); 3625 3626 struct cil_tree_node *test_ast_node; 3627 cil_tree_node_init(&test_ast_node); 3628 3629 struct cil_db *test_db; 3630 cil_db_init(&test_db); 3631 3632 test_ast_node->parent = test_db->ast->root; 3633 test_ast_node->line = 1; 3634 3635 struct cil_booleanif *bif; 3636 cil_boolif_init(&bif); 3637 3638 int rc = cil_gen_expr_stack(test_tree->root->cl_head->cl_head->next, CIL_BOOL, &bif->expr_stack); 3639 CuAssertIntEquals(tc, SEPOL_OK, rc); 3640 } 3641 3642 void test_cil_gen_expr_stack_not_noexpr_neg(CuTest *tc) { 3643 char *line[] = {"(", "booleanif", "(", "not", ")", 3644 "(", "true", "(", "allow", "foo", "bar", "baz", "(", "read", ")", ")", ")", ")", NULL}; 3645 3646 struct cil_tree *test_tree; 3647 gen_test_tree(&test_tree, line); 3648 3649 struct cil_tree_node *test_ast_node; 3650 cil_tree_node_init(&test_ast_node); 3651 3652 struct cil_db *test_db; 3653 cil_db_init(&test_db); 3654 3655 test_ast_node->parent = test_db->ast->root; 3656 test_ast_node->line = 1; 3657 3658 struct cil_booleanif *bif; 3659 cil_boolif_init(&bif); 3660 3661 int rc = cil_gen_expr_stack(test_tree->root->cl_head->cl_head->next, CIL_BOOL, &bif->expr_stack); 3662 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3663 } 3664 3665 void test_cil_gen_expr_stack_not_extraexpr_neg(CuTest *tc) { 3666 char *line[] = {"(", "booleanif", "(", "not", "foo", "bar", ")", 3667 "(", "true", "(", "allow", "foo", "bar", "baz", "(", "read", ")", ")", ")", ")", NULL}; 3668 3669 struct cil_tree *test_tree; 3670 gen_test_tree(&test_tree, line); 3671 3672 struct cil_tree_node *test_ast_node; 3673 cil_tree_node_init(&test_ast_node); 3674 3675 struct cil_db *test_db; 3676 cil_db_init(&test_db); 3677 3678 test_ast_node->parent = test_db->ast->root; 3679 test_ast_node->line = 1; 3680 3681 struct cil_booleanif *bif; 3682 cil_boolif_init(&bif); 3683 3684 int rc = cil_gen_expr_stack(test_tree->root->cl_head->cl_head->next, CIL_BOOL, &bif->expr_stack); 3685 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3686 } 3687 3688 void test_cil_gen_expr_stack_eq(CuTest *tc) { 3689 char *line[] = {"(", "booleanif", "(", "eq", "foo", "bar", ")", 3690 "(", "true", "(", "allow", "foo", "bar", "baz", "(", "read", ")", ")", ")", ")", NULL}; 3691 3692 struct cil_tree *test_tree; 3693 gen_test_tree(&test_tree, line); 3694 3695 struct cil_tree_node *test_ast_node; 3696 cil_tree_node_init(&test_ast_node); 3697 3698 struct cil_db *test_db; 3699 cil_db_init(&test_db); 3700 3701 test_ast_node->parent = test_db->ast->root; 3702 test_ast_node->line = 1; 3703 3704 struct cil_booleanif *bif; 3705 cil_boolif_init(&bif); 3706 3707 int rc = cil_gen_expr_stack(test_tree->root->cl_head->cl_head->next, CIL_BOOL, &bif->expr_stack); 3708 CuAssertIntEquals(tc, SEPOL_OK, rc); 3709 } 3710 3711 void test_cil_gen_expr_stack_neq(CuTest *tc) { 3712 char *line[] = {"(", "booleanif", "(", "neq", "foo", "bar", ")", 3713 "(", "true", "(", "allow", "foo", "bar", "baz", "(", "read", ")", ")", ")", ")", NULL}; 3714 3715 struct cil_tree *test_tree; 3716 gen_test_tree(&test_tree, line); 3717 3718 struct cil_tree_node *test_ast_node; 3719 cil_tree_node_init(&test_ast_node); 3720 3721 struct cil_db *test_db; 3722 cil_db_init(&test_db); 3723 3724 test_ast_node->parent = test_db->ast->root; 3725 test_ast_node->line = 1; 3726 3727 struct cil_booleanif *bif; 3728 cil_boolif_init(&bif); 3729 3730 int rc = cil_gen_expr_stack(test_tree->root->cl_head->cl_head->next, CIL_BOOL, &bif->expr_stack); 3731 CuAssertIntEquals(tc, SEPOL_OK, rc); 3732 } 3733 3734 void test_cil_gen_expr_stack_nested(CuTest *tc) { 3735 char *line[] = {"(", "booleanif", "(", "or", "(","neq", "foo", "bar", ")", "(", "eq", "baz", "boo", ")", ")", 3736 "(", "true", "(", "allow", "foo", "bar", "baz", "(", "read", ")", ")", ")", ")", NULL}; 3737 3738 struct cil_tree *test_tree; 3739 gen_test_tree(&test_tree, line); 3740 3741 struct cil_tree_node *test_ast_node; 3742 cil_tree_node_init(&test_ast_node); 3743 3744 struct cil_db *test_db; 3745 cil_db_init(&test_db); 3746 3747 test_ast_node->parent = test_db->ast->root; 3748 test_ast_node->line = 1; 3749 3750 struct cil_booleanif *bif; 3751 cil_boolif_init(&bif); 3752 3753 int rc = cil_gen_expr_stack(test_tree->root->cl_head->cl_head->next, CIL_BOOL, &bif->expr_stack); 3754 CuAssertIntEquals(tc, SEPOL_OK, rc); 3755 } 3756 3757 void test_cil_gen_expr_stack_nested_neg(CuTest *tc) { 3758 char *line[] = {"(", "booleanif", "(", "(","neq", "foo", "bar", ")", ")", 3759 "(", "true", "(", "allow", "foo", "bar", "baz", "(", "read", ")", ")", ")", ")", NULL}; 3760 3761 struct cil_tree *test_tree; 3762 gen_test_tree(&test_tree, line); 3763 3764 struct cil_tree_node *test_ast_node; 3765 cil_tree_node_init(&test_ast_node); 3766 3767 struct cil_db *test_db; 3768 cil_db_init(&test_db); 3769 3770 test_ast_node->parent = test_db->ast->root; 3771 test_ast_node->line = 1; 3772 3773 struct cil_booleanif *bif; 3774 cil_boolif_init(&bif); 3775 3776 int rc = cil_gen_expr_stack(test_tree->root->cl_head->cl_head->next, CIL_BOOL, &bif->expr_stack); 3777 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3778 } 3779 3780 void test_cil_gen_expr_stack_nested_emptyargs_neg(CuTest *tc) { 3781 char *line[] = {"(", "booleanif", "(", "eq", "(", ")", "(", ")", ")", 3782 "(", "true", "(", "allow", "foo", "bar", "baz", "(", "read", ")", ")", ")", ")", NULL}; 3783 3784 struct cil_tree *test_tree; 3785 gen_test_tree(&test_tree, line); 3786 3787 struct cil_tree_node *test_ast_node; 3788 cil_tree_node_init(&test_ast_node); 3789 3790 struct cil_db *test_db; 3791 cil_db_init(&test_db); 3792 3793 test_ast_node->parent = test_db->ast->root; 3794 test_ast_node->line = 1; 3795 3796 struct cil_booleanif *bif; 3797 cil_boolif_init(&bif); 3798 3799 int rc = cil_gen_expr_stack(test_tree->root->cl_head->cl_head->next, CIL_BOOL, &bif->expr_stack); 3800 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3801 } 3802 3803 void test_cil_gen_expr_stack_nested_missingoperator_neg(CuTest *tc) { 3804 char *line[] = {"(", "booleanif", "(", "or", "(","foo", "bar", ")", "(", "eq", "baz", "boo", ")", ")", 3805 "(", "true", "(", "allow", "foo", "bar", "baz", "(", "read", ")", ")", ")", ")", NULL}; 3806 3807 struct cil_tree *test_tree; 3808 gen_test_tree(&test_tree, line); 3809 3810 struct cil_tree_node *test_ast_node; 3811 cil_tree_node_init(&test_ast_node); 3812 3813 struct cil_db *test_db; 3814 cil_db_init(&test_db); 3815 3816 test_ast_node->parent = test_db->ast->root; 3817 test_ast_node->line = 1; 3818 3819 struct cil_booleanif *bif; 3820 cil_boolif_init(&bif); 3821 3822 int rc = cil_gen_expr_stack(test_tree->root->cl_head->cl_head->next, CIL_BOOL, &bif->expr_stack); 3823 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3824 } 3825 3826 void test_cil_gen_expr_stack_arg1null_neg(CuTest *tc) { 3827 char *line[] = {"(", "booleanif", "(", "eq", ")", 3828 "(", "true", "(", "allow", "foo", "bar", "baz", "(", "read", ")", ")", ")", ")", NULL}; 3829 3830 struct cil_tree *test_tree; 3831 gen_test_tree(&test_tree, line); 3832 3833 struct cil_tree_node *test_ast_node; 3834 cil_tree_node_init(&test_ast_node); 3835 3836 struct cil_db *test_db; 3837 cil_db_init(&test_db); 3838 3839 test_ast_node->parent = test_db->ast->root; 3840 test_ast_node->line = 1; 3841 3842 struct cil_booleanif *bif; 3843 cil_boolif_init(&bif); 3844 3845 int rc = cil_gen_expr_stack(test_tree->root->cl_head->cl_head->next, CIL_BOOL, &bif->expr_stack); 3846 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3847 } 3848 3849 void test_cil_gen_expr_stack_arg2null_neg(CuTest *tc) { 3850 char *line[] = {"(", "booleanif", "(", "eq", "foo", ")", 3851 "(", "true", "(", "allow", "foo", "bar", "baz", "(", "read", ")", ")", ")", ")", NULL}; 3852 3853 struct cil_tree *test_tree; 3854 gen_test_tree(&test_tree, line); 3855 3856 struct cil_tree_node *test_ast_node; 3857 cil_tree_node_init(&test_ast_node); 3858 3859 struct cil_db *test_db; 3860 cil_db_init(&test_db); 3861 3862 test_ast_node->parent = test_db->ast->root; 3863 test_ast_node->line = 1; 3864 3865 struct cil_booleanif *bif; 3866 cil_boolif_init(&bif); 3867 3868 int rc = cil_gen_expr_stack(test_tree->root->cl_head->cl_head->next, CIL_BOOL, &bif->expr_stack); 3869 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3870 } 3871 3872 void test_cil_gen_expr_stack_extraarg_neg(CuTest *tc) { 3873 char *line[] = {"(", "booleanif", "(", "eq", "foo", "bar", "extra", ")", 3874 "(", "true", "(", "allow", "foo", "bar", "baz", "(", "read", ")", ")", ")", ")", NULL}; 3875 3876 struct cil_tree *test_tree; 3877 gen_test_tree(&test_tree, line); 3878 3879 struct cil_tree_node *test_ast_node; 3880 cil_tree_node_init(&test_ast_node); 3881 3882 struct cil_db *test_db; 3883 cil_db_init(&test_db); 3884 3885 test_ast_node->parent = test_db->ast->root; 3886 test_ast_node->line = 1; 3887 3888 struct cil_booleanif *bif; 3889 cil_boolif_init(&bif); 3890 3891 int rc = cil_gen_expr_stack(test_tree->root->cl_head->cl_head->next, CIL_BOOL, &bif->expr_stack); 3892 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3893 } 3894 3895 void test_cil_gen_expr_stack_currnull_neg(CuTest *tc) { 3896 char *line[] = {"(", "booleanif", "(", ")", ")", NULL}; 3897 3898 struct cil_tree *test_tree; 3899 gen_test_tree(&test_tree, line); 3900 3901 struct cil_tree_node *test_ast_node; 3902 cil_tree_node_init(&test_ast_node); 3903 3904 struct cil_db *test_db; 3905 cil_db_init(&test_db); 3906 3907 test_ast_node->parent = test_db->ast->root; 3908 test_ast_node->line = 1; 3909 3910 struct cil_booleanif *bif; 3911 cil_boolif_init(&bif); 3912 3913 int rc = cil_gen_expr_stack(test_tree->root->cl_head->cl_head->next, CIL_BOOL, &bif->expr_stack); 3914 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3915 } 3916 3917 void test_cil_gen_expr_stack_stacknull_neg(CuTest *tc) { 3918 char *line[] = {"(", "booleanif", "(", "xor", "foo", "bar", ")", 3919 "(", "true", "(", "allow", "foo", "bar", "(", "read", ")", ")", ")", ")", NULL}; 3920 3921 struct cil_tree *test_tree; 3922 gen_test_tree(&test_tree, line); 3923 3924 struct cil_tree_node *test_ast_node; 3925 cil_tree_node_init(&test_ast_node); 3926 3927 struct cil_db *test_db; 3928 cil_db_init(&test_db); 3929 3930 test_ast_node->parent = test_db->ast->root; 3931 test_ast_node->line = 1; 3932 3933 int rc = cil_gen_expr_stack(test_tree->root->cl_head->cl_head->next, CIL_BOOL, NULL); 3934 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3935 } 3936 3937 void test_cil_gen_boolif_multiplebools_true(CuTest *tc) { 3938 char *line[] = {"(", "booleanif", "(", "and", "foo", "bar", ")", 3939 "(", "true", "(", "allow", "foo", "bar", "(", "read", ")", ")", ")", 3940 "(", "true", "(", "allow", "foo", "bar", "(", "write", ")", ")", ")", ")", NULL}; 3941 3942 struct cil_tree *test_tree; 3943 gen_test_tree(&test_tree, line); 3944 3945 struct cil_tree_node *test_ast_node; 3946 cil_tree_node_init(&test_ast_node); 3947 3948 struct cil_db *test_db; 3949 cil_db_init(&test_db); 3950 3951 test_ast_node->parent = test_db->ast->root; 3952 test_ast_node->line = 1; 3953 3954 int rc = cil_gen_boolif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 3955 CuAssertIntEquals(tc, SEPOL_OK, rc); 3956 } 3957 3958 void test_cil_gen_boolif_multiplebools_false(CuTest *tc) { 3959 char *line[] = {"(", "booleanif", "(", "and", "foo", "bar", ")", 3960 "(", "true", "(", "allow", "foo", "bar", "(", "read", ")", ")", ")", 3961 "(", "false", "(", "allow", "foo", "bar", "(", "write", ")", ")", ")", ")", NULL}; 3962 3963 struct cil_tree *test_tree; 3964 gen_test_tree(&test_tree, line); 3965 3966 struct cil_tree_node *test_ast_node; 3967 cil_tree_node_init(&test_ast_node); 3968 3969 struct cil_db *test_db; 3970 cil_db_init(&test_db); 3971 3972 test_ast_node->parent = test_db->ast->root; 3973 test_ast_node->line = 1; 3974 3975 int rc = cil_gen_boolif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 3976 CuAssertIntEquals(tc, SEPOL_OK, rc); 3977 } 3978 3979 void test_cil_gen_boolif_multiplebools_unknowncond_neg(CuTest *tc) { 3980 char *line[] = {"(", "booleanif", "(", "and", "foo", "bar", ")", 3981 "(", "true", "(", "allow", "foo", "bar", "(", "read", ")", ")", ")", 3982 "(", "dne", "(", "allow", "foo", "bar", "(", "write", ")", ")", ")", ")", NULL}; 3983 3984 struct cil_tree *test_tree; 3985 gen_test_tree(&test_tree, line); 3986 3987 struct cil_tree_node *test_ast_node; 3988 cil_tree_node_init(&test_ast_node); 3989 3990 struct cil_db *test_db; 3991 cil_db_init(&test_db); 3992 3993 test_ast_node->parent = test_db->ast->root; 3994 test_ast_node->line = 1; 3995 3996 int rc = cil_gen_boolif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 3997 CuAssertIntEquals(tc, SEPOL_ERR, rc); 3998 } 3999 4000 void test_cil_gen_boolif_true(CuTest *tc) { 4001 char *line[] = {"(", "booleanif", "(", "and", "foo", "bar", ")", 4002 "(", "true", "(", "allow", "foo", "bar", "(", "read", ")", ")", ")", ")", NULL}; 4003 4004 struct cil_tree *test_tree; 4005 gen_test_tree(&test_tree, line); 4006 4007 struct cil_tree_node *test_ast_node; 4008 cil_tree_node_init(&test_ast_node); 4009 4010 struct cil_db *test_db; 4011 cil_db_init(&test_db); 4012 4013 test_ast_node->parent = test_db->ast->root; 4014 test_ast_node->line = 1; 4015 4016 int rc = cil_gen_boolif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4017 CuAssertIntEquals(tc, SEPOL_OK, rc); 4018 } 4019 4020 void test_cil_gen_boolif_false(CuTest *tc) { 4021 char *line[] = {"(", "booleanif", "(", "and", "foo", "bar", ")", 4022 "(", "false", "(", "allow", "foo", "bar", "(", "read", ")", ")", ")", ")", NULL}; 4023 4024 struct cil_tree *test_tree; 4025 gen_test_tree(&test_tree, line); 4026 4027 struct cil_tree_node *test_ast_node; 4028 cil_tree_node_init(&test_ast_node); 4029 4030 struct cil_db *test_db; 4031 cil_db_init(&test_db); 4032 4033 test_ast_node->parent = test_db->ast->root; 4034 test_ast_node->line = 1; 4035 4036 int rc = cil_gen_boolif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4037 CuAssertIntEquals(tc, SEPOL_OK, rc); 4038 } 4039 4040 void test_cil_gen_boolif_unknowncond_neg(CuTest *tc) { 4041 char *line[] = {"(", "booleanif", "(", "and", "foo", "bar", ")", 4042 "(", "dne", "(", "allow", "foo", "bar", "(", "read", ")", ")", ")", ")", NULL}; 4043 4044 struct cil_tree *test_tree; 4045 gen_test_tree(&test_tree, line); 4046 4047 struct cil_tree_node *test_ast_node; 4048 cil_tree_node_init(&test_ast_node); 4049 4050 struct cil_db *test_db; 4051 cil_db_init(&test_db); 4052 4053 test_ast_node->parent = test_db->ast->root; 4054 test_ast_node->line = 1; 4055 4056 int rc = cil_gen_boolif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4057 CuAssertIntEquals(tc, SEPOL_ERR, rc); 4058 } 4059 4060 void test_cil_gen_boolif_nested(CuTest *tc) { 4061 char *line[] = {"(", "booleanif", "(", "and", "(", "or", "foo", "bar", ")", "baz", ")", 4062 "(", "true", "(", "allow", "foo", "baz", "(", "read", ")", ")", ")", ")", NULL}; 4063 4064 struct cil_tree *test_tree; 4065 gen_test_tree(&test_tree, line); 4066 4067 struct cil_tree_node *test_ast_node; 4068 cil_tree_node_init(&test_ast_node); 4069 4070 struct cil_db *test_db; 4071 cil_db_init(&test_db); 4072 4073 test_ast_node->parent = test_db->ast->root; 4074 test_ast_node->line = 1; 4075 4076 int rc = cil_gen_boolif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4077 CuAssertIntEquals(tc, SEPOL_OK, rc); 4078 } 4079 4080 void test_cil_gen_boolif_nested_neg(CuTest *tc) { 4081 char *line[] = {"(", "booleanif", "(", "(", "or", "foo", "bar", ")", "baz", ")", 4082 "(", "true", "(", "allow", "foo", "baz", "(", "read", ")", ")", ")", ")", NULL}; 4083 4084 struct cil_tree *test_tree; 4085 gen_test_tree(&test_tree, line); 4086 4087 struct cil_tree_node *test_ast_node; 4088 cil_tree_node_init(&test_ast_node); 4089 4090 struct cil_db *test_db; 4091 cil_db_init(&test_db); 4092 4093 test_ast_node->parent = test_db->ast->root; 4094 test_ast_node->line = 1; 4095 4096 int rc = cil_gen_boolif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4097 CuAssertIntEquals(tc, SEPOL_ERR, rc); 4098 } 4099 4100 void test_cil_gen_boolif_extra_neg(CuTest *tc) { 4101 char *line[] = {"(", "booleanif", "(", "and", "(", "or", "foo", "bar", ")", "baz", "beef", ")", 4102 "(", "true", "(", "allow", "foo", "baz", "(", "read", ")", ")", ")", ")", NULL}; 4103 4104 struct cil_tree *test_tree; 4105 gen_test_tree(&test_tree, line); 4106 4107 struct cil_tree_node *test_ast_node; 4108 cil_tree_node_init(&test_ast_node); 4109 4110 struct cil_db *test_db; 4111 cil_db_init(&test_db); 4112 4113 test_ast_node->parent = test_db->ast->root; 4114 test_ast_node->line = 1; 4115 4116 int rc = cil_gen_boolif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4117 CuAssertIntEquals(tc, SEPOL_ERR, rc); 4118 } 4119 4120 void test_cil_gen_boolif_extra_parens_neg(CuTest *tc) { 4121 char *line[] = {"(", "booleanif", "(", "(", "or", "foo", "bar", ")", ")", 4122 "(", "true", "(", "allow", "foo", "baz", "(", "read", ")", ")", ")", ")", NULL}; 4123 4124 struct cil_tree *test_tree; 4125 gen_test_tree(&test_tree, line); 4126 4127 struct cil_tree_node *test_ast_node; 4128 cil_tree_node_init(&test_ast_node); 4129 4130 struct cil_db *test_db; 4131 cil_db_init(&test_db); 4132 4133 test_ast_node->parent = test_db->ast->root; 4134 test_ast_node->line = 1; 4135 4136 int rc = cil_gen_boolif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4137 CuAssertIntEquals(tc, SEPOL_ERR, rc); 4138 } 4139 4140 void test_cil_gen_boolif_nocond(CuTest *tc) { 4141 char *line[] = {"(", "booleanif", "baz", 4142 "(", "true", "(", "allow", "foo", "bar", "(", "read", ")", ")", ")", ")", NULL}; 4143 4144 struct cil_tree *test_tree; 4145 gen_test_tree(&test_tree, line); 4146 4147 struct cil_tree_node *test_ast_node; 4148 cil_tree_node_init(&test_ast_node); 4149 4150 struct cil_db *test_db; 4151 cil_db_init(&test_db); 4152 4153 test_ast_node->parent = test_db->ast->root; 4154 test_ast_node->line = 1; 4155 4156 int rc = cil_gen_boolif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4157 CuAssertIntEquals(tc, SEPOL_OK, rc); 4158 } 4159 4160 void test_cil_gen_boolif_neg(CuTest *tc) { 4161 char *line[] = {"(", "booleanif", "(", "**", "foo", "bar", ")", 4162 "(", "true", "(", "allow", "foo", "bar", "(", "read", ")", ")", ")", ")", NULL}; 4163 4164 struct cil_tree *test_tree; 4165 gen_test_tree(&test_tree, line); 4166 4167 struct cil_tree_node *test_ast_node; 4168 cil_tree_node_init(&test_ast_node); 4169 4170 struct cil_db *test_db; 4171 cil_db_init(&test_db); 4172 4173 test_ast_node->parent = test_db->ast->root; 4174 test_ast_node->line = 1; 4175 4176 int rc = cil_gen_boolif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4177 CuAssertIntEquals(tc, SEPOL_ERR, rc); 4178 } 4179 4180 void test_cil_gen_boolif_dbnull_neg(CuTest *tc) { 4181 char *line[] = {"(", "booleanif", "(", "and", "foo", "bar", ")", 4182 "(", "true", "(", "allow", "foo", "bar", "(", "read", ")", ")", ")", ")", NULL}; 4183 4184 struct cil_tree *test_tree; 4185 gen_test_tree(&test_tree, line); 4186 4187 struct cil_tree_node *test_ast_node; 4188 cil_tree_node_init(&test_ast_node); 4189 4190 struct cil_db *test_db = NULL; 4191 4192 int rc = cil_gen_boolif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4193 CuAssertIntEquals(tc, SEPOL_ERR, rc); 4194 } 4195 4196 void test_cil_gen_boolif_currnull_neg(CuTest *tc) { 4197 char *line[] = {"(", ")", NULL}; 4198 4199 struct cil_tree *test_tree; 4200 gen_test_tree(&test_tree, line); 4201 4202 struct cil_tree_node *test_ast_node; 4203 cil_tree_node_init(&test_ast_node); 4204 4205 struct cil_db *test_db; 4206 cil_db_init(&test_db); 4207 4208 test_ast_node->parent = test_db->ast->root; 4209 test_ast_node->line = 1; 4210 4211 int rc = cil_gen_boolif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4212 CuAssertIntEquals(tc, SEPOL_ERR, rc); 4213 } 4214 4215 void test_cil_gen_boolif_astnull_neg(CuTest *tc) { 4216 char *line[] = {"(", "booleanif", "(", "and", "foo", "bar", ")", 4217 "(", "true", "(", "allow", "foo", "bar", "(", "read", ")", ")", ")", ")", NULL}; 4218 4219 struct cil_tree *test_tree; 4220 gen_test_tree(&test_tree, line); 4221 4222 struct cil_tree_node *test_ast_node = NULL; 4223 4224 struct cil_db *test_db; 4225 cil_db_init(&test_db); 4226 4227 int rc = cil_gen_boolif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4228 CuAssertIntEquals(tc, SEPOL_ERR, rc); 4229 } 4230 4231 void test_cil_gen_boolif_nocond_neg(CuTest *tc) { 4232 char *line[] = {"(", "booleanif", ")", NULL}; 4233 4234 struct cil_tree *test_tree; 4235 gen_test_tree(&test_tree, line); 4236 4237 struct cil_tree_node *test_ast_node; 4238 cil_tree_node_init(&test_ast_node); 4239 4240 struct cil_db *test_db; 4241 cil_db_init(&test_db); 4242 4243 test_ast_node->parent = test_db->ast->root; 4244 test_ast_node->line = 1; 4245 4246 int rc = cil_gen_boolif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4247 CuAssertIntEquals(tc, SEPOL_ERR, rc); 4248 } 4249 4250 void test_cil_gen_boolif_notruelist_neg(CuTest *tc) { 4251 char *line[] = {"(", "booleanif", "(", "and", "foo", "bar", ")", ")", NULL}; 4252 4253 struct cil_tree *test_tree; 4254 gen_test_tree(&test_tree, line); 4255 4256 struct cil_tree_node *test_ast_node; 4257 cil_tree_node_init(&test_ast_node); 4258 4259 struct cil_db *test_db; 4260 cil_db_init(&test_db); 4261 4262 test_ast_node->parent = test_db->ast->root; 4263 test_ast_node->line = 1; 4264 4265 int rc = cil_gen_boolif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4266 CuAssertIntEquals(tc, SEPOL_ERR, rc); 4267 } 4268 4269 void test_cil_gen_boolif_empty_cond_neg(CuTest *tc) { 4270 char *line[] = {"(", "booleanif", "(", ")", 4271 "(", "true", "(", "allow", "foo", "bar", "(", "read", ")", ")", ")", ")", NULL}; 4272 4273 struct cil_tree *test_tree; 4274 gen_test_tree(&test_tree, line); 4275 4276 struct cil_tree_node *test_ast_node; 4277 cil_tree_node_init(&test_ast_node); 4278 4279 struct cil_db *test_db; 4280 cil_db_init(&test_db); 4281 4282 test_ast_node->parent = test_db->ast->root; 4283 test_ast_node->line = 1; 4284 4285 int rc = cil_gen_boolif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4286 CuAssertIntEquals(tc, SEPOL_ERR, rc); 4287 } 4288 4289 void test_cil_gen_tunif_multiplebools_true(CuTest *tc) { 4290 char *line[] = {"(", "tunableif", "(", "and", "foo", "bar", ")", 4291 "(", "true", "(", "allow", "foo", "bar", "(", "read", ")", ")", ")", 4292 "(", "true", "(", "allow", "foo", "bar", "(", "write", ")", ")", ")", ")", NULL}; 4293 4294 struct cil_tree *test_tree; 4295 gen_test_tree(&test_tree, line); 4296 4297 struct cil_tree_node *test_ast_node; 4298 cil_tree_node_init(&test_ast_node); 4299 4300 struct cil_db *test_db; 4301 cil_db_init(&test_db); 4302 4303 test_ast_node->parent = test_db->ast->root; 4304 test_ast_node->line = 1; 4305 4306 int rc = cil_gen_tunif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4307 CuAssertIntEquals(tc, SEPOL_OK, rc); 4308 } 4309 4310 void test_cil_gen_tunif_multiplebools_false(CuTest *tc) { 4311 char *line[] = {"(", "tunableif", "(", "and", "foo", "bar", ")", 4312 "(", "true", "(", "allow", "foo", "bar", "(", "read", ")", ")", ")", 4313 "(", "false", "(", "allow", "foo", "bar", "(", "write", ")", ")", ")", ")", NULL}; 4314 4315 struct cil_tree *test_tree; 4316 gen_test_tree(&test_tree, line); 4317 4318 struct cil_tree_node *test_ast_node; 4319 cil_tree_node_init(&test_ast_node); 4320 4321 struct cil_db *test_db; 4322 cil_db_init(&test_db); 4323 4324 test_ast_node->parent = test_db->ast->root; 4325 test_ast_node->line = 1; 4326 4327 int rc = cil_gen_tunif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4328 CuAssertIntEquals(tc, SEPOL_OK, rc); 4329 } 4330 4331 void test_cil_gen_tunif_multiplebools_unknowncond_neg(CuTest *tc) { 4332 char *line[] = {"(", "tunableif", "(", "and", "foo", "bar", ")", 4333 "(", "true", "(", "allow", "foo", "bar", "(", "read", ")", ")", ")", 4334 "(", "dne", "(", "allow", "foo", "bar", "(", "write", ")", ")", ")", ")", NULL}; 4335 4336 struct cil_tree *test_tree; 4337 gen_test_tree(&test_tree, line); 4338 4339 struct cil_tree_node *test_ast_node; 4340 cil_tree_node_init(&test_ast_node); 4341 4342 struct cil_db *test_db; 4343 cil_db_init(&test_db); 4344 4345 test_ast_node->parent = test_db->ast->root; 4346 test_ast_node->line = 1; 4347 4348 int rc = cil_gen_tunif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4349 CuAssertIntEquals(tc, SEPOL_ERR, rc); 4350 } 4351 4352 void test_cil_gen_tunif_true(CuTest *tc) { 4353 char *line[] = {"(", "tunableif", "(", "and", "foo", "bar", ")", 4354 "(", "true", "(", "allow", "foo", "bar", "(", "read", ")", ")", ")", ")", NULL}; 4355 4356 struct cil_tree *test_tree; 4357 gen_test_tree(&test_tree, line); 4358 4359 struct cil_tree_node *test_ast_node; 4360 cil_tree_node_init(&test_ast_node); 4361 4362 struct cil_db *test_db; 4363 cil_db_init(&test_db); 4364 4365 test_ast_node->parent = test_db->ast->root; 4366 test_ast_node->line = 1; 4367 4368 int rc = cil_gen_tunif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4369 CuAssertIntEquals(tc, SEPOL_OK, rc); 4370 } 4371 4372 void test_cil_gen_tunif_false(CuTest *tc) { 4373 char *line[] = {"(", "tunableif", "(", "and", "foo", "bar", ")", 4374 "(", "false", "(", "allow", "foo", "bar", "(", "read", ")", ")", ")", ")", NULL}; 4375 4376 struct cil_tree *test_tree; 4377 gen_test_tree(&test_tree, line); 4378 4379 struct cil_tree_node *test_ast_node; 4380 cil_tree_node_init(&test_ast_node); 4381 4382 struct cil_db *test_db; 4383 cil_db_init(&test_db); 4384 4385 test_ast_node->parent = test_db->ast->root; 4386 test_ast_node->line = 1; 4387 4388 int rc = cil_gen_tunif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4389 CuAssertIntEquals(tc, SEPOL_OK, rc); 4390 } 4391 4392 void test_cil_gen_tunif_unknowncond_neg(CuTest *tc) { 4393 char *line[] = {"(", "tunableif", "(", "and", "foo", "bar", ")", 4394 "(", "dne", "(", "allow", "foo", "bar", "(", "read", ")", ")", ")", ")", NULL}; 4395 4396 struct cil_tree *test_tree; 4397 gen_test_tree(&test_tree, line); 4398 4399 struct cil_tree_node *test_ast_node; 4400 cil_tree_node_init(&test_ast_node); 4401 4402 struct cil_db *test_db; 4403 cil_db_init(&test_db); 4404 4405 test_ast_node->parent = test_db->ast->root; 4406 test_ast_node->line = 1; 4407 4408 int rc = cil_gen_tunif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4409 CuAssertIntEquals(tc, SEPOL_ERR, rc); 4410 } 4411 4412 void test_cil_gen_tunif_nocond(CuTest *tc) { 4413 char *line[] = {"(", "tunableif", "baz", 4414 "(", "true", "(", "allow", "foo", "bar", "(", "read", ")", ")", ")", ")", NULL}; 4415 4416 struct cil_tree *test_tree; 4417 gen_test_tree(&test_tree, line); 4418 4419 struct cil_tree_node *test_ast_node; 4420 cil_tree_node_init(&test_ast_node); 4421 4422 struct cil_db *test_db; 4423 cil_db_init(&test_db); 4424 4425 test_ast_node->parent = test_db->ast->root; 4426 test_ast_node->line = 1; 4427 4428 int rc = cil_gen_tunif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4429 CuAssertIntEquals(tc, SEPOL_OK, rc); 4430 } 4431 4432 void test_cil_gen_tunif_nested(CuTest *tc) { 4433 char *line[] = {"(", "tunableif", "(", "and", "(", "or", "foo", "bar", ")", "baz", ")", 4434 "(", "true", "(", "allow", "foo", "baz", "(", "read", ")", ")", ")", ")", NULL}; 4435 4436 struct cil_tree *test_tree; 4437 gen_test_tree(&test_tree, line); 4438 4439 struct cil_tree_node *test_ast_node; 4440 cil_tree_node_init(&test_ast_node); 4441 4442 struct cil_db *test_db; 4443 cil_db_init(&test_db); 4444 4445 test_ast_node->parent = test_db->ast->root; 4446 test_ast_node->line = 1; 4447 4448 int rc = cil_gen_tunif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4449 CuAssertIntEquals(tc, SEPOL_OK, rc); 4450 } 4451 4452 void test_cil_gen_tunif_nested_neg(CuTest *tc) { 4453 char *line[] = {"(", "tunableif", "(", "(", "or", "foo", "bar", ")", "baz", ")", 4454 "(", "true", "(", "allow", "foo", "baz", "(", "read", ")", ")", ")", ")", NULL}; 4455 4456 struct cil_tree *test_tree; 4457 gen_test_tree(&test_tree, line); 4458 4459 struct cil_tree_node *test_ast_node; 4460 cil_tree_node_init(&test_ast_node); 4461 4462 struct cil_db *test_db; 4463 cil_db_init(&test_db); 4464 4465 test_ast_node->parent = test_db->ast->root; 4466 test_ast_node->line = 1; 4467 4468 int rc = cil_gen_tunif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4469 CuAssertIntEquals(tc, SEPOL_ERR, rc); 4470 } 4471 4472 void test_cil_gen_tunif_extra_neg(CuTest *tc) { 4473 char *line[] = {"(", "tunableif", "(", "and", "(", "or", "foo", "bar", ")", "baz", "beef", ")", 4474 "(", "true", "(", "allow", "foo", "baz", "(", "read", ")", ")", ")", ")", NULL}; 4475 4476 struct cil_tree *test_tree; 4477 gen_test_tree(&test_tree, line); 4478 4479 struct cil_tree_node *test_ast_node; 4480 cil_tree_node_init(&test_ast_node); 4481 4482 struct cil_db *test_db; 4483 cil_db_init(&test_db); 4484 4485 test_ast_node->parent = test_db->ast->root; 4486 test_ast_node->line = 1; 4487 4488 int rc = cil_gen_tunif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4489 CuAssertIntEquals(tc, SEPOL_ERR, rc); 4490 } 4491 4492 void test_cil_gen_tunif_extra_parens_neg(CuTest *tc) { 4493 char *line[] = {"(", "tunableif", "(", "(", "or", "foo", "bar", ")", ")", 4494 "(", "true", "(", "allow", "foo", "baz", "(", "read", ")", ")", ")", ")", NULL}; 4495 4496 struct cil_tree *test_tree; 4497 gen_test_tree(&test_tree, line); 4498 4499 struct cil_tree_node *test_ast_node; 4500 cil_tree_node_init(&test_ast_node); 4501 4502 struct cil_db *test_db; 4503 cil_db_init(&test_db); 4504 4505 test_ast_node->parent = test_db->ast->root; 4506 test_ast_node->line = 1; 4507 4508 int rc = cil_gen_tunif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4509 CuAssertIntEquals(tc, SEPOL_ERR, rc); 4510 } 4511 4512 void test_cil_gen_tunif_neg(CuTest *tc) { 4513 char *line[] = {"(", "tunableif", "(", "**", "foo", "bar", ")", 4514 "(", "true", "(", "allow", "foo", "bar", "(", "read", ")", ")", ")", ")", NULL}; 4515 4516 struct cil_tree *test_tree; 4517 gen_test_tree(&test_tree, line); 4518 4519 struct cil_tree_node *test_ast_node; 4520 cil_tree_node_init(&test_ast_node); 4521 4522 struct cil_db *test_db; 4523 cil_db_init(&test_db); 4524 4525 test_ast_node->parent = test_db->ast->root; 4526 test_ast_node->line = 1; 4527 4528 int rc = cil_gen_tunif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4529 CuAssertIntEquals(tc, SEPOL_ERR, rc); 4530 } 4531 4532 void test_cil_gen_tunif_dbnull_neg(CuTest *tc) { 4533 char *line[] = {"(", "tunableif", "(", "and", "foo", "bar", ")", 4534 "(", "true", "(", "allow", "foo", "bar", "(", "read", ")", ")", ")", ")", NULL}; 4535 4536 struct cil_tree *test_tree; 4537 gen_test_tree(&test_tree, line); 4538 4539 struct cil_tree_node *test_ast_node; 4540 cil_tree_node_init(&test_ast_node); 4541 4542 struct cil_db *test_db = NULL; 4543 4544 int rc = cil_gen_tunif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4545 CuAssertIntEquals(tc, SEPOL_ERR, rc); 4546 } 4547 4548 void test_cil_gen_tunif_currnull_neg(CuTest *tc) { 4549 char *line[] = {"(", ")", NULL}; 4550 4551 struct cil_tree *test_tree; 4552 gen_test_tree(&test_tree, line); 4553 4554 struct cil_tree_node *test_ast_node; 4555 cil_tree_node_init(&test_ast_node); 4556 4557 struct cil_db *test_db; 4558 cil_db_init(&test_db); 4559 4560 test_ast_node->parent = test_db->ast->root; 4561 test_ast_node->line = 1; 4562 4563 int rc = cil_gen_tunif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4564 CuAssertIntEquals(tc, SEPOL_ERR, rc); 4565 } 4566 4567 void test_cil_gen_tunif_astnull_neg(CuTest *tc) { 4568 char *line[] = {"(", "tunableif", "(", "and", "foo", "bar", ")", 4569 "(", "true", "(", "allow", "foo", "bar", "(", "read", ")", ")", ")", ")", NULL}; 4570 4571 struct cil_tree *test_tree; 4572 gen_test_tree(&test_tree, line); 4573 4574 struct cil_tree_node *test_ast_node = NULL; 4575 4576 struct cil_db *test_db; 4577 cil_db_init(&test_db); 4578 4579 int rc = cil_gen_tunif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4580 CuAssertIntEquals(tc, SEPOL_ERR, rc); 4581 } 4582 4583 void test_cil_gen_tunif_nocond_neg(CuTest *tc) { 4584 char *line[] = {"(", "tunableif", ")", NULL}; 4585 4586 struct cil_tree *test_tree; 4587 gen_test_tree(&test_tree, line); 4588 4589 struct cil_tree_node *test_ast_node; 4590 cil_tree_node_init(&test_ast_node); 4591 4592 struct cil_db *test_db; 4593 cil_db_init(&test_db); 4594 4595 test_ast_node->parent = test_db->ast->root; 4596 test_ast_node->line = 1; 4597 4598 int rc = cil_gen_tunif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4599 CuAssertIntEquals(tc, SEPOL_ERR, rc); 4600 } 4601 4602 void test_cil_gen_tunif_notruelist_neg(CuTest *tc) { 4603 char *line[] = {"(", "tunableif", "(", "and", "foo", "bar", ")", ")", NULL}; 4604 4605 struct cil_tree *test_tree; 4606 gen_test_tree(&test_tree, line); 4607 4608 struct cil_tree_node *test_ast_node; 4609 cil_tree_node_init(&test_ast_node); 4610 4611 struct cil_db *test_db; 4612 cil_db_init(&test_db); 4613 4614 test_ast_node->parent = test_db->ast->root; 4615 test_ast_node->line = 1; 4616 4617 int rc = cil_gen_tunif(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4618 CuAssertIntEquals(tc, SEPOL_ERR, rc); 4619 } 4620 4621 void test_cil_gen_condblock_true(CuTest *tc) { 4622 char *line[] = {"(", "true", "(", "allow", "foo", "bar", "baz", "(", "read", ")", ")", ")", NULL}; 4623 4624 struct cil_tree *test_tree; 4625 gen_test_tree(&test_tree, line); 4626 4627 struct cil_tree_node *test_ast_node; 4628 cil_tree_node_init(&test_ast_node); 4629 4630 struct cil_db *test_db; 4631 cil_db_init(&test_db); 4632 4633 test_ast_node->parent = test_db->ast->root; 4634 test_ast_node->line = 1; 4635 4636 int rc = cil_gen_condblock(test_db, test_tree->root->cl_head->cl_head, test_ast_node, CIL_CONDTRUE); 4637 CuAssertIntEquals(tc, SEPOL_OK, rc); 4638 } 4639 4640 void test_cil_gen_condblock_false(CuTest *tc) { 4641 char *line[] = {"(", "false", "(", "allow", "foo", "bar", "baz", "(", "read", ")", ")", ")", NULL}; 4642 4643 struct cil_tree *test_tree; 4644 gen_test_tree(&test_tree, line); 4645 4646 struct cil_tree_node *test_ast_node; 4647 cil_tree_node_init(&test_ast_node); 4648 4649 struct cil_db *test_db; 4650 cil_db_init(&test_db); 4651 4652 test_ast_node->parent = test_db->ast->root; 4653 test_ast_node->line = 1; 4654 4655 int rc = cil_gen_condblock(test_db, test_tree->root->cl_head->cl_head, test_ast_node, CIL_CONDFALSE); 4656 CuAssertIntEquals(tc, SEPOL_OK, rc); 4657 } 4658 4659 void test_cil_gen_condblock_dbnull_neg(CuTest *tc) { 4660 char *line[] = {"(", "false", "(", "allow", "foo", "bar", "baz", "(", "read", ")", ")", ")", NULL}; 4661 4662 struct cil_tree *test_tree; 4663 gen_test_tree(&test_tree, line); 4664 4665 struct cil_tree_node *test_ast_node; 4666 cil_tree_node_init(&test_ast_node); 4667 4668 struct cil_db *test_db = NULL; 4669 4670 int rc = cil_gen_condblock(test_db, test_tree->root->cl_head->cl_head, test_ast_node, CIL_CONDFALSE); 4671 CuAssertIntEquals(tc, SEPOL_ERR, rc); 4672 } 4673 4674 void test_cil_gen_condblock_currnull_neg(CuTest *tc) { 4675 char *line[] = {"(", ")", NULL}; 4676 4677 struct cil_tree *test_tree; 4678 gen_test_tree(&test_tree, line); 4679 4680 struct cil_tree_node *test_ast_node; 4681 cil_tree_node_init(&test_ast_node); 4682 4683 struct cil_db *test_db; 4684 cil_db_init(&test_db); 4685 4686 test_ast_node->parent = test_db->ast->root; 4687 test_ast_node->line = 1; 4688 4689 int rc = cil_gen_condblock(test_db, test_tree->root->cl_head->cl_head, test_ast_node, CIL_CONDFALSE); 4690 CuAssertIntEquals(tc, SEPOL_ERR, rc); 4691 } 4692 4693 void test_cil_gen_condblock_astnull_neg(CuTest *tc) { 4694 char *line[] = {"(", "false", "(", "allow", "foo", "bar", "baz", "(", "read", ")", ")", ")", NULL}; 4695 4696 struct cil_tree *test_tree; 4697 gen_test_tree(&test_tree, line); 4698 4699 struct cil_tree_node *test_ast_node = NULL; 4700 4701 struct cil_db *test_db; 4702 cil_db_init(&test_db); 4703 4704 int rc = cil_gen_condblock(test_db, test_tree->root->cl_head->cl_head, test_ast_node, CIL_CONDFALSE); 4705 CuAssertIntEquals(tc, SEPOL_ERR, rc); 4706 } 4707 4708 void test_cil_gen_condblock_nocond_neg(CuTest *tc) { 4709 char *line[] = {"(", "true", ")", NULL}; 4710 4711 struct cil_tree *test_tree; 4712 gen_test_tree(&test_tree, line); 4713 4714 struct cil_tree_node *test_ast_node; 4715 cil_tree_node_init(&test_ast_node); 4716 4717 struct cil_db *test_db; 4718 cil_db_init(&test_db); 4719 4720 test_ast_node->parent = test_db->ast->root; 4721 test_ast_node->line = 1; 4722 4723 int rc = cil_gen_condblock(test_db, test_tree->root->cl_head->cl_head, test_ast_node, CIL_CONDTRUE); 4724 CuAssertIntEquals(tc, SEPOL_ERR, rc); 4725 } 4726 4727 void test_cil_gen_condblock_extra_neg(CuTest *tc) { 4728 char *line[] = {"(", "true", "(", "allow", "foo", "bar", "baz", "(", "read", ")", ")", "Extra", ")", NULL}; 4729 4730 struct cil_tree *test_tree; 4731 gen_test_tree(&test_tree, line); 4732 4733 struct cil_tree_node *test_ast_node; 4734 cil_tree_node_init(&test_ast_node); 4735 4736 struct cil_db *test_db; 4737 cil_db_init(&test_db); 4738 4739 test_ast_node->parent = test_db->ast->root; 4740 test_ast_node->line = 1; 4741 4742 int rc = cil_gen_condblock(test_db, test_tree->root->cl_head->cl_head, test_ast_node, CIL_CONDTRUE); 4743 CuAssertIntEquals(tc, SEPOL_ERR, rc); 4744 } 4745 4746 void test_cil_gen_typealias(CuTest *tc) { 4747 char *line[] = {"(", "typealias", ".test.type", "type_t", ")", "(", "type", "test", ")", NULL}; 4748 4749 struct cil_tree *test_tree; 4750 gen_test_tree(&test_tree, line); 4751 4752 struct cil_tree_node *test_ast_node; 4753 cil_tree_node_init(&test_ast_node); 4754 4755 struct cil_db *test_db; 4756 cil_db_init(&test_db); 4757 4758 test_ast_node->parent = test_db->ast->root; 4759 test_ast_node->line = 1; 4760 4761 int rc = cil_gen_typealias(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4762 CuAssertIntEquals(tc, SEPOL_OK, rc); 4763 CuAssertPtrNotNull(tc, test_ast_node->data); 4764 CuAssertStrEquals(tc, ((struct cil_typealias*)test_ast_node->data)->type_str, test_tree->root->cl_head->cl_head->next->data); 4765 CuAssertIntEquals(tc, test_ast_node->flavor, CIL_TYPEALIAS); 4766 } 4767 4768 void test_cil_gen_typealias_incomplete_neg(CuTest *tc) { 4769 char *line[] = {"(", "typealias", ")", NULL}; 4770 4771 struct cil_tree *test_tree; 4772 gen_test_tree(&test_tree, line); 4773 4774 struct cil_tree_node *test_ast_node; 4775 cil_tree_node_init(&test_ast_node); 4776 4777 struct cil_db *test_db; 4778 cil_db_init(&test_db); 4779 4780 test_ast_node->parent = test_db->ast->root; 4781 test_ast_node->line = 1; 4782 4783 int rc = cil_gen_typealias(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4784 CuAssertIntEquals(tc, SEPOL_ERR, rc); 4785 } 4786 4787 void test_cil_gen_typealias_incomplete_neg2(CuTest *tc) { 4788 char *line[] = {"(", "typealias", ".test.type", ")", NULL}; 4789 4790 struct cil_tree *test_tree; 4791 gen_test_tree(&test_tree, line); 4792 4793 struct cil_tree_node *test_ast_node; 4794 cil_tree_node_init(&test_ast_node); 4795 4796 struct cil_db *test_db; 4797 cil_db_init(&test_db); 4798 4799 test_ast_node->parent = test_db->ast->root; 4800 test_ast_node->line = 1; 4801 4802 int rc = cil_gen_typealias(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4803 CuAssertIntEquals(tc, SEPOL_ERR, rc); 4804 } 4805 4806 void test_cil_gen_typealias_extratype_neg(CuTest *tc) { 4807 char *line[] = {"(", "typealias", ".test.type", "foo", "extra_t", ")", NULL}; 4808 4809 struct cil_tree *test_tree; 4810 gen_test_tree(&test_tree, line); 4811 4812 struct cil_tree_node *test_ast_node; 4813 cil_tree_node_init(&test_ast_node); 4814 4815 struct cil_db *test_db; 4816 cil_db_init(&test_db); 4817 4818 test_ast_node->parent = test_db->ast->root; 4819 test_ast_node->line = 1; 4820 4821 int rc = cil_gen_typealias(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4822 CuAssertIntEquals(tc, SEPOL_ERR, rc); 4823 } 4824 4825 void test_cil_gen_typealias_dbnull_neg(CuTest *tc) { 4826 char *line[] = {"(", "typealias", ".test.type", "type_t", ")", "(", "type", "test", ")", NULL}; 4827 4828 struct cil_tree *test_tree; 4829 gen_test_tree(&test_tree, line); 4830 4831 struct cil_tree_node *test_ast_node; 4832 cil_tree_node_init(&test_ast_node); 4833 4834 struct cil_db *test_db = NULL; 4835 4836 int rc = cil_gen_typealias(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4837 CuAssertIntEquals(tc, SEPOL_ERR, rc); 4838 } 4839 4840 void test_cil_gen_typealias_currnull_neg(CuTest *tc) { 4841 char *line[] = {"(", ")", NULL}; 4842 4843 struct cil_tree *test_tree; 4844 gen_test_tree(&test_tree, line); 4845 4846 struct cil_tree_node *test_ast_node; 4847 cil_tree_node_init(&test_ast_node); 4848 4849 struct cil_db *test_db; 4850 cil_db_init(&test_db); 4851 4852 test_ast_node->parent = test_db->ast->root; 4853 test_ast_node->line = 1; 4854 4855 int rc = cil_gen_typealias(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4856 CuAssertIntEquals(tc, SEPOL_ERR, rc); 4857 } 4858 4859 void test_cil_gen_typealias_astnull_neg(CuTest *tc) { 4860 char *line[] = {"(", "typealias", ".test.type", "type_t", ")", "(", "type", "test", ")", NULL}; 4861 4862 struct cil_tree *test_tree; 4863 gen_test_tree(&test_tree, line); 4864 4865 struct cil_tree_node *test_ast_node = NULL; 4866 4867 struct cil_db *test_db; 4868 cil_db_init(&test_db); 4869 4870 int rc = cil_gen_typealias(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4871 CuAssertIntEquals(tc, SEPOL_ERR, rc); 4872 } 4873 4874 void test_cil_gen_typeattributeset(CuTest *tc) { 4875 char *line[] = {"(", "typeattributeset", "filetypes", "test_t", ")", NULL}; 4876 4877 struct cil_tree *test_tree; 4878 gen_test_tree(&test_tree, line); 4879 4880 struct cil_tree_node *test_ast_node; 4881 cil_tree_node_init(&test_ast_node); 4882 4883 struct cil_db *test_db; 4884 cil_db_init(&test_db); 4885 4886 test_ast_node->parent = test_db->ast->root; 4887 test_ast_node->line = 1; 4888 4889 int rc = cil_gen_typeattributeset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4890 CuAssertIntEquals(tc, SEPOL_OK, rc); 4891 CuAssertPtrNotNull(tc, test_ast_node->data); 4892 } 4893 4894 void test_cil_gen_typeattributeset_and_two_types(CuTest *tc) { 4895 char *line[] = {"(", "typeattributeset", "filetypes", "(", "and", "test_t", "test2_t", ")", ")", NULL}; 4896 4897 struct cil_tree *test_tree; 4898 gen_test_tree(&test_tree, line); 4899 4900 struct cil_tree_node *test_ast_node; 4901 cil_tree_node_init(&test_ast_node); 4902 4903 struct cil_db *test_db; 4904 cil_db_init(&test_db); 4905 4906 test_ast_node->parent = test_db->ast->root; 4907 test_ast_node->line = 1; 4908 4909 int rc = cil_gen_typeattributeset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4910 CuAssertIntEquals(tc, SEPOL_OK, rc); 4911 CuAssertPtrNotNull(tc, test_ast_node->data); 4912 } 4913 4914 void test_cil_gen_typeattributeset_not(CuTest *tc) { 4915 char *line[] = {"(", "typeattributeset", "filetypes", "(", "not", "notypes_t", ")", ")", NULL}; 4916 4917 struct cil_tree *test_tree; 4918 gen_test_tree(&test_tree, line); 4919 4920 struct cil_tree_node *test_ast_node; 4921 cil_tree_node_init(&test_ast_node); 4922 4923 struct cil_db *test_db; 4924 cil_db_init(&test_db); 4925 4926 test_ast_node->parent = test_db->ast->root; 4927 test_ast_node->line = 1; 4928 4929 int rc = cil_gen_typeattributeset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4930 CuAssertIntEquals(tc, SEPOL_OK, rc); 4931 CuAssertPtrNotNull(tc, test_ast_node->data); 4932 } 4933 4934 void test_cil_gen_typeattributeset_exclude_attr(CuTest *tc) { 4935 char *line[] = {"(", "typeattributeset", "filetypes", "(", "not", "attr", ")", ")", NULL}; 4936 4937 struct cil_tree *test_tree; 4938 gen_test_tree(&test_tree, line); 4939 4940 struct cil_tree_node *test_ast_node; 4941 cil_tree_node_init(&test_ast_node); 4942 4943 struct cil_db *test_db; 4944 cil_db_init(&test_db); 4945 4946 test_ast_node->parent = test_db->ast->root; 4947 test_ast_node->line = 1; 4948 4949 int rc = cil_gen_typeattributeset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4950 CuAssertIntEquals(tc, SEPOL_OK, rc); 4951 CuAssertPtrNotNull(tc, test_ast_node->data); 4952 } 4953 4954 void test_cil_gen_typeattributeset_exclude_neg(CuTest *tc) { 4955 char *line[] = {"(", "typeattributeset", "filetypes", "(", "not", ")", ")", NULL}; 4956 4957 struct cil_tree *test_tree; 4958 gen_test_tree(&test_tree, line); 4959 4960 struct cil_tree_node *test_ast_node; 4961 cil_tree_node_init(&test_ast_node); 4962 4963 struct cil_db *test_db; 4964 cil_db_init(&test_db); 4965 4966 test_ast_node->parent = test_db->ast->root; 4967 test_ast_node->line = 1; 4968 4969 int rc = cil_gen_typeattributeset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4970 CuAssertIntEquals(tc, SEPOL_ERR, rc); 4971 } 4972 4973 void test_cil_gen_typeattributeset_dbnull_neg(CuTest *tc) { 4974 char *line[] = {"(", "typeattributeset", "filetypes", "(", "not", "type_t", ")", ")", NULL}; 4975 4976 struct cil_tree *test_tree; 4977 gen_test_tree(&test_tree, line); 4978 4979 struct cil_tree_node *test_ast_node; 4980 cil_tree_node_init(&test_ast_node); 4981 4982 struct cil_db *test_db = NULL; 4983 4984 int rc = cil_gen_typeattributeset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 4985 CuAssertIntEquals(tc, SEPOL_ERR, rc); 4986 } 4987 4988 void test_cil_gen_typeattributeset_currnull_neg(CuTest *tc) { 4989 char *line[] = {"(", ")", NULL}; 4990 4991 struct cil_tree *test_tree; 4992 gen_test_tree(&test_tree, line); 4993 4994 struct cil_tree_node *test_ast_node; 4995 cil_tree_node_init(&test_ast_node); 4996 4997 struct cil_db *test_db; 4998 cil_db_init(&test_db); 4999 5000 test_ast_node->parent = test_db->ast->root; 5001 test_ast_node->line = 1; 5002 5003 int rc = cil_gen_typeattributeset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 5004 CuAssertIntEquals(tc, SEPOL_ERR, rc); 5005 } 5006 5007 void test_cil_gen_typeattributeset_astnull_neg(CuTest *tc) { 5008 char *line[] = {"(", "typeattributeset", "filetypes", "(", "not", ")", ")", NULL}; 5009 5010 struct cil_tree *test_tree; 5011 gen_test_tree(&test_tree, line); 5012 5013 struct cil_tree_node *test_ast_node = NULL; 5014 5015 struct cil_db *test_db; 5016 cil_db_init(&test_db); 5017 5018 int rc = cil_gen_typeattributeset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 5019 CuAssertIntEquals(tc, SEPOL_ERR, rc); 5020 } 5021 5022 void test_cil_gen_typeattributeset_noname_neg(CuTest *tc) { 5023 char *line[] = {"(", "typeattributeset", ")", NULL}; 5024 5025 struct cil_tree *test_tree; 5026 gen_test_tree(&test_tree, line); 5027 5028 struct cil_tree_node *test_ast_node; 5029 cil_tree_node_init(&test_ast_node); 5030 5031 struct cil_db *test_db; 5032 cil_db_init(&test_db); 5033 5034 test_ast_node->parent = test_db->ast->root; 5035 test_ast_node->line = 1; 5036 5037 int rc = cil_gen_typeattributeset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 5038 CuAssertIntEquals(tc, SEPOL_ERR, rc); 5039 } 5040 5041 void test_cil_gen_typeattributeset_nameinparens_neg(CuTest *tc) { 5042 char *line[] = {"(", "typeattributeset", "(", "filetypes", ")", "(", "test_t", ")", ")", NULL}; 5043 5044 struct cil_tree *test_tree; 5045 gen_test_tree(&test_tree, line); 5046 5047 struct cil_tree_node *test_ast_node; 5048 cil_tree_node_init(&test_ast_node); 5049 5050 struct cil_db *test_db; 5051 cil_db_init(&test_db); 5052 5053 test_ast_node->parent = test_db->ast->root; 5054 test_ast_node->line = 1; 5055 5056 int rc = cil_gen_typeattributeset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 5057 CuAssertIntEquals(tc, SEPOL_ERR, rc); 5058 } 5059 5060 void test_cil_gen_typeattributeset_emptylists_neg(CuTest *tc) { 5061 char *line[] = {"(", "typeattributeset", "filetypes", "(", ")", ")", NULL}; 5062 5063 struct cil_tree *test_tree; 5064 gen_test_tree(&test_tree, line); 5065 5066 struct cil_tree_node *test_ast_node; 5067 cil_tree_node_init(&test_ast_node); 5068 5069 struct cil_db *test_db; 5070 cil_db_init(&test_db); 5071 5072 test_ast_node->parent = test_db->ast->root; 5073 test_ast_node->line = 1; 5074 5075 int rc = cil_gen_typeattributeset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 5076 CuAssertIntEquals(tc, SEPOL_ERR, rc); 5077 } 5078 5079 void test_cil_gen_typeattributeset_listinparens_neg(CuTest *tc) { 5080 char *line[] = {"(", "typeattributeset", "filetypes", "(", "(", "test_t", ")", ")", ")", NULL}; 5081 5082 struct cil_tree *test_tree; 5083 gen_test_tree(&test_tree, line); 5084 5085 struct cil_tree_node *test_ast_node; 5086 cil_tree_node_init(&test_ast_node); 5087 5088 struct cil_db *test_db; 5089 cil_db_init(&test_db); 5090 5091 test_ast_node->parent = test_db->ast->root; 5092 test_ast_node->line = 1; 5093 5094 int rc = cil_gen_typeattributeset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 5095 CuAssertIntEquals(tc, SEPOL_ERR, rc); 5096 } 5097 5098 void test_cil_gen_typeattributeset_extra_neg(CuTest *tc) { 5099 char *line[] = {"(", "typeattributeset", "filetypes", "(", "test_t", ")", "extra", ")", NULL}; 5100 5101 struct cil_tree *test_tree; 5102 gen_test_tree(&test_tree, line); 5103 5104 struct cil_tree_node *test_ast_node; 5105 cil_tree_node_init(&test_ast_node); 5106 5107 struct cil_db *test_db; 5108 cil_db_init(&test_db); 5109 5110 test_ast_node->parent = test_db->ast->root; 5111 test_ast_node->line = 1; 5112 5113 int rc = cil_gen_typeattributeset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 5114 CuAssertIntEquals(tc, SEPOL_ERR, rc); 5115 } 5116 5117 void test_cil_gen_userbounds(CuTest *tc) { 5118 char *line[] = {"(", "userbounds", "user1", "user2", ")", NULL}; 5119 5120 struct cil_tree *test_tree; 5121 gen_test_tree(&test_tree, line); 5122 5123 struct cil_tree_node *test_ast_node; 5124 cil_tree_node_init(&test_ast_node); 5125 5126 struct cil_db *test_db; 5127 cil_db_init(&test_db); 5128 5129 test_ast_node->parent = test_db->ast->root; 5130 test_ast_node->line = 1; 5131 5132 int rc = cil_gen_userbounds(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 5133 CuAssertIntEquals(tc, rc, SEPOL_OK); 5134 } 5135 5136 void test_cil_gen_userbounds_notype1_neg(CuTest *tc) { 5137 char *line[] = {"(", "userbounds", ")", NULL}; 5138 5139 struct cil_tree *test_tree; 5140 gen_test_tree(&test_tree, line); 5141 5142 struct cil_tree_node *test_ast_node; 5143 cil_tree_node_init(&test_ast_node); 5144 5145 struct cil_db *test_db; 5146 cil_db_init(&test_db); 5147 5148 test_ast_node->parent = test_db->ast->root; 5149 test_ast_node->line = 1; 5150 5151 int rc = cil_gen_userbounds(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 5152 CuAssertIntEquals(tc, rc, SEPOL_ERR); 5153 } 5154 5155 void test_cil_gen_userbounds_type1_inparens_neg(CuTest *tc) { 5156 char *line[] = {"(", "userbounds", "(", "user1", ")", "user2", ")", NULL}; 5157 5158 struct cil_tree *test_tree; 5159 gen_test_tree(&test_tree, line); 5160 5161 struct cil_tree_node *test_ast_node; 5162 cil_tree_node_init(&test_ast_node); 5163 5164 struct cil_db *test_db; 5165 cil_db_init(&test_db); 5166 5167 test_ast_node->parent = test_db->ast->root; 5168 test_ast_node->line = 1; 5169 5170 int rc = cil_gen_userbounds(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 5171 CuAssertIntEquals(tc, rc, SEPOL_ERR); 5172 } 5173 5174 void test_cil_gen_userbounds_notype2_neg(CuTest *tc) { 5175 char *line[] = {"(", "userbounds", "user1", ")", NULL}; 5176 5177 struct cil_tree *test_tree; 5178 gen_test_tree(&test_tree, line); 5179 5180 struct cil_tree_node *test_ast_node; 5181 cil_tree_node_init(&test_ast_node); 5182 5183 struct cil_db *test_db; 5184 cil_db_init(&test_db); 5185 5186 test_ast_node->parent = test_db->ast->root; 5187 test_ast_node->line = 1; 5188 5189 int rc = cil_gen_userbounds(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 5190 CuAssertIntEquals(tc, rc, SEPOL_ERR); 5191 } 5192 5193 void test_cil_gen_userbounds_type2_inparens_neg(CuTest *tc) { 5194 char *line[] = {"(", "userbounds", "user1", "(", "user2", ")", ")", NULL}; 5195 5196 struct cil_tree *test_tree; 5197 gen_test_tree(&test_tree, line); 5198 5199 struct cil_tree_node *test_ast_node; 5200 cil_tree_node_init(&test_ast_node); 5201 5202 struct cil_db *test_db; 5203 cil_db_init(&test_db); 5204 5205 test_ast_node->parent = test_db->ast->root; 5206 test_ast_node->line = 1; 5207 5208 int rc = cil_gen_userbounds(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 5209 CuAssertIntEquals(tc, rc, SEPOL_ERR); 5210 } 5211 5212 void test_cil_gen_userbounds_extra_neg(CuTest *tc) { 5213 char *line[] = {"(", "userbounds", "user1", "user2", "extra", ")", NULL}; 5214 5215 struct cil_tree *test_tree; 5216 gen_test_tree(&test_tree, line); 5217 5218 struct cil_tree_node *test_ast_node; 5219 cil_tree_node_init(&test_ast_node); 5220 5221 struct cil_db *test_db; 5222 cil_db_init(&test_db); 5223 5224 test_ast_node->parent = test_db->ast->root; 5225 test_ast_node->line = 1; 5226 5227 int rc = cil_gen_userbounds(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 5228 CuAssertIntEquals(tc, rc, SEPOL_ERR); 5229 } 5230 5231 void test_cil_gen_userbounds_dbnull_neg(CuTest *tc) { 5232 char *line[] = {"(", "userbounds", "user1", "user2", ")", NULL}; 5233 5234 struct cil_tree *test_tree; 5235 gen_test_tree(&test_tree, line); 5236 5237 struct cil_tree_node *test_ast_node; 5238 cil_tree_node_init(&test_ast_node); 5239 5240 struct cil_db *test_db = NULL; 5241 5242 int rc = cil_gen_userbounds(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 5243 CuAssertIntEquals(tc, rc, SEPOL_ERR); 5244 } 5245 5246 void test_cil_gen_userbounds_currnull_neg(CuTest *tc) { 5247 char *line[] = {"(", ")", NULL}; 5248 5249 struct cil_tree *test_tree; 5250 gen_test_tree(&test_tree, line); 5251 5252 struct cil_tree_node *test_ast_node; 5253 cil_tree_node_init(&test_ast_node); 5254 5255 struct cil_db *test_db; 5256 cil_db_init(&test_db); 5257 5258 test_ast_node->parent = test_db->ast->root; 5259 test_ast_node->line = 1; 5260 5261 int rc = cil_gen_userbounds(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 5262 CuAssertIntEquals(tc, rc, SEPOL_ERR); 5263 } 5264 5265 void test_cil_gen_userbounds_astnull_neg(CuTest *tc) { 5266 char *line[] = {"(", "userbounds", "user1", "user2", ")", NULL}; 5267 5268 struct cil_tree *test_tree; 5269 gen_test_tree(&test_tree, line); 5270 5271 struct cil_tree_node *test_ast_node = NULL; 5272 5273 struct cil_db *test_db; 5274 cil_db_init(&test_db); 5275 5276 int rc = cil_gen_userbounds(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 5277 CuAssertIntEquals(tc, rc, SEPOL_ERR); 5278 } 5279 5280 void test_cil_gen_role(CuTest *tc) { 5281 char *line[] = {"(", "role", "test_r", ")", NULL}; 5282 5283 struct cil_tree *test_tree; 5284 gen_test_tree(&test_tree, line); 5285 5286 struct cil_tree_node *test_ast_node; 5287 cil_tree_node_init(&test_ast_node); 5288 5289 struct cil_db *test_db; 5290 cil_db_init(&test_db); 5291 5292 test_ast_node->parent = test_db->ast->root; 5293 test_ast_node->line = 1; 5294 5295 int rc = cil_gen_role(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 5296 CuAssertIntEquals(tc, SEPOL_OK, rc); 5297 CuAssertPtrNotNull(tc, test_ast_node->data); 5298 CuAssertIntEquals(tc, test_ast_node->flavor, CIL_ROLE); 5299 } 5300 5301 void test_cil_gen_role_dbnull_neg(CuTest *tc) { 5302 char *line[] = {"(", "role", "test_r", ")", NULL}; 5303 5304 struct cil_tree *test_tree; 5305 gen_test_tree(&test_tree, line); 5306 5307 struct cil_tree_node *test_ast_node; 5308 cil_tree_node_init(&test_ast_node); 5309 5310 struct cil_db *test_db = NULL; 5311 5312 int rc = cil_gen_role(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 5313 5314 CuAssertIntEquals(tc, SEPOL_ERR, rc); 5315 } 5316 5317 void test_cil_gen_role_currnull_neg(CuTest *tc) { 5318 char *line[] = {"(", ")", NULL}; 5319 5320 struct cil_tree *test_tree; 5321 gen_test_tree(&test_tree, line); 5322 5323 struct cil_tree_node *test_ast_node; 5324 cil_tree_node_init(&test_ast_node); 5325 5326 struct cil_db *test_db; 5327 cil_db_init(&test_db); 5328 5329 int rc = cil_gen_role(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 5330 5331 CuAssertIntEquals(tc, SEPOL_ERR, rc); 5332 } 5333 5334 void test_cil_gen_role_astnull_neg(CuTest *tc) { 5335 char *line[] = {"(", "role", "test_r", ")", NULL}; 5336 5337 struct cil_tree *test_tree; 5338 gen_test_tree(&test_tree, line); 5339 5340 struct cil_tree_node *test_ast_node = NULL; 5341 5342 struct cil_db *test_db; 5343 cil_db_init(&test_db); 5344 5345 int rc = cil_gen_role(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 5346 5347 CuAssertIntEquals(tc, SEPOL_ERR, rc); 5348 } 5349 5350 void test_cil_gen_role_extrarole_neg(CuTest *tc) { 5351 char *line[] = {"(", "role", "test_r", "extra_r", ")", NULL}; 5352 5353 struct cil_tree *test_tree; 5354 gen_test_tree(&test_tree, line); 5355 5356 struct cil_tree_node *test_ast_node; 5357 cil_tree_node_init(&test_ast_node); 5358 5359 struct cil_db *test_db; 5360 cil_db_init(&test_db); 5361 5362 test_ast_node->parent = test_db->ast->root; 5363 test_ast_node->line = 1; 5364 5365 int rc = cil_gen_role(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 5366 5367 CuAssertIntEquals(tc, SEPOL_ERR, rc); 5368 } 5369 5370 void test_cil_gen_role_noname_neg(CuTest *tc) { 5371 char *line[] = {"(", "role", ")", NULL}; 5372 5373 struct cil_tree *test_tree; 5374 gen_test_tree(&test_tree, line); 5375 5376 struct cil_tree_node *test_ast_node; 5377 cil_tree_node_init(&test_ast_node); 5378 5379 struct cil_db *test_db; 5380 cil_db_init(&test_db); 5381 5382 test_ast_node->parent = test_db->ast->root; 5383 test_ast_node->line = 1; 5384 5385 int rc = cil_gen_role(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 5386 5387 CuAssertIntEquals(tc, SEPOL_ERR, rc); 5388 } 5389 5390 void test_cil_gen_roletransition(CuTest *tc) { 5391 char *line[] = {"(", "roletransition", "foo_r", "bar_t", "process", "foobar_r", ")", NULL}; 5392 5393 struct cil_tree *test_tree; 5394 gen_test_tree(&test_tree, line); 5395 5396 struct cil_tree_node *test_ast_node; 5397 cil_tree_node_init(&test_ast_node); 5398 5399 struct cil_db *test_db; 5400 cil_db_init(&test_db); 5401 5402 test_ast_node->parent = test_db->ast->root; 5403 test_ast_node->line = 1; 5404 5405 int rc = cil_gen_roletransition(test_tree->root->cl_head->cl_head, test_ast_node); 5406 CuAssertIntEquals(tc, SEPOL_OK, rc); 5407 CuAssertPtrNotNull(tc, test_ast_node->data); 5408 CuAssertIntEquals(tc, test_ast_node->flavor, CIL_ROLETRANSITION); 5409 } 5410 5411 void test_cil_gen_roletransition_currnull_neg(CuTest *tc) { 5412 struct cil_tree_node *test_ast_node; 5413 cil_tree_node_init(&test_ast_node); 5414 5415 int rc = cil_gen_roletransition(NULL, test_ast_node); 5416 CuAssertIntEquals(tc, SEPOL_ERR, rc); 5417 } 5418 5419 void test_cil_gen_roletransition_astnull_neg (CuTest *tc) { 5420 char *line[] = {"(", "roletransition" "foo_r", "bar_t", "process", "foobar_r", ")", NULL}; 5421 5422 struct cil_tree *test_tree; 5423 gen_test_tree(&test_tree, line); 5424 5425 struct cil_tree_node *test_ast_node = NULL; 5426 5427 int rc = cil_gen_roletransition(test_tree->root->cl_head->cl_head, test_ast_node); 5428 CuAssertIntEquals(tc, SEPOL_ERR, rc); 5429 } 5430 5431 void test_cil_gen_roletransition_srcnull_neg(CuTest *tc) { 5432 char *line[] = {"(", "roletransition", "foo_r", "bar_t", "process", "foobar_r", ")", NULL}; 5433 5434 struct cil_tree *test_tree; 5435 gen_test_tree(&test_tree, line); 5436 5437 test_tree->root->cl_head->cl_head->next = NULL; 5438 5439 struct cil_tree_node *test_ast_node; 5440 cil_tree_node_init(&test_ast_node); 5441 5442 int rc = cil_gen_roletransition(test_tree->root->cl_head->cl_head, test_ast_node); 5443 CuAssertIntEquals(tc, SEPOL_ERR, rc); 5444 } 5445 5446 void test_cil_gen_roletransition_tgtnull_neg(CuTest *tc) { 5447 char *line[] = {"(", "roletransition", "foo_r", "bar_t", "process", "foobar_r", ")", NULL}; 5448 5449 struct cil_tree *test_tree; 5450 gen_test_tree(&test_tree, line); 5451 5452 test_tree->root->cl_head->cl_head->next->next = NULL; 5453 5454 struct cil_tree_node *test_ast_node; 5455 cil_tree_node_init(&test_ast_node); 5456 5457 int rc = cil_gen_roletransition(test_tree->root->cl_head->cl_head, test_ast_node); 5458 CuAssertIntEquals(tc, SEPOL_ERR, rc); 5459 } 5460 5461 void test_cil_gen_roletransition_resultnull_neg(CuTest *tc) { 5462 char *line[] = {"(", "roletransition", "foo_r", "bar_t", "process", "foobar_r", ")", NULL}; 5463 5464 struct cil_tree *test_tree; 5465 gen_test_tree(&test_tree, line); 5466 5467 test_tree->root->cl_head->cl_head->next->next->next->next = NULL; 5468 5469 struct cil_tree_node *test_ast_node; 5470 cil_tree_node_init(&test_ast_node); 5471 5472 int rc = cil_gen_roletransition(test_tree->root->cl_head->cl_head, test_ast_node); 5473 CuAssertIntEquals(tc, SEPOL_ERR, rc); 5474 } 5475 5476 void test_cil_gen_roletransition_extra_neg(CuTest *tc) { 5477 char *line[] = {"(", "roletransition", "foo_r", "bar_t", "process", "foobar_r", "extra", ")", NULL}; 5478 5479 struct cil_tree *test_tree; 5480 gen_test_tree(&test_tree, line); 5481 5482 struct cil_tree_node *test_ast_node; 5483 cil_tree_node_init(&test_ast_node); 5484 5485 int rc = cil_gen_roletransition(test_tree->root->cl_head->cl_head, test_ast_node); 5486 CuAssertIntEquals(tc, SEPOL_ERR, rc); 5487 } 5488 5489 void test_cil_gen_bool_true(CuTest *tc) { 5490 char *line[] = {"(", "boolean", "foo", "true", ")", NULL}; 5491 5492 struct cil_tree *test_tree; 5493 gen_test_tree(&test_tree, line); 5494 5495 struct cil_tree_node *test_ast_node; 5496 cil_tree_node_init(&test_ast_node); 5497 5498 struct cil_db *test_db; 5499 cil_db_init(&test_db); 5500 5501 test_ast_node->parent = test_db->ast->root; 5502 test_ast_node->line = 1; 5503 5504 int rc = cil_gen_bool(test_db, test_tree->root->cl_head->cl_head, test_ast_node, CIL_BOOL); 5505 CuAssertIntEquals(tc, SEPOL_OK, rc); 5506 CuAssertPtrNotNull(tc, test_ast_node->data); 5507 CuAssertIntEquals(tc, ((struct cil_bool*)test_ast_node->data)->value, 1); 5508 CuAssertIntEquals(tc, test_ast_node->flavor, CIL_BOOL); 5509 } 5510 5511 void test_cil_gen_bool_tunable_true(CuTest *tc) { 5512 char *line[] = {"(", "tunable", "foo", "true", ")", NULL}; 5513 5514 struct cil_tree *test_tree; 5515 gen_test_tree(&test_tree, line); 5516 5517 struct cil_tree_node *test_ast_node; 5518 cil_tree_node_init(&test_ast_node); 5519 5520 struct cil_db *test_db; 5521 cil_db_init(&test_db); 5522 5523 test_ast_node->parent = test_db->ast->root; 5524 test_ast_node->line = 1; 5525 5526 int rc = cil_gen_bool(test_db, test_tree->root->cl_head->cl_head, test_ast_node, CIL_TUNABLE); 5527 CuAssertIntEquals(tc, SEPOL_OK, rc); 5528 CuAssertPtrNotNull(tc, test_ast_node->data); 5529 CuAssertIntEquals(tc, ((struct cil_bool*)test_ast_node->data)->value, 1); 5530 CuAssertIntEquals(tc, test_ast_node->flavor, CIL_TUNABLE); 5531 } 5532 5533 void test_cil_gen_bool_false(CuTest *tc) { 5534 char *line[] = {"(", "boolean", "bar", "false", ")", NULL}; 5535 5536 struct cil_tree *test_tree; 5537 gen_test_tree(&test_tree, line); 5538 5539 struct cil_tree_node *test_ast_node; 5540 cil_tree_node_init(&test_ast_node); 5541 5542 struct cil_db *test_db; 5543 cil_db_init(&test_db); 5544 5545 test_ast_node->parent = test_db->ast->root; 5546 test_ast_node->line = 1; 5547 5548 int rc = cil_gen_bool(test_db, test_tree->root->cl_head->cl_head, test_ast_node, CIL_BOOL); 5549 CuAssertIntEquals(tc, SEPOL_OK, rc); 5550 CuAssertPtrNotNull(tc, test_ast_node->data); 5551 CuAssertIntEquals(tc, ((struct cil_bool*)test_ast_node->data)->value, 0); 5552 CuAssertIntEquals(tc, test_ast_node->flavor, CIL_BOOL); 5553 } 5554 5555 void test_cil_gen_bool_tunable_false(CuTest *tc) { 5556 char *line[] = {"(", "tunable", "bar", "false", ")", NULL}; 5557 5558 struct cil_tree *test_tree; 5559 gen_test_tree(&test_tree, line); 5560 5561 struct cil_tree_node *test_ast_node; 5562 cil_tree_node_init(&test_ast_node); 5563 5564 struct cil_db *test_db; 5565 cil_db_init(&test_db); 5566 5567 test_ast_node->parent = test_db->ast->root; 5568 test_ast_node->line = 1; 5569 5570 int rc = cil_gen_bool(test_db, test_tree->root->cl_head->cl_head, test_ast_node, CIL_TUNABLE); 5571 CuAssertIntEquals(tc, SEPOL_OK, rc); 5572 CuAssertPtrNotNull(tc, test_ast_node->data); 5573 CuAssertIntEquals(tc, ((struct cil_bool*)test_ast_node->data)->value, 0); 5574 CuAssertIntEquals(tc, test_ast_node->flavor, CIL_TUNABLE); 5575 } 5576 5577 void test_cil_gen_bool_none_neg(CuTest *tc) { 5578 char *line[] = {"(", "boolean", "foo", ")", NULL}; 5579 5580 struct cil_tree *test_tree; 5581 gen_test_tree(&test_tree, line); 5582 5583 struct cil_tree_node *test_ast_node; 5584 cil_tree_node_init(&test_ast_node); 5585 5586 struct cil_db *test_db; 5587 cil_db_init(&test_db); 5588 5589 test_ast_node->parent = test_db->ast->root; 5590 test_ast_node->line = 1; 5591 5592 int rc = cil_gen_bool(test_db, test_tree->root->cl_head->cl_head, test_ast_node, CIL_BOOL); 5593 CuAssertIntEquals(tc, SEPOL_ERR, rc); 5594 } 5595 5596 void test_cil_gen_bool_dbnull_neg(CuTest *tc) { 5597 char *line[] = {"(", "boolean", "foo", "bar", ")", NULL}; 5598 5599 struct cil_tree *test_tree; 5600 gen_test_tree(&test_tree, line); 5601 5602 struct cil_tree_node *test_ast_node; 5603 cil_tree_node_init(&test_ast_node); 5604 5605 struct cil_db *test_db = NULL; 5606 5607 int rc = cil_gen_bool(test_db, test_tree->root->cl_head->cl_head, test_ast_node, CIL_BOOL); 5608 CuAssertIntEquals(tc, SEPOL_ERR, rc); 5609 } 5610 5611 void test_cil_gen_bool_currnull_neg(CuTest *tc) { 5612 char *line[] = {"(", ")", NULL}; 5613 5614 struct cil_tree *test_tree; 5615 gen_test_tree(&test_tree, line); 5616 5617 struct cil_tree_node *test_ast_node; 5618 cil_tree_node_init(&test_ast_node); 5619 5620 struct cil_db *test_db; 5621 cil_db_init(&test_db); 5622 5623 test_ast_node->parent = test_db->ast->root; 5624 test_ast_node->line = 1; 5625 5626 int rc = cil_gen_bool(test_db, test_tree->root->cl_head->cl_head, test_ast_node, CIL_BOOL); 5627 CuAssertIntEquals(tc, SEPOL_ERR, rc); 5628 } 5629 5630 void test_cil_gen_bool_astnull_neg(CuTest *tc) { 5631 char *line[] = {"(", "boolean", "foo", "bar", ")", NULL}; 5632 5633 struct cil_tree *test_tree; 5634 gen_test_tree(&test_tree, line); 5635 5636 struct cil_tree_node *test_ast_node = NULL; 5637 5638 struct cil_db *test_db; 5639 cil_db_init(&test_db); 5640 5641 int rc = cil_gen_bool(test_db, test_tree->root->cl_head->cl_head, test_ast_node, CIL_BOOL); 5642 CuAssertIntEquals(tc, SEPOL_ERR, rc); 5643 } 5644 5645 void test_cil_gen_bool_notbool_neg(CuTest *tc) { 5646 char *line[] = {"(", "boolean", "foo", "bar", ")", NULL}; 5647 5648 struct cil_tree *test_tree; 5649 gen_test_tree(&test_tree, line); 5650 5651 struct cil_tree_node *test_ast_node; 5652 cil_tree_node_init(&test_ast_node); 5653 5654 struct cil_db *test_db; 5655 cil_db_init(&test_db); 5656 5657 test_ast_node->parent = test_db->ast->root; 5658 test_ast_node->line = 1; 5659 5660 int rc = cil_gen_bool(test_db, test_tree->root->cl_head->cl_head, test_ast_node, CIL_BOOL); 5661 CuAssertIntEquals(tc, SEPOL_ERR, rc); 5662 } 5663 5664 void test_cil_gen_bool_boolname_neg(CuTest *tc) { 5665 char *line[] = {"(", "boolean", ")", NULL}; 5666 5667 struct cil_tree *test_tree; 5668 gen_test_tree(&test_tree, line); 5669 5670 struct cil_tree_node *test_ast_node; 5671 cil_tree_node_init(&test_ast_node); 5672 5673 struct cil_db *test_db; 5674 cil_db_init(&test_db); 5675 5676 test_ast_node->parent = test_db->ast->root; 5677 test_ast_node->line = 1; 5678 5679 int rc = cil_gen_bool(test_db, test_tree->root->cl_head->cl_head, test_ast_node, CIL_BOOL); 5680 CuAssertIntEquals(tc, SEPOL_ERR, rc); 5681 } 5682 5683 void test_cil_gen_bool_extraname_false_neg(CuTest *tc) { 5684 char *line[] = {"(", "boolean", "foo", "false", "bar", ")", NULL}; 5685 5686 struct cil_tree *test_tree; 5687 gen_test_tree(&test_tree, line); 5688 5689 struct cil_tree_node *test_ast_node; 5690 cil_tree_node_init(&test_ast_node); 5691 5692 struct cil_db *test_db; 5693 cil_db_init(&test_db); 5694 5695 test_ast_node->parent = test_db->ast->root; 5696 test_ast_node->line = 1; 5697 5698 int rc = cil_gen_bool(test_db, test_tree->root->cl_head->cl_head, test_ast_node, CIL_BOOL); 5699 CuAssertIntEquals(tc, SEPOL_ERR, rc); 5700 } 5701 5702 void test_cil_gen_bool_extraname_true_neg(CuTest *tc) { 5703 char *line[] = {"(", "boolean", "foo", "true", "bar", ")", NULL}; 5704 5705 struct cil_tree *test_tree; 5706 gen_test_tree(&test_tree, line); 5707 5708 struct cil_tree_node *test_ast_node; 5709 cil_tree_node_init(&test_ast_node); 5710 5711 struct cil_db *test_db; 5712 cil_db_init(&test_db); 5713 5714 test_ast_node->parent = test_db->ast->root; 5715 test_ast_node->line = 1; 5716 5717 int rc = cil_gen_bool(test_db, test_tree->root->cl_head->cl_head, test_ast_node, CIL_BOOL); 5718 CuAssertIntEquals(tc, SEPOL_ERR, rc); 5719 } 5720 5721 void test_cil_gen_constrain_expr_stack_eq2_t1type(CuTest *tc) { 5722 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "t1", "type_t", ")", ")", NULL}; 5723 struct cil_tree *test_tree; 5724 gen_test_tree(&test_tree, line); 5725 5726 struct cil_tree_node *test_ast_node; 5727 cil_tree_node_init(&test_ast_node); 5728 5729 struct cil_db *test_db; 5730 cil_db_init(&test_db); 5731 5732 test_ast_node->parent = test_db->ast->root; 5733 test_ast_node->line = 1; 5734 5735 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 5736 5737 struct cil_constrain *cons; 5738 cil_constrain_init(&cons); 5739 5740 cil_classpermset_init(&cons->classpermset); 5741 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 5742 5743 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 5744 CuAssertIntEquals(tc, SEPOL_OK, rc); 5745 } 5746 5747 void test_cil_gen_constrain_expr_stack_eq2_t1t1_neg(CuTest *tc) { 5748 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "t1", "t1", ")", ")", NULL}; 5749 struct cil_tree *test_tree; 5750 gen_test_tree(&test_tree, line); 5751 5752 struct cil_tree_node *test_ast_node; 5753 cil_tree_node_init(&test_ast_node); 5754 5755 struct cil_db *test_db; 5756 cil_db_init(&test_db); 5757 5758 test_ast_node->parent = test_db->ast->root; 5759 test_ast_node->line = 1; 5760 5761 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 5762 5763 struct cil_constrain *cons; 5764 cil_constrain_init(&cons); 5765 cil_classpermset_init(&cons->classpermset); 5766 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 5767 5768 int rc = cil_gen_expr_stack(parse_current->next->next->next, CIL_MLSCONSTRAIN, &cons->expr); 5769 CuAssertIntEquals(tc, SEPOL_ERR, rc); 5770 } 5771 5772 void test_cil_gen_constrain_expr_stack_eq2_t2type(CuTest *tc) { 5773 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "t2", "type_t", ")", ")", NULL}; 5774 struct cil_tree *test_tree; 5775 gen_test_tree(&test_tree, line); 5776 5777 struct cil_tree_node *test_ast_node; 5778 cil_tree_node_init(&test_ast_node); 5779 5780 struct cil_db *test_db; 5781 cil_db_init(&test_db); 5782 5783 test_ast_node->parent = test_db->ast->root; 5784 test_ast_node->line = 1; 5785 5786 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 5787 5788 struct cil_constrain *cons; 5789 cil_constrain_init(&cons); 5790 cil_classpermset_init(&cons->classpermset); 5791 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 5792 5793 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 5794 CuAssertIntEquals(tc, SEPOL_OK, rc); 5795 } 5796 5797 void test_cil_gen_constrain_expr_stack_eq2_t2t2_neg(CuTest *tc) { 5798 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "t2", "t2", ")", ")", NULL}; 5799 struct cil_tree *test_tree; 5800 gen_test_tree(&test_tree, line); 5801 5802 struct cil_tree_node *test_ast_node; 5803 cil_tree_node_init(&test_ast_node); 5804 5805 struct cil_db *test_db; 5806 cil_db_init(&test_db); 5807 5808 test_ast_node->parent = test_db->ast->root; 5809 test_ast_node->line = 1; 5810 5811 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 5812 5813 struct cil_constrain *cons; 5814 cil_constrain_init(&cons); 5815 cil_classpermset_init(&cons->classpermset); 5816 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 5817 5818 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 5819 CuAssertIntEquals(tc, SEPOL_ERR, rc); 5820 } 5821 5822 void test_cil_gen_constrain_expr_stack_eq2_r1role(CuTest *tc) { 5823 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "r1", "role_r", ")", ")", NULL}; 5824 struct cil_tree *test_tree; 5825 gen_test_tree(&test_tree, line); 5826 5827 struct cil_tree_node *test_ast_node; 5828 cil_tree_node_init(&test_ast_node); 5829 5830 struct cil_db *test_db; 5831 cil_db_init(&test_db); 5832 5833 test_ast_node->parent = test_db->ast->root; 5834 test_ast_node->line = 1; 5835 5836 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 5837 5838 struct cil_constrain *cons; 5839 cil_constrain_init(&cons); 5840 cil_classpermset_init(&cons->classpermset); 5841 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 5842 5843 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 5844 CuAssertIntEquals(tc, SEPOL_OK, rc); 5845 } 5846 5847 void test_cil_gen_constrain_expr_stack_eq2_r1r1_neg(CuTest *tc) { 5848 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "r1", "r1", ")", ")", NULL}; 5849 struct cil_tree *test_tree; 5850 gen_test_tree(&test_tree, line); 5851 5852 struct cil_tree_node *test_ast_node; 5853 cil_tree_node_init(&test_ast_node); 5854 5855 struct cil_db *test_db; 5856 cil_db_init(&test_db); 5857 5858 test_ast_node->parent = test_db->ast->root; 5859 test_ast_node->line = 1; 5860 5861 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 5862 5863 struct cil_constrain *cons; 5864 cil_constrain_init(&cons); 5865 cil_classpermset_init(&cons->classpermset); 5866 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 5867 5868 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 5869 CuAssertIntEquals(tc, SEPOL_ERR, rc); 5870 } 5871 5872 void test_cil_gen_constrain_expr_stack_eq2_r2role(CuTest *tc) { 5873 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "r2", "role_r", ")", ")", NULL}; 5874 struct cil_tree *test_tree; 5875 gen_test_tree(&test_tree, line); 5876 5877 struct cil_tree_node *test_ast_node; 5878 cil_tree_node_init(&test_ast_node); 5879 5880 struct cil_db *test_db; 5881 cil_db_init(&test_db); 5882 5883 test_ast_node->parent = test_db->ast->root; 5884 test_ast_node->line = 1; 5885 5886 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 5887 5888 struct cil_constrain *cons; 5889 cil_constrain_init(&cons); 5890 cil_classpermset_init(&cons->classpermset); 5891 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 5892 5893 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 5894 CuAssertIntEquals(tc, SEPOL_OK, rc); 5895 } 5896 5897 void test_cil_gen_constrain_expr_stack_eq2_r2r2_neg(CuTest *tc) { 5898 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "r2", "r2", ")", ")", NULL}; 5899 struct cil_tree *test_tree; 5900 gen_test_tree(&test_tree, line); 5901 5902 struct cil_tree_node *test_ast_node; 5903 cil_tree_node_init(&test_ast_node); 5904 5905 struct cil_db *test_db; 5906 cil_db_init(&test_db); 5907 5908 test_ast_node->parent = test_db->ast->root; 5909 test_ast_node->line = 1; 5910 5911 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 5912 5913 struct cil_constrain *cons; 5914 cil_constrain_init(&cons); 5915 cil_classpermset_init(&cons->classpermset); 5916 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 5917 5918 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 5919 CuAssertIntEquals(tc, SEPOL_ERR, rc); 5920 } 5921 5922 void test_cil_gen_constrain_expr_stack_eq2_t1t2(CuTest *tc) { 5923 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "t1", "t2", ")", ")", NULL}; 5924 struct cil_tree *test_tree; 5925 gen_test_tree(&test_tree, line); 5926 5927 struct cil_tree_node *test_ast_node; 5928 cil_tree_node_init(&test_ast_node); 5929 5930 struct cil_db *test_db; 5931 cil_db_init(&test_db); 5932 5933 test_ast_node->parent = test_db->ast->root; 5934 test_ast_node->line = 1; 5935 5936 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 5937 5938 struct cil_constrain *cons; 5939 cil_constrain_init(&cons); 5940 cil_classpermset_init(&cons->classpermset); 5941 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 5942 5943 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 5944 CuAssertIntEquals(tc, SEPOL_OK, rc); 5945 } 5946 5947 void test_cil_gen_constrain_expr_stack_eq_r1r2(CuTest *tc) { 5948 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "r1", "r2", ")", ")", NULL}; 5949 struct cil_tree *test_tree; 5950 gen_test_tree(&test_tree, line); 5951 5952 struct cil_tree_node *test_ast_node; 5953 cil_tree_node_init(&test_ast_node); 5954 5955 struct cil_db *test_db; 5956 cil_db_init(&test_db); 5957 5958 test_ast_node->parent = test_db->ast->root; 5959 test_ast_node->line = 1; 5960 5961 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 5962 5963 struct cil_constrain *cons; 5964 cil_constrain_init(&cons); 5965 cil_classpermset_init(&cons->classpermset); 5966 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 5967 5968 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 5969 CuAssertIntEquals(tc, SEPOL_OK, rc); 5970 } 5971 5972 void test_cil_gen_constrain_expr_stack_eq2_r1r2(CuTest *tc) { 5973 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "r1", "r2", ")", ")", NULL}; 5974 struct cil_tree *test_tree; 5975 gen_test_tree(&test_tree, line); 5976 5977 struct cil_tree_node *test_ast_node; 5978 cil_tree_node_init(&test_ast_node); 5979 5980 struct cil_db *test_db; 5981 cil_db_init(&test_db); 5982 5983 test_ast_node->parent = test_db->ast->root; 5984 test_ast_node->line = 1; 5985 5986 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 5987 5988 struct cil_constrain *cons; 5989 cil_constrain_init(&cons); 5990 cil_classpermset_init(&cons->classpermset); 5991 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 5992 5993 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 5994 CuAssertIntEquals(tc, SEPOL_OK, rc); 5995 } 5996 5997 void test_cil_gen_constrain_expr_stack_eq2_u1u2(CuTest *tc) { 5998 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "u1", "u2", ")", ")", NULL}; 5999 struct cil_tree *test_tree; 6000 gen_test_tree(&test_tree, line); 6001 6002 struct cil_tree_node *test_ast_node; 6003 cil_tree_node_init(&test_ast_node); 6004 6005 struct cil_db *test_db; 6006 cil_db_init(&test_db); 6007 6008 test_ast_node->parent = test_db->ast->root; 6009 test_ast_node->line = 1; 6010 6011 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6012 6013 struct cil_constrain *cons; 6014 cil_constrain_init(&cons); 6015 cil_classpermset_init(&cons->classpermset); 6016 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6017 6018 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6019 CuAssertIntEquals(tc, SEPOL_OK, rc); 6020 } 6021 6022 void test_cil_gen_constrain_expr_stack_eq2_u1user(CuTest *tc) { 6023 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "u1", "user_u", ")", ")", NULL}; 6024 struct cil_tree *test_tree; 6025 gen_test_tree(&test_tree, line); 6026 6027 struct cil_tree_node *test_ast_node; 6028 cil_tree_node_init(&test_ast_node); 6029 6030 struct cil_db *test_db; 6031 cil_db_init(&test_db); 6032 6033 test_ast_node->parent = test_db->ast->root; 6034 test_ast_node->line = 1; 6035 6036 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6037 6038 struct cil_constrain *cons; 6039 cil_constrain_init(&cons); 6040 cil_classpermset_init(&cons->classpermset); 6041 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6042 6043 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6044 CuAssertIntEquals(tc, SEPOL_OK, rc); 6045 } 6046 6047 void test_cil_gen_constrain_expr_stack_eq2_u1u1_neg(CuTest *tc) { 6048 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "u1", "u1", ")", ")", NULL}; 6049 struct cil_tree *test_tree; 6050 gen_test_tree(&test_tree, line); 6051 6052 struct cil_tree_node *test_ast_node; 6053 cil_tree_node_init(&test_ast_node); 6054 6055 struct cil_db *test_db; 6056 cil_db_init(&test_db); 6057 6058 test_ast_node->parent = test_db->ast->root; 6059 test_ast_node->line = 1; 6060 6061 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6062 6063 struct cil_constrain *cons; 6064 cil_constrain_init(&cons); 6065 cil_classpermset_init(&cons->classpermset); 6066 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6067 6068 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6069 CuAssertIntEquals(tc, SEPOL_ERR, rc); 6070 } 6071 6072 void test_cil_gen_constrain_expr_stack_eq2_u2user(CuTest *tc) { 6073 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "u2", "user_u", ")", ")", NULL}; 6074 struct cil_tree *test_tree; 6075 gen_test_tree(&test_tree, line); 6076 6077 struct cil_tree_node *test_ast_node; 6078 cil_tree_node_init(&test_ast_node); 6079 6080 struct cil_db *test_db; 6081 cil_db_init(&test_db); 6082 6083 test_ast_node->parent = test_db->ast->root; 6084 test_ast_node->line = 1; 6085 6086 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6087 6088 struct cil_constrain *cons; 6089 cil_constrain_init(&cons); 6090 cil_classpermset_init(&cons->classpermset); 6091 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6092 6093 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6094 CuAssertIntEquals(tc, SEPOL_OK, rc); 6095 } 6096 6097 void test_cil_gen_constrain_expr_stack_eq2_u2u2_neg(CuTest *tc) { 6098 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "u2", "u2", ")", ")", NULL}; 6099 struct cil_tree *test_tree; 6100 gen_test_tree(&test_tree, line); 6101 6102 struct cil_tree_node *test_ast_node; 6103 cil_tree_node_init(&test_ast_node); 6104 6105 struct cil_db *test_db; 6106 cil_db_init(&test_db); 6107 6108 test_ast_node->parent = test_db->ast->root; 6109 test_ast_node->line = 1; 6110 6111 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6112 6113 struct cil_constrain *cons; 6114 cil_constrain_init(&cons); 6115 cil_classpermset_init(&cons->classpermset); 6116 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6117 6118 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6119 CuAssertIntEquals(tc, SEPOL_ERR, rc); 6120 } 6121 6122 void test_cil_gen_constrain_expr_stack_eq_l2h2(CuTest *tc) { 6123 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "l2", "h2", ")", ")", NULL}; 6124 struct cil_tree *test_tree; 6125 gen_test_tree(&test_tree, line); 6126 6127 struct cil_tree_node *test_ast_node; 6128 cil_tree_node_init(&test_ast_node); 6129 6130 struct cil_db *test_db; 6131 cil_db_init(&test_db); 6132 6133 test_ast_node->parent = test_db->ast->root; 6134 test_ast_node->line = 1; 6135 6136 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6137 6138 struct cil_constrain *cons; 6139 cil_constrain_init(&cons); 6140 cil_classpermset_init(&cons->classpermset); 6141 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6142 6143 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6144 CuAssertIntEquals(tc, SEPOL_OK, rc); 6145 } 6146 6147 void test_cil_gen_constrain_expr_stack_eq_l2_neg(CuTest *tc) { 6148 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "l2", "h1", ")", ")", NULL}; 6149 struct cil_tree *test_tree; 6150 gen_test_tree(&test_tree, line); 6151 6152 struct cil_tree_node *test_ast_node; 6153 cil_tree_node_init(&test_ast_node); 6154 6155 struct cil_db *test_db; 6156 cil_db_init(&test_db); 6157 6158 test_ast_node->parent = test_db->ast->root; 6159 test_ast_node->line = 1; 6160 6161 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6162 6163 struct cil_constrain *cons; 6164 cil_constrain_init(&cons); 6165 cil_classpermset_init(&cons->classpermset); 6166 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6167 6168 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6169 CuAssertIntEquals(tc, SEPOL_ERR, rc); 6170 } 6171 6172 void test_cil_gen_constrain_expr_stack_eq_l1l2(CuTest *tc) { 6173 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "l1", "l2", ")", ")", NULL}; 6174 struct cil_tree *test_tree; 6175 gen_test_tree(&test_tree, line); 6176 6177 struct cil_tree_node *test_ast_node; 6178 cil_tree_node_init(&test_ast_node); 6179 6180 struct cil_db *test_db; 6181 cil_db_init(&test_db); 6182 6183 test_ast_node->parent = test_db->ast->root; 6184 test_ast_node->line = 1; 6185 6186 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6187 6188 struct cil_constrain *cons; 6189 cil_constrain_init(&cons); 6190 cil_classpermset_init(&cons->classpermset); 6191 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6192 6193 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6194 CuAssertIntEquals(tc, SEPOL_OK, rc); 6195 } 6196 6197 void test_cil_gen_constrain_expr_stack_eq_l1h1(CuTest *tc) { 6198 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "l1", "h1", ")", ")", NULL}; 6199 struct cil_tree *test_tree; 6200 gen_test_tree(&test_tree, line); 6201 6202 struct cil_tree_node *test_ast_node; 6203 cil_tree_node_init(&test_ast_node); 6204 6205 struct cil_db *test_db; 6206 cil_db_init(&test_db); 6207 6208 test_ast_node->parent = test_db->ast->root; 6209 test_ast_node->line = 1; 6210 6211 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6212 6213 struct cil_constrain *cons; 6214 cil_constrain_init(&cons); 6215 cil_classpermset_init(&cons->classpermset); 6216 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6217 6218 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6219 CuAssertIntEquals(tc, SEPOL_OK, rc); 6220 } 6221 6222 void test_cil_gen_constrain_expr_stack_eq_l1h2(CuTest *tc) { 6223 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "l1", "h2", ")", ")", NULL}; 6224 struct cil_tree *test_tree; 6225 gen_test_tree(&test_tree, line); 6226 6227 struct cil_tree_node *test_ast_node; 6228 cil_tree_node_init(&test_ast_node); 6229 6230 struct cil_db *test_db; 6231 cil_db_init(&test_db); 6232 6233 test_ast_node->parent = test_db->ast->root; 6234 test_ast_node->line = 1; 6235 6236 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6237 6238 struct cil_constrain *cons; 6239 cil_constrain_init(&cons); 6240 cil_classpermset_init(&cons->classpermset); 6241 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6242 6243 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6244 CuAssertIntEquals(tc, SEPOL_OK, rc); 6245 } 6246 6247 void test_cil_gen_constrain_expr_stack_eq_h1l2(CuTest *tc) { 6248 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "h1", "l2", ")", ")", NULL}; 6249 struct cil_tree *test_tree; 6250 gen_test_tree(&test_tree, line); 6251 6252 struct cil_tree_node *test_ast_node; 6253 cil_tree_node_init(&test_ast_node); 6254 6255 struct cil_db *test_db; 6256 cil_db_init(&test_db); 6257 6258 test_ast_node->parent = test_db->ast->root; 6259 test_ast_node->line = 1; 6260 6261 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6262 6263 struct cil_constrain *cons; 6264 cil_constrain_init(&cons); 6265 cil_classpermset_init(&cons->classpermset); 6266 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6267 6268 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6269 CuAssertIntEquals(tc, SEPOL_OK, rc); 6270 } 6271 6272 void test_cil_gen_constrain_expr_stack_eq_h1h2(CuTest *tc) { 6273 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "h1", "h2", ")", ")", NULL}; 6274 struct cil_tree *test_tree; 6275 gen_test_tree(&test_tree, line); 6276 6277 struct cil_tree_node *test_ast_node; 6278 cil_tree_node_init(&test_ast_node); 6279 6280 struct cil_db *test_db; 6281 cil_db_init(&test_db); 6282 6283 test_ast_node->parent = test_db->ast->root; 6284 test_ast_node->line = 1; 6285 6286 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6287 6288 struct cil_constrain *cons; 6289 cil_constrain_init(&cons); 6290 cil_classpermset_init(&cons->classpermset); 6291 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6292 6293 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6294 CuAssertIntEquals(tc, SEPOL_OK, rc); 6295 } 6296 6297 void test_cil_gen_constrain_expr_stack_eq_h1_neg(CuTest *tc) { 6298 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "h1", "l1", ")", ")", NULL}; 6299 struct cil_tree *test_tree; 6300 gen_test_tree(&test_tree, line); 6301 6302 struct cil_tree_node *test_ast_node; 6303 cil_tree_node_init(&test_ast_node); 6304 6305 struct cil_db *test_db; 6306 cil_db_init(&test_db); 6307 6308 test_ast_node->parent = test_db->ast->root; 6309 test_ast_node->line = 1; 6310 6311 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6312 6313 struct cil_constrain *cons; 6314 cil_constrain_init(&cons); 6315 cil_classpermset_init(&cons->classpermset); 6316 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6317 6318 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6319 CuAssertIntEquals(tc, SEPOL_ERR, rc); 6320 } 6321 6322 void test_cil_gen_constrain_expr_stack_eq_l1l1_neg(CuTest *tc) { 6323 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "l1", "l1", ")", ")", NULL}; 6324 struct cil_tree *test_tree; 6325 gen_test_tree(&test_tree, line); 6326 6327 struct cil_tree_node *test_ast_node; 6328 cil_tree_node_init(&test_ast_node); 6329 6330 struct cil_db *test_db; 6331 cil_db_init(&test_db); 6332 6333 test_ast_node->parent = test_db->ast->root; 6334 test_ast_node->line = 1; 6335 6336 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6337 6338 struct cil_constrain *cons; 6339 cil_constrain_init(&cons); 6340 cil_classpermset_init(&cons->classpermset); 6341 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6342 6343 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6344 CuAssertIntEquals(tc, SEPOL_ERR, rc); 6345 } 6346 6347 void test_cil_gen_constrain_expr_stack_eq2_l1l2_constrain_neg(CuTest *tc) { 6348 char *line[] = {"(", "constrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "l1", "l2", ")", ")", NULL}; 6349 struct cil_tree *test_tree; 6350 gen_test_tree(&test_tree, line); 6351 6352 struct cil_tree_node *test_ast_node; 6353 cil_tree_node_init(&test_ast_node); 6354 6355 struct cil_db *test_db; 6356 cil_db_init(&test_db); 6357 6358 test_ast_node->parent = test_db->ast->root; 6359 test_ast_node->line = 1; 6360 6361 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6362 6363 struct cil_constrain *cons; 6364 cil_constrain_init(&cons); 6365 cil_classpermset_init(&cons->classpermset); 6366 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6367 6368 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_CONSTRAIN, &cons->expr); 6369 CuAssertIntEquals(tc, SEPOL_ERR, rc); 6370 } 6371 6372 void test_cil_gen_constrain_expr_stack_eq_l1l2_constrain_neg(CuTest *tc) { 6373 char *line[] = {"(", "constrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "l1", "l2", ")", ")", NULL}; 6374 struct cil_tree *test_tree; 6375 gen_test_tree(&test_tree, line); 6376 6377 struct cil_tree_node *test_ast_node; 6378 cil_tree_node_init(&test_ast_node); 6379 6380 struct cil_db *test_db; 6381 cil_db_init(&test_db); 6382 6383 test_ast_node->parent = test_db->ast->root; 6384 test_ast_node->line = 1; 6385 6386 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6387 6388 struct cil_constrain *cons; 6389 cil_constrain_init(&cons); 6390 cil_classpermset_init(&cons->classpermset); 6391 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6392 6393 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_CONSTRAIN, &cons->expr); 6394 CuAssertIntEquals(tc, SEPOL_ERR, rc); 6395 } 6396 6397 void test_cil_gen_constrain_expr_stack_eq_leftkeyword_neg(CuTest *tc) { 6398 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "h2", "h1", ")", ")", NULL}; 6399 struct cil_tree *test_tree; 6400 gen_test_tree(&test_tree, line); 6401 6402 struct cil_tree_node *test_ast_node; 6403 cil_tree_node_init(&test_ast_node); 6404 6405 struct cil_db *test_db; 6406 cil_db_init(&test_db); 6407 6408 test_ast_node->parent = test_db->ast->root; 6409 test_ast_node->line = 1; 6410 6411 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6412 6413 struct cil_constrain *cons; 6414 cil_constrain_init(&cons); 6415 cil_classpermset_init(&cons->classpermset); 6416 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6417 6418 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6419 CuAssertIntEquals(tc, SEPOL_ERR, rc); 6420 } 6421 6422 void test_cil_gen_constrain_expr_stack_eq_noexpr1_neg(CuTest *tc) { 6423 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", ")", ")", ")", NULL}; 6424 struct cil_tree *test_tree; 6425 gen_test_tree(&test_tree, line); 6426 6427 struct cil_tree_node *test_ast_node; 6428 cil_tree_node_init(&test_ast_node); 6429 6430 struct cil_db *test_db; 6431 cil_db_init(&test_db); 6432 6433 test_ast_node->parent = test_db->ast->root; 6434 test_ast_node->line = 1; 6435 6436 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6437 6438 struct cil_constrain *cons; 6439 cil_constrain_init(&cons); 6440 cil_classpermset_init(&cons->classpermset); 6441 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6442 6443 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6444 CuAssertIntEquals(tc, SEPOL_ERR, rc); 6445 } 6446 6447 void test_cil_gen_constrain_expr_stack_eq_expr1inparens_neg(CuTest *tc) { 6448 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "(", "l1", ")", ")", ")", NULL}; 6449 struct cil_tree *test_tree; 6450 gen_test_tree(&test_tree, line); 6451 6452 struct cil_tree_node *test_ast_node; 6453 cil_tree_node_init(&test_ast_node); 6454 6455 struct cil_db *test_db; 6456 cil_db_init(&test_db); 6457 6458 test_ast_node->parent = test_db->ast->root; 6459 test_ast_node->line = 1; 6460 6461 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6462 6463 struct cil_constrain *cons; 6464 cil_constrain_init(&cons); 6465 cil_classpermset_init(&cons->classpermset); 6466 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6467 6468 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6469 CuAssertIntEquals(tc, SEPOL_ERR, rc); 6470 } 6471 6472 void test_cil_gen_constrain_expr_stack_eq_noexpr2_neg(CuTest *tc) { 6473 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "l1", ")", ")", ")", NULL}; 6474 struct cil_tree *test_tree; 6475 gen_test_tree(&test_tree, line); 6476 6477 struct cil_tree_node *test_ast_node; 6478 cil_tree_node_init(&test_ast_node); 6479 6480 struct cil_db *test_db; 6481 cil_db_init(&test_db); 6482 6483 test_ast_node->parent = test_db->ast->root; 6484 test_ast_node->line = 1; 6485 6486 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6487 6488 struct cil_constrain *cons; 6489 cil_constrain_init(&cons); 6490 cil_classpermset_init(&cons->classpermset); 6491 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6492 6493 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6494 CuAssertIntEquals(tc, SEPOL_ERR, rc); 6495 } 6496 6497 void test_cil_gen_constrain_expr_stack_eq_expr2inparens_neg(CuTest *tc) { 6498 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "l1", "(", "h2", ")", ")", ")", NULL}; 6499 struct cil_tree *test_tree; 6500 gen_test_tree(&test_tree, line); 6501 6502 struct cil_tree_node *test_ast_node; 6503 cil_tree_node_init(&test_ast_node); 6504 6505 struct cil_db *test_db; 6506 cil_db_init(&test_db); 6507 6508 test_ast_node->parent = test_db->ast->root; 6509 test_ast_node->line = 1; 6510 6511 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6512 6513 struct cil_constrain *cons; 6514 cil_constrain_init(&cons); 6515 cil_classpermset_init(&cons->classpermset); 6516 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6517 6518 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6519 CuAssertIntEquals(tc, SEPOL_ERR, rc); 6520 } 6521 6522 void test_cil_gen_constrain_expr_stack_eq_extraexpr_neg(CuTest *tc) { 6523 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "foo", "foo", "extra", ")", ")", NULL}; 6524 struct cil_tree *test_tree; 6525 gen_test_tree(&test_tree, line); 6526 6527 struct cil_tree_node *test_ast_node; 6528 cil_tree_node_init(&test_ast_node); 6529 6530 struct cil_db *test_db; 6531 cil_db_init(&test_db); 6532 6533 test_ast_node->parent = test_db->ast->root; 6534 test_ast_node->line = 1; 6535 6536 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6537 6538 struct cil_constrain *cons; 6539 cil_constrain_init(&cons); 6540 cil_classpermset_init(&cons->classpermset); 6541 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6542 6543 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6544 CuAssertIntEquals(tc, SEPOL_ERR, rc); 6545 } 6546 6547 void test_cil_gen_constrain_expr_stack_eq2(CuTest *tc) { 6548 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "l2", "h2", ")", ")", NULL}; 6549 struct cil_tree *test_tree; 6550 gen_test_tree(&test_tree, line); 6551 6552 struct cil_tree_node *test_ast_node; 6553 cil_tree_node_init(&test_ast_node); 6554 6555 struct cil_db *test_db; 6556 cil_db_init(&test_db); 6557 6558 test_ast_node->parent = test_db->ast->root; 6559 test_ast_node->line = 1; 6560 6561 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6562 6563 struct cil_constrain *cons; 6564 cil_constrain_init(&cons); 6565 cil_classpermset_init(&cons->classpermset); 6566 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6567 6568 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6569 CuAssertIntEquals(tc, SEPOL_OK, rc); 6570 } 6571 6572 void test_cil_gen_constrain_expr_stack_eq2_noexpr1_neg(CuTest *tc) { 6573 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", ")", ")", ")", NULL}; 6574 struct cil_tree *test_tree; 6575 gen_test_tree(&test_tree, line); 6576 6577 struct cil_tree_node *test_ast_node; 6578 cil_tree_node_init(&test_ast_node); 6579 6580 struct cil_db *test_db; 6581 cil_db_init(&test_db); 6582 6583 test_ast_node->parent = test_db->ast->root; 6584 test_ast_node->line = 1; 6585 6586 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6587 6588 struct cil_constrain *cons; 6589 cil_constrain_init(&cons); 6590 cil_classpermset_init(&cons->classpermset); 6591 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6592 6593 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6594 CuAssertIntEquals(tc, SEPOL_ERR, rc); 6595 } 6596 6597 void test_cil_gen_constrain_expr_stack_eq2_expr1inparens_neg(CuTest *tc) { 6598 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "(", "l1", ")", ")", ")", NULL}; 6599 struct cil_tree *test_tree; 6600 gen_test_tree(&test_tree, line); 6601 6602 struct cil_tree_node *test_ast_node; 6603 cil_tree_node_init(&test_ast_node); 6604 6605 struct cil_db *test_db; 6606 cil_db_init(&test_db); 6607 6608 test_ast_node->parent = test_db->ast->root; 6609 test_ast_node->line = 1; 6610 6611 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6612 6613 struct cil_constrain *cons; 6614 cil_constrain_init(&cons); 6615 cil_classpermset_init(&cons->classpermset); 6616 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6617 6618 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6619 CuAssertIntEquals(tc, SEPOL_ERR, rc); 6620 } 6621 6622 void test_cil_gen_constrain_expr_stack_eq2_noexpr2_neg(CuTest *tc) { 6623 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "l1", ")", ")", ")", NULL}; 6624 struct cil_tree *test_tree; 6625 gen_test_tree(&test_tree, line); 6626 6627 struct cil_tree_node *test_ast_node; 6628 cil_tree_node_init(&test_ast_node); 6629 6630 struct cil_db *test_db; 6631 cil_db_init(&test_db); 6632 6633 test_ast_node->parent = test_db->ast->root; 6634 test_ast_node->line = 1; 6635 6636 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6637 6638 struct cil_constrain *cons; 6639 cil_constrain_init(&cons); 6640 cil_classpermset_init(&cons->classpermset); 6641 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6642 6643 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6644 CuAssertIntEquals(tc, SEPOL_ERR, rc); 6645 } 6646 6647 void test_cil_gen_constrain_expr_stack_eq2_expr2inparens_neg(CuTest *tc) { 6648 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "l1", "(", "h2", ")", ")", ")", NULL}; 6649 struct cil_tree *test_tree; 6650 gen_test_tree(&test_tree, line); 6651 6652 struct cil_tree_node *test_ast_node; 6653 cil_tree_node_init(&test_ast_node); 6654 6655 struct cil_db *test_db; 6656 cil_db_init(&test_db); 6657 6658 test_ast_node->parent = test_db->ast->root; 6659 test_ast_node->line = 1; 6660 6661 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6662 6663 struct cil_constrain *cons; 6664 cil_constrain_init(&cons); 6665 cil_classpermset_init(&cons->classpermset); 6666 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6667 6668 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6669 CuAssertIntEquals(tc, SEPOL_ERR, rc); 6670 } 6671 6672 void test_cil_gen_constrain_expr_stack_eq2_extraexpr_neg(CuTest *tc) { 6673 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "foo", "foo", "extra", ")", ")", NULL}; 6674 struct cil_tree *test_tree; 6675 gen_test_tree(&test_tree, line); 6676 6677 struct cil_tree_node *test_ast_node; 6678 cil_tree_node_init(&test_ast_node); 6679 6680 struct cil_db *test_db; 6681 cil_db_init(&test_db); 6682 6683 test_ast_node->parent = test_db->ast->root; 6684 test_ast_node->line = 1; 6685 6686 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6687 6688 struct cil_constrain *cons; 6689 cil_constrain_init(&cons); 6690 cil_classpermset_init(&cons->classpermset); 6691 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6692 6693 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6694 CuAssertIntEquals(tc, SEPOL_ERR, rc); 6695 } 6696 6697 void test_cil_gen_constrain_expr_stack_noteq(CuTest *tc) { 6698 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "neq", "l2", "h2", ")", ")", NULL}; 6699 struct cil_tree *test_tree; 6700 gen_test_tree(&test_tree, line); 6701 6702 struct cil_tree_node *test_ast_node; 6703 cil_tree_node_init(&test_ast_node); 6704 6705 struct cil_db *test_db; 6706 cil_db_init(&test_db); 6707 6708 test_ast_node->parent = test_db->ast->root; 6709 test_ast_node->line = 1; 6710 6711 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6712 6713 struct cil_constrain *cons; 6714 cil_constrain_init(&cons); 6715 cil_classpermset_init(&cons->classpermset); 6716 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6717 6718 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6719 CuAssertIntEquals(tc, SEPOL_OK, rc); 6720 } 6721 6722 void test_cil_gen_constrain_expr_stack_noteq_noexpr1_neg(CuTest *tc) { 6723 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "neq", ")", ")", ")", NULL}; 6724 struct cil_tree *test_tree; 6725 gen_test_tree(&test_tree, line); 6726 6727 struct cil_tree_node *test_ast_node; 6728 cil_tree_node_init(&test_ast_node); 6729 6730 struct cil_db *test_db; 6731 cil_db_init(&test_db); 6732 6733 test_ast_node->parent = test_db->ast->root; 6734 test_ast_node->line = 1; 6735 6736 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6737 6738 struct cil_constrain *cons; 6739 cil_constrain_init(&cons); 6740 cil_classpermset_init(&cons->classpermset); 6741 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6742 6743 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6744 CuAssertIntEquals(tc, SEPOL_ERR, rc); 6745 } 6746 6747 void test_cil_gen_constrain_expr_stack_noteq_expr1inparens_neg(CuTest *tc) { 6748 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "neq", "(", "l1", ")", ")", ")", NULL}; 6749 struct cil_tree *test_tree; 6750 gen_test_tree(&test_tree, line); 6751 6752 struct cil_tree_node *test_ast_node; 6753 cil_tree_node_init(&test_ast_node); 6754 6755 struct cil_db *test_db; 6756 cil_db_init(&test_db); 6757 6758 test_ast_node->parent = test_db->ast->root; 6759 test_ast_node->line = 1; 6760 6761 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6762 6763 struct cil_constrain *cons; 6764 cil_constrain_init(&cons); 6765 cil_classpermset_init(&cons->classpermset); 6766 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6767 6768 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6769 CuAssertIntEquals(tc, SEPOL_ERR, rc); 6770 } 6771 6772 void test_cil_gen_constrain_expr_stack_noteq_noexpr2_neg(CuTest *tc) { 6773 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "neq", "l1", ")", ")", ")", NULL}; 6774 struct cil_tree *test_tree; 6775 gen_test_tree(&test_tree, line); 6776 6777 struct cil_tree_node *test_ast_node; 6778 cil_tree_node_init(&test_ast_node); 6779 6780 struct cil_db *test_db; 6781 cil_db_init(&test_db); 6782 6783 test_ast_node->parent = test_db->ast->root; 6784 test_ast_node->line = 1; 6785 6786 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6787 6788 struct cil_constrain *cons; 6789 cil_constrain_init(&cons); 6790 cil_classpermset_init(&cons->classpermset); 6791 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6792 6793 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6794 CuAssertIntEquals(tc, SEPOL_ERR, rc); 6795 } 6796 6797 void test_cil_gen_constrain_expr_stack_noteq_expr2inparens_neg(CuTest *tc) { 6798 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "neq", "l1", "(", "h2", ")", ")", ")", NULL}; 6799 struct cil_tree *test_tree; 6800 gen_test_tree(&test_tree, line); 6801 6802 struct cil_tree_node *test_ast_node; 6803 cil_tree_node_init(&test_ast_node); 6804 6805 struct cil_db *test_db; 6806 cil_db_init(&test_db); 6807 6808 test_ast_node->parent = test_db->ast->root; 6809 test_ast_node->line = 1; 6810 6811 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6812 6813 struct cil_constrain *cons; 6814 cil_constrain_init(&cons); 6815 cil_classpermset_init(&cons->classpermset); 6816 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6817 6818 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6819 CuAssertIntEquals(tc, SEPOL_ERR, rc); 6820 } 6821 6822 void test_cil_gen_constrain_expr_stack_noteq_extraexpr_neg(CuTest *tc) { 6823 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "neq", "foo", "foo", "extra", ")", ")", NULL}; 6824 struct cil_tree *test_tree; 6825 gen_test_tree(&test_tree, line); 6826 6827 struct cil_tree_node *test_ast_node; 6828 cil_tree_node_init(&test_ast_node); 6829 6830 struct cil_db *test_db; 6831 cil_db_init(&test_db); 6832 6833 test_ast_node->parent = test_db->ast->root; 6834 test_ast_node->line = 1; 6835 6836 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6837 6838 struct cil_constrain *cons; 6839 cil_constrain_init(&cons); 6840 cil_classpermset_init(&cons->classpermset); 6841 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6842 6843 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6844 CuAssertIntEquals(tc, SEPOL_ERR, rc); 6845 } 6846 6847 void test_cil_gen_constrain_expr_stack_not(CuTest *tc) { 6848 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "not", "(", "neq", "l2", "h2", ")", ")", ")", NULL}; 6849 struct cil_tree *test_tree; 6850 gen_test_tree(&test_tree, line); 6851 6852 struct cil_tree_node *test_ast_node; 6853 cil_tree_node_init(&test_ast_node); 6854 6855 struct cil_db *test_db; 6856 cil_db_init(&test_db); 6857 6858 test_ast_node->parent = test_db->ast->root; 6859 test_ast_node->line = 1; 6860 6861 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6862 6863 struct cil_constrain *cons; 6864 cil_constrain_init(&cons); 6865 cil_classpermset_init(&cons->classpermset); 6866 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6867 6868 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6869 CuAssertIntEquals(tc, SEPOL_OK, rc); 6870 } 6871 6872 void test_cil_gen_constrain_expr_stack_not_noexpr_neg(CuTest *tc) { 6873 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "not", ")", ")", ")", NULL}; 6874 struct cil_tree *test_tree; 6875 gen_test_tree(&test_tree, line); 6876 6877 struct cil_tree_node *test_ast_node; 6878 cil_tree_node_init(&test_ast_node); 6879 6880 struct cil_db *test_db; 6881 cil_db_init(&test_db); 6882 6883 test_ast_node->parent = test_db->ast->root; 6884 test_ast_node->line = 1; 6885 6886 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6887 6888 struct cil_constrain *cons; 6889 cil_constrain_init(&cons); 6890 cil_classpermset_init(&cons->classpermset); 6891 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6892 6893 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6894 CuAssertIntEquals(tc, SEPOL_ERR, rc); 6895 } 6896 6897 void test_cil_gen_constrain_expr_stack_not_emptyparens_neg(CuTest *tc) { 6898 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "not", "(", ")", ")", ")", NULL}; 6899 struct cil_tree *test_tree; 6900 gen_test_tree(&test_tree, line); 6901 6902 struct cil_tree_node *test_ast_node; 6903 cil_tree_node_init(&test_ast_node); 6904 6905 struct cil_db *test_db; 6906 cil_db_init(&test_db); 6907 6908 test_ast_node->parent = test_db->ast->root; 6909 test_ast_node->line = 1; 6910 6911 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6912 6913 struct cil_constrain *cons; 6914 cil_constrain_init(&cons); 6915 cil_classpermset_init(&cons->classpermset); 6916 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6917 6918 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6919 CuAssertIntEquals(tc, SEPOL_ERR, rc); 6920 } 6921 6922 void test_cil_gen_constrain_expr_stack_not_extraparens_neg(CuTest *tc) { 6923 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "not", "(", "neq", "l2", "h2", ")", "(", ")", ")", ")", NULL}; 6924 struct cil_tree *test_tree; 6925 gen_test_tree(&test_tree, line); 6926 6927 struct cil_tree_node *test_ast_node; 6928 cil_tree_node_init(&test_ast_node); 6929 6930 struct cil_db *test_db; 6931 cil_db_init(&test_db); 6932 6933 test_ast_node->parent = test_db->ast->root; 6934 test_ast_node->line = 1; 6935 6936 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6937 6938 struct cil_constrain *cons; 6939 cil_constrain_init(&cons); 6940 cil_classpermset_init(&cons->classpermset); 6941 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6942 6943 6944 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6945 CuAssertIntEquals(tc, SEPOL_ERR, rc); 6946 } 6947 6948 void test_cil_gen_constrain_expr_stack_or(CuTest *tc) { 6949 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "or", 6950 "(", "neq", "l1", "l2", ")", "(", "neq", "l1", "h1", ")", ")", ")", NULL}; 6951 struct cil_tree *test_tree; 6952 gen_test_tree(&test_tree, line); 6953 6954 struct cil_tree_node *test_ast_node; 6955 cil_tree_node_init(&test_ast_node); 6956 6957 struct cil_db *test_db; 6958 cil_db_init(&test_db); 6959 6960 test_ast_node->parent = test_db->ast->root; 6961 test_ast_node->line = 1; 6962 6963 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6964 6965 struct cil_constrain *cons; 6966 cil_constrain_init(&cons); 6967 cil_classpermset_init(&cons->classpermset); 6968 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6969 6970 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6971 CuAssertIntEquals(tc, SEPOL_OK, rc); 6972 } 6973 6974 void test_cil_gen_constrain_expr_stack_or_neg(CuTest *tc) { 6975 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "or", 6976 "(", "foo", ")", "(", "neq", "l1", "h1", ")", ")", ")", NULL}; 6977 struct cil_tree *test_tree; 6978 gen_test_tree(&test_tree, line); 6979 6980 struct cil_tree_node *test_ast_node; 6981 cil_tree_node_init(&test_ast_node); 6982 6983 struct cil_db *test_db; 6984 cil_db_init(&test_db); 6985 6986 test_ast_node->parent = test_db->ast->root; 6987 test_ast_node->line = 1; 6988 6989 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 6990 6991 struct cil_constrain *cons; 6992 cil_constrain_init(&cons); 6993 cil_classpermset_init(&cons->classpermset); 6994 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 6995 6996 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 6997 CuAssertIntEquals(tc, SEPOL_ERR, rc); 6998 } 6999 7000 void test_cil_gen_constrain_expr_stack_or_noexpr_neg(CuTest *tc) { 7001 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "or", ")", ")", ")", NULL}; 7002 struct cil_tree *test_tree; 7003 gen_test_tree(&test_tree, line); 7004 7005 struct cil_tree_node *test_ast_node; 7006 cil_tree_node_init(&test_ast_node); 7007 7008 struct cil_db *test_db; 7009 cil_db_init(&test_db); 7010 7011 test_ast_node->parent = test_db->ast->root; 7012 test_ast_node->line = 1; 7013 7014 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 7015 7016 struct cil_constrain *cons; 7017 cil_constrain_init(&cons); 7018 cil_classpermset_init(&cons->classpermset); 7019 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 7020 7021 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 7022 CuAssertIntEquals(tc, SEPOL_ERR, rc); 7023 } 7024 7025 void test_cil_gen_constrain_expr_stack_or_emptyfirstparens_neg(CuTest *tc) { 7026 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "or", "(", ")", ")", ")", NULL}; 7027 struct cil_tree *test_tree; 7028 gen_test_tree(&test_tree, line); 7029 7030 struct cil_tree_node *test_ast_node; 7031 cil_tree_node_init(&test_ast_node); 7032 7033 struct cil_db *test_db; 7034 cil_db_init(&test_db); 7035 7036 test_ast_node->parent = test_db->ast->root; 7037 test_ast_node->line = 1; 7038 7039 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 7040 7041 struct cil_constrain *cons; 7042 cil_constrain_init(&cons); 7043 cil_classpermset_init(&cons->classpermset); 7044 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 7045 7046 7047 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 7048 CuAssertIntEquals(tc, SEPOL_ERR, rc); 7049 } 7050 7051 void test_cil_gen_constrain_expr_stack_or_missingsecondexpr_neg(CuTest *tc) { 7052 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "or", "(", "foo", ")", ")", ")", ")", NULL}; 7053 struct cil_tree *test_tree; 7054 gen_test_tree(&test_tree, line); 7055 7056 struct cil_tree_node *test_ast_node; 7057 cil_tree_node_init(&test_ast_node); 7058 7059 struct cil_db *test_db; 7060 cil_db_init(&test_db); 7061 7062 test_ast_node->parent = test_db->ast->root; 7063 test_ast_node->line = 1; 7064 7065 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 7066 7067 struct cil_constrain *cons; 7068 cil_constrain_init(&cons); 7069 cil_classpermset_init(&cons->classpermset); 7070 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 7071 7072 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 7073 CuAssertIntEquals(tc, SEPOL_ERR, rc); 7074 } 7075 7076 void test_cil_gen_constrain_expr_stack_or_emptysecondparens_neg(CuTest *tc) { 7077 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "or", "(", "foo", ")", "(", ")", ")", ")", NULL}; 7078 struct cil_tree *test_tree; 7079 gen_test_tree(&test_tree, line); 7080 7081 struct cil_tree_node *test_ast_node; 7082 cil_tree_node_init(&test_ast_node); 7083 7084 struct cil_db *test_db; 7085 cil_db_init(&test_db); 7086 7087 test_ast_node->parent = test_db->ast->root; 7088 test_ast_node->line = 1; 7089 7090 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 7091 7092 struct cil_constrain *cons; 7093 cil_constrain_init(&cons); 7094 cil_classpermset_init(&cons->classpermset); 7095 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 7096 7097 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 7098 CuAssertIntEquals(tc, SEPOL_ERR, rc); 7099 } 7100 7101 void test_cil_gen_constrain_expr_stack_or_extraexpr_neg(CuTest *tc) { 7102 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "or", "(", "foo", ")", "(", "foo", ")", "(", ")", ")", ")", NULL}; 7103 struct cil_tree *test_tree; 7104 gen_test_tree(&test_tree, line); 7105 7106 struct cil_tree_node *test_ast_node; 7107 cil_tree_node_init(&test_ast_node); 7108 7109 struct cil_db *test_db; 7110 cil_db_init(&test_db); 7111 7112 test_ast_node->parent = test_db->ast->root; 7113 test_ast_node->line = 1; 7114 7115 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 7116 7117 struct cil_constrain *cons; 7118 cil_constrain_init(&cons); 7119 cil_classpermset_init(&cons->classpermset); 7120 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 7121 7122 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 7123 CuAssertIntEquals(tc, SEPOL_ERR, rc); 7124 } 7125 7126 void test_cil_gen_constrain_expr_stack_and(CuTest *tc) { 7127 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "and", 7128 "(", "neq", "l1", "l2", ")", "(", "neq", "l1", "h1", ")", ")", ")", NULL}; 7129 struct cil_tree *test_tree; 7130 gen_test_tree(&test_tree, line); 7131 7132 struct cil_tree_node *test_ast_node; 7133 cil_tree_node_init(&test_ast_node); 7134 7135 struct cil_db *test_db; 7136 cil_db_init(&test_db); 7137 7138 test_ast_node->parent = test_db->ast->root; 7139 test_ast_node->line = 1; 7140 7141 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 7142 7143 struct cil_constrain *cons; 7144 cil_constrain_init(&cons); 7145 cil_classpermset_init(&cons->classpermset); 7146 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 7147 7148 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 7149 CuAssertIntEquals(tc, SEPOL_OK, rc); 7150 } 7151 7152 void test_cil_gen_constrain_expr_stack_and_neg(CuTest *tc) { 7153 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "and", 7154 "(", "foo", ")", "(", "neq", "l1", "h1", ")", ")", ")", NULL}; 7155 struct cil_tree *test_tree; 7156 gen_test_tree(&test_tree, line); 7157 7158 struct cil_tree_node *test_ast_node; 7159 cil_tree_node_init(&test_ast_node); 7160 7161 struct cil_db *test_db; 7162 cil_db_init(&test_db); 7163 7164 test_ast_node->parent = test_db->ast->root; 7165 test_ast_node->line = 1; 7166 7167 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 7168 7169 struct cil_constrain *cons; 7170 cil_constrain_init(&cons); 7171 cil_classpermset_init(&cons->classpermset); 7172 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 7173 7174 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 7175 CuAssertIntEquals(tc, SEPOL_ERR, rc); 7176 } 7177 7178 void test_cil_gen_constrain_expr_stack_and_noexpr_neg(CuTest *tc) { 7179 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "and", ")", ")", ")", NULL}; 7180 struct cil_tree *test_tree; 7181 gen_test_tree(&test_tree, line); 7182 7183 struct cil_tree_node *test_ast_node; 7184 cil_tree_node_init(&test_ast_node); 7185 7186 struct cil_db *test_db; 7187 cil_db_init(&test_db); 7188 7189 test_ast_node->parent = test_db->ast->root; 7190 test_ast_node->line = 1; 7191 7192 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 7193 7194 struct cil_constrain *cons; 7195 cil_constrain_init(&cons); 7196 cil_classpermset_init(&cons->classpermset); 7197 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 7198 7199 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 7200 CuAssertIntEquals(tc, SEPOL_ERR, rc); 7201 } 7202 7203 void test_cil_gen_constrain_expr_stack_and_emptyfirstparens_neg(CuTest *tc) { 7204 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "and", "(", ")", ")", ")", NULL}; 7205 struct cil_tree *test_tree; 7206 gen_test_tree(&test_tree, line); 7207 7208 struct cil_tree_node *test_ast_node; 7209 cil_tree_node_init(&test_ast_node); 7210 7211 struct cil_db *test_db; 7212 cil_db_init(&test_db); 7213 7214 test_ast_node->parent = test_db->ast->root; 7215 test_ast_node->line = 1; 7216 7217 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 7218 7219 struct cil_constrain *cons; 7220 cil_constrain_init(&cons); 7221 cil_classpermset_init(&cons->classpermset); 7222 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 7223 7224 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 7225 CuAssertIntEquals(tc, SEPOL_ERR, rc); 7226 } 7227 7228 void test_cil_gen_constrain_expr_stack_and_missingsecondexpr_neg(CuTest *tc) { 7229 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "and", "(", "foo", ")", ")", ")", ")", NULL}; 7230 struct cil_tree *test_tree; 7231 gen_test_tree(&test_tree, line); 7232 7233 struct cil_tree_node *test_ast_node; 7234 cil_tree_node_init(&test_ast_node); 7235 7236 struct cil_db *test_db; 7237 cil_db_init(&test_db); 7238 7239 test_ast_node->parent = test_db->ast->root; 7240 test_ast_node->line = 1; 7241 7242 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 7243 7244 struct cil_constrain *cons; 7245 cil_constrain_init(&cons); 7246 cil_classpermset_init(&cons->classpermset); 7247 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 7248 7249 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 7250 CuAssertIntEquals(tc, SEPOL_ERR, rc); 7251 } 7252 7253 void test_cil_gen_constrain_expr_stack_and_emptysecondparens_neg(CuTest *tc) { 7254 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "and", "(", "foo", ")", "(", ")", ")", ")", NULL}; 7255 struct cil_tree *test_tree; 7256 gen_test_tree(&test_tree, line); 7257 7258 struct cil_tree_node *test_ast_node; 7259 cil_tree_node_init(&test_ast_node); 7260 7261 struct cil_db *test_db; 7262 cil_db_init(&test_db); 7263 7264 test_ast_node->parent = test_db->ast->root; 7265 test_ast_node->line = 1; 7266 7267 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 7268 7269 struct cil_constrain *cons; 7270 cil_constrain_init(&cons); 7271 cil_classpermset_init(&cons->classpermset); 7272 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 7273 7274 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 7275 CuAssertIntEquals(tc, SEPOL_ERR, rc); 7276 } 7277 7278 void test_cil_gen_constrain_expr_stack_and_extraexpr_neg(CuTest *tc) { 7279 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "and", "(", "foo", ")", "(", "foo", ")", "(", ")", ")", ")", NULL}; 7280 struct cil_tree *test_tree; 7281 gen_test_tree(&test_tree, line); 7282 7283 struct cil_tree_node *test_ast_node; 7284 cil_tree_node_init(&test_ast_node); 7285 7286 struct cil_db *test_db; 7287 cil_db_init(&test_db); 7288 7289 test_ast_node->parent = test_db->ast->root; 7290 test_ast_node->line = 1; 7291 7292 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 7293 7294 struct cil_constrain *cons; 7295 cil_constrain_init(&cons); 7296 cil_classpermset_init(&cons->classpermset); 7297 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 7298 7299 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 7300 CuAssertIntEquals(tc, SEPOL_ERR, rc); 7301 } 7302 7303 void test_cil_gen_constrain_expr_stack_dom(CuTest *tc) { 7304 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "dom", "l2", "h2", ")", ")", NULL}; 7305 struct cil_tree *test_tree; 7306 gen_test_tree(&test_tree, line); 7307 7308 struct cil_tree_node *test_ast_node; 7309 cil_tree_node_init(&test_ast_node); 7310 7311 struct cil_db *test_db; 7312 cil_db_init(&test_db); 7313 7314 test_ast_node->parent = test_db->ast->root; 7315 test_ast_node->line = 1; 7316 7317 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 7318 7319 struct cil_constrain *cons; 7320 cil_constrain_init(&cons); 7321 cil_classpermset_init(&cons->classpermset); 7322 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 7323 7324 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 7325 CuAssertIntEquals(tc, SEPOL_OK, rc); 7326 } 7327 7328 void test_cil_gen_constrain_expr_stack_dom_noexpr1_neg(CuTest *tc) { 7329 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "dom", ")", ")", ")", NULL}; 7330 struct cil_tree *test_tree; 7331 gen_test_tree(&test_tree, line); 7332 7333 struct cil_tree_node *test_ast_node; 7334 cil_tree_node_init(&test_ast_node); 7335 7336 struct cil_db *test_db; 7337 cil_db_init(&test_db); 7338 7339 test_ast_node->parent = test_db->ast->root; 7340 test_ast_node->line = 1; 7341 7342 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 7343 7344 struct cil_constrain *cons; 7345 cil_constrain_init(&cons); 7346 cil_classpermset_init(&cons->classpermset); 7347 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 7348 7349 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 7350 CuAssertIntEquals(tc, SEPOL_ERR, rc); 7351 } 7352 7353 void test_cil_gen_constrain_expr_stack_dom_expr1inparens_neg(CuTest *tc) { 7354 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "dom", "(", "l1", ")", ")", ")", NULL}; 7355 struct cil_tree *test_tree; 7356 gen_test_tree(&test_tree, line); 7357 7358 struct cil_tree_node *test_ast_node; 7359 cil_tree_node_init(&test_ast_node); 7360 7361 struct cil_db *test_db; 7362 cil_db_init(&test_db); 7363 7364 test_ast_node->parent = test_db->ast->root; 7365 test_ast_node->line = 1; 7366 7367 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 7368 7369 struct cil_constrain *cons; 7370 cil_constrain_init(&cons); 7371 cil_classpermset_init(&cons->classpermset); 7372 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 7373 7374 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 7375 CuAssertIntEquals(tc, SEPOL_ERR, rc); 7376 } 7377 7378 void test_cil_gen_constrain_expr_stack_dom_noexpr2_neg(CuTest *tc) { 7379 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "dom", "l1", ")", ")", ")", NULL}; 7380 struct cil_tree *test_tree; 7381 gen_test_tree(&test_tree, line); 7382 7383 struct cil_tree_node *test_ast_node; 7384 cil_tree_node_init(&test_ast_node); 7385 7386 struct cil_db *test_db; 7387 cil_db_init(&test_db); 7388 7389 test_ast_node->parent = test_db->ast->root; 7390 test_ast_node->line = 1; 7391 7392 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 7393 7394 struct cil_constrain *cons; 7395 cil_constrain_init(&cons); 7396 cil_classpermset_init(&cons->classpermset); 7397 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 7398 7399 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 7400 CuAssertIntEquals(tc, SEPOL_ERR, rc); 7401 } 7402 7403 void test_cil_gen_constrain_expr_stack_dom_expr2inparens_neg(CuTest *tc) { 7404 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "dom", "l1", "(", "h2", ")", ")", ")", NULL}; 7405 struct cil_tree *test_tree; 7406 gen_test_tree(&test_tree, line); 7407 7408 struct cil_tree_node *test_ast_node; 7409 cil_tree_node_init(&test_ast_node); 7410 7411 struct cil_db *test_db; 7412 cil_db_init(&test_db); 7413 7414 test_ast_node->parent = test_db->ast->root; 7415 test_ast_node->line = 1; 7416 7417 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 7418 7419 struct cil_constrain *cons; 7420 cil_constrain_init(&cons); 7421 cil_classpermset_init(&cons->classpermset); 7422 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 7423 7424 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 7425 CuAssertIntEquals(tc, SEPOL_ERR, rc); 7426 } 7427 7428 void test_cil_gen_constrain_expr_stack_dom_extraexpr_neg(CuTest *tc) { 7429 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "dom", "foo", "foo", "extra", ")", ")", NULL}; 7430 struct cil_tree *test_tree; 7431 gen_test_tree(&test_tree, line); 7432 7433 struct cil_tree_node *test_ast_node; 7434 cil_tree_node_init(&test_ast_node); 7435 7436 struct cil_db *test_db; 7437 cil_db_init(&test_db); 7438 7439 test_ast_node->parent = test_db->ast->root; 7440 test_ast_node->line = 1; 7441 7442 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 7443 7444 struct cil_constrain *cons; 7445 cil_constrain_init(&cons); 7446 cil_classpermset_init(&cons->classpermset); 7447 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 7448 7449 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 7450 CuAssertIntEquals(tc, SEPOL_ERR, rc); 7451 } 7452 7453 void test_cil_gen_constrain_expr_stack_domby(CuTest *tc) { 7454 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "domby", "l2", "h2", ")", ")", NULL}; 7455 struct cil_tree *test_tree; 7456 gen_test_tree(&test_tree, line); 7457 7458 struct cil_tree_node *test_ast_node; 7459 cil_tree_node_init(&test_ast_node); 7460 7461 struct cil_db *test_db; 7462 cil_db_init(&test_db); 7463 7464 test_ast_node->parent = test_db->ast->root; 7465 test_ast_node->line = 1; 7466 7467 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 7468 7469 struct cil_constrain *cons; 7470 cil_constrain_init(&cons); 7471 cil_classpermset_init(&cons->classpermset); 7472 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 7473 7474 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 7475 CuAssertIntEquals(tc, SEPOL_OK, rc); 7476 } 7477 7478 void test_cil_gen_constrain_expr_stack_domby_noexpr1_neg(CuTest *tc) { 7479 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "domby", ")", ")", ")", NULL}; 7480 struct cil_tree *test_tree; 7481 gen_test_tree(&test_tree, line); 7482 7483 struct cil_tree_node *test_ast_node; 7484 cil_tree_node_init(&test_ast_node); 7485 7486 struct cil_db *test_db; 7487 cil_db_init(&test_db); 7488 7489 test_ast_node->parent = test_db->ast->root; 7490 test_ast_node->line = 1; 7491 7492 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 7493 7494 struct cil_constrain *cons; 7495 cil_constrain_init(&cons); 7496 cil_classpermset_init(&cons->classpermset); 7497 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 7498 7499 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 7500 CuAssertIntEquals(tc, SEPOL_ERR, rc); 7501 } 7502 7503 void test_cil_gen_constrain_expr_stack_domby_expr1inparens_neg(CuTest *tc) { 7504 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "domby", "(", "l1", ")", ")", ")", NULL}; 7505 struct cil_tree *test_tree; 7506 gen_test_tree(&test_tree, line); 7507 7508 struct cil_tree_node *test_ast_node; 7509 cil_tree_node_init(&test_ast_node); 7510 7511 struct cil_db *test_db; 7512 cil_db_init(&test_db); 7513 7514 test_ast_node->parent = test_db->ast->root; 7515 test_ast_node->line = 1; 7516 7517 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 7518 7519 struct cil_constrain *cons; 7520 cil_constrain_init(&cons); 7521 cil_classpermset_init(&cons->classpermset); 7522 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 7523 7524 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 7525 CuAssertIntEquals(tc, SEPOL_ERR, rc); 7526 } 7527 7528 void test_cil_gen_constrain_expr_stack_domby_noexpr2_neg(CuTest *tc) { 7529 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "domby", "l1", ")", ")", ")", NULL}; 7530 struct cil_tree *test_tree; 7531 gen_test_tree(&test_tree, line); 7532 7533 struct cil_tree_node *test_ast_node; 7534 cil_tree_node_init(&test_ast_node); 7535 7536 struct cil_db *test_db; 7537 cil_db_init(&test_db); 7538 7539 test_ast_node->parent = test_db->ast->root; 7540 test_ast_node->line = 1; 7541 7542 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 7543 7544 struct cil_constrain *cons; 7545 cil_constrain_init(&cons); 7546 cil_classpermset_init(&cons->classpermset); 7547 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 7548 7549 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 7550 CuAssertIntEquals(tc, SEPOL_ERR, rc); 7551 } 7552 7553 void test_cil_gen_constrain_expr_stack_domby_expr2inparens_neg(CuTest *tc) { 7554 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "domby", "l1", "(", "h2", ")", ")", ")", NULL}; 7555 struct cil_tree *test_tree; 7556 gen_test_tree(&test_tree, line); 7557 7558 struct cil_tree_node *test_ast_node; 7559 cil_tree_node_init(&test_ast_node); 7560 7561 struct cil_db *test_db; 7562 cil_db_init(&test_db); 7563 7564 test_ast_node->parent = test_db->ast->root; 7565 test_ast_node->line = 1; 7566 7567 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 7568 7569 struct cil_constrain *cons; 7570 cil_constrain_init(&cons); 7571 cil_classpermset_init(&cons->classpermset); 7572 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 7573 7574 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 7575 CuAssertIntEquals(tc, SEPOL_ERR, rc); 7576 } 7577 7578 void test_cil_gen_constrain_expr_stack_domby_extraexpr_neg(CuTest *tc) { 7579 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "domby", "foo", "foo", "extra", ")", ")", NULL}; 7580 struct cil_tree *test_tree; 7581 gen_test_tree(&test_tree, line); 7582 7583 struct cil_tree_node *test_ast_node; 7584 cil_tree_node_init(&test_ast_node); 7585 7586 struct cil_db *test_db; 7587 cil_db_init(&test_db); 7588 7589 test_ast_node->parent = test_db->ast->root; 7590 test_ast_node->line = 1; 7591 7592 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 7593 7594 struct cil_constrain *cons; 7595 cil_constrain_init(&cons); 7596 cil_classpermset_init(&cons->classpermset); 7597 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 7598 7599 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 7600 CuAssertIntEquals(tc, SEPOL_ERR, rc); 7601 } 7602 7603 void test_cil_gen_constrain_expr_stack_incomp(CuTest *tc) { 7604 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "incomp", "l2", "h2", ")", ")", NULL}; 7605 struct cil_tree *test_tree; 7606 gen_test_tree(&test_tree, line); 7607 7608 struct cil_tree_node *test_ast_node; 7609 cil_tree_node_init(&test_ast_node); 7610 7611 struct cil_db *test_db; 7612 cil_db_init(&test_db); 7613 7614 test_ast_node->parent = test_db->ast->root; 7615 test_ast_node->line = 1; 7616 7617 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 7618 7619 struct cil_constrain *cons; 7620 cil_constrain_init(&cons); 7621 cil_classpermset_init(&cons->classpermset); 7622 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 7623 7624 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 7625 CuAssertIntEquals(tc, SEPOL_OK, rc); 7626 } 7627 7628 void test_cil_gen_constrain_expr_stack_incomp_noexpr1_neg(CuTest *tc) { 7629 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "incomp", ")", ")", ")", NULL}; 7630 struct cil_tree *test_tree; 7631 gen_test_tree(&test_tree, line); 7632 7633 struct cil_tree_node *test_ast_node; 7634 cil_tree_node_init(&test_ast_node); 7635 7636 struct cil_db *test_db; 7637 cil_db_init(&test_db); 7638 7639 test_ast_node->parent = test_db->ast->root; 7640 test_ast_node->line = 1; 7641 7642 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 7643 7644 struct cil_constrain *cons; 7645 cil_constrain_init(&cons); 7646 cil_classpermset_init(&cons->classpermset); 7647 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 7648 7649 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 7650 CuAssertIntEquals(tc, SEPOL_ERR, rc); 7651 } 7652 7653 void test_cil_gen_constrain_expr_stack_incomp_expr1inparens_neg(CuTest *tc) { 7654 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "incomp", "(", "l1", ")", ")", ")", NULL}; 7655 struct cil_tree *test_tree; 7656 gen_test_tree(&test_tree, line); 7657 7658 struct cil_tree_node *test_ast_node; 7659 cil_tree_node_init(&test_ast_node); 7660 7661 struct cil_db *test_db; 7662 cil_db_init(&test_db); 7663 7664 test_ast_node->parent = test_db->ast->root; 7665 test_ast_node->line = 1; 7666 7667 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 7668 7669 struct cil_constrain *cons; 7670 cil_constrain_init(&cons); 7671 cil_classpermset_init(&cons->classpermset); 7672 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 7673 7674 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 7675 CuAssertIntEquals(tc, SEPOL_ERR, rc); 7676 } 7677 7678 void test_cil_gen_constrain_expr_stack_incomp_noexpr2_neg(CuTest *tc) { 7679 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "incomp", "l1", ")", ")", ")", NULL}; 7680 struct cil_tree *test_tree; 7681 gen_test_tree(&test_tree, line); 7682 7683 struct cil_tree_node *test_ast_node; 7684 cil_tree_node_init(&test_ast_node); 7685 7686 struct cil_db *test_db; 7687 cil_db_init(&test_db); 7688 7689 test_ast_node->parent = test_db->ast->root; 7690 test_ast_node->line = 1; 7691 7692 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 7693 7694 struct cil_constrain *cons; 7695 cil_constrain_init(&cons); 7696 cil_classpermset_init(&cons->classpermset); 7697 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 7698 7699 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 7700 CuAssertIntEquals(tc, SEPOL_ERR, rc); 7701 } 7702 7703 void test_cil_gen_constrain_expr_stack_incomp_expr2inparens_neg(CuTest *tc) { 7704 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "incomp", "l1", "(", "h2", ")", ")", ")", NULL}; 7705 struct cil_tree *test_tree; 7706 gen_test_tree(&test_tree, line); 7707 7708 struct cil_tree_node *test_ast_node; 7709 cil_tree_node_init(&test_ast_node); 7710 7711 struct cil_db *test_db; 7712 cil_db_init(&test_db); 7713 7714 test_ast_node->parent = test_db->ast->root; 7715 test_ast_node->line = 1; 7716 7717 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 7718 7719 struct cil_constrain *cons; 7720 cil_constrain_init(&cons); 7721 cil_classpermset_init(&cons->classpermset); 7722 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 7723 7724 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 7725 CuAssertIntEquals(tc, SEPOL_ERR, rc); 7726 } 7727 7728 void test_cil_gen_constrain_expr_stack_incomp_extraexpr_neg(CuTest *tc) { 7729 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "incomp", "foo", "foo", "extra", ")", ")", NULL}; 7730 struct cil_tree *test_tree; 7731 gen_test_tree(&test_tree, line); 7732 7733 struct cil_tree_node *test_ast_node; 7734 cil_tree_node_init(&test_ast_node); 7735 7736 struct cil_db *test_db; 7737 cil_db_init(&test_db); 7738 7739 test_ast_node->parent = test_db->ast->root; 7740 test_ast_node->line = 1; 7741 7742 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 7743 7744 struct cil_constrain *cons; 7745 cil_constrain_init(&cons); 7746 cil_classpermset_init(&cons->classpermset); 7747 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 7748 7749 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 7750 CuAssertIntEquals(tc, SEPOL_ERR, rc); 7751 } 7752 7753 void test_cil_gen_constrain_expr_stack_currnull_neg(CuTest *tc) { 7754 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", ")", ")", NULL}; 7755 struct cil_tree *test_tree; 7756 gen_test_tree(&test_tree, line); 7757 7758 struct cil_tree_node *test_ast_node; 7759 cil_tree_node_init(&test_ast_node); 7760 7761 struct cil_db *test_db; 7762 cil_db_init(&test_db); 7763 7764 test_ast_node->parent = test_db->ast->root; 7765 test_ast_node->line = 1; 7766 7767 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 7768 7769 struct cil_constrain *cons; 7770 cil_constrain_init(&cons); 7771 cil_classpermset_init(&cons->classpermset); 7772 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 7773 7774 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 7775 CuAssertIntEquals(tc, SEPOL_ERR, rc); 7776 } 7777 7778 void test_cil_gen_constrain_expr_stack_stacknull_neg(CuTest *tc) { 7779 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "t1", "type_t", ")", ")", NULL}; 7780 struct cil_tree *test_tree; 7781 gen_test_tree(&test_tree, line); 7782 7783 struct cil_tree_node *test_ast_node; 7784 cil_tree_node_init(&test_ast_node); 7785 7786 struct cil_db *test_db; 7787 cil_db_init(&test_db); 7788 7789 test_ast_node->parent = test_db->ast->root; 7790 test_ast_node->line = 1; 7791 7792 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 7793 7794 struct cil_constrain *cons; 7795 cil_constrain_init(&cons); 7796 cil_classpermset_init(&cons->classpermset); 7797 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 7798 7799 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, NULL); 7800 CuAssertIntEquals(tc, SEPOL_ERR, rc); 7801 } 7802 7803 void test_cil_gen_constrain_expr_stack_operatorinparens_neg(CuTest *tc) { 7804 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "(", "eq", ")", "t1", "type_t", ")", ")", NULL}; 7805 struct cil_tree *test_tree; 7806 gen_test_tree(&test_tree, line); 7807 7808 struct cil_tree_node *test_ast_node; 7809 cil_tree_node_init(&test_ast_node); 7810 7811 struct cil_db *test_db; 7812 cil_db_init(&test_db); 7813 7814 test_ast_node->parent = test_db->ast->root; 7815 test_ast_node->line = 1; 7816 7817 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 7818 7819 struct cil_constrain *cons; 7820 cil_constrain_init(&cons); 7821 cil_classpermset_init(&cons->classpermset); 7822 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 7823 7824 int rc = cil_gen_expr_stack(parse_current->next->next, CIL_MLSCONSTRAIN, &cons->expr); 7825 CuAssertIntEquals(tc, SEPOL_ERR, rc); 7826 } 7827 7828 void test_cil_gen_constrain_expr_stack_incorrectcall_neg(CuTest *tc) { 7829 char *line[] = {"(", "mlsconstrain", "(", "file", "(", "create", "relabelto", ")", ")", "(", "eq", "t1", "type_t", ")", ")", NULL}; 7830 struct cil_tree *test_tree; 7831 gen_test_tree(&test_tree, line); 7832 7833 struct cil_tree_node *test_ast_node; 7834 cil_tree_node_init(&test_ast_node); 7835 7836 struct cil_db *test_db; 7837 cil_db_init(&test_db); 7838 7839 test_ast_node->parent = test_db->ast->root; 7840 test_ast_node->line = 1; 7841 7842 struct cil_tree_node *parse_current = test_tree->root->cl_head->cl_head; 7843 7844 struct cil_constrain *cons; 7845 cil_constrain_init(&cons); 7846 cil_classpermset_init(&cons->classpermset); 7847 cil_fill_classpermset(parse_current->next->cl_head, cons->classpermset); 7848 7849 int rc = cil_gen_expr_stack(parse_current->next->next->cl_head->next->next, CIL_MLSCONSTRAIN, &cons->expr); 7850 CuAssertIntEquals(tc, SEPOL_ERR, rc); 7851 } 7852 7853 void test_cil_gen_roleallow(CuTest *tc) { 7854 char *line[] = {"(", "roleallow", "staff_r", "sysadm_r", NULL}; 7855 7856 struct cil_tree *test_tree; 7857 gen_test_tree(&test_tree, line); 7858 7859 struct cil_tree_node *test_ast_node; 7860 cil_tree_node_init(&test_ast_node); 7861 7862 struct cil_db *test_db; 7863 cil_db_init(&test_db); 7864 7865 struct cil_tree_node *test_current; 7866 test_current = test_tree->root->cl_head->cl_head; 7867 7868 test_ast_node->parent = test_db->ast->root; 7869 test_ast_node->line = 1; 7870 7871 int rc = cil_gen_roleallow(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 7872 CuAssertPtrNotNull(tc, test_ast_node->data); 7873 CuAssertStrEquals(tc, ((struct cil_roleallow*)test_ast_node->data)->src_str, test_current->next->data); 7874 CuAssertStrEquals(tc, ((struct cil_roleallow*)test_ast_node->data)->tgt_str, test_current->next->next->data); 7875 CuAssertIntEquals(tc, test_ast_node->flavor, CIL_ROLEALLOW); 7876 CuAssertIntEquals(tc, SEPOL_OK, rc); 7877 } 7878 7879 void test_cil_gen_roleallow_dbnull_neg(CuTest *tc) { 7880 char *line[] = {"(", "roleallow", "foo", "bar", ")", NULL}; 7881 7882 struct cil_tree *test_tree; 7883 gen_test_tree(&test_tree, line); 7884 7885 struct cil_tree_node *test_ast_node; 7886 cil_tree_node_init(&test_ast_node); 7887 7888 struct cil_db *test_db = NULL; 7889 7890 int rc = cil_gen_roleallow(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 7891 CuAssertIntEquals(tc, SEPOL_ERR, rc); 7892 } 7893 7894 void test_cil_gen_roleallow_currnull_neg(CuTest *tc) { 7895 struct cil_tree_node *test_ast_node; 7896 cil_tree_node_init(&test_ast_node); 7897 7898 struct cil_db *test_db; 7899 cil_db_init(&test_db); 7900 7901 int rc = cil_gen_roleallow(test_db, NULL, test_ast_node); 7902 CuAssertIntEquals(tc, SEPOL_ERR, rc); 7903 } 7904 7905 void test_cil_gen_roleallow_astnull_neg(CuTest *tc) { 7906 char *line[] = {"(", "roleallow", "foo", "bar", ")", NULL}; 7907 7908 struct cil_tree *test_tree; 7909 gen_test_tree(&test_tree, line); 7910 7911 struct cil_db *test_db; 7912 cil_db_init(&test_db); 7913 7914 struct cil_tree_node *test_ast_node = NULL; 7915 7916 int rc = cil_gen_roleallow(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 7917 CuAssertIntEquals(tc, SEPOL_ERR, rc); 7918 } 7919 7920 void test_cil_gen_roleallow_srcnull_neg(CuTest *tc) { 7921 char *line[] = {"(", "roleallow", "foo", "bar", ")", NULL}; 7922 7923 struct cil_tree *test_tree; 7924 gen_test_tree(&test_tree, line); 7925 7926 test_tree->root->cl_head->cl_head->next = NULL; 7927 7928 struct cil_db *test_db; 7929 cil_db_init(&test_db); 7930 7931 struct cil_tree_node *test_ast_node; 7932 cil_tree_node_init(&test_ast_node); 7933 7934 int rc = cil_gen_roleallow(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 7935 CuAssertIntEquals(tc, SEPOL_ERR, rc); 7936 } 7937 7938 void test_cil_gen_roleallow_tgtnull_neg(CuTest *tc) { 7939 char *line[] = {"(", "roleallow", "foo", "bar", ")", NULL}; 7940 7941 struct cil_tree *test_tree; 7942 gen_test_tree(&test_tree, line); 7943 7944 test_tree->root->cl_head->cl_head->next->next = NULL; 7945 7946 struct cil_db *test_db; 7947 cil_db_init(&test_db); 7948 7949 struct cil_tree_node *test_ast_node; 7950 cil_tree_node_init(&test_ast_node); 7951 7952 int rc = cil_gen_roleallow(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 7953 CuAssertIntEquals(tc, SEPOL_ERR, rc); 7954 } 7955 7956 void test_cil_gen_roleallow_extra_neg(CuTest *tc) { 7957 char *line[] = {"(", "roleallow", "foo", "bar", "extra", ")", NULL}; 7958 7959 struct cil_tree *test_tree; 7960 gen_test_tree(&test_tree, line); 7961 7962 struct cil_db *test_db; 7963 cil_db_init(&test_db); 7964 7965 struct cil_tree_node *test_ast_node; 7966 cil_tree_node_init(&test_ast_node); 7967 7968 int rc = cil_gen_roleallow(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 7969 CuAssertIntEquals(tc, SEPOL_ERR, rc); 7970 } 7971 7972 void test_cil_gen_rolebounds(CuTest *tc) { 7973 char *line[] = {"(", "rolebounds", "role1", "role2", ")", NULL}; 7974 7975 struct cil_tree *test_tree; 7976 gen_test_tree(&test_tree, line); 7977 7978 struct cil_tree_node *test_ast_node; 7979 cil_tree_node_init(&test_ast_node); 7980 7981 struct cil_db *test_db; 7982 cil_db_init(&test_db); 7983 7984 test_ast_node->parent = test_db->ast->root; 7985 test_ast_node->line = 1; 7986 7987 int rc = cil_gen_rolebounds(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 7988 CuAssertIntEquals(tc, rc, SEPOL_OK); 7989 } 7990 7991 void test_cil_gen_rolebounds_norole1_neg(CuTest *tc) { 7992 char *line[] = {"(", "rolebounds", ")", NULL}; 7993 7994 struct cil_tree *test_tree; 7995 gen_test_tree(&test_tree, line); 7996 7997 struct cil_tree_node *test_ast_node; 7998 cil_tree_node_init(&test_ast_node); 7999 8000 struct cil_db *test_db; 8001 cil_db_init(&test_db); 8002 8003 test_ast_node->parent = test_db->ast->root; 8004 test_ast_node->line = 1; 8005 8006 int rc = cil_gen_rolebounds(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 8007 CuAssertIntEquals(tc, rc, SEPOL_ERR); 8008 } 8009 8010 void test_cil_gen_rolebounds_role1_inparens_neg(CuTest *tc) { 8011 char *line[] = {"(", "rolebounds", "(", "role1", ")", "role2", ")", NULL}; 8012 8013 struct cil_tree *test_tree; 8014 gen_test_tree(&test_tree, line); 8015 8016 struct cil_tree_node *test_ast_node; 8017 cil_tree_node_init(&test_ast_node); 8018 8019 struct cil_db *test_db; 8020 cil_db_init(&test_db); 8021 8022 test_ast_node->parent = test_db->ast->root; 8023 test_ast_node->line = 1; 8024 8025 int rc = cil_gen_rolebounds(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 8026 CuAssertIntEquals(tc, rc, SEPOL_ERR); 8027 } 8028 8029 void test_cil_gen_rolebounds_norole2_neg(CuTest *tc) { 8030 char *line[] = {"(", "rolebounds", "role1", ")", NULL}; 8031 8032 struct cil_tree *test_tree; 8033 gen_test_tree(&test_tree, line); 8034 8035 struct cil_tree_node *test_ast_node; 8036 cil_tree_node_init(&test_ast_node); 8037 8038 struct cil_db *test_db; 8039 cil_db_init(&test_db); 8040 8041 test_ast_node->parent = test_db->ast->root; 8042 test_ast_node->line = 1; 8043 8044 int rc = cil_gen_rolebounds(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 8045 CuAssertIntEquals(tc, rc, SEPOL_ERR); 8046 } 8047 8048 void test_cil_gen_rolebounds_role2_inparens_neg(CuTest *tc) { 8049 char *line[] = {"(", "rolebounds", "role1", "(", "role2", ")", ")", NULL}; 8050 8051 struct cil_tree *test_tree; 8052 gen_test_tree(&test_tree, line); 8053 8054 struct cil_tree_node *test_ast_node; 8055 cil_tree_node_init(&test_ast_node); 8056 8057 struct cil_db *test_db; 8058 cil_db_init(&test_db); 8059 8060 test_ast_node->parent = test_db->ast->root; 8061 test_ast_node->line = 1; 8062 8063 int rc = cil_gen_rolebounds(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 8064 CuAssertIntEquals(tc, rc, SEPOL_ERR); 8065 } 8066 8067 void test_cil_gen_rolebounds_extra_neg(CuTest *tc) { 8068 char *line[] = {"(", "rolebounds", "role1", "role2", "extra", ")", NULL}; 8069 8070 struct cil_tree *test_tree; 8071 gen_test_tree(&test_tree, line); 8072 8073 struct cil_tree_node *test_ast_node; 8074 cil_tree_node_init(&test_ast_node); 8075 8076 struct cil_db *test_db; 8077 cil_db_init(&test_db); 8078 8079 test_ast_node->parent = test_db->ast->root; 8080 test_ast_node->line = 1; 8081 8082 int rc = cil_gen_rolebounds(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 8083 CuAssertIntEquals(tc, rc, SEPOL_ERR); 8084 } 8085 8086 void test_cil_gen_rolebounds_dbnull_neg(CuTest *tc) { 8087 char *line[] = {"(", "rolebounds", "role1", "role2", ")", NULL}; 8088 8089 struct cil_tree *test_tree; 8090 gen_test_tree(&test_tree, line); 8091 8092 struct cil_tree_node *test_ast_node; 8093 cil_tree_node_init(&test_ast_node); 8094 8095 struct cil_db *test_db = NULL; 8096 8097 int rc = cil_gen_rolebounds(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 8098 CuAssertIntEquals(tc, rc, SEPOL_ERR); 8099 } 8100 8101 void test_cil_gen_rolebounds_currnull_neg(CuTest *tc) { 8102 char *line[] = {"(", ")", NULL}; 8103 8104 struct cil_tree *test_tree; 8105 gen_test_tree(&test_tree, line); 8106 8107 struct cil_tree_node *test_ast_node; 8108 cil_tree_node_init(&test_ast_node); 8109 8110 struct cil_db *test_db; 8111 cil_db_init(&test_db); 8112 8113 test_ast_node->parent = test_db->ast->root; 8114 test_ast_node->line = 1; 8115 8116 int rc = cil_gen_rolebounds(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 8117 CuAssertIntEquals(tc, rc, SEPOL_ERR); 8118 } 8119 8120 void test_cil_gen_rolebounds_astnull_neg(CuTest *tc) { 8121 char *line[] = {"(", "rolebounds", "role1", "role2", ")", NULL}; 8122 8123 struct cil_tree *test_tree; 8124 gen_test_tree(&test_tree, line); 8125 8126 struct cil_tree_node *test_ast_node = NULL; 8127 8128 struct cil_db *test_db; 8129 cil_db_init(&test_db); 8130 8131 int rc = cil_gen_rolebounds(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 8132 CuAssertIntEquals(tc, rc, SEPOL_ERR); 8133 } 8134 8135 void test_cil_gen_avrule(CuTest *tc) { 8136 char *line[] = {"(", "allow", "test", "foo", "(", "bar", "(", "read", "write", ")", ")", ")", NULL}; 8137 8138 struct cil_tree *test_tree; 8139 gen_test_tree(&test_tree, line); 8140 8141 struct cil_tree_node *test_ast_node; 8142 cil_tree_node_init(&test_ast_node); 8143 8144 struct cil_db *test_db; 8145 cil_db_init(&test_db); 8146 8147 test_ast_node->parent = test_db->ast->root; 8148 test_ast_node->line = 1; 8149 8150 struct cil_tree_node *test_current; 8151 test_current = test_tree->root->cl_head->cl_head; 8152 8153 int rc = cil_gen_avrule(test_current, test_ast_node, CIL_AVRULE_ALLOWED); 8154 CuAssertIntEquals(tc, SEPOL_OK, rc); 8155 CuAssertPtrNotNull(tc, test_ast_node->data); 8156 CuAssertStrEquals(tc, ((struct cil_avrule*)test_ast_node->data)->src_str, test_current->next->data); 8157 CuAssertStrEquals(tc, ((struct cil_avrule*)test_ast_node->data)->tgt_str, test_current->next->next->data); 8158 CuAssertStrEquals(tc, ((struct cil_avrule*)test_ast_node->data)->classpermset->class_str, test_current->next->next->next->cl_head->data); 8159 CuAssertIntEquals(tc, test_ast_node->flavor, CIL_AVRULE); 8160 CuAssertPtrNotNull(tc, ((struct cil_avrule*)test_ast_node->data)->classpermset->permset->perms_list_str); 8161 8162 struct cil_list_item *test_list = ((struct cil_avrule*)test_ast_node->data)->classpermset->permset->perms_list_str->head; 8163 test_current = test_current->next->next->next->cl_head->next->cl_head; 8164 8165 while(test_list != NULL) { 8166 CuAssertIntEquals(tc, test_list->flavor, CIL_AST_STR); 8167 CuAssertStrEquals(tc, test_list->data, test_current->data ); 8168 test_list = test_list->next; 8169 test_current = test_current->next; 8170 } 8171 } 8172 8173 void test_cil_gen_avrule_permset(CuTest *tc) { 8174 char *line[] = {"(", "allow", "test", "foo", "(", "bar", "permset", ")", ")", NULL}; 8175 8176 struct cil_tree *test_tree; 8177 gen_test_tree(&test_tree, line); 8178 8179 struct cil_tree_node *test_ast_node; 8180 cil_tree_node_init(&test_ast_node); 8181 8182 struct cil_db *test_db; 8183 cil_db_init(&test_db); 8184 8185 test_ast_node->parent = test_db->ast->root; 8186 test_ast_node->line = 1; 8187 8188 struct cil_tree_node *test_current; 8189 test_current = test_tree->root->cl_head->cl_head; 8190 8191 int rc = cil_gen_avrule(test_current, test_ast_node, CIL_AVRULE_ALLOWED); 8192 CuAssertIntEquals(tc, SEPOL_OK, rc); 8193 } 8194 8195 void test_cil_gen_avrule_permset_anon(CuTest *tc) { 8196 char *line[] = {"(", "allow", "test", "foo", "(", "bar", "(", "read", "write", ")", ")", ")", NULL}; 8197 8198 struct cil_tree *test_tree; 8199 gen_test_tree(&test_tree, line); 8200 8201 struct cil_tree_node *test_ast_node; 8202 cil_tree_node_init(&test_ast_node); 8203 8204 struct cil_db *test_db; 8205 cil_db_init(&test_db); 8206 8207 test_ast_node->parent = test_db->ast->root; 8208 test_ast_node->line = 1; 8209 8210 struct cil_tree_node *test_current; 8211 test_current = test_tree->root->cl_head->cl_head; 8212 8213 int rc = cil_gen_avrule(test_current, test_ast_node, CIL_AVRULE_ALLOWED); 8214 CuAssertIntEquals(tc, SEPOL_OK, rc); 8215 } 8216 8217 void test_cil_gen_avrule_extra_neg(CuTest *tc) { 8218 char *line[] = {"(", "allow", "test", "foo", "(", "bar", "permset", ")", "extra", ")", NULL}; 8219 8220 struct cil_tree *test_tree; 8221 gen_test_tree(&test_tree, line); 8222 8223 struct cil_tree_node *test_ast_node; 8224 cil_tree_node_init(&test_ast_node); 8225 8226 struct cil_db *test_db; 8227 cil_db_init(&test_db); 8228 8229 test_ast_node->parent = test_db->ast->root; 8230 test_ast_node->line = 1; 8231 8232 struct cil_tree_node *test_current; 8233 test_current = test_tree->root->cl_head->cl_head; 8234 8235 int rc = cil_gen_avrule(test_current, test_ast_node, CIL_AVRULE_ALLOWED); 8236 CuAssertIntEquals(tc, SEPOL_ERR, rc); 8237 } 8238 8239 void test_cil_gen_avrule_sourceparens(CuTest *tc) { 8240 char *line[] = {"(", "allow", "(", "test", ")", "foo", "(", "bar", "(", "read", "write", ")", ")", ")", NULL}; 8241 8242 struct cil_tree *test_tree; 8243 gen_test_tree(&test_tree, line); 8244 8245 struct cil_tree_node *test_ast_node; 8246 cil_tree_node_init(&test_ast_node); 8247 8248 struct cil_db *test_db; 8249 cil_db_init(&test_db); 8250 8251 test_ast_node->parent = test_db->ast->root; 8252 test_ast_node->line = 1; 8253 8254 struct cil_tree_node *test_current; 8255 test_current = test_tree->root->cl_head->cl_head; 8256 8257 int rc = cil_gen_avrule(test_current, test_ast_node, CIL_AVRULE_ALLOWED); 8258 CuAssertIntEquals(tc, SEPOL_ERR, rc); 8259 } 8260 8261 void test_cil_gen_avrule_sourceemptyparen_neg(CuTest *tc) { 8262 char *line[] = {"(", "allow", "(", ")", "bar", "file", "(", "read", ")", ")", NULL}; 8263 8264 struct cil_tree *test_tree; 8265 gen_test_tree(&test_tree, line); 8266 8267 struct cil_tree_node *test_ast_node; 8268 cil_tree_node_init(&test_ast_node); 8269 8270 struct cil_db *test_db; 8271 cil_db_init(&test_db); 8272 8273 test_ast_node->parent = test_db->ast->root; 8274 test_ast_node->line = 1; 8275 8276 struct cil_tree_node *test_current; 8277 test_current = test_tree->root->cl_head->cl_head; 8278 8279 int rc = cil_gen_avrule(test_current, test_ast_node, CIL_AVRULE_ALLOWED); 8280 CuAssertIntEquals(tc, SEPOL_ERR, rc); 8281 } 8282 8283 void test_cil_gen_avrule_targetparens(CuTest *tc) { 8284 char *line[] = {"(", "allow", "test", "(", "foo", ")", "bar", "(", "read", "write", ")", ")", NULL}; 8285 8286 struct cil_tree *test_tree; 8287 gen_test_tree(&test_tree, line); 8288 8289 struct cil_tree_node *test_ast_node; 8290 cil_tree_node_init(&test_ast_node); 8291 8292 struct cil_db *test_db; 8293 cil_db_init(&test_db); 8294 8295 test_ast_node->parent = test_db->ast->root; 8296 test_ast_node->line = 1; 8297 8298 struct cil_tree_node *test_current; 8299 test_current = test_tree->root->cl_head->cl_head; 8300 8301 int rc = cil_gen_avrule(test_current, test_ast_node, CIL_AVRULE_ALLOWED); 8302 CuAssertIntEquals(tc, SEPOL_ERR, rc); 8303 } 8304 8305 void test_cil_gen_avrule_targetemptyparen_neg(CuTest *tc) { 8306 char *line[] = {"(", "allow", "bar", "(", ")", "file", "(", "read", ")", ")", NULL}; 8307 8308 struct cil_tree *test_tree; 8309 gen_test_tree(&test_tree, line); 8310 8311 struct cil_tree_node *test_ast_node; 8312 cil_tree_node_init(&test_ast_node); 8313 8314 struct cil_db *test_db; 8315 cil_db_init(&test_db); 8316 8317 test_ast_node->parent = test_db->ast->root; 8318 test_ast_node->line = 1; 8319 8320 struct cil_tree_node *test_current; 8321 test_current = test_tree->root->cl_head->cl_head; 8322 8323 int rc = cil_gen_avrule(test_current, test_ast_node, CIL_AVRULE_ALLOWED); 8324 CuAssertIntEquals(tc, SEPOL_ERR, rc); 8325 } 8326 8327 void test_cil_gen_avrule_currnull_neg(CuTest *tc) { 8328 char *line[] = {"(", ")", NULL}; 8329 8330 struct cil_tree *test_tree; 8331 gen_test_tree(&test_tree, line); 8332 8333 struct cil_tree_node *test_ast_node; 8334 cil_tree_node_init(&test_ast_node); 8335 8336 struct cil_db *test_db; 8337 cil_db_init(&test_db); 8338 8339 test_ast_node->parent = test_db->ast->root; 8340 test_ast_node->line = 1; 8341 8342 struct cil_tree_node *test_current; 8343 test_current = test_tree->root->cl_head->cl_head; 8344 8345 int rc = cil_gen_avrule(test_current, test_ast_node, CIL_AVRULE_ALLOWED); 8346 CuAssertIntEquals(tc, SEPOL_ERR, rc); 8347 } 8348 8349 void test_cil_gen_avrule_astnull_neg(CuTest *tc) { 8350 char *line[] = {"(", "allow", "test", "foo", "bar", "(", "read", "write", ")", ")", NULL}; 8351 8352 struct cil_tree *test_tree; 8353 gen_test_tree(&test_tree, line); 8354 8355 struct cil_tree_node *test_ast_node = NULL; 8356 8357 struct cil_tree_node *test_current; 8358 test_current = test_tree->root->cl_head->cl_head; 8359 8360 int rc = cil_gen_avrule(test_current, test_ast_node, CIL_AVRULE_ALLOWED); 8361 CuAssertIntEquals(tc, SEPOL_ERR, rc); 8362 } 8363 8364 void test_cil_gen_avrule_sourcedomainnull_neg(CuTest *tc) { 8365 char *line[] = {"(", "allow", ")", NULL}; 8366 8367 struct cil_tree *test_tree; 8368 gen_test_tree(&test_tree, line); 8369 8370 struct cil_tree_node *test_ast_node; 8371 cil_tree_node_init(&test_ast_node); 8372 8373 struct cil_db *test_db; 8374 cil_db_init(&test_db); 8375 8376 test_ast_node->parent = test_db->ast->root; 8377 test_ast_node->line = 1; 8378 8379 struct cil_tree_node *test_current; 8380 test_current = test_tree->root->cl_head->cl_head; 8381 8382 int rc = cil_gen_avrule(test_current, test_ast_node, CIL_AVRULE_ALLOWED); 8383 CuAssertIntEquals(tc, SEPOL_ERR, rc); 8384 } 8385 8386 void test_cil_gen_avrule_targetdomainnull_neg(CuTest *tc) { 8387 char *line[] = {"(", "allow", "foo", ")", NULL}; 8388 8389 struct cil_tree *test_tree; 8390 gen_test_tree(&test_tree, line); 8391 8392 struct cil_tree_node *test_ast_node; 8393 cil_tree_node_init(&test_ast_node); 8394 8395 struct cil_db *test_db; 8396 cil_db_init(&test_db); 8397 8398 test_ast_node->parent = test_db->ast->root; 8399 test_ast_node->line = 1; 8400 8401 struct cil_tree_node *test_current; 8402 test_current = test_tree->root->cl_head->cl_head; 8403 8404 int rc = cil_gen_avrule(test_current, test_ast_node, CIL_AVRULE_ALLOWED); 8405 CuAssertIntEquals(tc, SEPOL_ERR, rc); 8406 } 8407 8408 void test_cil_gen_avrule_objectclassnull_neg(CuTest *tc) { 8409 char *line[] = {"(", "allow", "foo", "bar", ")", NULL}; 8410 8411 struct cil_tree *test_tree; 8412 gen_test_tree(&test_tree, line); 8413 8414 struct cil_tree_node *test_ast_node; 8415 cil_tree_node_init(&test_ast_node); 8416 8417 struct cil_db *test_db; 8418 cil_db_init(&test_db); 8419 8420 test_ast_node->parent = test_db->ast->root; 8421 test_ast_node->line = 1; 8422 8423 struct cil_tree_node *test_current; 8424 test_current = test_tree->root->cl_head->cl_head; 8425 8426 int rc = cil_gen_avrule(test_current, test_ast_node, CIL_AVRULE_ALLOWED); 8427 CuAssertIntEquals(tc, SEPOL_ERR, rc); 8428 } 8429 8430 void test_cil_gen_avrule_permsnull_neg(CuTest *tc) { 8431 char *line[] = {"(", "allow", "foo", "bar", "(", "baz", ")", ")", NULL}; 8432 8433 struct cil_tree *test_tree; 8434 gen_test_tree(&test_tree, line); 8435 8436 struct cil_tree_node *test_ast_node; 8437 cil_tree_node_init(&test_ast_node); 8438 8439 struct cil_db *test_db; 8440 cil_db_init(&test_db); 8441 8442 test_ast_node->parent = test_db->ast->root; 8443 test_ast_node->line = 1; 8444 8445 struct cil_tree_node *test_current; 8446 test_current = test_tree->root->cl_head->cl_head; 8447 8448 int rc = cil_gen_avrule(test_current, test_ast_node, CIL_AVRULE_ALLOWED); 8449 CuAssertIntEquals(tc, SEPOL_ERR, rc); 8450 } 8451 8452 void test_cil_gen_avrule_twolists_neg(CuTest *tc) { 8453 char *line[] = {"(", "allow", "test", "foo", "bar", "(", "write", ")", "(", "read", ")", NULL}; 8454 8455 struct cil_tree *test_tree; 8456 gen_test_tree(&test_tree, line); 8457 8458 struct cil_tree_node *test_ast_node; 8459 cil_tree_node_init(&test_ast_node); 8460 8461 struct cil_db *test_db; 8462 cil_db_init(&test_db); 8463 8464 test_ast_node->parent = test_db->ast->root; 8465 test_ast_node->line = 1; 8466 8467 struct cil_tree_node *test_current; 8468 test_current = test_tree->root->cl_head->cl_head; 8469 8470 int rc = cil_gen_avrule(test_current, test_ast_node, CIL_AVRULE_ALLOWED); 8471 CuAssertIntEquals(tc, SEPOL_ERR, rc); 8472 } 8473 8474 void test_cil_gen_type_rule_transition(CuTest *tc) { 8475 char *line[] = {"(", "typetransition", "foo", "bar", "file", "foobar", ")", NULL}; 8476 8477 struct cil_tree *test_tree; 8478 gen_test_tree(&test_tree, line); 8479 8480 struct cil_tree_node *test_ast_node; 8481 cil_tree_node_init(&test_ast_node); 8482 8483 struct cil_db *test_db; 8484 cil_db_init(&test_db); 8485 8486 test_ast_node->parent = test_db->ast->root; 8487 test_ast_node->line = 1; 8488 8489 int rc = cil_gen_type_rule(test_tree->root->cl_head->cl_head, test_ast_node, CIL_TYPE_TRANSITION); 8490 CuAssertIntEquals(tc, SEPOL_OK, rc); 8491 CuAssertStrEquals(tc, ((struct cil_type_rule*)test_ast_node->data)->src_str, test_tree->root->cl_head->cl_head->next->data); 8492 CuAssertStrEquals(tc, ((struct cil_type_rule*)test_ast_node->data)->tgt_str, test_tree->root->cl_head->cl_head->next->next->data); 8493 CuAssertStrEquals(tc, ((struct cil_type_rule*)test_ast_node->data)->obj_str, test_tree->root->cl_head->cl_head->next->next->next->data); 8494 CuAssertStrEquals(tc, ((struct cil_type_rule*)test_ast_node->data)->result_str, test_tree->root->cl_head->cl_head->next->next->next->next->data); 8495 CuAssertIntEquals(tc, ((struct cil_type_rule*)test_ast_node->data)->rule_kind, CIL_TYPE_TRANSITION); 8496 CuAssertIntEquals(tc, test_ast_node->flavor, CIL_TYPE_RULE); 8497 } 8498 8499 void test_cil_gen_type_rule_transition_currnull_neg(CuTest *tc) { 8500 struct cil_tree_node *test_ast_node; 8501 cil_tree_node_init(&test_ast_node); 8502 8503 int rc = cil_gen_type_rule(NULL, test_ast_node, CIL_TYPE_TRANSITION); 8504 CuAssertIntEquals(tc, SEPOL_ERR, rc); 8505 } 8506 8507 void test_cil_gen_type_rule_transition_astnull_neg(CuTest *tc) { 8508 char *line[] = {"(", "typetransition", "foo", "bar", "file", "foobar", ")", NULL}; 8509 8510 struct cil_tree *test_tree; 8511 gen_test_tree(&test_tree, line); 8512 8513 struct cil_tree_node *test_ast_node = NULL; 8514 8515 int rc = cil_gen_type_rule(test_tree->root->cl_head->cl_head, test_ast_node, CIL_TYPE_TRANSITION); 8516 CuAssertIntEquals(tc, SEPOL_ERR, rc); 8517 } 8518 8519 void test_cil_gen_type_rule_transition_srcnull_neg(CuTest *tc) { 8520 char *line[] = {"(", "typetransition", "foo", "bar", "file", "foobar", ")", NULL}; 8521 8522 struct cil_tree *test_tree; 8523 gen_test_tree(&test_tree, line); 8524 8525 struct cil_tree_node *test_ast_node; 8526 cil_tree_node_init(&test_ast_node); 8527 8528 struct cil_db *test_db; 8529 cil_db_init(&test_db); 8530 8531 test_ast_node->parent = test_db->ast->root; 8532 test_ast_node->line = 1; 8533 8534 test_tree->root->cl_head->cl_head->next = NULL; 8535 8536 int rc = cil_gen_type_rule(test_tree->root->cl_head->cl_head, test_ast_node, CIL_TYPE_TRANSITION); 8537 CuAssertIntEquals(tc, SEPOL_ERR, rc); 8538 } 8539 8540 void test_cil_gen_type_rule_transition_tgtnull_neg(CuTest *tc) { 8541 char *line[] = {"(", "typetransition", "foo", "bar", "file", "foobar", ")", NULL}; 8542 8543 struct cil_tree *test_tree; 8544 gen_test_tree(&test_tree, line); 8545 8546 struct cil_tree_node *test_ast_node; 8547 cil_tree_node_init(&test_ast_node); 8548 8549 struct cil_db *test_db; 8550 cil_db_init(&test_db); 8551 8552 test_ast_node->parent = test_db->ast->root; 8553 test_ast_node->line = 1; 8554 8555 test_tree->root->cl_head->cl_head->next->next = NULL; 8556 8557 int rc = cil_gen_type_rule(test_tree->root->cl_head->cl_head, test_ast_node, CIL_TYPE_TRANSITION); 8558 CuAssertIntEquals(tc, SEPOL_ERR, rc); 8559 } 8560 8561 void test_cil_gen_type_rule_transition_objnull_neg(CuTest *tc) { 8562 char *line[] = {"(", "typetransition", "foo", "bar", "file", "foobar", ")", NULL}; 8563 8564 struct cil_tree *test_tree; 8565 gen_test_tree(&test_tree, line); 8566 8567 struct cil_tree_node *test_ast_node; 8568 cil_tree_node_init(&test_ast_node); 8569 8570 struct cil_db *test_db; 8571 cil_db_init(&test_db); 8572 8573 test_ast_node->parent = test_db->ast->root; 8574 test_ast_node->line = 1; 8575 8576 test_tree->root->cl_head->cl_head->next->next->next = NULL; 8577 8578 int rc = cil_gen_type_rule(test_tree->root->cl_head->cl_head, test_ast_node, CIL_TYPE_TRANSITION); 8579 CuAssertIntEquals(tc, SEPOL_ERR, rc); 8580 } 8581 8582 void test_cil_gen_type_rule_transition_resultnull_neg(CuTest *tc) { 8583 char *line[] = {"(", "typetransition", "foo", "bar", "file", "foobar", ")", NULL}; 8584 8585 struct cil_tree *test_tree; 8586 gen_test_tree(&test_tree, line); 8587 8588 struct cil_tree_node *test_ast_node; 8589 cil_tree_node_init(&test_ast_node); 8590 8591 struct cil_db *test_db; 8592 cil_db_init(&test_db); 8593 8594 test_ast_node->parent = test_db->ast->root; 8595 test_ast_node->line = 1; 8596 8597 test_tree->root->cl_head->cl_head->next->next->next->next = NULL; 8598 8599 int rc = cil_gen_type_rule(test_tree->root->cl_head->cl_head, test_ast_node, CIL_TYPE_TRANSITION); 8600 CuAssertIntEquals(tc, SEPOL_ERR, rc); 8601 } 8602 8603 void test_cil_gen_type_rule_transition_extra_neg(CuTest *tc) { 8604 char *line[] = {"(", "typetransition", "foo", "bar", "file", "foobar", "extra", ")", NULL}; 8605 8606 struct cil_tree *test_tree; 8607 gen_test_tree(&test_tree, line); 8608 8609 struct cil_tree_node *test_ast_node; 8610 cil_tree_node_init(&test_ast_node); 8611 8612 struct cil_db *test_db; 8613 cil_db_init(&test_db); 8614 8615 test_ast_node->parent = test_db->ast->root; 8616 test_ast_node->line = 1; 8617 8618 int rc = cil_gen_type_rule(test_tree->root->cl_head->cl_head, test_ast_node, CIL_TYPE_TRANSITION); 8619 CuAssertIntEquals(tc, SEPOL_ERR, rc); 8620 } 8621 8622 void test_cil_gen_type_rule_change(CuTest *tc) { 8623 char *line[] = {"(", "typechange", "foo", "bar", "file", "foobar", ")", NULL}; 8624 8625 struct cil_tree *test_tree; 8626 gen_test_tree(&test_tree, line); 8627 8628 struct cil_tree_node *test_ast_node; 8629 cil_tree_node_init(&test_ast_node); 8630 8631 struct cil_db *test_db; 8632 cil_db_init(&test_db); 8633 8634 test_ast_node->parent = test_db->ast->root; 8635 test_ast_node->line = 1; 8636 8637 int rc = cil_gen_type_rule(test_tree->root->cl_head->cl_head, test_ast_node, CIL_TYPE_CHANGE); 8638 CuAssertIntEquals(tc, SEPOL_OK, rc); 8639 CuAssertStrEquals(tc, ((struct cil_type_rule*)test_ast_node->data)->src_str, test_tree->root->cl_head->cl_head->next->data); 8640 CuAssertStrEquals(tc, ((struct cil_type_rule*)test_ast_node->data)->tgt_str, test_tree->root->cl_head->cl_head->next->next->data); 8641 CuAssertStrEquals(tc, ((struct cil_type_rule*)test_ast_node->data)->obj_str, test_tree->root->cl_head->cl_head->next->next->next->data); 8642 CuAssertStrEquals(tc, ((struct cil_type_rule*)test_ast_node->data)->result_str, test_tree->root->cl_head->cl_head->next->next->next->next->data); 8643 CuAssertIntEquals(tc, ((struct cil_type_rule*)test_ast_node->data)->rule_kind, CIL_TYPE_CHANGE); 8644 CuAssertIntEquals(tc, test_ast_node->flavor, CIL_TYPE_RULE); 8645 } 8646 8647 void test_cil_gen_type_rule_change_currnull_neg(CuTest *tc) { 8648 struct cil_tree_node *test_ast_node; 8649 cil_tree_node_init(&test_ast_node); 8650 8651 int rc = cil_gen_type_rule(NULL, test_ast_node, CIL_TYPE_CHANGE); 8652 CuAssertIntEquals(tc, SEPOL_ERR, rc); 8653 } 8654 8655 void test_cil_gen_type_rule_change_astnull_neg(CuTest *tc) { 8656 char *line[] = {"(", "typechange", "foo", "bar", "file", "foobar", ")", NULL}; 8657 8658 struct cil_tree *test_tree; 8659 gen_test_tree(&test_tree, line); 8660 8661 struct cil_tree_node *test_ast_node = NULL; 8662 8663 int rc = cil_gen_type_rule(test_tree->root->cl_head->cl_head, test_ast_node, CIL_TYPE_CHANGE); 8664 CuAssertIntEquals(tc, SEPOL_ERR, rc); 8665 } 8666 8667 void test_cil_gen_type_rule_change_srcnull_neg(CuTest *tc) { 8668 char *line[] = {"(", "typechange", "foo", "bar", "file", "foobar", ")", NULL}; 8669 8670 struct cil_tree *test_tree; 8671 gen_test_tree(&test_tree, line); 8672 8673 struct cil_tree_node *test_ast_node; 8674 cil_tree_node_init(&test_ast_node); 8675 8676 struct cil_db *test_db; 8677 cil_db_init(&test_db); 8678 8679 test_ast_node->parent = test_db->ast->root; 8680 test_ast_node->line = 1; 8681 8682 test_tree->root->cl_head->cl_head->next = NULL; 8683 8684 int rc = cil_gen_type_rule(test_tree->root->cl_head->cl_head, test_ast_node, CIL_TYPE_CHANGE); 8685 CuAssertIntEquals(tc, SEPOL_ERR, rc); 8686 } 8687 8688 void test_cil_gen_type_rule_change_tgtnull_neg(CuTest *tc) { 8689 char *line[] = {"(", "typechange", "foo", "bar", "file", "foobar", ")", NULL}; 8690 8691 struct cil_tree *test_tree; 8692 gen_test_tree(&test_tree, line); 8693 8694 struct cil_tree_node *test_ast_node; 8695 cil_tree_node_init(&test_ast_node); 8696 8697 struct cil_db *test_db; 8698 cil_db_init(&test_db); 8699 8700 test_ast_node->parent = test_db->ast->root; 8701 test_ast_node->line = 1; 8702 8703 test_tree->root->cl_head->cl_head->next->next = NULL; 8704 8705 int rc = cil_gen_type_rule(test_tree->root->cl_head->cl_head, test_ast_node, CIL_TYPE_CHANGE); 8706 CuAssertIntEquals(tc, SEPOL_ERR, rc); 8707 } 8708 8709 void test_cil_gen_type_rule_change_objnull_neg(CuTest *tc) { 8710 char *line[] = {"(", "typechange", "foo", "bar", "file", "foobar", ")", NULL}; 8711 8712 struct cil_tree *test_tree; 8713 gen_test_tree(&test_tree, line); 8714 8715 struct cil_tree_node *test_ast_node; 8716 cil_tree_node_init(&test_ast_node); 8717 8718 struct cil_db *test_db; 8719 cil_db_init(&test_db); 8720 8721 test_ast_node->parent = test_db->ast->root; 8722 test_ast_node->line = 1; 8723 8724 test_tree->root->cl_head->cl_head->next->next->next = NULL; 8725 8726 int rc = cil_gen_type_rule(test_tree->root->cl_head->cl_head, test_ast_node, CIL_TYPE_CHANGE); 8727 CuAssertIntEquals(tc, SEPOL_ERR, rc); 8728 } 8729 8730 void test_cil_gen_type_rule_change_resultnull_neg(CuTest *tc) { 8731 char *line[] = {"(", "typechange", "foo", "bar", "file", "foobar", ")", NULL}; 8732 8733 struct cil_tree *test_tree; 8734 gen_test_tree(&test_tree, line); 8735 8736 struct cil_tree_node *test_ast_node; 8737 cil_tree_node_init(&test_ast_node); 8738 8739 struct cil_db *test_db; 8740 cil_db_init(&test_db); 8741 8742 test_ast_node->parent = test_db->ast->root; 8743 test_ast_node->line = 1; 8744 8745 test_tree->root->cl_head->cl_head->next->next->next->next = NULL; 8746 8747 int rc = cil_gen_type_rule(test_tree->root->cl_head->cl_head, test_ast_node, CIL_TYPE_CHANGE); 8748 CuAssertIntEquals(tc, SEPOL_ERR, rc); 8749 } 8750 8751 void test_cil_gen_type_rule_change_extra_neg(CuTest *tc) { 8752 char *line[] = {"(", "typechange", "foo", "bar", "file", "foobar", "extra", ")", NULL}; 8753 8754 struct cil_tree *test_tree; 8755 gen_test_tree(&test_tree, line); 8756 8757 struct cil_tree_node *test_ast_node; 8758 cil_tree_node_init(&test_ast_node); 8759 8760 struct cil_db *test_db; 8761 cil_db_init(&test_db); 8762 8763 test_ast_node->parent = test_db->ast->root; 8764 test_ast_node->line = 1; 8765 8766 int rc = cil_gen_type_rule(test_tree->root->cl_head->cl_head, test_ast_node, CIL_TYPE_CHANGE); 8767 CuAssertIntEquals(tc, SEPOL_ERR, rc); 8768 } 8769 8770 void test_cil_gen_type_rule_member(CuTest *tc) { 8771 char *line[] = {"(", "typemember", "foo", "bar", "file", "foobar", ")", NULL}; 8772 8773 struct cil_tree *test_tree; 8774 gen_test_tree(&test_tree, line); 8775 8776 struct cil_tree_node *test_ast_node; 8777 cil_tree_node_init(&test_ast_node); 8778 8779 struct cil_db *test_db; 8780 cil_db_init(&test_db); 8781 8782 test_ast_node->parent = test_db->ast->root; 8783 test_ast_node->line = 1; 8784 8785 int rc = cil_gen_type_rule(test_tree->root->cl_head->cl_head, test_ast_node, CIL_TYPE_MEMBER); 8786 CuAssertIntEquals(tc, SEPOL_OK, rc); 8787 CuAssertStrEquals(tc, ((struct cil_type_rule*)test_ast_node->data)->src_str, test_tree->root->cl_head->cl_head->next->data); 8788 CuAssertStrEquals(tc, ((struct cil_type_rule*)test_ast_node->data)->tgt_str, test_tree->root->cl_head->cl_head->next->next->data); 8789 CuAssertStrEquals(tc, ((struct cil_type_rule*)test_ast_node->data)->obj_str, test_tree->root->cl_head->cl_head->next->next->next->data); 8790 CuAssertStrEquals(tc, ((struct cil_type_rule*)test_ast_node->data)->result_str, test_tree->root->cl_head->cl_head->next->next->next->next->data); 8791 CuAssertIntEquals(tc, ((struct cil_type_rule*)test_ast_node->data)->rule_kind, CIL_TYPE_MEMBER); 8792 CuAssertIntEquals(tc, test_ast_node->flavor, CIL_TYPE_RULE); 8793 } 8794 8795 void test_cil_gen_type_rule_member_currnull_neg(CuTest *tc) { 8796 struct cil_tree_node *test_ast_node; 8797 cil_tree_node_init(&test_ast_node); 8798 8799 int rc = cil_gen_type_rule(NULL, test_ast_node, CIL_TYPE_MEMBER); 8800 CuAssertIntEquals(tc, SEPOL_ERR, rc); 8801 } 8802 8803 void test_cil_gen_type_rule_member_astnull_neg(CuTest *tc) { 8804 char *line[] = {"(", "typemember", "foo", "bar", "file", "foobar", ")", NULL}; 8805 8806 struct cil_tree *test_tree; 8807 gen_test_tree(&test_tree, line); 8808 8809 struct cil_tree_node *test_ast_node = NULL; 8810 8811 int rc = cil_gen_type_rule(test_tree->root->cl_head->cl_head, test_ast_node, CIL_TYPE_MEMBER); 8812 CuAssertIntEquals(tc, SEPOL_ERR, rc); 8813 } 8814 8815 void test_cil_gen_type_rule_member_srcnull_neg(CuTest *tc) { 8816 char *line[] = {"(", "typemember", "foo", "bar", "file", "foobar", ")", NULL}; 8817 8818 struct cil_tree *test_tree; 8819 gen_test_tree(&test_tree, line); 8820 8821 struct cil_tree_node *test_ast_node; 8822 cil_tree_node_init(&test_ast_node); 8823 8824 struct cil_db *test_db; 8825 cil_db_init(&test_db); 8826 8827 test_ast_node->parent = test_db->ast->root; 8828 test_ast_node->line = 1; 8829 8830 test_tree->root->cl_head->cl_head->next = NULL; 8831 8832 int rc = cil_gen_type_rule(test_tree->root->cl_head->cl_head, test_ast_node, CIL_TYPE_MEMBER); 8833 CuAssertIntEquals(tc, SEPOL_ERR, rc); 8834 } 8835 8836 void test_cil_gen_type_rule_member_tgtnull_neg(CuTest *tc) { 8837 char *line[] = {"(", "typemember", "foo", "bar", "file", "foobar", ")", NULL}; 8838 8839 struct cil_tree *test_tree; 8840 gen_test_tree(&test_tree, line); 8841 8842 struct cil_tree_node *test_ast_node; 8843 cil_tree_node_init(&test_ast_node); 8844 8845 struct cil_db *test_db; 8846 cil_db_init(&test_db); 8847 8848 test_ast_node->parent = test_db->ast->root; 8849 test_ast_node->line = 1; 8850 8851 test_tree->root->cl_head->cl_head->next->next = NULL; 8852 8853 int rc = cil_gen_type_rule(test_tree->root->cl_head->cl_head, test_ast_node, CIL_TYPE_MEMBER); 8854 CuAssertIntEquals(tc, SEPOL_ERR, rc); 8855 } 8856 8857 void test_cil_gen_type_rule_member_objnull_neg(CuTest *tc) { 8858 char *line[] = {"(", "typemember", "foo", "bar", "file", "foobar", ")", NULL}; 8859 8860 struct cil_tree *test_tree; 8861 gen_test_tree(&test_tree, line); 8862 8863 struct cil_tree_node *test_ast_node; 8864 cil_tree_node_init(&test_ast_node); 8865 8866 struct cil_db *test_db; 8867 cil_db_init(&test_db); 8868 8869 test_ast_node->parent = test_db->ast->root; 8870 test_ast_node->line = 1; 8871 8872 test_tree->root->cl_head->cl_head->next->next->next = NULL; 8873 8874 int rc = cil_gen_type_rule(test_tree->root->cl_head->cl_head, test_ast_node, CIL_TYPE_MEMBER); 8875 CuAssertIntEquals(tc, SEPOL_ERR, rc); 8876 } 8877 8878 void test_cil_gen_type_rule_member_resultnull_neg(CuTest *tc) { 8879 char *line[] = {"(", "typemember", "foo", "bar", "file", "foobar", ")", NULL}; 8880 8881 struct cil_tree *test_tree; 8882 gen_test_tree(&test_tree, line); 8883 8884 struct cil_tree_node *test_ast_node; 8885 cil_tree_node_init(&test_ast_node); 8886 8887 struct cil_db *test_db; 8888 cil_db_init(&test_db); 8889 8890 test_ast_node->parent = test_db->ast->root; 8891 test_ast_node->line = 1; 8892 8893 test_tree->root->cl_head->cl_head->next->next->next->next = NULL; 8894 8895 int rc = cil_gen_type_rule(test_tree->root->cl_head->cl_head, test_ast_node, CIL_TYPE_MEMBER); 8896 CuAssertIntEquals(tc, SEPOL_ERR, rc); 8897 } 8898 8899 void test_cil_gen_type_rule_member_extra_neg(CuTest *tc) { 8900 char *line[] = {"(", "typemember", "foo", "bar", "file", "foobar", "extra", ")", NULL}; 8901 8902 struct cil_tree *test_tree; 8903 gen_test_tree(&test_tree, line); 8904 8905 struct cil_tree_node *test_ast_node; 8906 cil_tree_node_init(&test_ast_node); 8907 8908 struct cil_db *test_db; 8909 cil_db_init(&test_db); 8910 8911 test_ast_node->parent = test_db->ast->root; 8912 test_ast_node->line = 1; 8913 8914 int rc = cil_gen_type_rule(test_tree->root->cl_head->cl_head, test_ast_node, CIL_TYPE_MEMBER); 8915 CuAssertIntEquals(tc, SEPOL_ERR, rc); 8916 } 8917 8918 void test_cil_gen_user(CuTest *tc) { 8919 char *line[] = {"(", "user", "sysadm", ")", NULL}; 8920 8921 struct cil_tree *test_tree; 8922 gen_test_tree(&test_tree, line); 8923 8924 struct cil_tree_node *test_ast_node; 8925 cil_tree_node_init(&test_ast_node); 8926 8927 struct cil_db *test_db; 8928 cil_db_init(&test_db); 8929 8930 test_ast_node->parent = test_db->ast->root; 8931 test_ast_node->line = 1; 8932 8933 int rc = cil_gen_user(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 8934 CuAssertIntEquals(tc, SEPOL_OK, rc); 8935 CuAssertIntEquals(tc, CIL_USER, test_ast_node->flavor); 8936 CuAssertPtrNotNull(tc, test_ast_node->data); 8937 CuAssertPtrEquals(tc, test_ast_node, ((struct cil_symtab_datum*)test_ast_node->data)->node); 8938 CuAssertStrEquals(tc, test_tree->root->cl_head->cl_head->next->data, ((struct cil_symtab_datum*)test_ast_node->data)->name); 8939 } 8940 8941 void test_cil_gen_user_dbnull_neg(CuTest *tc) { 8942 char *line[] = {"(", "user", ")", NULL}; 8943 8944 struct cil_tree *test_tree; 8945 gen_test_tree(&test_tree, line); 8946 8947 struct cil_tree_node *test_ast_node; 8948 cil_tree_node_init(&test_ast_node); 8949 8950 struct cil_db *test_db = NULL; 8951 8952 int rc = cil_gen_user(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 8953 CuAssertIntEquals(tc, SEPOL_ERR, rc); 8954 } 8955 8956 void test_cil_gen_user_currnull_neg(CuTest *tc) { 8957 char *line[] = {"(", ")", NULL}; 8958 8959 struct cil_tree *test_tree; 8960 gen_test_tree(&test_tree, line); 8961 8962 struct cil_tree_node *test_ast_node; 8963 cil_tree_node_init(&test_ast_node); 8964 8965 struct cil_db *test_db; 8966 cil_db_init(&test_db); 8967 8968 test_ast_node->parent = test_db->ast->root; 8969 test_ast_node->line = 1; 8970 8971 int rc = cil_gen_user(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 8972 CuAssertIntEquals(tc, SEPOL_ERR, rc); 8973 } 8974 8975 void test_cil_gen_user_astnull_neg(CuTest *tc) { 8976 char *line[] = {"(", "user", ")", NULL}; 8977 8978 struct cil_tree *test_tree; 8979 gen_test_tree(&test_tree, line); 8980 8981 struct cil_tree_node *test_ast_node = NULL; 8982 8983 struct cil_db *test_db; 8984 cil_db_init(&test_db); 8985 8986 int rc = cil_gen_user(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 8987 CuAssertIntEquals(tc, SEPOL_ERR, rc); 8988 } 8989 8990 void test_cil_gen_user_nouser_neg(CuTest *tc) { 8991 char *line[] = {"(", "user", ")", NULL}; 8992 8993 struct cil_tree *test_tree; 8994 gen_test_tree(&test_tree, line); 8995 8996 struct cil_tree_node *test_ast_node; 8997 cil_tree_node_init(&test_ast_node); 8998 8999 struct cil_db *test_db; 9000 cil_db_init(&test_db); 9001 9002 test_ast_node->parent = test_db->ast->root; 9003 test_ast_node->line = 1; 9004 9005 int rc = cil_gen_user(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9006 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9007 } 9008 9009 void test_cil_gen_user_xsinfo_neg(CuTest *tc) { 9010 char *line[] = {"(", "user", "sysadm", "xsinfo", ")", NULL}; 9011 9012 struct cil_tree *test_tree; 9013 gen_test_tree(&test_tree, line); 9014 9015 struct cil_tree_node *test_ast_node; 9016 cil_tree_node_init(&test_ast_node); 9017 9018 struct cil_db *test_db; 9019 cil_db_init(&test_db); 9020 9021 test_ast_node->parent = test_db->ast->root; 9022 test_ast_node->line = 1; 9023 9024 int rc = cil_gen_user(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9025 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9026 } 9027 9028 void test_cil_gen_userlevel(CuTest *tc) { 9029 char *line[] = {"(", "userlevel", "user_u", "lvl_l", ")", NULL}; 9030 9031 struct cil_tree *test_tree; 9032 gen_test_tree(&test_tree, line); 9033 9034 struct cil_tree_node *test_ast_node; 9035 cil_tree_node_init(&test_ast_node); 9036 9037 struct cil_db *test_db; 9038 cil_db_init(&test_db); 9039 9040 test_ast_node->parent = test_db->ast->root; 9041 test_ast_node->line = 1; 9042 9043 int rc = cil_gen_userlevel(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9044 CuAssertIntEquals(tc, SEPOL_OK, rc); 9045 } 9046 9047 void test_cil_gen_userlevel_anon_level(CuTest *tc) { 9048 char *line[] = {"(", "userlevel", "user_u", "(", "s0", "(", "c0", ")", ")", ")", NULL}; 9049 9050 struct cil_tree *test_tree; 9051 gen_test_tree(&test_tree, line); 9052 9053 struct cil_tree_node *test_ast_node; 9054 cil_tree_node_init(&test_ast_node); 9055 9056 struct cil_db *test_db; 9057 cil_db_init(&test_db); 9058 9059 test_ast_node->parent = test_db->ast->root; 9060 test_ast_node->line = 1; 9061 9062 int rc = cil_gen_userlevel(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9063 CuAssertIntEquals(tc, SEPOL_OK, rc); 9064 } 9065 9066 void test_cil_gen_userlevel_anon_level_neg(CuTest *tc) { 9067 char *line[] = {"(", "userlevel", "user_u", "(", "s0", "(", ")", ")", ")", NULL}; 9068 9069 struct cil_tree *test_tree; 9070 gen_test_tree(&test_tree, line); 9071 9072 struct cil_tree_node *test_ast_node; 9073 cil_tree_node_init(&test_ast_node); 9074 9075 struct cil_db *test_db; 9076 cil_db_init(&test_db); 9077 9078 test_ast_node->parent = test_db->ast->root; 9079 test_ast_node->line = 1; 9080 9081 int rc = cil_gen_userlevel(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9082 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9083 } 9084 9085 void test_cil_gen_userlevel_usernull_neg(CuTest *tc) { 9086 char *line[] = {"(", "userlevel", ")", NULL}; 9087 9088 struct cil_tree *test_tree; 9089 gen_test_tree(&test_tree, line); 9090 9091 struct cil_tree_node *test_ast_node; 9092 cil_tree_node_init(&test_ast_node); 9093 9094 struct cil_db *test_db; 9095 cil_db_init(&test_db); 9096 9097 test_ast_node->parent = test_db->ast->root; 9098 test_ast_node->line = 1; 9099 9100 int rc = cil_gen_userlevel(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9101 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9102 } 9103 9104 void test_cil_gen_userlevel_userrange_neg(CuTest *tc) { 9105 char *line[] = {"(", "userlevel", "(", "user", ")", "level", ")", NULL}; 9106 9107 struct cil_tree *test_tree; 9108 gen_test_tree(&test_tree, line); 9109 9110 struct cil_tree_node *test_ast_node; 9111 cil_tree_node_init(&test_ast_node); 9112 9113 struct cil_db *test_db; 9114 cil_db_init(&test_db); 9115 9116 test_ast_node->parent = test_db->ast->root; 9117 test_ast_node->line = 1; 9118 9119 int rc = cil_gen_userlevel(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9120 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9121 } 9122 9123 void test_cil_gen_userlevel_levelnull_neg(CuTest *tc) { 9124 char *line[] = {"(", "userlevel", "user_u", ")", NULL}; 9125 9126 struct cil_tree *test_tree; 9127 gen_test_tree(&test_tree, line); 9128 9129 struct cil_tree_node *test_ast_node; 9130 cil_tree_node_init(&test_ast_node); 9131 9132 struct cil_db *test_db; 9133 cil_db_init(&test_db); 9134 9135 test_ast_node->parent = test_db->ast->root; 9136 test_ast_node->line = 1; 9137 9138 int rc = cil_gen_userlevel(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9139 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9140 } 9141 9142 void test_cil_gen_userlevel_levelrangeempty_neg(CuTest *tc) { 9143 char *line[] = {"(", "userlevel", "user_u", "(", ")", ")", NULL}; 9144 9145 struct cil_tree *test_tree; 9146 gen_test_tree(&test_tree, line); 9147 9148 struct cil_tree_node *test_ast_node; 9149 cil_tree_node_init(&test_ast_node); 9150 9151 struct cil_db *test_db; 9152 cil_db_init(&test_db); 9153 9154 test_ast_node->parent = test_db->ast->root; 9155 test_ast_node->line = 1; 9156 9157 int rc = cil_gen_userlevel(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9158 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9159 } 9160 9161 void test_cil_gen_userlevel_extra_neg(CuTest *tc) { 9162 char *line[] = {"(", "userlevel", "user_u", "level", "extra", ")", NULL}; 9163 9164 struct cil_tree *test_tree; 9165 gen_test_tree(&test_tree, line); 9166 9167 struct cil_tree_node *test_ast_node; 9168 cil_tree_node_init(&test_ast_node); 9169 9170 struct cil_db *test_db; 9171 cil_db_init(&test_db); 9172 9173 test_ast_node->parent = test_db->ast->root; 9174 test_ast_node->line = 1; 9175 9176 int rc = cil_gen_userlevel(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9177 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9178 } 9179 9180 void test_cil_gen_userlevel_dbnull_neg(CuTest *tc) { 9181 char *line[] = {"(", "userlevel", "user", "level", ")", NULL}; 9182 9183 struct cil_tree *test_tree; 9184 gen_test_tree(&test_tree, line); 9185 9186 struct cil_tree_node *test_ast_node; 9187 cil_tree_node_init(&test_ast_node); 9188 9189 struct cil_db *test_db = NULL; 9190 9191 int rc = cil_gen_userlevel(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9192 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9193 } 9194 9195 void test_cil_gen_userlevel_currnull_neg(CuTest *tc) { 9196 char *line[] = {"(", ")", NULL}; 9197 9198 struct cil_tree *test_tree; 9199 gen_test_tree(&test_tree, line); 9200 9201 struct cil_tree_node *test_ast_node; 9202 cil_tree_node_init(&test_ast_node); 9203 9204 struct cil_db *test_db; 9205 cil_db_init(&test_db); 9206 9207 test_ast_node->parent = test_db->ast->root; 9208 test_ast_node->line = 1; 9209 9210 int rc = cil_gen_userlevel(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9211 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9212 } 9213 9214 void test_cil_gen_userlevel_astnull_neg(CuTest *tc) { 9215 char *line[] = {"(", "userlevel", "user", "level", ")", NULL}; 9216 9217 struct cil_tree *test_tree; 9218 gen_test_tree(&test_tree, line); 9219 9220 struct cil_tree_node *test_ast_node = NULL; 9221 9222 struct cil_db *test_db; 9223 cil_db_init(&test_db); 9224 9225 int rc = cil_gen_userlevel(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9226 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9227 } 9228 9229 void test_cil_gen_userrange_named(CuTest *tc) { 9230 char *line[] = {"(", "userrange", "user_u", "range", ")", NULL}; 9231 9232 struct cil_tree *test_tree; 9233 gen_test_tree(&test_tree, line); 9234 9235 struct cil_tree_node *test_ast_node; 9236 cil_tree_node_init(&test_ast_node); 9237 9238 struct cil_db *test_db; 9239 cil_db_init(&test_db); 9240 9241 test_ast_node->parent = test_db->ast->root; 9242 test_ast_node->line = 1; 9243 9244 int rc = cil_gen_userrange(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9245 CuAssertIntEquals(tc, SEPOL_OK, rc); 9246 } 9247 9248 void test_cil_gen_userrange_anon(CuTest *tc) { 9249 char *line[] = {"(", "userrange", "user_u", "(", "low", "high", ")", ")", NULL}; 9250 9251 struct cil_tree *test_tree; 9252 gen_test_tree(&test_tree, line); 9253 9254 struct cil_tree_node *test_ast_node; 9255 cil_tree_node_init(&test_ast_node); 9256 9257 struct cil_db *test_db; 9258 cil_db_init(&test_db); 9259 9260 test_ast_node->parent = test_db->ast->root; 9261 test_ast_node->line = 1; 9262 9263 int rc = cil_gen_userrange(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9264 CuAssertIntEquals(tc, SEPOL_OK, rc); 9265 } 9266 9267 void test_cil_gen_userrange_usernull_neg(CuTest *tc) { 9268 char *line[] = {"(", "userrange", ")", NULL}; 9269 9270 struct cil_tree *test_tree; 9271 gen_test_tree(&test_tree, line); 9272 9273 struct cil_tree_node *test_ast_node; 9274 cil_tree_node_init(&test_ast_node); 9275 9276 struct cil_db *test_db; 9277 cil_db_init(&test_db); 9278 9279 test_ast_node->parent = test_db->ast->root; 9280 test_ast_node->line = 1; 9281 9282 int rc = cil_gen_userrange(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9283 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9284 } 9285 9286 void test_cil_gen_userrange_anonuser_neg(CuTest *tc) { 9287 char *line[] = {"(", "userrange", "(", "user_u", ")", "(", "low", "high", ")", ")", NULL}; 9288 9289 struct cil_tree *test_tree; 9290 gen_test_tree(&test_tree, line); 9291 9292 struct cil_tree_node *test_ast_node; 9293 cil_tree_node_init(&test_ast_node); 9294 9295 struct cil_db *test_db; 9296 cil_db_init(&test_db); 9297 9298 test_ast_node->parent = test_db->ast->root; 9299 test_ast_node->line = 1; 9300 9301 int rc = cil_gen_userrange(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9302 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9303 } 9304 9305 void test_cil_gen_userrange_rangenamenull_neg(CuTest *tc) { 9306 char *line[] = {"(", "userrange", "user_u", ")", NULL}; 9307 9308 struct cil_tree *test_tree; 9309 gen_test_tree(&test_tree, line); 9310 9311 struct cil_tree_node *test_ast_node; 9312 cil_tree_node_init(&test_ast_node); 9313 9314 struct cil_db *test_db; 9315 cil_db_init(&test_db); 9316 9317 test_ast_node->parent = test_db->ast->root; 9318 test_ast_node->line = 1; 9319 9320 int rc = cil_gen_userrange(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9321 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9322 } 9323 9324 void test_cil_gen_userrange_anonrangeinvalid_neg(CuTest *tc) { 9325 char *line[] = {"(", "userrange", "user_u", "(", "low", ")", ")", NULL}; 9326 9327 struct cil_tree *test_tree; 9328 gen_test_tree(&test_tree, line); 9329 9330 struct cil_tree_node *test_ast_node; 9331 cil_tree_node_init(&test_ast_node); 9332 9333 struct cil_db *test_db; 9334 cil_db_init(&test_db); 9335 9336 test_ast_node->parent = test_db->ast->root; 9337 test_ast_node->line = 1; 9338 9339 int rc = cil_gen_userrange(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9340 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9341 } 9342 9343 void test_cil_gen_userrange_anonrangeempty_neg(CuTest *tc) { 9344 char *line[] = {"(", "userrange", "user_u", "(", ")", ")", NULL}; 9345 9346 struct cil_tree *test_tree; 9347 gen_test_tree(&test_tree, line); 9348 9349 struct cil_tree_node *test_ast_node; 9350 cil_tree_node_init(&test_ast_node); 9351 9352 struct cil_db *test_db; 9353 cil_db_init(&test_db); 9354 9355 test_ast_node->parent = test_db->ast->root; 9356 test_ast_node->line = 1; 9357 9358 int rc = cil_gen_userrange(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9359 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9360 } 9361 9362 void test_cil_gen_userrange_extra_neg(CuTest *tc) { 9363 char *line[] = {"(", "userrange", "user_u", "(", "low", "high", ")", "extra", ")", NULL}; 9364 9365 struct cil_tree *test_tree; 9366 gen_test_tree(&test_tree, line); 9367 9368 struct cil_tree_node *test_ast_node; 9369 cil_tree_node_init(&test_ast_node); 9370 9371 struct cil_db *test_db; 9372 cil_db_init(&test_db); 9373 9374 test_ast_node->parent = test_db->ast->root; 9375 test_ast_node->line = 1; 9376 9377 int rc = cil_gen_userrange(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9378 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9379 } 9380 9381 void test_cil_gen_userrange_dbnull_neg(CuTest *tc) { 9382 char *line[] = {"(", "userrange", "user", "range", ")", NULL}; 9383 9384 struct cil_tree *test_tree; 9385 gen_test_tree(&test_tree, line); 9386 9387 struct cil_tree_node *test_ast_node; 9388 cil_tree_node_init(&test_ast_node); 9389 9390 struct cil_db *test_db = NULL; 9391 9392 int rc = cil_gen_userrange(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9393 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9394 } 9395 9396 void test_cil_gen_userrange_currnull_neg(CuTest *tc) { 9397 char *line[] = {"(", ")", NULL}; 9398 9399 struct cil_tree *test_tree; 9400 gen_test_tree(&test_tree, line); 9401 9402 struct cil_tree_node *test_ast_node; 9403 cil_tree_node_init(&test_ast_node); 9404 9405 struct cil_db *test_db; 9406 cil_db_init(&test_db); 9407 9408 test_ast_node->parent = test_db->ast->root; 9409 test_ast_node->line = 1; 9410 9411 int rc = cil_gen_userrange(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9412 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9413 } 9414 9415 void test_cil_gen_userrange_astnull_neg(CuTest *tc) { 9416 char *line[] = {"(", "userrange", "user", "range", ")", NULL}; 9417 9418 struct cil_tree *test_tree; 9419 gen_test_tree(&test_tree, line); 9420 9421 struct cil_tree_node *test_ast_node = NULL; 9422 9423 struct cil_db *test_db; 9424 cil_db_init(&test_db); 9425 9426 int rc = cil_gen_userrange(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9427 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9428 } 9429 9430 void test_cil_gen_sensitivity(CuTest *tc) { 9431 char *line[] = {"(", "sensitivity", "s0", ")", NULL}; 9432 9433 struct cil_tree *test_tree; 9434 gen_test_tree(&test_tree, line); 9435 9436 struct cil_tree_node *test_ast_node; 9437 cil_tree_node_init(&test_ast_node); 9438 9439 struct cil_db *test_db; 9440 cil_db_init(&test_db); 9441 9442 test_ast_node->parent = test_db->ast->root; 9443 test_ast_node->line = 1; 9444 9445 int rc = cil_gen_sensitivity(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9446 CuAssertIntEquals(tc, SEPOL_OK, rc); 9447 CuAssertPtrNotNull(tc, test_ast_node->data); 9448 CuAssertIntEquals(tc, test_ast_node->flavor, CIL_SENS); 9449 9450 } 9451 9452 void test_cil_gen_sensitivity_dbnull_neg(CuTest *tc) { 9453 char *line[] = {"(", "sensitivity", "s0", ")", NULL}; 9454 9455 struct cil_tree *test_tree; 9456 gen_test_tree(&test_tree, line); 9457 9458 struct cil_tree_node *test_ast_node; 9459 cil_tree_node_init(&test_ast_node); 9460 9461 struct cil_db *test_db = NULL; 9462 9463 int rc = cil_gen_sensitivity(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9464 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9465 } 9466 9467 void test_cil_gen_sensitivity_currnull_neg(CuTest *tc) { 9468 struct cil_tree_node *test_ast_node; 9469 cil_tree_node_init(&test_ast_node); 9470 9471 struct cil_db *test_db; 9472 cil_db_init(&test_db); 9473 9474 int rc = cil_gen_sensitivity(test_db, NULL, test_ast_node); 9475 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9476 } 9477 9478 void test_cil_gen_sensitivity_astnull_neg(CuTest *tc) { 9479 char *line[] = {"(", "sensitivity", "s0", ")", NULL}; 9480 9481 struct cil_tree *test_tree; 9482 gen_test_tree(&test_tree, line); 9483 9484 struct cil_db *test_db; 9485 cil_db_init(&test_db); 9486 9487 struct cil_tree_node *test_ast_node = NULL; 9488 9489 int rc = cil_gen_sensitivity(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9490 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9491 } 9492 9493 void test_cil_gen_sensitivity_sensnull_neg(CuTest *tc) { 9494 char *line[] = {"(", "sensitivity", "s0", ")", NULL}; 9495 9496 struct cil_tree *test_tree; 9497 gen_test_tree(&test_tree, line); 9498 9499 test_tree->root->cl_head->cl_head->next = NULL; 9500 9501 struct cil_db *test_db; 9502 cil_db_init(&test_db); 9503 9504 struct cil_tree_node *test_ast_node; 9505 cil_tree_node_init(&test_ast_node); 9506 9507 int rc = cil_gen_sensitivity(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9508 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9509 } 9510 9511 void test_cil_gen_sensitivity_senslist_neg(CuTest *tc) { 9512 char *line[] = {"(", "sensitivity", "(", "s0", ")", ")", NULL}; 9513 9514 struct cil_tree *test_tree; 9515 gen_test_tree(&test_tree, line); 9516 9517 struct cil_db *test_db; 9518 cil_db_init(&test_db); 9519 9520 struct cil_tree_node *test_ast_node; 9521 cil_tree_node_init(&test_ast_node); 9522 9523 int rc = cil_gen_sensitivity(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9524 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9525 } 9526 9527 void test_cil_gen_sensitivity_extra_neg(CuTest *tc) { 9528 char *line[] = {"(", "sensitivity", "s0", "extra", ")", NULL}; 9529 9530 struct cil_tree *test_tree; 9531 gen_test_tree(&test_tree, line); 9532 9533 struct cil_db *test_db; 9534 cil_db_init(&test_db); 9535 9536 struct cil_tree_node *test_ast_node; 9537 cil_tree_node_init(&test_ast_node); 9538 9539 int rc = cil_gen_sensitivity(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9540 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9541 } 9542 9543 void test_cil_gen_sensalias(CuTest *tc) { 9544 char *line[] = {"(", "sensitivityalias", "s0", "alias", ")", NULL}; 9545 9546 struct cil_tree *test_tree; 9547 gen_test_tree(&test_tree, line); 9548 9549 struct cil_db *test_db; 9550 cil_db_init(&test_db); 9551 9552 struct cil_tree_node *test_ast_node; 9553 cil_tree_node_init(&test_ast_node); 9554 9555 test_ast_node->parent = test_db->ast->root; 9556 test_ast_node->line = 1; 9557 9558 int rc = cil_gen_sensalias(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9559 CuAssertIntEquals(tc, SEPOL_OK, rc); 9560 } 9561 9562 void test_cil_gen_sensalias_dbnull_neg(CuTest *tc) { 9563 char *line[] = {"(", "sensitivityalias", "s0", "alias", ")", NULL}; 9564 9565 struct cil_tree *test_tree; 9566 gen_test_tree(&test_tree, line); 9567 9568 struct cil_db *test_db = NULL; 9569 9570 struct cil_tree_node *test_ast_node; 9571 cil_tree_node_init(&test_ast_node); 9572 9573 int rc = cil_gen_sensalias(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9574 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9575 } 9576 9577 void test_cil_gen_sensalias_currnull_neg(CuTest *tc) { 9578 struct cil_tree_node *test_ast_node; 9579 cil_tree_node_init(&test_ast_node); 9580 9581 struct cil_db *test_db; 9582 cil_db_init(&test_db); 9583 9584 int rc = cil_gen_sensalias(test_db, NULL, test_ast_node); 9585 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9586 } 9587 9588 void test_cil_gen_sensalias_astnull_neg(CuTest *tc) { 9589 char *line[] = {"(", "sensitivityalias", "s0", "alias", ")", NULL}; 9590 9591 struct cil_tree *test_tree; 9592 gen_test_tree(&test_tree, line); 9593 9594 struct cil_db *test_db; 9595 cil_db_init (&test_db); 9596 9597 struct cil_tree_node *test_ast_node = NULL; 9598 9599 int rc = cil_gen_sensalias(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9600 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9601 } 9602 9603 void test_cil_gen_sensalias_sensnull_neg(CuTest *tc) { 9604 char *line[] = {"(", "sensitivityalias", "s0", "alias", ")", NULL}; 9605 9606 struct cil_tree *test_tree; 9607 gen_test_tree(&test_tree, line); 9608 9609 test_tree->root->cl_head->cl_head->next = NULL; 9610 9611 struct cil_db *test_db; 9612 cil_db_init(&test_db); 9613 struct cil_tree_node *test_ast_node; 9614 cil_tree_node_init(&test_ast_node); 9615 9616 int rc = cil_gen_sensalias(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9617 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9618 } 9619 9620 void test_cil_gen_sensalias_senslist_neg(CuTest *tc) { 9621 char *line[] = {"(", "sensitivityalias", "(", "s0", "s1", ")", "alias", ")", NULL}; 9622 9623 struct cil_tree *test_tree; 9624 gen_test_tree(&test_tree, line); 9625 9626 struct cil_db *test_db; 9627 cil_db_init(&test_db); 9628 9629 struct cil_tree_node *test_ast_node; 9630 cil_tree_node_init(&test_ast_node); 9631 9632 int rc = cil_gen_sensalias(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9633 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9634 } 9635 9636 void test_cil_gen_sensalias_aliasnull_neg(CuTest *tc) { 9637 char *line[] = {"(", "sensitivityalias", "s0", "alias", ")", NULL}; 9638 9639 struct cil_tree *test_tree; 9640 gen_test_tree(&test_tree, line); 9641 9642 test_tree->root->cl_head->cl_head->next->next = NULL; 9643 9644 struct cil_db *test_db; 9645 cil_db_init(&test_db); 9646 9647 struct cil_tree_node *test_ast_node; 9648 cil_tree_node_init(&test_ast_node); 9649 9650 int rc = cil_gen_sensalias(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9651 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9652 } 9653 9654 void test_cil_gen_sensalias_aliaslist_neg(CuTest *tc) { 9655 char *line[] = {"(", "sensitivityalias", "s0", "(", "alias", "alias2", ")", ")", NULL}; 9656 9657 struct cil_tree *test_tree; 9658 gen_test_tree(&test_tree, line); 9659 9660 struct cil_db *test_db; 9661 cil_db_init(&test_db); 9662 9663 struct cil_tree_node *test_ast_node; 9664 cil_tree_node_init(&test_ast_node); 9665 9666 int rc = cil_gen_sensalias(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9667 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9668 } 9669 9670 void test_cil_gen_sensalias_extra_neg(CuTest *tc) { 9671 char *line[] = {"(", "sensitivityalias", "s0", "alias", "extra", ")", NULL}; 9672 9673 struct cil_tree *test_tree; 9674 gen_test_tree(&test_tree, line); 9675 9676 struct cil_db *test_db; 9677 cil_db_init(&test_db); 9678 9679 struct cil_tree_node *test_ast_node; 9680 cil_tree_node_init(&test_ast_node); 9681 9682 int rc = cil_gen_sensalias(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9683 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9684 } 9685 9686 void test_cil_gen_category(CuTest *tc) { 9687 char *line[] = {"(", "category", "c0", ")", NULL}; 9688 9689 struct cil_tree *test_tree; 9690 gen_test_tree(&test_tree, line); 9691 9692 struct cil_db *test_db; 9693 cil_db_init(&test_db); 9694 9695 struct cil_tree_node *test_ast_node; 9696 cil_tree_node_init(&test_ast_node); 9697 9698 test_ast_node->parent = test_db->ast->root; 9699 test_ast_node->line = 1; 9700 9701 int rc = cil_gen_category(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9702 CuAssertIntEquals(tc, SEPOL_OK, rc); 9703 } 9704 9705 void test_cil_gen_category_dbnull_neg(CuTest *tc) { 9706 char *line[] = {"(", "category", "c0", ")", NULL}; 9707 9708 struct cil_tree *test_tree; 9709 gen_test_tree(&test_tree, line); 9710 9711 struct cil_db *test_db = NULL; 9712 9713 struct cil_tree_node *test_ast_node; 9714 cil_tree_node_init(&test_ast_node); 9715 9716 int rc = cil_gen_category(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9717 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9718 } 9719 9720 void test_cil_gen_category_astnull_neg(CuTest *tc) { 9721 char *line[] = {"(", "category", "c0", ")", NULL}; 9722 9723 struct cil_tree *test_tree; 9724 gen_test_tree(&test_tree, line); 9725 9726 struct cil_db *test_db; 9727 cil_db_init(&test_db); 9728 9729 struct cil_tree_node *test_ast_node = NULL; 9730 9731 int rc = cil_gen_category(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9732 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9733 } 9734 9735 void test_cil_gen_category_currnull_neg(CuTest *tc) { 9736 char *line[] = {"(", "category", "c0", ")", NULL}; 9737 9738 struct cil_tree *test_tree; 9739 gen_test_tree(&test_tree, line); 9740 9741 struct cil_db *test_db; 9742 cil_db_init(&test_db); 9743 9744 struct cil_tree_node *test_ast_node; 9745 cil_tree_node_init(&test_ast_node); 9746 9747 test_ast_node->parent = test_db->ast->root; 9748 test_ast_node->line = 1; 9749 9750 int rc = cil_gen_category(test_db, NULL, test_ast_node); 9751 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9752 } 9753 9754 void test_cil_gen_category_catnull_neg(CuTest *tc){ 9755 char *line[] = {"(", "category", "c0", ")", NULL}; 9756 9757 struct cil_tree *test_tree; 9758 gen_test_tree(&test_tree, line); 9759 9760 test_tree->root->cl_head->cl_head->next = NULL; 9761 9762 struct cil_db *test_db; 9763 cil_db_init(&test_db); 9764 9765 struct cil_tree_node *test_ast_node; 9766 cil_tree_node_init(&test_ast_node); 9767 9768 test_ast_node->parent = test_db->ast->root; 9769 test_ast_node->line = 1; 9770 9771 int rc = cil_gen_category(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9772 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9773 } 9774 9775 void test_cil_gen_category_catlist_neg(CuTest *tc){ 9776 char *line[] = {"(", "category", "(", "c0", ")", ")", NULL}; 9777 9778 struct cil_tree *test_tree; 9779 gen_test_tree(&test_tree, line); 9780 9781 struct cil_db *test_db; 9782 cil_db_init(&test_db); 9783 9784 struct cil_tree_node *test_ast_node; 9785 cil_tree_node_init(&test_ast_node); 9786 9787 test_ast_node->parent = test_db->ast->root; 9788 test_ast_node->line = 1; 9789 9790 int rc = cil_gen_category(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9791 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9792 } 9793 9794 void test_cil_gen_category_extra_neg(CuTest *tc) { 9795 char *line[] = {"(", "category", "c0", "extra", ")", NULL}; 9796 9797 struct cil_tree *test_tree; 9798 gen_test_tree(&test_tree, line); 9799 9800 struct cil_db *test_db; 9801 cil_db_init(&test_db); 9802 9803 struct cil_tree_node *test_ast_node; 9804 cil_tree_node_init(&test_ast_node); 9805 9806 test_ast_node->parent = test_db->ast->root; 9807 test_ast_node->line = 1; 9808 9809 int rc = cil_gen_category(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9810 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9811 } 9812 9813 void test_cil_gen_catset(CuTest *tc) { 9814 char *line[] = {"(", "categoryset", "somecats", "(", "c0", "c1", "c2", "(", "c3", "c4", ")", ")", ")", NULL}; 9815 9816 struct cil_tree *test_tree; 9817 gen_test_tree(&test_tree, line); 9818 9819 struct cil_db *test_db; 9820 cil_db_init(&test_db); 9821 9822 struct cil_tree_node *test_ast_node; 9823 cil_tree_node_init(&test_ast_node); 9824 9825 test_ast_node->parent = test_db->ast->root; 9826 test_ast_node->line = 1; 9827 9828 int rc = cil_gen_catset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9829 CuAssertIntEquals(tc, SEPOL_OK, rc); 9830 } 9831 9832 void test_cil_gen_catset_dbnull_neg(CuTest *tc) { 9833 char *line[] = {"(", "categoryset", "somecats", "(", "c0", "c1", "c2", "(", "c3", "c4", ")", ")", ")", NULL}; 9834 9835 struct cil_tree *test_tree; 9836 gen_test_tree(&test_tree, line); 9837 9838 struct cil_db *test_db = NULL; 9839 9840 struct cil_tree_node *test_ast_node; 9841 cil_tree_node_init(&test_ast_node); 9842 9843 int rc = cil_gen_catset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9844 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9845 } 9846 9847 void test_cil_gen_catset_currnull_neg(CuTest *tc) { 9848 char *line[] = {"(", "categoryset", "somecats", "(", "c0", "c1", "c2", "(", "c3", "c4", ")", ")", ")", NULL}; 9849 9850 struct cil_tree *test_tree; 9851 gen_test_tree(&test_tree, line); 9852 9853 struct cil_db *test_db; 9854 cil_db_init(&test_db); 9855 9856 struct cil_tree_node *test_ast_node; 9857 cil_tree_node_init(&test_ast_node); 9858 9859 test_ast_node->parent = test_db->ast->root; 9860 test_ast_node->line = 1; 9861 9862 int rc = cil_gen_catset(test_db, NULL, test_ast_node); 9863 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9864 } 9865 9866 void test_cil_gen_catset_astnull_neg(CuTest *tc) { 9867 char *line[] = {"(", "categoryset", "somecats", "(", "c0", "c1", "c2", "(", "c3", "c4", ")", ")", ")", NULL}; 9868 9869 struct cil_tree *test_tree; 9870 gen_test_tree(&test_tree, line); 9871 9872 struct cil_db *test_db; 9873 cil_db_init(&test_db); 9874 9875 struct cil_tree_node *test_ast_node = NULL; 9876 9877 int rc = cil_gen_catset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9878 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9879 } 9880 9881 void test_cil_gen_catset_namenull_neg(CuTest *tc) { 9882 char *line[] = {"(", "categoryset", "somecats", "(", "c0", "c1", "c2", "(", "c3", "c4", ")", ")", ")", NULL}; 9883 9884 struct cil_tree *test_tree; 9885 gen_test_tree(&test_tree, line); 9886 9887 test_tree->root->cl_head->cl_head->next = NULL; 9888 9889 struct cil_db *test_db; 9890 cil_db_init(&test_db); 9891 9892 struct cil_tree_node *test_ast_node; 9893 cil_tree_node_init(&test_ast_node); 9894 9895 test_ast_node->parent = test_db->ast->root; 9896 test_ast_node->line = 1; 9897 9898 int rc = cil_gen_catset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9899 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9900 } 9901 9902 void test_cil_gen_catset_setnull_neg(CuTest *tc) { 9903 char *line[] = {"(", "categoryset", "somecats", ")", NULL}; 9904 9905 struct cil_tree *test_tree; 9906 gen_test_tree(&test_tree, line); 9907 9908 struct cil_db *test_db; 9909 cil_db_init(&test_db); 9910 9911 struct cil_tree_node *test_ast_node; 9912 cil_tree_node_init(&test_ast_node); 9913 9914 test_ast_node->parent = test_db->ast->root; 9915 test_ast_node->line = 1; 9916 9917 int rc = cil_gen_catset(test_db, test_tree->root->cl_head->cl_head, test_ast_node); 9918 CuAssertIntEquals(tc, SEPOL_ERR, rc); 9919 } 9920 9921 void test_cil_gen_catset_namelist_neg(CuTest *tc) { //This should fail before gen_node call - additional syntax checks are needed 9922 char *line[] = {"(", "categoryset", "(", "somecats", ")", "(", "c0", "c1", "c2", "(", "c3", "c4", ")", ")", ")", NULL};