git.notmuchmail.org Git - notmuch/blob - test/T560-lib-error.sh

   1 #!/usr/bin/env bash
   2 test_description="error reporting for library"
   3
   4 . $(dirname "$0")/test-lib.sh || exit 1
   5
   6 add_email_corpus
   7
   8 test_begin_subtest "building database"
   9 test_expect_success "NOTMUCH_NEW"
  10
  11 test_begin_subtest "Open null pointer"
  12 test_C <<'EOF'
  13 #include <stdio.h>
  14 #include <notmuch.h>
  15 int main (int argc, char** argv)
  16 {
  17     notmuch_database_t *db;
  18     notmuch_status_t stat;
  19     stat = notmuch_database_open (NULL, 0, 0);
  20 }
  21 EOF
  22 cat <<'EOF' >EXPECTED
  23 == stdout ==
  24 == stderr ==
  25 Error: Cannot open a database for a NULL path.
  26 EOF
  27 test_expect_equal_file EXPECTED OUTPUT
  28
  29 test_begin_subtest "Open relative path"
  30 test_C <<'EOF'
  31 #include <stdio.h>
  32 #include <notmuch.h>
  33 int main (int argc, char** argv)
  34 {
  35     notmuch_database_t *db;
  36     notmuch_status_t stat;
  37     stat = notmuch_database_open ("./nonexistent/foo", 0, 0);
  38 }
  39 EOF
  40 cat <<'EOF' >EXPECTED
  41 == stdout ==
  42 == stderr ==
  43 Error: Database path must be absolute.
  44 EOF
  45 test_expect_equal_file EXPECTED OUTPUT
  46
  47 test_begin_subtest "Create database in relative path"
  48 test_C <<'EOF'
  49 #include <stdio.h>
  50 #include <notmuch.h>
  51 int main (int argc, char** argv)
  52 {
  53     notmuch_database_t *db;
  54     notmuch_status_t stat;
  55     stat = notmuch_database_create ("./nonexistent/foo", &db);
  56 }
  57 EOF
  58 cat <<'EOF' >EXPECTED
  59 == stdout ==
  60 == stderr ==
  61 Error: Database path must be absolute.
  62 EOF
  63 test_expect_equal_file EXPECTED OUTPUT
  64
  65 test_begin_subtest "Open nonexistent database"
  66 test_C ${PWD}/nonexistent/foo <<'EOF'
  67 #include <stdio.h>
  68 #include <notmuch.h>
  69 int main (int argc, char** argv)
  70 {
  71     notmuch_database_t *db;
  72     notmuch_status_t stat;
  73     stat = notmuch_database_open (argv[1], 0, 0);
  74 }
  75 EOF
  76 cat <<'EOF' >EXPECTED
  77 == stdout ==
  78 == stderr ==
  79 Error opening database at CWD/nonexistent/foo/.notmuch: No such file or directory
  80 EOF
  81 test_expect_equal_file EXPECTED OUTPUT
  82
  83 test_begin_subtest "create NULL path"
  84 test_C <<'EOF'
  85 #include <stdio.h>
  86 #include <notmuch.h>
  87 int main (int argc, char** argv)
  88 {
  89     notmuch_status_t stat;
  90     stat = notmuch_database_create (NULL, NULL);
  91 }
  92 EOF
  93 cat <<'EOF' >EXPECTED
  94 == stdout ==
  95 == stderr ==
  96 Error: Cannot create a database for a NULL path.
  97 EOF
  98 test_expect_equal_file EXPECTED OUTPUT
  99
 100 test_begin_subtest "Create database in nonexistent directory"
 101 test_C ${PWD}/nonexistent/foo<<'EOF'
 102 #include <stdio.h>
 103 #include <notmuch.h>
 104 int main (int argc, char** argv)
 105 {
 106     notmuch_database_t *db;
 107     notmuch_status_t stat;
 108     stat = notmuch_database_create (argv[1], &db);
 109 }
 110 EOF
 111 cat <<'EOF' >EXPECTED
 112 == stdout ==
 113 == stderr ==
 114 Error: Cannot create database at CWD/nonexistent/foo: No such file or directory.
 115 EOF
 116 test_expect_equal_file EXPECTED OUTPUT
 117
 118 test_begin_subtest "Write to read-only database"
 119 test_C ${MAIL_DIR} <<'EOF'
 120 #include <stdio.h>
 121 #include <notmuch.h>
 122 int main (int argc, char** argv)
 123 {
 124    notmuch_database_t *db;
 125    notmuch_status_t stat;
 126    stat = notmuch_database_open (argv[1], NOTMUCH_DATABASE_MODE_READ_ONLY, &db);
 127    if (stat != NOTMUCH_STATUS_SUCCESS) {
 128      fprintf (stderr, "error opening database: %d\n", stat);
 129    }
 130    stat = notmuch_database_index_file (db, "/dev/null", NULL, NULL);
 131    if (stat)
 132        fputs (notmuch_database_status_string (db), stderr);
 133
 134 }
 135 EOF
 136 cat <<'EOF' >EXPECTED
 137 == stdout ==
 138 == stderr ==
 139 Cannot write to a read-only database.
 140 EOF
 141 test_expect_equal_file EXPECTED OUTPUT
 142
 143 test_begin_subtest "Add non-existent file"
 144 test_C ${MAIL_DIR} <<'EOF'
 145 #include <stdio.h>
 146 #include <notmuch.h>
 147 int main (int argc, char** argv)
 148 {
 149    notmuch_database_t *db;
 150    notmuch_status_t stat;
 151    stat = notmuch_database_open (argv[1], NOTMUCH_DATABASE_MODE_READ_WRITE, &db);
 152    if (stat != NOTMUCH_STATUS_SUCCESS) {
 153      fprintf (stderr, "error opening database: %d\n", stat);
 154    }
 155    stat = notmuch_database_index_file (db, "./nonexistent", NULL, NULL);
 156    if (stat) {
 157        char *status_string = notmuch_database_status_string (db);
 158        if (status_string) fputs (status_string, stderr);
 159    }
 160 }
 161 EOF
 162 cat <<'EOF' >EXPECTED
 163 == stdout ==
 164 == stderr ==
 165 Error opening ./nonexistent: No such file or directory
 166 EOF
 167 test_expect_equal_file EXPECTED OUTPUT
 168
 169 test_begin_subtest "compact, overwriting existing backup"
 170 test_C ${MAIL_DIR} <<'EOF'
 171 #include <stdio.h>
 172 #include <notmuch.h>
 173 static void
 174 status_cb (const char *msg, void *closure)
 175 {
 176     printf ("%s\n", msg);
 177 }
 178 int main (int argc, char** argv)
 179 {
 180    notmuch_database_t *db;
 181    notmuch_status_t stat;
 182    stat = notmuch_database_compact (argv[1], argv[1], status_cb, NULL);
 183 }
 184 EOF
 185 cat <<'EOF' >EXPECTED
 186 == stdout ==
 187 Path already exists: MAIL_DIR
 188
 189 == stderr ==
 190 EOF
 191 test_expect_equal_file EXPECTED OUTPUT
 192
 193 cat <<EOF > c_head
 194 #include <stdio.h>
 195 #include <sys/types.h>
 196 #include <sys/stat.h>
 197 #include <fcntl.h>
 198 #include <talloc.h>
 199 #include <notmuch.h>
 200
 201 int main (int argc, char** argv)
 202 {
 203    notmuch_database_t *db;
 204    notmuch_status_t stat;
 205    char *path;
 206    char *msg = NULL;
 207    int fd;
 208
 209    stat = notmuch_database_open_verbose (argv[1], NOTMUCH_DATABASE_MODE_READ_WRITE, &db, &msg);
 210    if (stat != NOTMUCH_STATUS_SUCCESS) {
 211      fprintf (stderr, "error opening database: %d %s\n", stat, msg ? msg : "");
 212      exit (1);
 213    }
 214    path = talloc_asprintf (db, "%s/.notmuch/xapian/postlist.${db_ending}", argv[1]);
 215    fd = open(path,O_WRONLY|O_TRUNC);
 216    if (fd < 0) {
 217        fprintf (stderr, "error opening %s\n", argv[1]);
 218        exit (1);
 219    }
 220 EOF
 221 cat <<'EOF' > c_tail
 222    if (stat) {
 223        const char *stat_str = notmuch_database_status_string (db);
 224        if (stat_str)
 225            fputs (stat_str, stderr);
 226     }
 227
 228 }
 229 EOF
 230
 231 backup_database
 232 test_begin_subtest "Xapian exception finding message"
 233 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 234    {
 235        notmuch_message_t *message = NULL;
 236        stat = notmuch_database_find_message (db, "id:nonexistent", &message);
 237    }
 238 EOF
 239 sed 's/^\(A Xapian exception [^:]*\):.*$/\1/' < OUTPUT > OUTPUT.clean
 240 cat <<'EOF' >EXPECTED
 241 == stdout ==
 242 == stderr ==
 243 A Xapian exception occurred finding message
 244 EOF
 245 test_expect_equal_file EXPECTED OUTPUT.clean
 246 restore_database
 247
 248 backup_database
 249 test_begin_subtest "Xapian exception getting tags"
 250 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 251    {
 252        notmuch_tags_t *tags = NULL;
 253        tags = notmuch_database_get_all_tags (db);
 254        stat = (tags == NULL);
 255    }
 256 EOF
 257 sed 's/^\(A Xapian exception [^:]*\):.*$/\1/' < OUTPUT > OUTPUT.clean
 258 cat <<'EOF' >EXPECTED
 259 == stdout ==
 260 == stderr ==
 261 A Xapian exception occurred getting tags
 262 EOF
 263 test_expect_equal_file EXPECTED OUTPUT.clean
 264 restore_database
 265
 266 backup_database
 267 test_begin_subtest "Xapian exception creating directory"
 268 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 269    {
 270        notmuch_directory_t *directory = NULL;
 271        stat = notmuch_database_get_directory (db, "none/existing", &directory);
 272    }
 273 EOF
 274 sed 's/^\(A Xapian exception [^:]*\):.*$/\1/' < OUTPUT > OUTPUT.clean
 275 cat <<'EOF' >EXPECTED
 276 == stdout ==
 277 == stderr ==
 278 A Xapian exception occurred creating a directory
 279 EOF
 280 test_expect_equal_file EXPECTED OUTPUT.clean
 281 restore_database
 282
 283 backup_database
 284 test_begin_subtest "Xapian exception searching messages"
 285 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 286    {
 287        notmuch_messages_t *messages = NULL;
 288        notmuch_query_t *query=notmuch_query_create (db, "*");
 289        stat = notmuch_query_search_messages (query, &messages);
 290    }
 291 EOF
 292 sed 's/^\(A Xapian exception [^:]*\):.*$/\1/' < OUTPUT > OUTPUT.clean
 293 cat <<'EOF' >EXPECTED
 294 == stdout ==
 295 == stderr ==
 296 A Xapian exception occurred performing query
 297 Query string was: *
 298 EOF
 299 test_expect_equal_file EXPECTED OUTPUT.clean
 300 restore_database
 301
 302 backup_database
 303 test_begin_subtest "Xapian exception counting messages"
 304 cat c_head - c_tail <<'EOF' | test_C ${MAIL_DIR}
 305    {
 306        int count;
 307        notmuch_query_t *query=notmuch_query_create (db, "id:87ocn0qh6d.fsf@yoom.home.cworth.org");
 308        stat = notmuch_query_count_messages (query, &count);
 309    }
 310 EOF
 311 sed 's/^\(A Xapian exception [^:]*\):.*$/\1/' < OUTPUT > OUTPUT.clean
 312 cat <<'EOF' >EXPECTED
 313 == stdout ==
 314 == stderr ==
 315 A Xapian exception occurred performing query
 316 Query string was: id:87ocn0qh6d.fsf@yoom.home.cworth.org
 317 EOF
 318 test_expect_equal_file EXPECTED OUTPUT.clean
 319 restore_database
 320
 321 cat <<EOF > c_head2
 322 #include <stdio.h>
 323 #include <notmuch.h>
 324 #include <notmuch-test.h>
 325 int main (int argc, char** argv)
 326 {
 327    notmuch_database_t *db;
 328    notmuch_status_t stat;
 329    char *msg = NULL;
 330    notmuch_message_t *message = NULL;
 331    const char *id = "1258471718-6781-1-git-send-email-dottedmag@dottedmag.net";
 332
 333    stat = notmuch_database_open_verbose (argv[1], NOTMUCH_DATABASE_MODE_READ_WRITE, &db, &msg);
 334    if (stat != NOTMUCH_STATUS_SUCCESS) {
 335      fprintf (stderr, "error opening database: %d %s\n", stat, msg ? msg : "");
 336      exit (1);
 337    }
 338    EXPECT0(notmuch_database_find_message (db, id, &message));
 339    EXPECT0(notmuch_database_close (db));
 340 EOF
 341
 342 test_begin_subtest "Handle getting message-id from closed database"
 343 cat c_head2 - c_tail <<'EOF' | test_C ${MAIL_DIR}
 344     {
 345         const char *id2;
 346         id2=notmuch_message_get_message_id (message);
 347         printf("%d\n%d\n", message != NULL, id2==NULL);
 348         stat = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
 349     }
 350 EOF
 351 cat <<EOF > EXPECTED
 352 == stdout ==
 353 1
 354 1
 355 == stderr ==
 356 A Xapian exception occurred at lib/message.cc:XXX: Database has been closed
 357 EOF
 358 test_expect_equal_file EXPECTED OUTPUT
 359
 360 test_begin_subtest "Handle getting thread-id from closed database"
 361 cat c_head2 - c_tail <<'EOF' | test_C ${MAIL_DIR}
 362     {
 363         const char *id2;
 364         id2=notmuch_message_get_thread_id (message);
 365         printf("%d\n%d\n", message != NULL, id2==NULL);
 366         stat = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
 367     }
 368 EOF
 369 cat <<EOF > EXPECTED
 370 == stdout ==
 371 1
 372 1
 373 == stderr ==
 374 A Xapian exception occurred at lib/message.cc:XXX: Database has been closed
 375 EOF
 376 test_expect_equal_file EXPECTED OUTPUT
 377
 378 test_begin_subtest "Handle getting header from closed database"
 379 cat c_head2 - c_tail <<'EOF' | test_C ${MAIL_DIR}
 380     {
 381         const char *from;
 382         from=notmuch_message_get_header (message, "from");
 383         printf("%s\n%d\n", id, from == NULL);
 384         stat = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
 385     }
 386 EOF
 387 cat <<EOF > EXPECTED
 388 == stdout ==
 389 1258471718-6781-1-git-send-email-dottedmag@dottedmag.net
 390 1
 391 == stderr ==
 392 A Xapian exception occurred at lib/message.cc:XXX: Database has been closed
 393 EOF
 394 test_expect_equal_file EXPECTED OUTPUT
 395
 396 # XXX TODO: test on a message from notmuch_thread_get_toplevel_messages
 397 # XXX this test only tests the trivial code path
 398 test_begin_subtest "Handle getting replies from closed database"
 399 cat c_head2 - c_tail <<'EOF' | test_C ${MAIL_DIR}
 400     {
 401         notmuch_messages_t *replies;
 402         replies = notmuch_message_get_replies (message);
 403         printf("%d\n%d\n", message != NULL, replies==NULL);
 404         stat = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
 405     }
 406 EOF
 407 cat <<EOF > EXPECTED
 408 == stdout ==
 409 1
 410 1
 411 == stderr ==
 412 EOF
 413 test_expect_equal_file EXPECTED OUTPUT
 414
 415 test_begin_subtest "Handle getting message filename from closed database"
 416 cat c_head2 - c_tail <<'EOF' | test_C ${MAIL_DIR}
 417     {
 418         const char *filename;
 419         filename = notmuch_message_get_filename (message);
 420         printf("%d\n%d\n", message != NULL, filename == NULL);
 421         stat = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
 422     }
 423 EOF
 424 cat <<EOF > EXPECTED
 425 == stdout ==
 426 1
 427 1
 428 == stderr ==
 429 A Xapian exception occurred at lib/message.cc:XXX: Database has been closed
 430 EOF
 431 test_expect_equal_file EXPECTED OUTPUT
 432
 433 test_begin_subtest "Handle getting all message filenames from closed database"
 434 cat c_head2 - c_tail <<'EOF' | test_C ${MAIL_DIR}
 435     {
 436         notmuch_filenames_t *filenames;
 437         filenames = notmuch_message_get_filenames (message);
 438         printf("%d\n%d\n", message != NULL, filenames == NULL);
 439         stat = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
 440     }
 441 EOF
 442 cat <<EOF > EXPECTED
 443 == stdout ==
 444 1
 445 1
 446 == stderr ==
 447 A Xapian exception occurred at lib/message.cc:XXX: Database has been closed
 448 EOF
 449 test_expect_equal_file EXPECTED OUTPUT
 450
 451 test_begin_subtest "Handle getting ghost flag from closed database"
 452 cat c_head2 - c_tail <<'EOF' | test_C ${MAIL_DIR}
 453     {
 454         notmuch_bool_t result;
 455         result = notmuch_message_get_flag (message, NOTMUCH_MESSAGE_FLAG_GHOST);
 456         printf("%d\n%d\n", message != NULL, result == FALSE);
 457         stat = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
 458     }
 459 EOF
 460 cat <<EOF > EXPECTED
 461 == stdout ==
 462 1
 463 1
 464 == stderr ==
 465 A Xapian exception occurred at lib/message.cc:XXX: Database has been closed
 466 EOF
 467 test_expect_equal_file EXPECTED OUTPUT
 468
 469 test_begin_subtest "Handle getting date from closed database"
 470 cat c_head2 - c_tail <<'EOF' | test_C ${MAIL_DIR}
 471     {
 472         time_t result;
 473         result = notmuch_message_get_date (message);
 474         printf("%d\n%d\n", message != NULL, result == 0);
 475         stat = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
 476     }
 477 EOF
 478 cat <<EOF > EXPECTED
 479 == stdout ==
 480 1
 481 1
 482 == stderr ==
 483 A Xapian exception occurred at lib/message.cc:XXX: Database has been closed
 484 EOF
 485 test_expect_equal_file EXPECTED OUTPUT
 486
 487 test_begin_subtest "Handle getting tags from closed database"
 488 cat c_head2 - c_tail <<'EOF' | test_C ${MAIL_DIR}
 489     {
 490         notmuch_tags_t *result;
 491         result = notmuch_message_get_tags (message);
 492         printf("%d\n%d\n", message != NULL, result == NULL);
 493         stat = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
 494     }
 495 EOF
 496 cat <<EOF > EXPECTED
 497 == stdout ==
 498 1
 499 1
 500 == stderr ==
 501 A Xapian exception occurred at lib/message.cc:XXX: Database has been closed
 502 EOF
 503 test_expect_equal_file EXPECTED OUTPUT
 504
 505 test_begin_subtest "Handle counting files from closed database"
 506 cat c_head2 - c_tail <<'EOF' | test_C ${MAIL_DIR}
 507     {
 508         int result;
 509         result = notmuch_message_count_files (message);
 510         printf("%d\n%d\n", message != NULL, result < 0);
 511         stat = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
 512     }
 513 EOF
 514 cat <<EOF > EXPECTED
 515 == stdout ==
 516 1
 517 1
 518 == stderr ==
 519 A Xapian exception occurred at lib/message.cc:XXX: Database has been closed
 520 EOF
 521 test_expect_equal_file EXPECTED OUTPUT
 522
 523 test_begin_subtest "Handle adding tag with closed database"
 524 cat c_head2 - c_tail <<'EOF' | test_C ${MAIL_DIR}
 525     {
 526         stat = notmuch_message_add_tag (message, "boom");
 527         printf("%d\n%d\n", message != NULL, stat == NOTMUCH_STATUS_XAPIAN_EXCEPTION);
 528     }
 529 EOF
 530 cat <<EOF > EXPECTED
 531 == stdout ==
 532 1
 533 1
 534 == stderr ==
 535 A Xapian exception occurred at lib/message.cc:XXX: Database has been closed
 536 EOF
 537 test_expect_equal_file EXPECTED OUTPUT
 538
 539 test_begin_subtest "Handle removing tag with closed database"
 540 cat c_head2 - c_tail <<'EOF' | test_C ${MAIL_DIR}
 541     {
 542         stat = notmuch_message_remove_tag (message, "boom");
 543         printf("%d\n%d\n", message != NULL, stat == NOTMUCH_STATUS_XAPIAN_EXCEPTION);
 544     }
 545 EOF
 546 cat <<EOF > EXPECTED
 547 == stdout ==
 548 1
 549 1
 550 == stderr ==
 551 A Xapian exception occurred at lib/message.cc:XXX: Database has been closed
 552 EOF
 553 test_expect_equal_file EXPECTED OUTPUT
 554
 555 test_begin_subtest "Handle read maildir flag with closed database"
 556 cat c_head2 - c_tail <<'EOF' | test_C ${MAIL_DIR}
 557     {
 558         notmuch_bool_t is_set = -1;
 559         is_set = notmuch_message_has_maildir_flag (message, 'S');
 560         printf("%d\n%d\n", message != NULL, is_set == FALSE || is_set == TRUE);
 561         stat = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
 562     }
 563 EOF
 564 cat <<EOF > EXPECTED
 565 == stdout ==
 566 1
 567 1
 568 == stderr ==
 569 A Xapian exception occurred at lib/message.cc:XXX: Database has been closed
 570 EOF
 571 test_expect_equal_file EXPECTED OUTPUT
 572
 573 test_begin_subtest "Handle checking maildir flag with closed db (new API)"
 574 cat c_head2 - c_tail <<'EOF' | test_C ${MAIL_DIR}
 575     {
 576         notmuch_bool_t out;
 577         stat = notmuch_message_has_maildir_flag_st (message, 'S', &out);
 578         printf("%d\n%d\n", message != NULL,  stat == NOTMUCH_STATUS_XAPIAN_EXCEPTION);
 579     }
 580 EOF
 581 cat <<EOF > EXPECTED
 582 == stdout ==
 583 1
 584 1
 585 == stderr ==
 586 A Xapian exception occurred at lib/message.cc:XXX: Database has been closed
 587 EOF
 588 test_expect_equal_file EXPECTED OUTPUT
 589
 590 test_begin_subtest "Handle converting maildir flags to tags with closed db"
 591 cat c_head2 - c_tail <<'EOF' | test_C ${MAIL_DIR}
 592     {
 593         stat = notmuch_message_maildir_flags_to_tags (message);
 594         printf("%d\n%d\n", message != NULL,  stat == NOTMUCH_STATUS_XAPIAN_EXCEPTION);
 595     }
 596 EOF
 597 cat <<EOF > EXPECTED
 598 == stdout ==
 599 1
 600 1
 601 == stderr ==
 602 A Xapian exception occurred at lib/message.cc:XXX: Database has been closed
 603 EOF
 604 test_expect_equal_file EXPECTED OUTPUT
 605
 606 test_begin_subtest "Handle removing all tags with closed db"
 607 cat c_head2 - c_tail <<'EOF' | test_C ${MAIL_DIR}
 608     {
 609         stat = notmuch_message_remove_all_tags (message);
 610         printf("%d\n%d\n", message != NULL,  stat == NOTMUCH_STATUS_XAPIAN_EXCEPTION);
 611     }
 612 EOF
 613 cat <<EOF > EXPECTED
 614 == stdout ==
 615 1
 616 1
 617 == stderr ==
 618 A Xapian exception occurred at lib/message.cc:XXX: Database has been closed
 619 EOF
 620 test_expect_equal_file EXPECTED OUTPUT
 621
 622 test_begin_subtest "Handle freezing message with closed db"
 623 cat c_head2 - c_tail <<'EOF' | test_C ${MAIL_DIR}
 624     {
 625         stat = notmuch_message_freeze (message);
 626         printf("%d\n%d\n", message != NULL,  stat == NOTMUCH_STATUS_SUCCESS);
 627     }
 628 EOF
 629 cat <<EOF > EXPECTED
 630 == stdout ==
 631 1
 632 1
 633 == stderr ==
 634 EOF
 635 test_expect_equal_file EXPECTED OUTPUT
 636
 637 test_begin_subtest "Handle thawing message with closed db"
 638 cat c_head2 - c_tail <<'EOF' | test_C ${MAIL_DIR}
 639     {
 640         stat = notmuch_message_thaw (message);
 641         printf("%d\n%d\n", message != NULL,  stat == NOTMUCH_STATUS_UNBALANCED_FREEZE_THAW);
 642     }
 643 EOF
 644 cat <<EOF > EXPECTED
 645 == stdout ==
 646 1
 647 1
 648 == stderr ==
 649 EOF
 650 test_expect_equal_file EXPECTED OUTPUT
 651
 652 test_begin_subtest "Handle destroying message with closed db"
 653 cat c_head2 - c_tail <<'EOF' | test_C ${MAIL_DIR}
 654     {
 655         notmuch_message_destroy (message);
 656         printf("%d\n%d\n", message != NULL,  1);
 657     }
 658 EOF
 659 cat <<EOF > EXPECTED
 660 == stdout ==
 661 1
 662 1
 663 == stderr ==
 664 EOF
 665 test_expect_equal_file EXPECTED OUTPUT
 666
 667 test_begin_subtest "Handle retrieving closed db from message"
 668 cat c_head2 - c_tail <<'EOF' | test_C ${MAIL_DIR}
 669     {
 670         notmuch_database_t *db2;
 671         db2 = notmuch_message_get_database (message);
 672         printf("%d\n%d\n", message != NULL,  db == db2);
 673     }
 674 EOF
 675 cat <<EOF > EXPECTED
 676 == stdout ==
 677 1
 678 1
 679 == stderr ==
 680 EOF
 681 test_expect_equal_file EXPECTED OUTPUT
 682
 683 test_begin_subtest "Handle reindexing message with closed db"
 684 cat c_head2 - c_tail <<'EOF' | test_C ${MAIL_DIR}
 685     {
 686         stat = notmuch_message_reindex (message, NULL);
 687         printf("%d\n%d\n", message != NULL,  stat == NOTMUCH_STATUS_XAPIAN_EXCEPTION);
 688     }
 689 EOF
 690 cat <<EOF > EXPECTED
 691 == stdout ==
 692 1
 693 1
 694 == stderr ==
 695 A Xapian exception occurred at lib/message.cc:XXX: Database has been closed
 696 EOF
 697 test_expect_equal_file EXPECTED OUTPUT
 698
 699 test_done