test_archive_match_path.c revision 238825
1/*- 2 * Copyright (c) 2012 Michihiro NAKAJIMA 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR 15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 17 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, 18 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 19 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 21 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 24 */ 25 26#include "test.h" 27__FBSDID("$FreeBSD$"); 28 29static void 30test_exclusion_mbs(void) 31{ 32 struct archive_entry *ae; 33 struct archive *m; 34 35 if (!assert((m = archive_match_new()) != NULL)) 36 return; 37 if (!assert((ae = archive_entry_new()) != NULL)) { 38 archive_match_free(m); 39 return; 40 } 41 42 /* Test for pattern "^aa*" */ 43 assertEqualIntA(m, 0, archive_match_exclude_pattern(m, "^aa*")); 44 45 /* Test with 'aa1234', which should be excluded. */ 46 archive_entry_copy_pathname(ae, "aa1234"); 47 failure("'aa1234' should be excluded"); 48 assertEqualInt(1, archive_match_path_excluded(m, ae)); 49 assertEqualInt(1, archive_match_excluded(m, ae)); 50 archive_entry_clear(ae); 51 archive_entry_copy_pathname_w(ae, L"aa1234"); 52 failure("'aa1234' should be excluded"); 53 assertEqualInt(1, archive_match_path_excluded(m, ae)); 54 assertEqualInt(1, archive_match_excluded(m, ae)); 55 56 /* Test with 'a1234', which should not be excluded. */ 57 archive_entry_copy_pathname(ae, "a1234"); 58 failure("'a1234' should not be excluded"); 59 assertEqualInt(0, archive_match_path_excluded(m, ae)); 60 assertEqualInt(0, archive_match_excluded(m, ae)); 61 archive_entry_clear(ae); 62 archive_entry_copy_pathname_w(ae, L"a1234"); 63 failure("'a1234' should not be excluded"); 64 assertEqualInt(0, archive_match_path_excluded(m, ae)); 65 assertEqualInt(0, archive_match_excluded(m, ae)); 66 67 /* Clean up. */ 68 archive_entry_free(ae); 69 archive_match_free(m); 70} 71 72static void 73test_exclusion_wcs(void) 74{ 75 struct archive_entry *ae; 76 struct archive *m; 77 78 if (!assert((m = archive_match_new()) != NULL)) 79 return; 80 if (!assert((ae = archive_entry_new()) != NULL)) { 81 archive_match_free(m); 82 return; 83 } 84 85 /* Test for pattern "^aa*" */ 86 assertEqualIntA(m, 0, archive_match_exclude_pattern_w(m, L"^aa*")); 87 88 /* Test with 'aa1234', which should be excluded. */ 89 archive_entry_copy_pathname(ae, "aa1234"); 90 failure("'aa1234' should be excluded"); 91 assertEqualInt(1, archive_match_path_excluded(m, ae)); 92 assertEqualInt(1, archive_match_excluded(m, ae)); 93 archive_entry_clear(ae); 94 archive_entry_copy_pathname_w(ae, L"aa1234"); 95 failure("'aa1234' should be excluded"); 96 assertEqualInt(1, archive_match_path_excluded(m, ae)); 97 assertEqualInt(1, archive_match_excluded(m, ae)); 98 99 /* Test with 'a1234', which should not be excluded. */ 100 archive_entry_copy_pathname(ae, "a1234"); 101 failure("'a1234' should not be excluded"); 102 assertEqualInt(0, archive_match_path_excluded(m, ae)); 103 assertEqualInt(0, archive_match_excluded(m, ae)); 104 archive_entry_clear(ae); 105 archive_entry_copy_pathname_w(ae, L"a1234"); 106 failure("'a1234' should not be excluded"); 107 assertEqualInt(0, archive_match_path_excluded(m, ae)); 108 assertEqualInt(0, archive_match_excluded(m, ae)); 109 110 /* Clean up. */ 111 archive_entry_free(ae); 112 archive_match_free(m); 113} 114 115static void 116exclusion_from_file(struct archive *m) 117{ 118 struct archive_entry *ae; 119 120 if (!assert((ae = archive_entry_new()) != NULL)) { 121 archive_match_free(m); 122 return; 123 } 124 125 /* Test with 'first', which should not be excluded. */ 126 archive_entry_copy_pathname(ae, "first"); 127 failure("'first' should not be excluded"); 128 assertEqualInt(0, archive_match_path_excluded(m, ae)); 129 assertEqualInt(0, archive_match_excluded(m, ae)); 130 archive_entry_clear(ae); 131 archive_entry_copy_pathname_w(ae, L"first"); 132 failure("'first' should not be excluded"); 133 assertEqualInt(0, archive_match_path_excluded(m, ae)); 134 assertEqualInt(0, archive_match_excluded(m, ae)); 135 136 /* Test with 'second', which should be excluded. */ 137 archive_entry_copy_pathname(ae, "second"); 138 failure("'second' should be excluded"); 139 assertEqualInt(1, archive_match_path_excluded(m, ae)); 140 assertEqualInt(1, archive_match_excluded(m, ae)); 141 archive_entry_clear(ae); 142 archive_entry_copy_pathname_w(ae, L"second"); 143 failure("'second' should be excluded"); 144 assertEqualInt(1, archive_match_path_excluded(m, ae)); 145 assertEqualInt(1, archive_match_excluded(m, ae)); 146 147 /* Test with 'third', which should not be excluded. */ 148 archive_entry_copy_pathname(ae, "third"); 149 failure("'third' should not be excluded"); 150 assertEqualInt(0, archive_match_path_excluded(m, ae)); 151 assertEqualInt(0, archive_match_excluded(m, ae)); 152 archive_entry_clear(ae); 153 archive_entry_copy_pathname_w(ae, L"third"); 154 failure("'third' should not be excluded"); 155 assertEqualInt(0, archive_match_path_excluded(m, ae)); 156 assertEqualInt(0, archive_match_excluded(m, ae)); 157 158 /* Test with 'four', which should be excluded. */ 159 archive_entry_copy_pathname(ae, "four"); 160 failure("'four' should be excluded"); 161 assertEqualInt(1, archive_match_path_excluded(m, ae)); 162 assertEqualInt(1, archive_match_excluded(m, ae)); 163 archive_entry_clear(ae); 164 archive_entry_copy_pathname_w(ae, L"four"); 165 failure("'four' should be excluded"); 166 assertEqualInt(1, archive_match_path_excluded(m, ae)); 167 assertEqualInt(1, archive_match_excluded(m, ae)); 168 169 /* Clean up. */ 170 archive_entry_free(ae); 171} 172 173static void 174test_exclusion_from_file_mbs(void) 175{ 176 struct archive *m; 177 178 /* Test1: read exclusion patterns from file */ 179 if (!assert((m = archive_match_new()) != NULL)) 180 return; 181 assertEqualIntA(m, 0, 182 archive_match_exclude_pattern_from_file(m, "exclusion", 0)); 183 exclusion_from_file(m); 184 /* Clean up. */ 185 archive_match_free(m); 186 187 /* Test2: read exclusion patterns in a null separator from file */ 188 if (!assert((m = archive_match_new()) != NULL)) 189 return; 190 /* Test for pattern reading from file */ 191 assertEqualIntA(m, 0, 192 archive_match_exclude_pattern_from_file(m, "exclusion_null", 1)); 193 exclusion_from_file(m); 194 /* Clean up. */ 195 archive_match_free(m); 196} 197 198static void 199test_exclusion_from_file_wcs(void) 200{ 201 struct archive *m; 202 203 /* Test1: read exclusion patterns from file */ 204 if (!assert((m = archive_match_new()) != NULL)) 205 return; 206 assertEqualIntA(m, 0, 207 archive_match_exclude_pattern_from_file_w(m, L"exclusion", 0)); 208 exclusion_from_file(m); 209 /* Clean up. */ 210 archive_match_free(m); 211 212 /* Test2: read exclusion patterns in a null separator from file */ 213 if (!assert((m = archive_match_new()) != NULL)) 214 return; 215 /* Test for pattern reading from file */ 216 assertEqualIntA(m, 0, 217 archive_match_exclude_pattern_from_file_w(m, L"exclusion_null", 1)); 218 exclusion_from_file(m); 219 /* Clean up. */ 220 archive_match_free(m); 221} 222 223static void 224test_inclusion_mbs(void) 225{ 226 struct archive_entry *ae; 227 struct archive *m; 228 const char *mp; 229 230 if (!assert((m = archive_match_new()) != NULL)) 231 return; 232 if (!assert((ae = archive_entry_new()) != NULL)) { 233 archive_match_free(m); 234 return; 235 } 236 237 /* Test for pattern "^aa*" */ 238 assertEqualIntA(m, 0, archive_match_include_pattern(m, "^aa*")); 239 240 /* Test with 'aa1234', which should not be excluded. */ 241 archive_entry_copy_pathname(ae, "aa1234"); 242 failure("'aa1234' should not be excluded"); 243 assertEqualInt(0, archive_match_path_excluded(m, ae)); 244 assertEqualInt(0, archive_match_excluded(m, ae)); 245 archive_entry_clear(ae); 246 archive_entry_copy_pathname_w(ae, L"aa1234"); 247 failure("'aa1234' should not be excluded"); 248 assertEqualInt(0, archive_match_path_excluded(m, ae)); 249 assertEqualInt(0, archive_match_excluded(m, ae)); 250 251 /* Test with 'a1234', which should be excluded. */ 252 archive_entry_copy_pathname(ae, "a1234"); 253 failure("'a1234' should be excluded"); 254 assertEqualInt(1, archive_match_path_excluded(m, ae)); 255 assertEqualInt(1, archive_match_excluded(m, ae)); 256 archive_entry_clear(ae); 257 archive_entry_copy_pathname_w(ae, L"a1234"); 258 failure("'a1234' should be excluded"); 259 assertEqualInt(1, archive_match_path_excluded(m, ae)); 260 assertEqualInt(1, archive_match_excluded(m, ae)); 261 262 /* Verify unmatched_inclusions. */ 263 assertEqualInt(0, archive_match_path_unmatched_inclusions(m)); 264 assertEqualIntA(m, ARCHIVE_EOF, 265 archive_match_path_unmatched_inclusions_next(m, &mp)); 266 267 /* Clean up. */ 268 archive_entry_free(ae); 269 archive_match_free(m); 270} 271 272static void 273test_inclusion_wcs(void) 274{ 275 struct archive_entry *ae; 276 struct archive *m; 277 const char *mp; 278 279 if (!assert((m = archive_match_new()) != NULL)) 280 return; 281 if (!assert((ae = archive_entry_new()) != NULL)) { 282 archive_match_free(m); 283 return; 284 } 285 286 /* Test for pattern "^aa*" */ 287 assertEqualIntA(m, 0, archive_match_include_pattern_w(m, L"^aa*")); 288 289 /* Test with 'aa1234', which should not be excluded. */ 290 archive_entry_copy_pathname(ae, "aa1234"); 291 failure("'aa1234' should not be excluded"); 292 assertEqualInt(0, archive_match_path_excluded(m, ae)); 293 assertEqualInt(0, archive_match_excluded(m, ae)); 294 archive_entry_clear(ae); 295 archive_entry_copy_pathname_w(ae, L"aa1234"); 296 failure("'aa1234' should not be excluded"); 297 assertEqualInt(0, archive_match_path_excluded(m, ae)); 298 assertEqualInt(0, archive_match_excluded(m, ae)); 299 300 /* Test with 'a1234', which should be excluded. */ 301 archive_entry_copy_pathname(ae, "a1234"); 302 failure("'a1234' should be excluded"); 303 assertEqualInt(1, archive_match_path_excluded(m, ae)); 304 assertEqualInt(1, archive_match_excluded(m, ae)); 305 archive_entry_clear(ae); 306 archive_entry_copy_pathname_w(ae, L"a1234"); 307 failure("'a1234' should be excluded"); 308 assertEqualInt(1, archive_match_path_excluded(m, ae)); 309 assertEqualInt(1, archive_match_excluded(m, ae)); 310 311 /* Verify unmatched_inclusions. */ 312 assertEqualInt(0, archive_match_path_unmatched_inclusions(m)); 313 assertEqualIntA(m, ARCHIVE_EOF, 314 archive_match_path_unmatched_inclusions_next(m, &mp)); 315 316 /* Clean up. */ 317 archive_entry_free(ae); 318 archive_match_free(m); 319} 320 321static void 322test_inclusion_from_file_mbs(void) 323{ 324 struct archive *m; 325 326 /* Test1: read inclusion patterns from file */ 327 if (!assert((m = archive_match_new()) != NULL)) 328 return; 329 assertEqualIntA(m, 0, 330 archive_match_include_pattern_from_file(m, "inclusion", 0)); 331 exclusion_from_file(m); 332 /* Clean up. */ 333 archive_match_free(m); 334 335 /* Test2: read inclusion patterns in a null separator from file */ 336 if (!assert((m = archive_match_new()) != NULL)) 337 return; 338 assertEqualIntA(m, 0, 339 archive_match_include_pattern_from_file(m, "inclusion_null", 1)); 340 exclusion_from_file(m); 341 /* Clean up. */ 342 archive_match_free(m); 343} 344 345static void 346test_inclusion_from_file_wcs(void) 347{ 348 struct archive *m; 349 350 /* Test1: read inclusion patterns from file */ 351 if (!assert((m = archive_match_new()) != NULL)) 352 return; 353 /* Test for pattern reading from file */ 354 assertEqualIntA(m, 0, 355 archive_match_include_pattern_from_file_w(m, L"inclusion", 0)); 356 exclusion_from_file(m); 357 /* Clean up. */ 358 archive_match_free(m); 359 360 /* Test2: read inclusion patterns in a null separator from file */ 361 if (!assert((m = archive_match_new()) != NULL)) 362 return; 363 /* Test for pattern reading from file */ 364 assertEqualIntA(m, 0, 365 archive_match_include_pattern_from_file_w(m, L"inclusion_null", 1)); 366 exclusion_from_file(m); 367 /* Clean up. */ 368 archive_match_free(m); 369} 370 371static void 372test_exclusion_and_inclusion(void) 373{ 374 struct archive_entry *ae; 375 struct archive *m; 376 const char *mp; 377 const wchar_t *wp; 378 379 if (!assert((m = archive_match_new()) != NULL)) 380 return; 381 if (!assert((ae = archive_entry_new()) != NULL)) { 382 archive_match_free(m); 383 return; 384 } 385 386 assertEqualIntA(m, 0, archive_match_exclude_pattern(m, "^aaa*")); 387 assertEqualIntA(m, 0, archive_match_include_pattern_w(m, L"^aa*")); 388 assertEqualIntA(m, 0, archive_match_include_pattern(m, "^a1*")); 389 390 /* Test with 'aa1234', which should not be excluded. */ 391 archive_entry_copy_pathname(ae, "aa1234"); 392 failure("'aa1234' should not be excluded"); 393 assertEqualInt(0, archive_match_path_excluded(m, ae)); 394 assertEqualInt(0, archive_match_excluded(m, ae)); 395 archive_entry_clear(ae); 396 archive_entry_copy_pathname_w(ae, L"aa1234"); 397 failure("'aa1234' should not be excluded"); 398 assertEqualInt(0, archive_match_path_excluded(m, ae)); 399 assertEqualInt(0, archive_match_excluded(m, ae)); 400 401 /* Test with 'aaa1234', which should be excluded. */ 402 archive_entry_copy_pathname(ae, "aaa1234"); 403 failure("'aaa1234' should be excluded"); 404 assertEqualInt(1, archive_match_path_excluded(m, ae)); 405 assertEqualInt(1, archive_match_excluded(m, ae)); 406 archive_entry_clear(ae); 407 archive_entry_copy_pathname_w(ae, L"aaa1234"); 408 failure("'aaa1234' should be excluded"); 409 assertEqualInt(1, archive_match_path_excluded(m, ae)); 410 assertEqualInt(1, archive_match_excluded(m, ae)); 411 412 /* Verify unmatched_inclusions. */ 413 assertEqualInt(1, archive_match_path_unmatched_inclusions(m)); 414 /* Verify unmatched inclusion patterns. */ 415 assertEqualIntA(m, ARCHIVE_OK, 416 archive_match_path_unmatched_inclusions_next(m, &mp)); 417 assertEqualString("^a1*", mp); 418 assertEqualIntA(m, ARCHIVE_EOF, 419 archive_match_path_unmatched_inclusions_next(m, &mp)); 420 /* Verify unmatched inclusion patterns again in Wide-Char. */ 421 assertEqualIntA(m, ARCHIVE_OK, 422 archive_match_path_unmatched_inclusions_next_w(m, &wp)); 423 assertEqualWString(L"^a1*", wp); 424 assertEqualIntA(m, ARCHIVE_EOF, 425 archive_match_path_unmatched_inclusions_next_w(m, &wp)); 426 427 /* Clean up. */ 428 archive_entry_free(ae); 429 archive_match_free(m); 430} 431 432DEFINE_TEST(test_archive_match_path) 433{ 434 /* Make exclusion sample files which contain exclusion patterns. */ 435 assertMakeFile("exclusion", 0666, "second\nfour\n"); 436 assertMakeBinFile("exclusion_null", 0666, 12, "second\0four\0"); 437 /* Make inclusion sample files which contain inclusion patterns. */ 438 assertMakeFile("inclusion", 0666, "first\nthird\n"); 439 assertMakeBinFile("inclusion_null", 0666, 12, "first\0third\0"); 440 441 test_exclusion_mbs(); 442 test_exclusion_wcs(); 443 test_exclusion_from_file_mbs(); 444 test_exclusion_from_file_wcs(); 445 test_inclusion_mbs(); 446 test_inclusion_wcs(); 447 test_inclusion_from_file_mbs(); 448 test_inclusion_from_file_wcs(); 449 test_exclusion_and_inclusion(); 450} 451