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
29 #define __LIBARCHIVE_BUILD 1
30 #include "archive_getdate.h"
31
32 static void
test_newer_time(void)33 test_newer_time(void)
34 {
35 struct archive_entry *ae;
36 struct archive *m;
37
38 if (!assert((m = archive_match_new()) != NULL))
39 return;
40 if (!assert((ae = archive_entry_new()) != NULL)) {
41 archive_match_free(m);
42 return;
43 }
44
45 assertEqualIntA(m, 0, archive_match_include_time(m,
46 ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_CTIME |
47 ARCHIVE_MATCH_NEWER, 7880, 0));
48
49 archive_entry_copy_pathname(ae, "file1");
50 archive_entry_set_mtime(ae, 7880, 0);
51 archive_entry_set_ctime(ae, 7880, 0);
52 failure("Both Its mtime and ctime should be excluded");
53 assertEqualInt(1, archive_match_time_excluded(m, ae));
54 assertEqualInt(1, archive_match_excluded(m, ae));
55 archive_entry_set_mtime(ae, 7879, 999);
56 archive_entry_set_ctime(ae, 7879, 999);
57 failure("Both Its mtime and ctime should be excluded");
58 assertEqualInt(1, archive_match_time_excluded(m, ae));
59 assertEqualInt(1, archive_match_excluded(m, ae));
60
61 archive_entry_set_mtime(ae, 7881, 0);
62 archive_entry_set_ctime(ae, 7881, 0);
63 failure("Both Its mtime and ctime should not be excluded");
64 assertEqualInt(0, archive_match_time_excluded(m, ae));
65 assertEqualInt(0, archive_match_excluded(m, ae));
66
67 archive_entry_set_mtime(ae, 7880, 1);
68 archive_entry_set_ctime(ae, 7880, 0);
69 failure("Its mtime should be excluded");
70 assertEqualInt(1, archive_match_time_excluded(m, ae));
71 assertEqualInt(1, archive_match_excluded(m, ae));
72
73 archive_entry_set_mtime(ae, 7880, 0);
74 archive_entry_set_ctime(ae, 7880, 1);
75 failure("Its ctime should be excluded");
76 assertEqualInt(1, archive_match_time_excluded(m, ae));
77 assertEqualInt(1, archive_match_excluded(m, ae));
78
79 /* Clean up. */
80 archive_entry_free(ae);
81 archive_match_free(m);
82 }
83
84 static void
test_newer_time_str(void)85 test_newer_time_str(void)
86 {
87 struct archive_entry *ae;
88 struct archive *m;
89 time_t now, t;
90
91 if (!assert((m = archive_match_new()) != NULL))
92 return;
93 if (!assert((ae = archive_entry_new()) != NULL)) {
94 archive_match_free(m);
95 return;
96 }
97
98 time(&now);
99
100 assertEqualIntA(m, 0, archive_match_include_date(m,
101 ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_CTIME |
102 ARCHIVE_MATCH_NEWER, "1980/2/1 0:0:0 UTC"));
103
104 /* Test1: Allow newer time. */
105 archive_entry_copy_pathname(ae, "file1");
106 t = __archive_get_date(now, "1980/2/1 0:0:0 UTC");
107 archive_entry_set_mtime(ae, t, 0);
108 archive_entry_set_ctime(ae, t, 0);
109 failure("Both Its mtime and ctime should be excluded");
110 assertEqualInt(1, archive_match_time_excluded(m, ae));
111 assertEqualInt(1, archive_match_excluded(m, ae));
112 t = __archive_get_date(now, "1980/1/1 0:0:0 UTC");
113 archive_entry_set_mtime(ae, t, 0);
114 archive_entry_set_ctime(ae, t, 0);
115 failure("Both Its mtime and ctime should be excluded");
116 assertEqualInt(1, archive_match_time_excluded(m, ae));
117 assertEqualInt(1, archive_match_excluded(m, ae));
118
119 t = __archive_get_date(now, "1980/2/1 0:0:1 UTC");
120 archive_entry_set_mtime(ae, t, 0);
121 archive_entry_set_ctime(ae, t, 0);
122 failure("Both Its mtime and ctime should not be excluded");
123 assertEqualInt(0, archive_match_time_excluded(m, ae));
124 assertEqualInt(0, archive_match_excluded(m, ae));
125
126 t = __archive_get_date(now, "1980/2/1 0:0:0 UTC");
127 archive_entry_set_mtime(ae, t, 1);
128 archive_entry_set_ctime(ae, t, 0);
129 failure("Its mtime should be excluded");
130 assertEqualInt(1, archive_match_time_excluded(m, ae));
131 assertEqualInt(1, archive_match_excluded(m, ae));
132
133 archive_entry_set_mtime(ae, t, 0);
134 archive_entry_set_ctime(ae, t, 1);
135 failure("Its ctime should be excluded");
136 assertEqualInt(1, archive_match_time_excluded(m, ae));
137 assertEqualInt(1, archive_match_excluded(m, ae));
138
139
140 /* Test2: Allow equal or newer time. */
141 assertEqualIntA(m, 0, archive_match_include_date(m,
142 ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_CTIME |
143 ARCHIVE_MATCH_NEWER | ARCHIVE_MATCH_EQUAL,
144 "1980/2/1 0:0:0 UTC"));
145
146 archive_entry_copy_pathname(ae, "file1");
147 t = __archive_get_date(now, "1980/2/1 0:0:0 UTC");
148 archive_entry_set_mtime(ae, t, 0);
149 archive_entry_set_ctime(ae, t, 0);
150 failure("Both Its mtime and ctime should not be excluded");
151 assertEqualInt(0, archive_match_time_excluded(m, ae));
152 assertEqualInt(0, archive_match_excluded(m, ae));
153 t = __archive_get_date(now, "1980/1/1 0:0:0 UTC");
154 archive_entry_set_mtime(ae, t, 0);
155 archive_entry_set_ctime(ae, t, 0);
156 failure("Both Its mtime and ctime should be excluded");
157 assertEqualInt(1, archive_match_time_excluded(m, ae));
158 assertEqualInt(1, archive_match_excluded(m, ae));
159
160 t = __archive_get_date(now, "1980/2/1 0:0:1 UTC");
161 archive_entry_set_mtime(ae, t, 0);
162 archive_entry_set_ctime(ae, t, 0);
163 failure("Both Its mtime and ctime should not be excluded");
164 assertEqualInt(0, archive_match_time_excluded(m, ae));
165 assertEqualInt(0, archive_match_excluded(m, ae));
166
167 /* Clean up. */
168 archive_entry_free(ae);
169 archive_match_free(m);
170 }
171
172 static void
test_newer_time_str_w(void)173 test_newer_time_str_w(void)
174 {
175 struct archive_entry *ae;
176 struct archive *m;
177 time_t now, t;
178
179 if (!assert((m = archive_match_new()) != NULL))
180 return;
181 if (!assert((ae = archive_entry_new()) != NULL)) {
182 archive_match_free(m);
183 return;
184 }
185
186 time(&now);
187
188 assertEqualIntA(m, 0, archive_match_include_date_w(m,
189 ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_CTIME |
190 ARCHIVE_MATCH_NEWER, L"1980/2/1 0:0:0 UTC"));
191
192 /* Test1: Allow newer time. */
193 archive_entry_copy_pathname(ae, "file1");
194 t = __archive_get_date(now, "1980/2/1 0:0:0 UTC");
195 archive_entry_set_mtime(ae, t, 0);
196 archive_entry_set_ctime(ae, t, 0);
197 failure("Both Its mtime and ctime should be excluded");
198 assertEqualInt(1, archive_match_time_excluded(m, ae));
199 assertEqualInt(1, archive_match_excluded(m, ae));
200 t = __archive_get_date(now, "1980/1/1 0:0:0 UTC");
201 archive_entry_set_mtime(ae, t, 0);
202 archive_entry_set_ctime(ae, t, 0);
203 failure("Both Its mtime and ctime should be excluded");
204 assertEqualInt(1, archive_match_time_excluded(m, ae));
205 assertEqualInt(1, archive_match_excluded(m, ae));
206
207 t = __archive_get_date(now, "1980/2/1 0:0:1 UTC");
208 archive_entry_set_mtime(ae, t, 0);
209 archive_entry_set_ctime(ae, t, 0);
210 failure("Both Its mtime and ctime should not be excluded");
211 assertEqualInt(0, archive_match_time_excluded(m, ae));
212 assertEqualInt(0, archive_match_excluded(m, ae));
213
214 t = __archive_get_date(now, "1980/2/1 0:0:0 UTC");
215 archive_entry_set_mtime(ae, t, 1);
216 archive_entry_set_ctime(ae, t, 0);
217 failure("Its mtime should be excluded");
218 assertEqualInt(1, archive_match_time_excluded(m, ae));
219 assertEqualInt(1, archive_match_excluded(m, ae));
220
221 archive_entry_set_mtime(ae, t, 0);
222 archive_entry_set_ctime(ae, t, 1);
223 failure("Its ctime should be excluded");
224 assertEqualInt(1, archive_match_time_excluded(m, ae));
225 assertEqualInt(1, archive_match_excluded(m, ae));
226
227
228 /* Test2: Allow equal or newer time. */
229 assertEqualIntA(m, 0, archive_match_include_date_w(m,
230 ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_CTIME |
231 ARCHIVE_MATCH_NEWER | ARCHIVE_MATCH_EQUAL,
232 L"1980/2/1 0:0:0 UTC"));
233
234 archive_entry_copy_pathname(ae, "file1");
235 t = __archive_get_date(now, "1980/2/1 0:0:0 UTC");
236 archive_entry_set_mtime(ae, t, 0);
237 archive_entry_set_ctime(ae, t, 0);
238 failure("Both Its mtime and ctime should not be excluded");
239 assertEqualInt(0, archive_match_time_excluded(m, ae));
240 assertEqualInt(0, archive_match_excluded(m, ae));
241 t = __archive_get_date(now, "1980/1/1 0:0:0 UTC");
242 archive_entry_set_mtime(ae, t, 0);
243 archive_entry_set_ctime(ae, t, 0);
244 failure("Both Its mtime and ctime should be excluded");
245 assertEqualInt(1, archive_match_time_excluded(m, ae));
246 assertEqualInt(1, archive_match_excluded(m, ae));
247
248 t = __archive_get_date(now, "1980/2/1 0:0:1 UTC");
249 archive_entry_set_mtime(ae, t, 0);
250 archive_entry_set_ctime(ae, t, 0);
251 failure("Both Its mtime and ctime should not be excluded");
252 assertEqualInt(0, archive_match_time_excluded(m, ae));
253 assertEqualInt(0, archive_match_excluded(m, ae));
254
255 /* Clean up. */
256 archive_entry_free(ae);
257 archive_match_free(m);
258 }
259
260 static void
test_newer_mtime_than_file_mbs(void)261 test_newer_mtime_than_file_mbs(void)
262 {
263 struct archive *a;
264 struct archive_entry *ae;
265 struct archive *m;
266
267 if (!assert((m = archive_match_new()) != NULL))
268 return;
269 if (!assert((ae = archive_entry_new()) != NULL)) {
270 archive_match_free(m);
271 return;
272 }
273 if (!assert((a = archive_read_disk_new()) != NULL)) {
274 archive_match_free(m);
275 archive_entry_free(ae);
276 return;
277 }
278
279 /*
280 * Test: newer mtime than a file specified in MBS file name.
281 */
282 assertEqualIntA(m, 0, archive_match_include_file_time(m,
283 ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_NEWER, "mid_mtime"));
284
285 /* Verify 'old_mtime' file. */
286 archive_entry_copy_pathname(ae, "old_mtime");
287 assertEqualIntA(a, ARCHIVE_OK,
288 archive_read_disk_entry_from_file(a, ae, -1, NULL));
289 failure("old_mtime should be excluded");
290 assertEqualInt(1, archive_match_time_excluded(m, ae));
291 assertEqualInt(1, archive_match_excluded(m, ae));
292
293 /* Verify 'mid_mtime' file. */
294 archive_entry_clear(ae);
295 archive_entry_copy_pathname(ae, "mid_mtime");
296 assertEqualIntA(a, ARCHIVE_OK,
297 archive_read_disk_entry_from_file(a, ae, -1, NULL));
298 failure("mid_mtime should be excluded");
299 assertEqualInt(1, archive_match_time_excluded(m, ae));
300 assertEqualInt(1, archive_match_excluded(m, ae));
301
302 /* Verify 'new_mtime' file. */
303 archive_entry_clear(ae);
304 archive_entry_copy_pathname(ae, "new_mtime");
305 assertEqualIntA(a, ARCHIVE_OK,
306 archive_read_disk_entry_from_file(a, ae, -1, NULL));
307 failure("new_mtime should not be excluded");
308 assertEqualInt(0, archive_match_time_excluded(m, ae));
309 assertEqualInt(0, archive_match_excluded(m, ae));
310
311 /* Clean up. */
312 archive_read_free(a);
313 archive_entry_free(ae);
314 archive_match_free(m);
315 }
316
317 static void
test_newer_ctime_than_file_mbs(void)318 test_newer_ctime_than_file_mbs(void)
319 {
320 struct archive *a;
321 struct archive_entry *ae;
322 struct archive *m;
323
324 if (!assert((m = archive_match_new()) != NULL))
325 return;
326 if (!assert((ae = archive_entry_new()) != NULL)) {
327 archive_match_free(m);
328 return;
329 }
330 if (!assert((a = archive_read_disk_new()) != NULL)) {
331 archive_match_free(m);
332 archive_entry_free(ae);
333 return;
334 }
335
336 /*
337 * Test: newer ctime than a file specified in MBS file name.
338 */
339 assertEqualIntA(m, 0, archive_match_include_file_time(m,
340 ARCHIVE_MATCH_CTIME | ARCHIVE_MATCH_NEWER, "mid_ctime"));
341
342 /* Verify 'old_ctime' file. */
343 archive_entry_copy_pathname(ae, "old_ctime");
344 assertEqualIntA(a, ARCHIVE_OK,
345 archive_read_disk_entry_from_file(a, ae, -1, NULL));
346 failure("old_ctime should be excluded");
347 assertEqualInt(1, archive_match_time_excluded(m, ae));
348 assertEqualInt(1, archive_match_excluded(m, ae));
349
350 /* Verify 'mid_ctime' file. */
351 archive_entry_clear(ae);
352 archive_entry_copy_pathname(ae, "mid_ctime");
353 assertEqualIntA(a, ARCHIVE_OK,
354 archive_read_disk_entry_from_file(a, ae, -1, NULL));
355 failure("mid_ctime should be excluded");
356 assertEqualInt(1, archive_match_time_excluded(m, ae));
357 assertEqualInt(1, archive_match_excluded(m, ae));
358
359 /* Verify 'new_ctime' file. */
360 archive_entry_clear(ae);
361 archive_entry_copy_pathname(ae, "new_ctime");
362 assertEqualIntA(a, ARCHIVE_OK,
363 archive_read_disk_entry_from_file(a, ae, -1, NULL));
364 failure("new_ctime should not be excluded");
365 assertEqualInt(0, archive_match_time_excluded(m, ae));
366 assertEqualInt(0, archive_match_excluded(m, ae));
367
368 /* Clean up. */
369 archive_read_free(a);
370 archive_entry_free(ae);
371 archive_match_free(m);
372 }
373
374 static void
test_newer_mtime_than_file_wcs(void)375 test_newer_mtime_than_file_wcs(void)
376 {
377 struct archive *a;
378 struct archive_entry *ae;
379 struct archive *m;
380
381 if (!assert((m = archive_match_new()) != NULL))
382 return;
383 if (!assert((ae = archive_entry_new()) != NULL)) {
384 archive_match_free(m);
385 return;
386 }
387 if (!assert((a = archive_read_disk_new()) != NULL)) {
388 archive_match_free(m);
389 archive_entry_free(ae);
390 return;
391 }
392
393 /*
394 * Test: newer mtime than a file specified in WCS file name.
395 */
396 assertEqualIntA(m, 0, archive_match_include_file_time_w(m,
397 ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_NEWER, L"mid_mtime"));
398
399 /* Verify 'old_mtime' file. */
400 archive_entry_copy_pathname(ae, "old_mtime");
401 assertEqualIntA(a, ARCHIVE_OK,
402 archive_read_disk_entry_from_file(a, ae, -1, NULL));
403 failure("old_mtime should be excluded");
404 assertEqualInt(1, archive_match_time_excluded(m, ae));
405 assertEqualInt(1, archive_match_excluded(m, ae));
406
407 /* Verify 'mid_mtime' file. */
408 archive_entry_clear(ae);
409 archive_entry_copy_pathname(ae, "mid_mtime");
410 assertEqualIntA(a, ARCHIVE_OK,
411 archive_read_disk_entry_from_file(a, ae, -1, NULL));
412 failure("mid_mtime should be excluded");
413 assertEqualInt(1, archive_match_time_excluded(m, ae));
414 assertEqualInt(1, archive_match_excluded(m, ae));
415
416 /* Verify 'new_mtime' file. */
417 archive_entry_clear(ae);
418 archive_entry_copy_pathname(ae, "new_mtime");
419 assertEqualIntA(a, ARCHIVE_OK,
420 archive_read_disk_entry_from_file(a, ae, -1, NULL));
421 failure("new_mtime should not be excluded");
422 assertEqualInt(0, archive_match_time_excluded(m, ae));
423 assertEqualInt(0, archive_match_excluded(m, ae));
424
425 /* Clean up. */
426 archive_read_free(a);
427 archive_entry_free(ae);
428 archive_match_free(m);
429 }
430
431 static void
test_newer_ctime_than_file_wcs(void)432 test_newer_ctime_than_file_wcs(void)
433 {
434 struct archive *a;
435 struct archive_entry *ae;
436 struct archive *m;
437
438 if (!assert((m = archive_match_new()) != NULL))
439 return;
440 if (!assert((ae = archive_entry_new()) != NULL)) {
441 archive_match_free(m);
442 return;
443 }
444 if (!assert((a = archive_read_disk_new()) != NULL)) {
445 archive_match_free(m);
446 archive_entry_free(ae);
447 return;
448 }
449
450 /*
451 * Test: newer ctime than a file specified in WCS file name.
452 */
453 assertEqualIntA(m, 0, archive_match_include_file_time_w(m,
454 ARCHIVE_MATCH_CTIME | ARCHIVE_MATCH_NEWER, L"mid_ctime"));
455
456 /* Verify 'old_ctime' file. */
457 archive_entry_clear(ae);
458 archive_entry_copy_pathname(ae, "old_ctime");
459 assertEqualIntA(a, ARCHIVE_OK,
460 archive_read_disk_entry_from_file(a, ae, -1, NULL));
461 failure("old_ctime should be excluded");
462 assertEqualInt(1, archive_match_time_excluded(m, ae));
463 assertEqualInt(1, archive_match_excluded(m, ae));
464
465 /* Verify 'mid_ctime' file. */
466 archive_entry_clear(ae);
467 archive_entry_copy_pathname(ae, "mid_ctime");
468 assertEqualIntA(a, ARCHIVE_OK,
469 archive_read_disk_entry_from_file(a, ae, -1, NULL));
470 failure("mid_ctime should be excluded");
471 assertEqualInt(1, archive_match_time_excluded(m, ae));
472 assertEqualInt(1, archive_match_excluded(m, ae));
473
474 /* Verify 'new_ctime' file. */
475 archive_entry_clear(ae);
476 archive_entry_copy_pathname(ae, "new_ctime");
477 assertEqualIntA(a, ARCHIVE_OK,
478 archive_read_disk_entry_from_file(a, ae, -1, NULL));
479 failure("new_ctime should not be excluded");
480 assertEqualInt(0, archive_match_time_excluded(m, ae));
481 assertEqualInt(0, archive_match_excluded(m, ae));
482
483 /* Clean up. */
484 archive_read_free(a);
485 archive_entry_free(ae);
486 archive_match_free(m);
487 }
488
489 static void
test_older_time(void)490 test_older_time(void)
491 {
492 struct archive_entry *ae;
493 struct archive *m;
494
495 if (!assert((m = archive_match_new()) != NULL))
496 return;
497 if (!assert((ae = archive_entry_new()) != NULL)) {
498 archive_match_free(m);
499 return;
500 }
501
502 assertEqualIntA(m, 0, archive_match_include_time(m,
503 ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_CTIME |
504 ARCHIVE_MATCH_OLDER, 7880, 0));
505
506 archive_entry_copy_pathname(ae, "file1");
507 archive_entry_set_mtime(ae, 7880, 0);
508 archive_entry_set_ctime(ae, 7880, 0);
509 failure("Both Its mtime and ctime should be excluded");
510 assertEqualInt(1, archive_match_time_excluded(m, ae));
511 assertEqualInt(1, archive_match_excluded(m, ae));
512 archive_entry_set_mtime(ae, 7879, 999);
513 archive_entry_set_ctime(ae, 7879, 999);
514 failure("Both Its mtime and ctime should not be excluded");
515 assertEqualInt(0, archive_match_time_excluded(m, ae));
516 assertEqualInt(0, archive_match_excluded(m, ae));
517
518 archive_entry_set_mtime(ae, 7881, 0);
519 archive_entry_set_ctime(ae, 7881, 0);
520 failure("Both Its mtime and ctime should be excluded");
521 assertEqualInt(1, archive_match_time_excluded(m, ae));
522 assertEqualInt(1, archive_match_excluded(m, ae));
523
524 archive_entry_set_mtime(ae, 7880, 1);
525 archive_entry_set_ctime(ae, 7879, 0);
526 failure("Its mtime should be excluded");
527 assertEqualInt(1, archive_match_time_excluded(m, ae));
528 assertEqualInt(1, archive_match_excluded(m, ae));
529
530 archive_entry_set_mtime(ae, 7879, 0);
531 archive_entry_set_ctime(ae, 7880, 1);
532 failure("Its ctime should be excluded");
533 assertEqualInt(1, archive_match_time_excluded(m, ae));
534 assertEqualInt(1, archive_match_excluded(m, ae));
535
536 /* Clean up. */
537 archive_entry_free(ae);
538 archive_match_free(m);
539 }
540
541 static void
test_older_time_str(void)542 test_older_time_str(void)
543 {
544 struct archive_entry *ae;
545 struct archive *m;
546 time_t now, t;
547
548 if (!assert((m = archive_match_new()) != NULL))
549 return;
550 if (!assert((ae = archive_entry_new()) != NULL)) {
551 archive_match_free(m);
552 return;
553 }
554
555 time(&now);
556
557 /* Test1: Allow newer time. */
558 assertEqualIntA(m, 0, archive_match_include_date(m,
559 ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_CTIME |
560 ARCHIVE_MATCH_OLDER, "1980/2/1 0:0:0 UTC"));
561
562 archive_entry_copy_pathname(ae, "file1");
563 t = __archive_get_date(now, "1980/2/1 0:0:0 UTC");
564 archive_entry_set_mtime(ae, t, 0);
565 archive_entry_set_ctime(ae, t, 0);
566 failure("Both Its mtime and ctime should be excluded");
567 assertEqualInt(1, archive_match_time_excluded(m, ae));
568 assertEqualInt(1, archive_match_excluded(m, ae));
569 t = __archive_get_date(now, "1980/1/1 0:0:0 UTC");
570 archive_entry_set_mtime(ae, t, 0);
571 archive_entry_set_ctime(ae, t, 0);
572 failure("Both Its mtime and ctime should not be excluded");
573 assertEqualInt(0, archive_match_time_excluded(m, ae));
574 assertEqualInt(0, archive_match_excluded(m, ae));
575
576 t = __archive_get_date(now, "1980/3/1 0:0:0 UTC");
577 archive_entry_set_mtime(ae, t, 0);
578 archive_entry_set_ctime(ae, t, 0);
579 failure("Both Its mtime and ctime should be excluded");
580 assertEqualInt(1, archive_match_time_excluded(m, ae));
581 assertEqualInt(1, archive_match_excluded(m, ae));
582
583 t = __archive_get_date(now, "1980/3/1 0:0:0 UTC");
584 archive_entry_set_mtime(ae, t, 0);
585 t = __archive_get_date(now, "1980/1/1 0:0:0 UTC");
586 archive_entry_set_ctime(ae, t, 0);
587 failure("Its mtime should be excluded");
588 assertEqualInt(1, archive_match_time_excluded(m, ae));
589 assertEqualInt(1, archive_match_excluded(m, ae));
590
591 t = __archive_get_date(now, "1980/1/1 0:0:0 UTC");
592 archive_entry_set_mtime(ae, t, 0);
593 t = __archive_get_date(now, "1980/3/1 0:0:0 UTC");
594 archive_entry_set_ctime(ae, t, 0);
595 failure("Its ctime should be excluded");
596 assertEqualInt(1, archive_match_time_excluded(m, ae));
597 assertEqualInt(1, archive_match_excluded(m, ae));
598
599 /* Test2: Allow equal or newer time. */
600 assertEqualIntA(m, 0, archive_match_include_date(m,
601 ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_CTIME |
602 ARCHIVE_MATCH_OLDER | ARCHIVE_MATCH_EQUAL,
603 "1980/2/1 0:0:0 UTC"));
604
605 archive_entry_copy_pathname(ae, "file1");
606 t = __archive_get_date(now, "1980/2/1 0:0:0 UTC");
607 archive_entry_set_mtime(ae, t, 0);
608 archive_entry_set_ctime(ae, t, 0);
609 failure("Both Its mtime and ctime should not be excluded");
610 assertEqualInt(0, archive_match_time_excluded(m, ae));
611 assertEqualInt(0, archive_match_excluded(m, ae));
612 t = __archive_get_date(now, "1980/1/1 0:0:0 UTC");
613 archive_entry_set_mtime(ae, t, 0);
614 archive_entry_set_ctime(ae, t, 0);
615 failure("Both Its mtime and ctime should not be excluded");
616 assertEqualInt(0, archive_match_time_excluded(m, ae));
617 assertEqualInt(0, archive_match_excluded(m, ae));
618
619 t = __archive_get_date(now, "1980/3/1 0:0:0 UTC");
620 archive_entry_set_mtime(ae, t, 0);
621 archive_entry_set_ctime(ae, t, 0);
622 failure("Both Its mtime and ctime should be excluded");
623 assertEqualInt(1, archive_match_time_excluded(m, ae));
624 assertEqualInt(1, archive_match_excluded(m, ae));
625
626 /* Clean up. */
627 archive_entry_free(ae);
628 archive_match_free(m);
629 }
630
631 static void
test_older_time_str_w(void)632 test_older_time_str_w(void)
633 {
634 struct archive_entry *ae;
635 struct archive *m;
636 time_t now, t;
637
638 if (!assert((m = archive_match_new()) != NULL))
639 return;
640 if (!assert((ae = archive_entry_new()) != NULL)) {
641 archive_match_free(m);
642 return;
643 }
644
645 time(&now);
646
647 /* Test1: Allow newer time. */
648 assertEqualIntA(m, 0, archive_match_include_date_w(m,
649 ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_CTIME |
650 ARCHIVE_MATCH_OLDER, L"1980/2/1 0:0:0 UTC"));
651
652 archive_entry_copy_pathname(ae, "file1");
653 t = __archive_get_date(now, "1980/2/1 0:0:0 UTC");
654 archive_entry_set_mtime(ae, t, 0);
655 archive_entry_set_ctime(ae, t, 0);
656 failure("Both Its mtime and ctime should be excluded");
657 assertEqualInt(1, archive_match_time_excluded(m, ae));
658 assertEqualInt(1, archive_match_excluded(m, ae));
659 t = __archive_get_date(now, "1980/1/1 0:0:0 UTC");
660 archive_entry_set_mtime(ae, t, 0);
661 archive_entry_set_ctime(ae, t, 0);
662 failure("Both Its mtime and ctime should not be excluded");
663 assertEqualInt(0, archive_match_time_excluded(m, ae));
664 assertEqualInt(0, archive_match_excluded(m, ae));
665
666 t = __archive_get_date(now, "1980/3/1 0:0:0 UTC");
667 archive_entry_set_mtime(ae, t, 0);
668 archive_entry_set_ctime(ae, t, 0);
669 failure("Both Its mtime and ctime should be excluded");
670 assertEqualInt(1, archive_match_time_excluded(m, ae));
671 assertEqualInt(1, archive_match_excluded(m, ae));
672
673 t = __archive_get_date(now, "1980/3/1 0:0:0 UTC");
674 archive_entry_set_mtime(ae, t, 0);
675 t = __archive_get_date(now, "1980/1/1 0:0:0 UTC");
676 archive_entry_set_ctime(ae, t, 0);
677 failure("Its mtime should be excluded");
678 assertEqualInt(1, archive_match_time_excluded(m, ae));
679 assertEqualInt(1, archive_match_excluded(m, ae));
680
681 t = __archive_get_date(now, "1980/1/1 0:0:0 UTC");
682 archive_entry_set_mtime(ae, t, 0);
683 t = __archive_get_date(now, "1980/3/1 0:0:0 UTC");
684 archive_entry_set_ctime(ae, t, 0);
685 failure("Its ctime should be excluded");
686 assertEqualInt(1, archive_match_time_excluded(m, ae));
687 assertEqualInt(1, archive_match_excluded(m, ae));
688
689 /* Test2: Allow equal or newer time. */
690 assertEqualIntA(m, 0, archive_match_include_date_w(m,
691 ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_CTIME |
692 ARCHIVE_MATCH_OLDER | ARCHIVE_MATCH_EQUAL,
693 L"1980/2/1 0:0:0 UTC"));
694
695 archive_entry_copy_pathname(ae, "file1");
696 t = __archive_get_date(now, "1980/2/1 0:0:0 UTC");
697 archive_entry_set_mtime(ae, t, 0);
698 archive_entry_set_ctime(ae, t, 0);
699 failure("Both Its mtime and ctime should not be excluded");
700 assertEqualInt(0, archive_match_time_excluded(m, ae));
701 assertEqualInt(0, archive_match_excluded(m, ae));
702 t = __archive_get_date(now, "1980/1/1 0:0:0 UTC");
703 archive_entry_set_mtime(ae, t, 0);
704 archive_entry_set_ctime(ae, t, 0);
705 failure("Both Its mtime and ctime should not be excluded");
706 assertEqualInt(0, archive_match_time_excluded(m, ae));
707 assertEqualInt(0, archive_match_excluded(m, ae));
708
709 t = __archive_get_date(now, "1980/3/1 0:0:0 UTC");
710 archive_entry_set_mtime(ae, t, 0);
711 archive_entry_set_ctime(ae, t, 0);
712 failure("Both Its mtime and ctime should be excluded");
713 assertEqualInt(1, archive_match_time_excluded(m, ae));
714 assertEqualInt(1, archive_match_excluded(m, ae));
715
716 /* Clean up. */
717 archive_entry_free(ae);
718 archive_match_free(m);
719 }
720
721 static void
test_older_mtime_than_file_mbs(void)722 test_older_mtime_than_file_mbs(void)
723 {
724 struct archive *a;
725 struct archive_entry *ae;
726 struct archive *m;
727
728 if (!assert((m = archive_match_new()) != NULL))
729 return;
730 if (!assert((ae = archive_entry_new()) != NULL)) {
731 archive_match_free(m);
732 return;
733 }
734 if (!assert((a = archive_read_disk_new()) != NULL)) {
735 archive_match_free(m);
736 archive_entry_free(ae);
737 return;
738 }
739
740 /*
741 * Test: older mtime than a file specified in MBS file name.
742 */
743 assertEqualIntA(m, 0, archive_match_include_file_time(m,
744 ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_OLDER, "mid_mtime"));
745
746 /* Verify 'old_mtime' file. */
747 archive_entry_copy_pathname(ae, "old_mtime");
748 assertEqualIntA(a, ARCHIVE_OK,
749 archive_read_disk_entry_from_file(a, ae, -1, NULL));
750 failure("old_mtime should not be excluded");
751 assertEqualInt(0, archive_match_time_excluded(m, ae));
752 assertEqualInt(0, archive_match_excluded(m, ae));
753
754 /* Verify 'mid_mtime' file. */
755 archive_entry_clear(ae);
756 archive_entry_copy_pathname(ae, "mid_mtime");
757 assertEqualIntA(a, ARCHIVE_OK,
758 archive_read_disk_entry_from_file(a, ae, -1, NULL));
759 failure("mid_mtime should be excluded");
760 assertEqualInt(1, archive_match_time_excluded(m, ae));
761 assertEqualInt(1, archive_match_excluded(m, ae));
762
763 /* Verify 'new_mtime' file. */
764 archive_entry_clear(ae);
765 archive_entry_copy_pathname(ae, "new_mtime");
766 assertEqualIntA(a, ARCHIVE_OK,
767 archive_read_disk_entry_from_file(a, ae, -1, NULL));
768 failure("new_mtime should be excluded");
769 assertEqualInt(1, archive_match_time_excluded(m, ae));
770 assertEqualInt(1, archive_match_excluded(m, ae));
771
772 /* Clean up. */
773 archive_read_free(a);
774 archive_entry_free(ae);
775 archive_match_free(m);
776 }
777
778 static void
test_older_ctime_than_file_mbs(void)779 test_older_ctime_than_file_mbs(void)
780 {
781 struct archive *a;
782 struct archive_entry *ae;
783 struct archive *m;
784
785 if (!assert((m = archive_match_new()) != NULL))
786 return;
787 if (!assert((ae = archive_entry_new()) != NULL)) {
788 archive_match_free(m);
789 return;
790 }
791 if (!assert((a = archive_read_disk_new()) != NULL)) {
792 archive_match_free(m);
793 archive_entry_free(ae);
794 return;
795 }
796
797 /*
798 * Test: older ctime than a file specified in MBS file name.
799 */
800 assertEqualIntA(m, 0, archive_match_include_file_time(m,
801 ARCHIVE_MATCH_CTIME | ARCHIVE_MATCH_OLDER, "mid_ctime"));
802
803 /* Verify 'old_ctime' file. */
804 archive_entry_clear(ae);
805 archive_entry_copy_pathname(ae, "old_ctime");
806 assertEqualIntA(a, ARCHIVE_OK,
807 archive_read_disk_entry_from_file(a, ae, -1, NULL));
808 failure("old_ctime should not be excluded");
809 assertEqualInt(0, archive_match_time_excluded(m, ae));
810 assertEqualInt(0, archive_match_excluded(m, ae));
811
812 /* Verify 'mid_ctime' file. */
813 archive_entry_clear(ae);
814 archive_entry_copy_pathname(ae, "mid_ctime");
815 assertEqualIntA(a, ARCHIVE_OK,
816 archive_read_disk_entry_from_file(a, ae, -1, NULL));
817 failure("mid_ctime should be excluded");
818 assertEqualInt(1, archive_match_time_excluded(m, ae));
819 assertEqualInt(1, archive_match_excluded(m, ae));
820
821 /* Verify 'new_ctime' file. */
822 archive_entry_clear(ae);
823 archive_entry_copy_pathname(ae, "new_ctime");
824 assertEqualIntA(a, ARCHIVE_OK,
825 archive_read_disk_entry_from_file(a, ae, -1, NULL));
826 failure("new_ctime should be excluded");
827 assertEqualInt(1, archive_match_time_excluded(m, ae));
828 assertEqualInt(1, archive_match_excluded(m, ae));
829
830 /* Clean up. */
831 archive_read_free(a);
832 archive_entry_free(ae);
833 archive_match_free(m);
834 }
835
836 static void
test_older_mtime_than_file_wcs(void)837 test_older_mtime_than_file_wcs(void)
838 {
839 struct archive *a;
840 struct archive_entry *ae;
841 struct archive *m;
842
843 if (!assert((m = archive_match_new()) != NULL))
844 return;
845 if (!assert((ae = archive_entry_new()) != NULL)) {
846 archive_match_free(m);
847 return;
848 }
849 if (!assert((a = archive_read_disk_new()) != NULL)) {
850 archive_match_free(m);
851 archive_entry_free(ae);
852 return;
853 }
854
855 /*
856 * Test: older mtime than a file specified in WCS file name.
857 */
858 assertEqualIntA(m, 0, archive_match_include_file_time_w(m,
859 ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_OLDER, L"mid_mtime"));
860
861 /* Verify 'old_mtime' file. */
862 archive_entry_copy_pathname(ae, "old_mtime");
863 assertEqualIntA(a, ARCHIVE_OK,
864 archive_read_disk_entry_from_file(a, ae, -1, NULL));
865 failure("old_mtime should not be excluded");
866 assertEqualInt(0, archive_match_time_excluded(m, ae));
867 assertEqualInt(0, archive_match_excluded(m, ae));
868
869 /* Verify 'mid_mtime' file. */
870 archive_entry_clear(ae);
871 archive_entry_copy_pathname(ae, "mid_mtime");
872 assertEqualIntA(a, ARCHIVE_OK,
873 archive_read_disk_entry_from_file(a, ae, -1, NULL));
874 failure("mid_mtime should be excluded");
875 assertEqualInt(1, archive_match_time_excluded(m, ae));
876 assertEqualInt(1, archive_match_excluded(m, ae));
877
878 /* Verify 'new_mtime' file. */
879 archive_entry_clear(ae);
880 archive_entry_copy_pathname(ae, "new_mtime");
881 assertEqualIntA(a, ARCHIVE_OK,
882 archive_read_disk_entry_from_file(a, ae, -1, NULL));
883 failure("new_mtime should be excluded");
884 assertEqualInt(1, archive_match_time_excluded(m, ae));
885 assertEqualInt(1, archive_match_excluded(m, ae));
886
887 /* Clean up. */
888 archive_read_free(a);
889 archive_entry_free(ae);
890 archive_match_free(m);
891 }
892
893 static void
test_older_ctime_than_file_wcs(void)894 test_older_ctime_than_file_wcs(void)
895 {
896 struct archive *a;
897 struct archive_entry *ae;
898 struct archive *m;
899
900 if (!assert((m = archive_match_new()) != NULL))
901 return;
902 if (!assert((ae = archive_entry_new()) != NULL)) {
903 archive_match_free(m);
904 return;
905 }
906 if (!assert((a = archive_read_disk_new()) != NULL)) {
907 archive_match_free(m);
908 archive_entry_free(ae);
909 return;
910 }
911
912 /*
913 * Test: older ctime than a file specified in WCS file name.
914 */
915 assertEqualIntA(m, 0, archive_match_include_file_time_w(m,
916 ARCHIVE_MATCH_CTIME | ARCHIVE_MATCH_OLDER, L"mid_ctime"));
917
918 /* Verify 'old_ctime' file. */
919 archive_entry_clear(ae);
920 archive_entry_copy_pathname(ae, "old_ctime");
921 assertEqualIntA(a, ARCHIVE_OK,
922 archive_read_disk_entry_from_file(a, ae, -1, NULL));
923 failure("old_ctime should not be excluded");
924 assertEqualInt(0, archive_match_time_excluded(m, ae));
925 assertEqualInt(0, archive_match_excluded(m, ae));
926
927 /* Verify 'mid_ctime' file. */
928 archive_entry_clear(ae);
929 archive_entry_copy_pathname(ae, "mid_ctime");
930 assertEqualIntA(a, ARCHIVE_OK,
931 archive_read_disk_entry_from_file(a, ae, -1, NULL));
932 failure("mid_ctime should be excluded");
933 assertEqualInt(1, archive_match_time_excluded(m, ae));
934 assertEqualInt(1, archive_match_excluded(m, ae));
935
936 /* Verify 'new_ctime' file. */
937 archive_entry_clear(ae);
938 archive_entry_copy_pathname(ae, "new_ctime");
939 assertEqualIntA(a, ARCHIVE_OK,
940 archive_read_disk_entry_from_file(a, ae, -1, NULL));
941 failure("new_ctime should be excluded");
942 assertEqualInt(1, archive_match_time_excluded(m, ae));
943 assertEqualInt(1, archive_match_excluded(m, ae));
944
945 /* Clean up. */
946 archive_read_free(a);
947 archive_entry_free(ae);
948 archive_match_free(m);
949 }
950
951 static void
test_mtime_between_files_mbs(void)952 test_mtime_between_files_mbs(void)
953 {
954 struct archive *a;
955 struct archive_entry *ae;
956 struct archive *m;
957
958 if (!assert((m = archive_match_new()) != NULL))
959 return;
960 if (!assert((ae = archive_entry_new()) != NULL)) {
961 archive_match_free(m);
962 return;
963 }
964 if (!assert((a = archive_read_disk_new()) != NULL)) {
965 archive_match_free(m);
966 archive_entry_free(ae);
967 return;
968 }
969
970 /*
971 * Test: mtime between file specified in MBS file name.
972 */
973 assertEqualIntA(m, 0, archive_match_include_file_time(m,
974 ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_NEWER, "old_mtime"));
975 assertEqualIntA(m, 0, archive_match_include_file_time(m,
976 ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_OLDER, "new_mtime"));
977
978 /* Verify 'old_mtime' file. */
979 archive_entry_copy_pathname(ae, "old_mtime");
980 assertEqualIntA(a, ARCHIVE_OK,
981 archive_read_disk_entry_from_file(a, ae, -1, NULL));
982 failure("old_mtime should be excluded");
983 assertEqualInt(1, archive_match_time_excluded(m, ae));
984 assertEqualInt(1, archive_match_excluded(m, ae));
985
986 /* Verify 'mid_mtime' file. */
987 archive_entry_clear(ae);
988 archive_entry_copy_pathname(ae, "mid_mtime");
989 assertEqualIntA(a, ARCHIVE_OK,
990 archive_read_disk_entry_from_file(a, ae, -1, NULL));
991 failure("mid_mtime should not be excluded");
992 assertEqualInt(0, archive_match_time_excluded(m, ae));
993 assertEqualInt(0, archive_match_excluded(m, ae));
994
995 /* Verify 'new_mtime' file. */
996 archive_entry_clear(ae);
997 archive_entry_copy_pathname(ae, "new_mtime");
998 assertEqualIntA(a, ARCHIVE_OK,
999 archive_read_disk_entry_from_file(a, ae, -1, NULL));
1000 failure("new_mtime should be excluded");
1001 assertEqualInt(1, archive_match_time_excluded(m, ae));
1002 assertEqualInt(1, archive_match_excluded(m, ae));
1003
1004 /* Clean up. */
1005 archive_read_free(a);
1006 archive_entry_free(ae);
1007 archive_match_free(m);
1008 }
1009
1010 static void
test_mtime_between_files_wcs(void)1011 test_mtime_between_files_wcs(void)
1012 {
1013 struct archive *a;
1014 struct archive_entry *ae;
1015 struct archive *m;
1016
1017 if (!assert((m = archive_match_new()) != NULL))
1018 return;
1019 if (!assert((ae = archive_entry_new()) != NULL)) {
1020 archive_match_free(m);
1021 return;
1022 }
1023 if (!assert((a = archive_read_disk_new()) != NULL)) {
1024 archive_match_free(m);
1025 archive_entry_free(ae);
1026 return;
1027 }
1028
1029 /*
1030 * Test: mtime between file specified in WCS file name.
1031 */
1032 assertEqualIntA(m, 0, archive_match_include_file_time_w(m,
1033 ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_NEWER, L"old_mtime"));
1034 assertEqualIntA(m, 0, archive_match_include_file_time_w(m,
1035 ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_OLDER, L"new_mtime"));
1036
1037 /* Verify 'old_mtime' file. */
1038 archive_entry_copy_pathname(ae, "old_mtime");
1039 assertEqualIntA(a, ARCHIVE_OK,
1040 archive_read_disk_entry_from_file(a, ae, -1, NULL));
1041 failure("old_mtime should be excluded");
1042 assertEqualInt(1, archive_match_time_excluded(m, ae));
1043 assertEqualInt(1, archive_match_excluded(m, ae));
1044
1045 /* Verify 'mid_mtime' file. */
1046 archive_entry_clear(ae);
1047 archive_entry_copy_pathname(ae, "mid_mtime");
1048 assertEqualIntA(a, ARCHIVE_OK,
1049 archive_read_disk_entry_from_file(a, ae, -1, NULL));
1050 failure("mid_mtime should not be excluded");
1051 assertEqualInt(0, archive_match_time_excluded(m, ae));
1052 assertEqualInt(0, archive_match_excluded(m, ae));
1053
1054 /* Verify 'new_mtime' file. */
1055 archive_entry_clear(ae);
1056 archive_entry_copy_pathname(ae, "new_mtime");
1057 assertEqualIntA(a, ARCHIVE_OK,
1058 archive_read_disk_entry_from_file(a, ae, -1, NULL));
1059 failure("new_mtime should be excluded");
1060 assertEqualInt(1, archive_match_time_excluded(m, ae));
1061 assertEqualInt(1, archive_match_excluded(m, ae));
1062
1063 /* Clean up. */
1064 archive_read_free(a);
1065 archive_entry_free(ae);
1066 archive_match_free(m);
1067 }
1068
1069 static void
test_ctime_between_files_mbs(void)1070 test_ctime_between_files_mbs(void)
1071 {
1072 struct archive *a;
1073 struct archive_entry *ae;
1074 struct archive *m;
1075
1076 if (!assert((m = archive_match_new()) != NULL))
1077 return;
1078 if (!assert((ae = archive_entry_new()) != NULL)) {
1079 archive_match_free(m);
1080 return;
1081 }
1082 if (!assert((a = archive_read_disk_new()) != NULL)) {
1083 archive_match_free(m);
1084 archive_entry_free(ae);
1085 return;
1086 }
1087
1088 /*
1089 * Test: ctime between files specified in MBS file name.
1090 */
1091 assertEqualIntA(m, 0, archive_match_include_file_time(m,
1092 ARCHIVE_MATCH_CTIME | ARCHIVE_MATCH_NEWER, "old_ctime"));
1093 assertEqualIntA(m, 0, archive_match_include_file_time(m,
1094 ARCHIVE_MATCH_CTIME | ARCHIVE_MATCH_OLDER, "new_ctime"));
1095
1096 /* Verify 'old_ctime' file. */
1097 archive_entry_copy_pathname(ae, "old_ctime");
1098 assertEqualIntA(a, ARCHIVE_OK,
1099 archive_read_disk_entry_from_file(a, ae, -1, NULL));
1100 failure("old_ctime should be excluded");
1101 assertEqualInt(1, archive_match_time_excluded(m, ae));
1102 assertEqualInt(1, archive_match_excluded(m, ae));
1103
1104 /* Verify 'mid_ctime' file. */
1105 archive_entry_clear(ae);
1106 archive_entry_copy_pathname(ae, "mid_ctime");
1107 assertEqualIntA(a, ARCHIVE_OK,
1108 archive_read_disk_entry_from_file(a, ae, -1, NULL));
1109 failure("mid_ctime should not be excluded");
1110 assertEqualInt(0, archive_match_time_excluded(m, ae));
1111 assertEqualInt(0, archive_match_excluded(m, ae));
1112
1113 /* Verify 'new_ctime' file. */
1114 archive_entry_clear(ae);
1115 archive_entry_copy_pathname(ae, "new_ctime");
1116 assertEqualIntA(a, ARCHIVE_OK,
1117 archive_read_disk_entry_from_file(a, ae, -1, NULL));
1118 failure("new_ctime should be excluded");
1119 assertEqualInt(1, archive_match_time_excluded(m, ae));
1120 assertEqualInt(1, archive_match_excluded(m, ae));
1121
1122 /* Clean up. */
1123 archive_read_free(a);
1124 archive_entry_free(ae);
1125 archive_match_free(m);
1126 }
1127
1128 static void
test_ctime_between_files_wcs(void)1129 test_ctime_between_files_wcs(void)
1130 {
1131 struct archive *a;
1132 struct archive_entry *ae;
1133 struct archive *m;
1134
1135 if (!assert((m = archive_match_new()) != NULL))
1136 return;
1137 if (!assert((ae = archive_entry_new()) != NULL)) {
1138 archive_match_free(m);
1139 return;
1140 }
1141 if (!assert((a = archive_read_disk_new()) != NULL)) {
1142 archive_match_free(m);
1143 archive_entry_free(ae);
1144 return;
1145 }
1146
1147 /*
1148 * Test: ctime between files specified in WCS file name.
1149 */
1150 assertEqualIntA(m, 0, archive_match_include_file_time_w(m,
1151 ARCHIVE_MATCH_CTIME | ARCHIVE_MATCH_NEWER, L"old_ctime"));
1152 assertEqualIntA(m, 0, archive_match_include_file_time_w(m,
1153 ARCHIVE_MATCH_CTIME | ARCHIVE_MATCH_OLDER, L"new_ctime"));
1154
1155 /* Verify 'old_ctime' file. */
1156 archive_entry_copy_pathname(ae, "old_ctime");
1157 assertEqualIntA(a, ARCHIVE_OK,
1158 archive_read_disk_entry_from_file(a, ae, -1, NULL));
1159 failure("old_ctime should be excluded");
1160 assertEqualInt(1, archive_match_time_excluded(m, ae));
1161 assertEqualInt(1, archive_match_excluded(m, ae));
1162
1163 /* Verify 'mid_ctime' file. */
1164 archive_entry_clear(ae);
1165 archive_entry_copy_pathname(ae, "mid_ctime");
1166 assertEqualIntA(a, ARCHIVE_OK,
1167 archive_read_disk_entry_from_file(a, ae, -1, NULL));
1168 failure("mid_ctime should not be excluded");
1169 assertEqualInt(0, archive_match_time_excluded(m, ae));
1170 assertEqualInt(0, archive_match_excluded(m, ae));
1171
1172 /* Verify 'new_ctime' file. */
1173 archive_entry_clear(ae);
1174 archive_entry_copy_pathname(ae, "new_ctime");
1175 assertEqualIntA(a, ARCHIVE_OK,
1176 archive_read_disk_entry_from_file(a, ae, -1, NULL));
1177 failure("new_ctime should be excluded");
1178 assertEqualInt(1, archive_match_time_excluded(m, ae));
1179 assertEqualInt(1, archive_match_excluded(m, ae));
1180
1181 /* Clean up. */
1182 archive_read_free(a);
1183 archive_entry_free(ae);
1184 archive_match_free(m);
1185 }
1186
1187 static void
excluded(struct archive * m)1188 excluded(struct archive *m)
1189 {
1190 struct archive_entry *ae;
1191
1192 if (!assert((ae = archive_entry_new()) != NULL))
1193 return;
1194
1195 archive_entry_copy_pathname(ae, "file1");
1196 archive_entry_set_mtime(ae, 7879, 999);
1197 failure("It should be excluded");
1198 assertEqualInt(1, archive_match_time_excluded(m, ae));
1199 assertEqualInt(1, archive_match_excluded(m, ae));
1200 archive_entry_set_mtime(ae, 7880, 0);
1201 failure("It should be excluded");
1202 assertEqualInt(1, archive_match_time_excluded(m, ae));
1203 assertEqualInt(1, archive_match_excluded(m, ae));
1204 archive_entry_set_mtime(ae, 7880, 1);
1205 failure("It should not be excluded");
1206 assertEqualInt(0, archive_match_time_excluded(m, ae));
1207 assertEqualInt(0, archive_match_excluded(m, ae));
1208
1209 archive_entry_copy_pathname(ae, "file2");
1210 archive_entry_set_mtime(ae, 7879, 999);
1211 failure("It should not be excluded");
1212 assertEqualInt(0, archive_match_time_excluded(m, ae));
1213 assertEqualInt(0, archive_match_excluded(m, ae));
1214 archive_entry_set_mtime(ae, 7880, 0);
1215 failure("It should not be excluded");
1216 assertEqualInt(0, archive_match_time_excluded(m, ae));
1217 assertEqualInt(0, archive_match_excluded(m, ae));
1218 archive_entry_set_mtime(ae, 7880, 1);
1219 failure("It should not be excluded");
1220 assertEqualInt(0, archive_match_time_excluded(m, ae));
1221 assertEqualInt(0, archive_match_excluded(m, ae));
1222
1223 archive_entry_copy_pathname(ae, "file3");
1224 archive_entry_set_mtime(ae, 7879, 999);
1225 failure("It should be excluded");
1226 assertEqualInt(1, archive_match_time_excluded(m, ae));
1227 assertEqualInt(1, archive_match_excluded(m, ae));
1228 archive_entry_set_mtime(ae, 7880, 0);
1229 failure("It should be excluded");
1230 assertEqualInt(1, archive_match_time_excluded(m, ae));
1231 assertEqualInt(1, archive_match_excluded(m, ae));
1232 archive_entry_set_mtime(ae, 7880, 1);
1233 failure("It should be excluded");
1234 assertEqualInt(1, archive_match_time_excluded(m, ae));
1235 assertEqualInt(1, archive_match_excluded(m, ae));
1236
1237 /*
1238 * "file4" is not registered, that sort of a file should not be
1239 * excluded with any mtime.
1240 */
1241 archive_entry_copy_pathname(ae, "file4");
1242 archive_entry_set_mtime(ae, 7879, 999);
1243 failure("It should not be excluded");
1244 assertEqualInt(0, archive_match_time_excluded(m, ae));
1245 assertEqualInt(0, archive_match_excluded(m, ae));
1246 archive_entry_set_mtime(ae, 7880, 0);
1247 failure("It should not be excluded");
1248 assertEqualInt(0, archive_match_time_excluded(m, ae));
1249 assertEqualInt(0, archive_match_excluded(m, ae));
1250 archive_entry_set_mtime(ae, 7880, 1);
1251 failure("It should not be excluded");
1252 assertEqualInt(0, archive_match_time_excluded(m, ae));
1253 assertEqualInt(0, archive_match_excluded(m, ae));
1254
1255
1256 /* Clean up. */
1257 archive_entry_free(ae);
1258 }
1259
1260 static void
test_pathname_newer_mtime(void)1261 test_pathname_newer_mtime(void)
1262 {
1263 struct archive_entry *ae;
1264 struct archive *m;
1265
1266 if (!assert((m = archive_match_new()) != NULL))
1267 return;
1268 if (!assert((ae = archive_entry_new()) != NULL)) {
1269 archive_match_free(m);
1270 return;
1271 }
1272
1273 archive_entry_copy_pathname(ae, "file1");
1274 archive_entry_set_mtime(ae, 7880, 0);
1275 assertEqualIntA(m, 0, archive_match_exclude_entry(m,
1276 ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_OLDER |
1277 ARCHIVE_MATCH_EQUAL, ae));
1278 archive_entry_copy_pathname(ae, "file2");
1279 archive_entry_set_mtime(ae, 1, 0);
1280 assertEqualIntA(m, 0, archive_match_exclude_entry(m,
1281 ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_OLDER |
1282 ARCHIVE_MATCH_EQUAL, ae));
1283 archive_entry_copy_pathname(ae, "file3");
1284 archive_entry_set_mtime(ae, 99999, 0);
1285 assertEqualIntA(m, 0, archive_match_exclude_entry(m,
1286 ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_OLDER |
1287 ARCHIVE_MATCH_EQUAL, ae));
1288
1289 excluded(m);
1290
1291 /* Clean up. */
1292 archive_entry_free(ae);
1293 archive_match_free(m);
1294 }
1295
DEFINE_TEST(test_archive_match_time)1296 DEFINE_TEST(test_archive_match_time)
1297 {
1298 struct stat st;
1299
1300 /* Test: matching newer times. */
1301 test_newer_time();
1302 test_newer_time_str();
1303 test_newer_time_str_w();
1304 /* Test: matching older times. */
1305 test_older_time();
1306 test_older_time_str();
1307 test_older_time_str_w();
1308
1309 /*
1310 * Create sample files for tests matching mtime.
1311 * ctimes of those files may be all the same or the ctime of
1312 * new_mtime may be older than old_mtime.
1313 */
1314 assertMakeFile("new_mtime", 0666, "new");
1315 assertUtimes("new_mtime", 10002, 0, 10002, 0);
1316 assertMakeFile("mid_mtime", 0666, "mid");
1317 assertUtimes("mid_mtime", 10001, 0, 10001, 0);
1318 assertMakeFile("old_mtime", 0666, "old");
1319 assertUtimes("old_mtime", 10000, 0, 10000, 0);
1320
1321 /*
1322 * Create sample files for tests matching ctime.
1323 * the mtime of mid_ctime is older than old_ctime and also the mtime
1324 * of new_ctime is older than both mid_ctime and old_ctime.
1325 */
1326 assertMakeFile("old_ctime", 0666, "old");
1327 assertUtimes("old_ctime", 10002, 0, 10002, 0);
1328 assertEqualInt(0, stat("old_ctime", &st));
1329 sleepUntilAfter(st.st_ctime);
1330 assertMakeFile("mid_ctime", 0666, "mid");
1331 assertUtimes("mid_ctime", 10001, 0, 10001, 0);
1332 assertEqualInt(0, stat("mid_ctime", &st));
1333 sleepUntilAfter(st.st_ctime);
1334 assertMakeFile("new_ctime", 0666, "new");
1335 assertUtimes("new_ctime", 10000, 0, 10000, 0);
1336
1337 /*
1338 * Test: matching mtime which indicated by files on the disk.
1339 */
1340 test_newer_mtime_than_file_mbs();
1341 test_newer_mtime_than_file_wcs();
1342 test_older_mtime_than_file_mbs();
1343 test_older_mtime_than_file_wcs();
1344 test_mtime_between_files_mbs();
1345 test_mtime_between_files_wcs();
1346
1347 /*
1348 * Test: matching ctime which indicated by files on the disk.
1349 */
1350 test_newer_ctime_than_file_mbs();
1351 test_newer_ctime_than_file_wcs();
1352 test_older_ctime_than_file_mbs();
1353 test_older_ctime_than_file_wcs();
1354 test_ctime_between_files_mbs();
1355 test_ctime_between_files_wcs();
1356
1357 /* Test: matching both pathname and mtime. */
1358 test_pathname_newer_mtime();
1359 }
1360