contrib/libarchive/libarchive/test/test_archive_match_time.c

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