libpoldiff-tests.h File Reference

00055 {
00056         COMPONENT = 0, RULES_AVRULE, RULES_TERULE, RULES_ROLEALLOW, RULES_ROLETRANS,
00057         MLS_CATEGORY, MLS_LEVEL, MLS_RANGETRANS, MLS_USER
00058 } test_numbers_e;

00227 {
00228         poldiff_t *return_diff = NULL;
00229         uint32_t flags = POLDIFF_DIFF_ALL;
00230         apol_policy_path_t *mod_pol_path = NULL;
00231         apol_policy_path_t *orig_pol_path = NULL;
00232 
00233         orig_pol_path = apol_policy_path_create(APOL_POLICY_PATH_TYPE_MONOLITHIC, orig_base_path, NULL);
00234         if (!orig_pol_path) {
00235                 ERR(NULL, "%s", strerror(errno));
00236                 goto err;
00237         }
00238 
00239         mod_pol_path = apol_policy_path_create(APOL_POLICY_PATH_TYPE_MONOLITHIC, mod_base_path, NULL);
00240         if (!mod_pol_path) {
00241                 ERR(NULL, "%s", strerror(errno));
00242                 goto err;
00243         }
00244 
00245         orig_policy = apol_policy_create_from_policy_path(orig_pol_path, 0, NULL, NULL);
00246         if (!orig_policy) {
00247                 ERR(NULL, "%s", strerror(errno));
00248                 goto err;
00249         }
00250 
00251         mod_policy = apol_policy_create_from_policy_path(mod_pol_path, 0, NULL, NULL);
00252         if (!mod_policy) {
00253                 ERR(NULL, "%s", strerror(errno));
00254                 goto err;
00255         }
00256 
00257         if (!(return_diff = poldiff_create(orig_policy, mod_policy, NULL, NULL))) {
00258                 ERR(NULL, "%s", strerror(errno));
00259                 goto err;
00260         }
00261         if (poldiff_run(return_diff, flags)) {
00262                 goto err;
00263         }
00264         apol_policy_path_destroy(&orig_pol_path);
00265         apol_policy_path_destroy(&mod_pol_path);
00266         return return_diff;
00267       err:
00268         apol_policy_destroy(&orig_policy);
00269         apol_policy_destroy(&mod_policy);
00270         apol_policy_path_destroy(&orig_pol_path);
00271         apol_policy_path_destroy(&mod_pol_path);
00272         poldiff_destroy(&return_diff);
00273         return NULL;
00274 }

00216 {
00217         component_funcs_t *funcs = (component_funcs_t *) malloc(sizeof(component_funcs_t));
00218         funcs->get_diff_vector = get_diff_vector;
00219         funcs->get_name = get_name;
00220         funcs->get_form = get_form;
00221         funcs->get_added = get_added;
00222         funcs->get_removed = get_removed;
00223         return funcs;
00224 }

00084 {
00085         added_v = apol_vector_create(free);
00086         removed_v = apol_vector_create(free);
00087         modified_v = apol_vector_create(free);
00088         modified_name_only_v = apol_vector_create(free);
00089         switch (test_num) {
00090         case COMPONENT:
00091                 build_component_vecs(component_funcs);
00092                 break;
00093         case RULES_AVRULE:
00094                 build_avrule_vecs();
00095                 break;
00096         case RULES_TERULE:
00097                 build_terule_vecs();
00098                 break;
00099         case RULES_ROLEALLOW:
00100                 build_roleallow_vecs();
00101                 break;
00102         case RULES_ROLETRANS:
00103                 build_roletrans_vecs();
00104                 break;
00105         case MLS_CATEGORY:
00106                 build_category_vecs();
00107                 break;
00108         case MLS_LEVEL:
00109                 build_level_vecs();
00110                 break;
00111         case MLS_RANGETRANS:
00112                 build_rangetrans_vecs();
00113                 break;
00114         case MLS_USER:
00115                 build_user_vecs();
00116                 break;
00117         }
00118         size_t first_diff;
00119         apol_vector_t *intersect = NULL, *all_changes = NULL;
00120         if (!(all_changes = apol_vector_create(NULL))) {
00121                 goto err;
00122         }
00123         apol_vector_cat(all_changes, added_v);
00124         apol_vector_cat(all_changes, removed_v);
00125         apol_vector_cat(all_changes, modified_name_only_v);
00126         if (!
00127             (intersect =
00128              apol_vector_create_from_intersection(all_changes, poldiff_test_answers->correct_unchanged_v, compare_str, NULL))) {
00129                 goto err;
00130         }
00131         /* unchanged */
00132         CU_ASSERT_EQUAL(apol_vector_get_size(intersect), 0);
00133         /* added */
00134         apol_vector_sort(added_v, compare_str, NULL);
00135         apol_vector_sort(poldiff_test_answers->correct_added_v, compare_str, NULL);
00136         int test_result;
00137         CU_ASSERT_FALSE(test_result =
00138                         apol_vector_compare(added_v, poldiff_test_answers->correct_added_v, compare_str, NULL, &first_diff));
00139         if (test_result) {
00140                 print_test_failure(added_v, poldiff_test_answers->correct_added_v, first_diff, "Added");
00141         }
00142         /* removed */
00143         apol_vector_sort(removed_v, compare_str, NULL);
00144         apol_vector_sort(poldiff_test_answers->correct_removed_v, compare_str, NULL);
00145         CU_ASSERT_FALSE(test_result =
00146                         apol_vector_compare(removed_v, poldiff_test_answers->correct_removed_v, compare_str, NULL, &first_diff));
00147         if (test_result) {
00148                 print_test_failure(removed_v, poldiff_test_answers->correct_removed_v, first_diff, "Removed");
00149         }
00150         /* modified */
00151         apol_vector_sort(modified_v, compare_str, NULL);
00152         apol_vector_sort(poldiff_test_answers->correct_modified_v, compare_str, NULL);
00153         CU_ASSERT_FALSE(test_result =
00154                         apol_vector_compare(modified_v, poldiff_test_answers->correct_modified_v, compare_str, NULL, &first_diff));
00155         if (test_result) {
00156                 print_test_failure(modified_v, poldiff_test_answers->correct_modified_v, first_diff, "Modified");
00157         }
00158 
00159         apol_vector_destroy(&intersect);
00160         apol_vector_destroy(&added_v);
00161         apol_vector_destroy(&removed_v);
00162         apol_vector_destroy(&modified_name_only_v);
00163         apol_vector_destroy(&modified_v);
00164         apol_vector_destroy(&all_changes);
00165         return;
00166       err:
00167         apol_vector_destroy(&intersect);
00168         apol_vector_destroy(&added_v);
00169         apol_vector_destroy(&removed_v);
00170         apol_vector_destroy(&modified_name_only_v);
00171         apol_vector_destroy(&modified_v);
00172         apol_vector_destroy(&all_changes);
00173         CU_FAIL_FATAL("Could not initialize vectors for test");
00174 }

00046 {
00047         apol_vector_t *v = apol_vector_create(free);
00048         int i;
00049         for (i = 0; arr[i] != NULL; ++i) {
00050                 apol_vector_append(v, strdup(arr[i]));
00051         }
00052         return v;
00053 }

00277 {
00278         if (answers != NULL) {
00279                 apol_vector_destroy(&answers->correct_added_v);
00280                 apol_vector_destroy(&answers->correct_unchanged_v);
00281                 apol_vector_destroy(&answers->correct_removed_v);
00282                 apol_vector_destroy(&answers->correct_modified_v);
00283                 free(answers);
00284         }
00285 }

00056 {
00057         char *item = NULL, *str = NULL, *tmp = NULL;
00058         size_t i = 0, str_len = 0, tmp_len = 0;
00059         size_t num_elements = apol_vector_get_size(v);
00060         for (i = 0; v && i < num_elements; i++) {
00061                 item = apol_vector_get_element(v, i);
00062                 if (apol_str_appendf(&tmp, &tmp_len, "%s%s", sep, item) < 0) {
00063                         return NULL;
00064                 }
00065         }
00066         apol_str_trim(tmp);
00067         if (tmp) {
00068                 apol_str_appendf(&str, &str_len, "%s%s", pre, tmp);
00069         } else {
00070                 str = strdup("");
00071         }
00072         free(tmp);
00073         return str;
00074 }

00193 {
00194         char *str1 = strdup((char *)s1);
00195         char *str2 = strdup((char *)s2);
00196         apol_str_trim(str1);
00197         apol_str_trim(str2);
00198         int result = strcmp(str1, str2);
00199         free(str1);
00200         free(str2);
00201         return result;
00202 }

00205 {
00206         poldiff_test_answers_t *answers = (poldiff_test_answers_t *) malloc(sizeof(poldiff_test_answers_t));
00207         answers->correct_added_v = string_array_to_vector(added_arr);
00208         answers->correct_removed_v = string_array_to_vector(removed_arr);
00209         answers->correct_unchanged_v = string_array_to_vector(unchanged_arr);
00210         answers->correct_modified_v = string_array_to_vector(modified_arr);
00211         return answers;
00212 }

00177 {
00178         printf("\nTEST FAILED\n");
00179         size_t i;
00180         printf("--- ACTUAL RESULT (%s) -----\n", test_name);
00181         for (i = first_diff; i < apol_vector_get_size(actual); ++i) {
00182                 char *item = (char *)apol_vector_get_element(actual, i);
00183                 printf("\t%3d. %s\n", (int)i, item);
00184         }
00185         printf("--- EXPECTED RESULT (%s) ---\n", test_name);
00186         for (i = first_diff; i < apol_vector_get_size(expected); ++i) {
00187                 char *item = (char *)apol_vector_get_element(expected, i);
00188                 printf("\t%3d. %s\n", (int)i, item);
00189         }
00190 }

00077 {
00078         apol_vector_t *copy = apol_vector_create_from_vector(v, NULL, NULL, NULL);
00079         apol_vector_sort(copy, apol_str_strcmp, NULL);
00080         return copy;
00081 }