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

   1 #
   2 # Copyright (c) 2005 Junio C Hamano
   3 # Copyright (c) 2010 Notmuch Developers
   4 #
   5 # This program is free software: you can redistribute it and/or modify
   6 # it under the terms of the GNU General Public License as published by
   7 # the Free Software Foundation, either version 2 of the License, or
   8 # (at your option) any later version.
   9 #
  10 # This program is distributed in the hope that it will be useful,
  11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 # GNU General Public License for more details.
  14 #
  15 # You should have received a copy of the GNU General Public License
  16 # along with this program.  If not, see https://www.gnu.org/licenses/ .
  17
  18 if [ ${BASH_VERSINFO[0]} -lt 4 ]; then
  19     echo "Error: The notmuch test suite requires a bash version >= 4.0"
  20     echo "due to use of associative arrays within the test suite."
  21     echo "Please try again with a newer bash (or help us fix the"
  22     echo "test suite to be more portable). Thanks."
  23     exit 1
  24 fi
  25
  26 # Make sure echo builtin does not expand backslash-escape sequences by default.
  27 shopt -u xpg_echo
  28
  29 # Ensure NOTMUCH_SRCDIR and NOTMUCH_BUILDDIR are set.
  30 . $(dirname "$0")/export-dirs.sh || exit 1
  31
  32 # It appears that people try to run tests without building...
  33 if [[ ! -x "$NOTMUCH_BUILDDIR/notmuch" ]]; then
  34         echo >&2 'You do not seem to have built notmuch yet.'
  35         exit 1
  36 fi
  37
  38 this_test=${0##*/}
  39 this_test=${this_test%.sh}
  40 this_test_bare=${this_test#T[0-9][0-9][0-9]-}
  41
  42 # if --tee was passed, write the output not only to the terminal, but
  43 # additionally to the file test-results/$BASENAME.out, too.
  44 case "$GIT_TEST_TEE_STARTED, $* " in
  45 done,*)
  46         # do not redirect again
  47         ;;
  48 *' --tee '*|*' --va'*)
  49         mkdir -p test-results
  50         BASE=test-results/$this_test
  51         (GIT_TEST_TEE_STARTED=done "$BASH" "$0" "$@" 2>&1;
  52          echo $? > $BASE.exit) | tee $BASE.out
  53         test "$(cat $BASE.exit)" = 0
  54         exit
  55         ;;
  56 esac
  57
  58 # STDIN from /dev/null. EOF for readers (and ENOTTY for tty related ioctls).
  59 exec </dev/null
  60
  61 # Save STDOUT to fd 6 and STDERR to fd 7.
  62 exec 6>&1 7>&2
  63 # Make xtrace debugging (when used) use redirected STDERR, with verbose lead:
  64 BASH_XTRACEFD=7
  65 export PS4='+(${BASH_SOURCE}:${LINENO}): ${FUNCNAME[0]:+${FUNCNAME[0]}(): }'
  66
  67 # Keep the original TERM for say_color and test_emacs
  68 ORIGINAL_TERM=$TERM
  69
  70 # Set SMART_TERM to vt100 for known dumb/unknown terminal.
  71 # Otherwise use whatever TERM is currently used so that
  72 # users' actual TERM environments are being used in tests.
  73 case ${TERM-} in
  74         '' | dumb | unknown )
  75                 SMART_TERM=vt100 ;;
  76         *)
  77                 SMART_TERM=$TERM ;;
  78 esac
  79
  80 # For repeatability, reset the environment to known value.
  81 LANG=C
  82 LC_ALL=C
  83 PAGER=cat
  84 TZ=UTC
  85 TERM=dumb
  86 export LANG LC_ALL PAGER TERM TZ
  87 GIT_TEST_CMP=${GIT_TEST_CMP:-diff -u}
  88 if [[ ( -n "$TEST_EMACS" && -z "$TEST_EMACSCLIENT" ) || \
  89       ( -z "$TEST_EMACS" && -n "$TEST_EMACSCLIENT" ) ]]; then
  90     echo "error: must specify both or neither of TEST_EMACS and TEST_EMACSCLIENT" >&2
  91     exit 1
  92 fi
  93 TEST_EMACS=${TEST_EMACS:-${EMACS:-emacs}}
  94 TEST_EMACSCLIENT=${TEST_EMACSCLIENT:-emacsclient}
  95 TEST_GDB=${TEST_GDB:-gdb}
  96 TEST_CC=${TEST_CC:-cc}
  97 TEST_CFLAGS=${TEST_CFLAGS:-"-g -O0"}
  98 TEST_SHIM_CFLAGS=${TEST_SHIM_CFLAGS:-"-fpic -shared"}
  99 TEST_SHIM_LDFLAGS=${TEST_SHIM_LDFLAGS:-"-ldl"}
 100
 101 # Protect ourselves from common misconfiguration to export
 102 # CDPATH into the environment
 103 unset CDPATH
 104
 105 unset GREP_OPTIONS
 106
 107 # For lib/open.cc:_load_key_file
 108 unset XDG_CONFIG_HOME
 109
 110 # For emacsclient
 111 unset ALTERNATE_EDITOR
 112
 113 # for reproducibility
 114 unset EMAIL
 115 unset NAME
 116
 117 add_gnupg_home ()
 118 {
 119     [ -e "${GNUPGHOME}/gpg.conf" ] && return
 120     _gnupg_exit () { gpgconf --kill all 2>/dev/null || true; }
 121     at_exit_function _gnupg_exit
 122     mkdir -p -m 0700 "$GNUPGHOME"
 123     gpg --no-tty --import <$NOTMUCH_SRCDIR/test/gnupg-secret-key.asc >"$GNUPGHOME"/import.log 2>&1
 124     test_debug "cat $GNUPGHOME/import.log"
 125     if (gpg --quick-random --version >/dev/null 2>&1) ; then
 126         echo quick-random >> "$GNUPGHOME"/gpg.conf
 127     elif (gpg --debug-quick-random --version >/dev/null 2>&1) ; then
 128         echo debug-quick-random >> "$GNUPGHOME"/gpg.conf
 129     fi
 130     echo no-emit-version >> "$GNUPGHOME"/gpg.conf
 131
 132     # Change this if we ship a new test key
 133     FINGERPRINT="5AEAB11F5E33DCE875DDB75B6D92612D94E46381"
 134     SELF_USERID="Notmuch Test Suite <test_suite@notmuchmail.org> (INSECURE!)"
 135     printf '%s:6:\n' "$FINGERPRINT" | gpg --quiet --batch --no-tty --import-ownertrust
 136 }
 137
 138 add_gpgsm_home ()
 139 {
 140     local fpr
 141     [ -e "$GNUPGHOME/gpgsm.conf" ] && return
 142     _gnupg_exit () { gpgconf --kill all 2>/dev/null || true; }
 143     at_exit_function _gnupg_exit
 144     mkdir -p -m 0700 "$GNUPGHOME"
 145     openssl pkcs12 -export -passout pass: -inkey "$NOTMUCH_SRCDIR/test/smime/key+cert.pem" \
 146         < "$NOTMUCH_SRCDIR/test/smime/test.crt" | \
 147         gpgsm --batch --no-tty --no-common-certs-import --pinentry-mode=loopback --passphrase-fd 3 \
 148               --disable-dirmngr --import  >"$GNUPGHOME"/import.log 2>&1 3<<<''
 149     fpr=$(gpgsm --batch --list-key test_suite@notmuchmail.org | sed -n 's/.*fingerprint: //p')
 150     echo "$fpr S relax" >> "$GNUPGHOME/trustlist.txt"
 151     gpgsm --quiet --batch --no-tty --no-common-certs-import --disable-dirmngr --import < $NOTMUCH_SRCDIR/test/smime/ca.crt
 152     echo "4D:E0:FF:63:C0:E9:EC:01:29:11:C8:7A:EE:DA:3A:9A:7F:6E:C1:0D S" >> "$GNUPGHOME/trustlist.txt"
 153     printf '%s::1\n' include-certs disable-crl-checks | gpgconf --output /dev/null --change-options gpgsm
 154     gpgsm --batch --no-tty --no-common-certs-import --pinentry-mode=loopback --passphrase-fd 3 \
 155               --disable-dirmngr --import "$NOTMUCH_SRCDIR/test/smime/bob.p12" >>"$GNUPGHOME"/import.log 2>&1 3<<<''
 156     test_debug "cat $GNUPGHOME/import.log"
 157 }
 158
 159 # Each test should start with something like this, after copyright notices:
 160 #
 161 # test_description='Description of this test...
 162 # This test checks if command xyzzy does the right thing...
 163 # '
 164 # . ./test-lib.sh || exit 1
 165
 166 color=maybe
 167
 168 while test "$#" -ne 0
 169 do
 170         case "$1" in
 171         -d|--debug)
 172                 debug=t; shift ;;
 173         -i|--immediate)
 174                 immediate=t; shift ;;
 175         -h|--help)
 176                 help=t; shift ;;
 177         -v|--verbose)
 178                 verbose=t; shift ;;
 179         -q|--quiet)
 180                 quiet=t; shift ;;
 181         --with-dashes)
 182                 with_dashes=t; shift ;;
 183         --no-color)
 184                 color=; shift ;;
 185         --no-python)
 186                 # noop now...
 187                 shift ;;
 188         --valgrind)
 189                 valgrind=t; verbose=t; shift ;;
 190         --tee)
 191                 shift ;; # was handled already
 192         *)
 193                 echo "error: unknown test option '$1'" >&2; exit 1 ;;
 194         esac
 195 done
 196
 197 if test -n "$debug"; then
 198     print_subtest () {
 199         printf " %-4s" "[$((test_count - 1))]"
 200     }
 201 else
 202     print_subtest () {
 203         true
 204     }
 205 fi
 206
 207 test -n "$COLORS_WITHOUT_TTY" || [ -t 1 ] || color=
 208
 209 if [ -n "$color" ] && [ "$ORIGINAL_TERM" != 'dumb' ] && (
 210                 TERM=$ORIGINAL_TERM &&
 211                 export TERM &&
 212                 tput bold
 213                 tput setaf
 214                 tput sgr0
 215         ) >/dev/null 2>&1
 216 then
 217         color=t
 218 else
 219         color=
 220 fi
 221
 222 if test -n "$color"; then
 223         say_color () {
 224                 (
 225                 TERM=$ORIGINAL_TERM
 226                 export TERM
 227                 case "$1" in
 228                         error) tput bold; tput setaf 1;; # bold red
 229                         skip)  tput bold; tput setaf 2;; # bold green
 230                         pass)  tput setaf 2;;            # green
 231                         info)  tput setaf 3;;            # brown
 232                         *) test -n "$quiet" && return;;
 233                 esac
 234                 shift
 235                 printf " "
 236                 printf "$@"
 237                 tput sgr0
 238                 print_subtest
 239                 )
 240         }
 241 else
 242         say_color() {
 243                 test -z "$1" && test -n "$quiet" && return
 244                 shift
 245                 printf " "
 246                 printf "$@"
 247                 print_subtest
 248         }
 249 fi
 250
 251 error () {
 252         say_color error "error: $*\n"
 253         GIT_EXIT_OK=t
 254         exit 1
 255 }
 256
 257 say () {
 258         say_color info "$*"
 259 }
 260
 261 test "${test_description}" != "" ||
 262 error "Test script did not set test_description."
 263
 264 if test "$help" = "t"
 265 then
 266         echo "Tests ${test_description}"
 267         exit 0
 268 fi
 269
 270 test_description_printed=
 271 print_test_description ()
 272 {
 273         test -z "$test_description_printed" || return 0
 274         echo
 275         echo $this_test: "Testing ${test_description}"
 276         test_description_printed=1
 277 }
 278 if [ -z "$NOTMUCH_TEST_QUIET" ]
 279 then
 280         print_test_description
 281 fi
 282
 283 test_failure=0
 284 test_count=0
 285 test_fixed=0
 286 test_broken=0
 287 test_success=0
 288
 289 declare -a _exit_functions=()
 290
 291 at_exit_function () {
 292         _exit_functions=($1 ${_exit_functions[@]/$1})
 293 }
 294
 295 rm_exit_function () {
 296         _exit_functions=(${_exit_functions[@]/$1})
 297 }
 298
 299 _exit_common () {
 300         code=$?
 301         trap - EXIT
 302         set +ex
 303         for _fn in ${_exit_functions[@]}; do $_fn; done
 304         rm -rf "$TEST_TMPDIR"
 305 }
 306
 307 trap_exit () {
 308         _exit_common
 309         if test -n "$GIT_EXIT_OK"
 310         then
 311                 exit $code
 312         else
 313                 exec >&6
 314                 say_color error '%-6s' FATAL
 315                 echo " $test_subtest_name"
 316                 echo
 317                 echo "Unexpected exit while executing $0. Exit code $code."
 318                 exit 1
 319         fi
 320 }
 321
 322 trap_signal () {
 323         _exit_common
 324         echo >&6 "FATAL: $0: interrupted by signal" $((code - 128))
 325         exit $code
 326 }
 327
 328 die () {
 329         _exit_common
 330         exec >&6
 331         say_color error '%-6s' FATAL
 332         echo " $*"
 333         echo
 334         echo "Unexpected exit while executing $0."
 335         exit 1
 336 }
 337
 338 GIT_EXIT_OK=
 339 # Note: TEST_TMPDIR *NOT* exported!
 340 TEST_TMPDIR=$(mktemp -d "${TMPDIR:-/tmp}/notmuch-test-$$.XXXXXX")
 341 # Put GNUPGHOME in TMPDIR to avoid problems with long paths.
 342 export GNUPGHOME="${TEST_TMPDIR}/gnupg"
 343 trap 'trap_exit' EXIT
 344 trap 'trap_signal' HUP INT TERM
 345
 346 # Deliver a message with emacs and add it to the database
 347 #
 348 # Uses emacs to generate and deliver a message to the mail store.
 349 # Accepts arbitrary extra emacs/elisp functions to modify the message
 350 # before sending, which is useful to doing things like attaching files
 351 # to the message and encrypting/signing.
 352 emacs_deliver_message ()
 353 {
 354     local subject body smtp_dummy_pid smtp_dummy_port
 355     subject="$1"
 356     body="$2"
 357     shift 2
 358     # before we can send a message, we have to prepare the FCC maildir
 359     mkdir -p "$MAIL_DIR"/sent/{cur,new,tmp}
 360     # eval'ing smtp-dummy --background will set smtp_dummy_pid and -_port
 361     smtp_dummy_pid= smtp_dummy_port=
 362     eval `$TEST_DIRECTORY/smtp-dummy --background sent_message`
 363     test -n "$smtp_dummy_pid" || return 1
 364     test -n "$smtp_dummy_port" || return 1
 365
 366     test_emacs \
 367         "(let ((message-send-mail-function 'message-smtpmail-send-it)
 368                (mail-host-address \"example.com\")
 369                (smtpmail-smtp-server \"localhost\")
 370                (smtpmail-smtp-service \"${smtp_dummy_port}\"))
 371            (notmuch-mua-mail)
 372            (message-goto-to)
 373            (insert \"test_suite@notmuchmail.org\nDate: 01 Jan 2000 12:00:00 -0000\")
 374            (message-goto-subject)
 375            (insert \"${subject}\")
 376            (message-goto-body)
 377            (insert \"${body}\")
 378            $*
 379            (notmuch-mua-send-and-exit))"
 380
 381     # In case message was sent properly, client waits for confirmation
 382     # before exiting and resuming control here; therefore making sure
 383     # that server exits by sending (KILL) signal to it is safe.
 384     kill -9 $smtp_dummy_pid
 385     notmuch new >/dev/null
 386 }
 387
 388 # Pretend to deliver a message with emacs. Really save it to a file
 389 # and add it to the database
 390 #
 391 # Uses emacs to generate and deliver a message to the mail store.
 392 # Accepts arbitrary extra emacs/elisp functions to modify the message
 393 # before sending, which is useful to doing things like attaching files
 394 # to the message and encrypting/signing.
 395 #
 396 # If any GNU-style long-arguments (like --quiet or --decrypt=true) are
 397 # at the head of the argument list, they are sent directly to "notmuch
 398 # new" after message delivery
 399 emacs_fcc_message ()
 400 {
 401     local nmn_args subject body
 402     nmn_args=''
 403     while [[ "$1" =~ ^-- ]]; do
 404         nmn_args="$nmn_args $1"
 405         shift
 406     done
 407     subject="$1"
 408     body="$2"
 409     shift 2
 410     # before we can send a message, we have to prepare the FCC maildir
 411     mkdir -p "$MAIL_DIR"/sent/{cur,new,tmp}
 412
 413     test_emacs \
 414         "(let ((message-send-mail-function (lambda () t))
 415                (mail-host-address \"example.com\"))
 416            (notmuch-mua-mail)
 417            (message-goto-to)
 418            (insert \"test_suite@notmuchmail.org\nDate: 01 Jan 2000 12:00:00 -0000\")
 419            (message-goto-subject)
 420            (insert \"${subject}\")
 421            (message-goto-body)
 422            (insert \"${body}\")
 423            $*
 424            (let ((mml-secure-smime-sign-with-sender t)
 425                  (mml-secure-openpgp-sign-with-sender t))
 426              (notmuch-mua-send-and-exit)))" || return 1
 427     notmuch new $nmn_args >/dev/null
 428 }
 429
 430 # Add an existing, fixed corpus of email to the database.
 431 #
 432 # $1 is the corpus dir under corpora to add, using "default" if unset.
 433 #
 434 # The default corpus is based on about 50 messages from early in the
 435 # history of the notmuch mailing list, which allows for reliably
 436 # testing commands that need to operate on a not-totally-trivial
 437 # number of messages.
 438 add_email_corpus ()
 439 {
 440     local corpus
 441     corpus=${1:-default}
 442
 443     rm -rf ${MAIL_DIR}
 444     cp -a $NOTMUCH_SRCDIR/test/corpora/$corpus ${MAIL_DIR}
 445     notmuch new >/dev/null || die "'notmuch new' failed while adding email corpus"
 446 }
 447
 448 test_begin_subtest ()
 449 {
 450     if [ -n "$inside_subtest" ]; then
 451         exec 1>&6 2>&7          # Restore stdout and stderr
 452         error "bug in test script: Missing test_expect_equal in ${BASH_SOURCE[1]}:${BASH_LINENO[0]}"
 453     fi
 454     test_subtest_name="$1"
 455     test_reset_state_
 456     # Redirect test output to the previously prepared file descriptors
 457     # 3 and 4 (see below)
 458     if test "$verbose" != "t"; then exec 4>test.output 3>&4; fi
 459     exec >&3 2>&4
 460     inside_subtest=t
 461 }
 462
 463 # Pass test if two arguments match
 464 #
 465 # Note: Unlike all other test_expect_* functions, this function does
 466 # not accept a test name. Instead, the caller should call
 467 # test_begin_subtest before calling this function in order to set the
 468 # name.
 469 test_expect_equal ()
 470 {
 471         local output expected testname
 472         exec 1>&6 2>&7          # Restore stdout and stderr
 473         if [ -z "$inside_subtest" ]; then
 474                 error "bug in the test script: test_expect_equal without test_begin_subtest"
 475         fi
 476         inside_subtest=
 477         test "$#" = 2 ||
 478         error "bug in the test script: not 2 parameters to test_expect_equal"
 479
 480         output="$1"
 481         expected="$2"
 482         if ! test_skip "$test_subtest_name"
 483         then
 484                 if [ "$output" = "$expected" ]; then
 485                         test_ok_
 486                 else
 487                         testname=$this_test.$test_count
 488                         echo "$expected" > $testname.expected
 489                         echo "$output" > $testname.output
 490                         test_failure_ "$(diff -u $testname.expected $testname.output)"
 491                 fi
 492     fi
 493 }
 494
 495 # Like test_expect_equal, but takes two filenames.
 496 test_expect_equal_file ()
 497 {
 498         local file1 file2 testname basename1 basename2
 499         exec 1>&6 2>&7          # Restore stdout and stderr
 500         if [ -z "$inside_subtest" ]; then
 501                 error "bug in the test script: test_expect_equal_file without test_begin_subtest"
 502         fi
 503         inside_subtest=
 504         test "$#" = 2 ||
 505         error "bug in the test script: not 2 parameters to test_expect_equal_file"
 506
 507         file1="$1"
 508         file2="$2"
 509         if ! test_skip "$test_subtest_name"
 510         then
 511                 if diff -q "$file1" "$file2" >/dev/null ; then
 512                         test_ok_
 513                 else
 514                         testname=$this_test.$test_count
 515                         basename1=`basename "$file1"`
 516                         basename2=`basename "$file2"`
 517                         cp "$file1" "$testname.$basename1"
 518                         cp "$file2" "$testname.$basename2"
 519                         test_failure_ "$(diff -u "$testname.$basename1" "$testname.$basename2")"
 520                 fi
 521     fi
 522 }
 523
 524 # Like test_expect_equal, but arguments are JSON expressions to be
 525 # canonicalized before diff'ing.  If an argument cannot be parsed, it
 526 # is used unchanged so that there's something to diff against.
 527 test_expect_equal_json () {
 528     local script output expected
 529     # The test suite forces LC_ALL=C, but this causes Python 3 to
 530     # decode stdin as ASCII.  We need to read JSON in UTF-8, so
 531     # override Python's stdio encoding defaults.
 532     script='import json, sys; json.dump(json.load(sys.stdin), sys.stdout, sort_keys=True, indent=4)'
 533     output=$(echo "$1" | PYTHONIOENCODING=utf-8 $NOTMUCH_PYTHON -c "$script" \
 534         || echo "$1")
 535     expected=$(echo "$2" | PYTHONIOENCODING=utf-8 $NOTMUCH_PYTHON -c "$script" \
 536         || echo "$2")
 537     shift 2
 538     test_expect_equal "$output" "$expected" "$@"
 539 }
 540
 541 # Ensure that the argument is valid JSON data.
 542 test_valid_json () {
 543     PYTHONIOENCODING=utf-8 $NOTMUCH_PYTHON -c "import sys, json; json.load(sys.stdin)" <<<"$1"
 544     test_expect_equal "$?" 0
 545 }
 546
 547 # Sort the top-level list of JSON data from stdin.
 548 test_sort_json () {
 549     PYTHONIOENCODING=utf-8 $NOTMUCH_PYTHON -c \
 550         "import sys, json; json.dump(sorted(json.load(sys.stdin)),sys.stdout)"
 551 }
 552
 553 # test for json objects:
 554 # read the source of test/json_check_nodes.py (or the output when
 555 # invoking it without arguments) for an explanation of the syntax.
 556 test_json_nodes () {
 557         local output
 558         exec 1>&6 2>&7          # Restore stdout and stderr
 559         if [ -z "$inside_subtest" ]; then
 560                 error "bug in the test script: test_json_eval without test_begin_subtest"
 561         fi
 562         inside_subtest=
 563         test "$#" > 0 ||
 564             error "bug in the test script: test_json_nodes needs at least 1 parameter"
 565
 566         if ! test_skip "$test_subtest_name"
 567         then
 568             output=$(PYTHONIOENCODING=utf-8 $NOTMUCH_PYTHON -B "$NOTMUCH_SRCDIR"/test/json_check_nodes.py "$@")
 569                 if [ "$?" = 0 ]
 570                 then
 571                         test_ok_
 572                 else
 573                         test_failure_ "$output"
 574                 fi
 575         fi
 576 }
 577
 578 test_emacs_expect_t () {
 579         local result
 580         test "$#" = 1 ||
 581         error "bug in the test script: not 1 parameter to test_emacs_expect_t"
 582         if [ -z "$inside_subtest" ]; then
 583                 error "bug in the test script: test_emacs_expect_t without test_begin_subtest"
 584         fi
 585
 586         # Run the test.
 587         if ! test_skip "$test_subtest_name"
 588         then
 589                 test_emacs "(notmuch-test-run $1)" >/dev/null
 590
 591                 # Restore state after the test.
 592                 exec 1>&6 2>&7          # Restore stdout and stderr
 593                 inside_subtest=
 594
 595                 # Report success/failure.
 596                 result=$(cat OUTPUT)
 597                 if [ "$result" = t ]
 598                 then
 599                         test_ok_
 600                 else
 601                         test_failure_ "${result}"
 602                 fi
 603         else
 604                 # Restore state after the (non) test.
 605                 exec 1>&6 2>&7          # Restore stdout and stderr
 606                 inside_subtest=
 607         fi
 608 }
 609
 610 NOTMUCH_NEW ()
 611 {
 612     notmuch new "${@}" | grep -v -E -e '^Processed [0-9]*( total)? file|Found [0-9]* total file'
 613 }
 614
 615 NOTMUCH_DUMP_TAGS ()
 616 {
 617     # this relies on the default format being batch-tag, otherwise some tests will break
 618     notmuch dump --include=tags "${@}" | sed '/^#/d' | sort
 619 }
 620
 621 notmuch_drop_mail_headers ()
 622 {
 623     $NOTMUCH_PYTHON -c '
 624 import email, sys
 625 msg = email.message_from_file(sys.stdin)
 626 for hdr in sys.argv[1:]: del msg[hdr]
 627 print(msg.as_string(False))
 628 ' "$@"
 629 }
 630
 631 notmuch_exception_sanitize ()
 632 {
 633     perl -pe 's/(A Xapian exception occurred at .*[.]cc?):([0-9]*)/\1:XXX/'
 634 }
 635
 636 notmuch_search_sanitize ()
 637 {
 638     perl -pe 's/("?thread"?: ?)("?)................("?)/\1\2XXX\3/'
 639 }
 640
 641 notmuch_search_files_sanitize ()
 642 {
 643     notmuch_dir_sanitize
 644 }
 645
 646 notmuch_dir_sanitize ()
 647 {
 648     sed -e "s,$MAIL_DIR,MAIL_DIR," -e "s,${PWD},CWD,g" "$@"
 649 }
 650
 651 NOTMUCH_SHOW_FILENAME_SQUELCH='s,filename:.*/mail,filename:/XXX/mail,'
 652 notmuch_show_sanitize ()
 653 {
 654     sed -e "$NOTMUCH_SHOW_FILENAME_SQUELCH"
 655 }
 656 notmuch_show_sanitize_all ()
 657 {
 658     sed \
 659         -e 's| filename:.*| filename:XXXXX|' \
 660         -e 's| id:[^ ]* | id:XXXXX |' | \
 661         notmuch_date_sanitize
 662 }
 663
 664 notmuch_json_show_sanitize ()
 665 {
 666     sed \
 667         -e 's|"id": "[^"]*",|"id": "XXXXX",|g' \
 668         -e 's|"Date": "Fri, 05 Jan 2001 [^"]*0000"|"Date": "GENERATED_DATE"|g' \
 669         -e 's|"filename": "signature.asc",||g' \
 670         -e 's|"filename": \["/[^"]*"\],|"filename": \["YYYYY"\],|g' \
 671         -e 's|"timestamp": 97.......|"timestamp": 42|g' \
 672         -e 's|"content-length": [1-9][0-9]*|"content-length": "NONZERO"|g'
 673 }
 674
 675 notmuch_emacs_error_sanitize ()
 676 {
 677     local command
 678     command=$1
 679     shift
 680     for file in "$@"; do
 681         echo "=== $file ==="
 682         cat "$file"
 683     done | sed \
 684         -e 's/^\[.*\]$/[XXX]/' \
 685         -e "s|^\(command: \)\{0,1\}/.*/$command|\1YYY/$command|"
 686 }
 687
 688 notmuch_date_sanitize ()
 689 {
 690     sed \
 691         -e 's/^Date: Fri, 05 Jan 2001 .*0000/Date: GENERATED_DATE/'
 692 }
 693
 694 notmuch_uuid_sanitize ()
 695 {
 696     sed 's/[0-9a-f]\{8\}-[0-9a-f]\{4\}-[0-9a-f]\{4\}-[0-9a-f]\{4\}-[0-9a-f]\{12\}/UUID/g'
 697 }
 698
 699 notmuch_built_with_sanitize ()
 700 {
 701     sed 's/^built_with[.]\(.*\)=.*$/built_with.\1=something/'
 702 }
 703
 704 notmuch_passwd_sanitize()
 705 {
 706     ${NOTMUCH_PYTHON} -c'
 707 import os, sys, pwd, socket
 708
 709 pw = pwd.getpwuid(os.getuid())
 710 user = pw.pw_name
 711 name = pw.pw_gecos.partition(",")[0]
 712 fqdn = socket.getaddrinfo(socket.gethostname(), 0, 0, socket.SOCK_STREAM, 0, socket.AI_CANONNAME)[0][3]
 713
 714 for l in sys.stdin:
 715     if user:
 716         l = l.replace(user, "USERNAME")
 717     if fqdn:
 718         l = l.replace(fqdn, "FQDN").replace(".(none)","")
 719     if name:
 720         l = l.replace(name, "USER_FULL_NAME")
 721     sys.stdout.write(l)
 722 '
 723 }
 724
 725 notmuch_config_sanitize ()
 726 {
 727     notmuch_dir_sanitize | notmuch_built_with_sanitize
 728 }
 729
 730 notmuch_show_part ()
 731 {
 732     awk '/^\014part}/{ f=0 }; { if (f) { print $0 } } /^\014part{ ID: '"$1"'/{ f=1 }'
 733 }
 734
 735 # End of notmuch helper functions
 736
 737 # Use test_set_prereq to tell that a particular prerequisite is available.
 738 #
 739 # The prerequisite can later be checked for by using test_have_prereq.
 740 #
 741 # The single parameter is the prerequisite tag (a simple word, in all
 742 # capital letters by convention).
 743
 744 test_set_prereq () {
 745         satisfied="$satisfied$1 "
 746 }
 747 satisfied=" "
 748
 749 test_have_prereq () {
 750         case $satisfied in
 751         *" $1 "*)
 752                 : yes, have it ;;
 753         *)
 754                 ! : nope ;;
 755         esac
 756 }
 757
 758 declare -A test_missing_external_prereq_
 759 declare -A test_subtest_missing_external_prereq_
 760
 761 # declare prerequisite for the given external binary
 762 test_declare_external_prereq () {
 763         local binary
 764         binary="$1"
 765         test "$#" = 2 && name=$2 || name="$binary(1)"
 766
 767         if ! hash $binary 2>/dev/null; then
 768                 test_missing_external_prereq_["${binary}"]=t
 769                 eval "
 770 $binary () {
 771         test_subtest_missing_external_prereq_[\"${name}\"]=t
 772         false
 773 }"
 774         fi
 775 }
 776
 777 # Explicitly require external prerequisite.  Useful when binary is
 778 # called indirectly (e.g. from emacs).
 779 # Returns success if dependency is available, failure otherwise.
 780 test_require_external_prereq () {
 781         local binary
 782         binary="$1"
 783         if [[ ${test_missing_external_prereq_["${binary}"]} == t ]]; then
 784                 # dependency is missing, call the replacement function to note it
 785                 eval "$binary"
 786         else
 787                 true
 788         fi
 789 }
 790
 791 # You are not expected to call test_ok_ and test_failure_ directly, use
 792 # the text_expect_* functions instead.
 793
 794 test_ok_ () {
 795         if test "$test_subtest_known_broken_" = "t"; then
 796                 test_known_broken_ok_
 797                 return
 798         fi
 799         test_success=$(($test_success + 1))
 800         if test -n "$NOTMUCH_TEST_QUIET"; then
 801                 return 0
 802         fi
 803         say_color pass "%-6s" "PASS"
 804         echo " $test_subtest_name"
 805 }
 806
 807 test_failure_ () {
 808         print_test_description
 809         if test "$test_subtest_known_broken_" = "t"; then
 810                 test_known_broken_failure_ "$@"
 811                 return
 812         fi
 813         test_failure=$(($test_failure + 1))
 814         test_failure_message_ "FAIL" "$test_subtest_name" "$@"
 815         test "$immediate" = "" || { GIT_EXIT_OK=t; exit 1; }
 816         return 1
 817 }
 818
 819 test_failure_message_ () {
 820         say_color error "%-6s" "$1"
 821         echo " $2"
 822         shift 2
 823         if [ "$#" != "0" ]; then
 824                 echo "$@" | sed -e 's/^/        /'
 825         fi
 826         if test "$verbose" != "t"; then cat test.output; fi
 827 }
 828
 829 test_known_broken_ok_ () {
 830         test_reset_state_
 831         test_fixed=$(($test_fixed+1))
 832         say_color pass "%-6s" "FIXED"
 833         echo " $test_subtest_name"
 834 }
 835
 836 test_known_broken_failure_ () {
 837         test_reset_state_
 838         test_broken=$(($test_broken+1))
 839         if [ -z "$NOTMUCH_TEST_QUIET" ]; then
 840                 test_failure_message_ "BROKEN" "$test_subtest_name" "$@"
 841         else
 842                 test_failure_message_ "BROKEN" "$test_subtest_name"
 843         fi
 844         return 1
 845 }
 846
 847 test_debug () {
 848         test "$debug" = "" || eval "$1"
 849 }
 850
 851 test_run_ () {
 852         test_cleanup=:
 853         if test "$verbose" != "t"; then exec 4>test.output 3>&4; fi
 854         eval >&3 2>&4 "$1"
 855         eval_ret=$?
 856         eval >&3 2>&4 "$test_cleanup"
 857         return 0
 858 }
 859
 860 test_skip () {
 861         test_count=$(($test_count+1))
 862         to_skip=
 863         for skp in $NOTMUCH_SKIP_TESTS
 864         do
 865                 case $this_test.$test_count in
 866                 $skp)
 867                         to_skip=t
 868                         break
 869                 esac
 870                 case $this_test_bare.$test_count in
 871                 $skp)
 872                         to_skip=t
 873                         break
 874                 esac
 875         done
 876         case "$to_skip" in
 877         t)
 878                 test_report_skip_ "$@"
 879                 ;;
 880         *)
 881                 test_check_missing_external_prereqs_ "$@"
 882                 ;;
 883         esac
 884 }
 885
 886 test_check_missing_external_prereqs_ () {
 887         if [[ ${#test_subtest_missing_external_prereq_[@]} != 0 ]]; then
 888                 say_color skip >&1 "missing prerequisites: "
 889                 echo ${!test_subtest_missing_external_prereq_[@]} >&1
 890                 test_report_skip_ "$@"
 891         else
 892                 false
 893         fi
 894 }
 895
 896 test_report_skip_ () {
 897         test_reset_state_
 898         say_color skip >&3 "skipping test:"
 899         echo " $@" >&3
 900         say_color skip "%-6s" "SKIP"
 901         echo " $1"
 902 }
 903
 904 test_subtest_known_broken () {
 905         test_subtest_known_broken_=t
 906 }
 907
 908 test_expect_success () {
 909         exec 1>&6 2>&7          # Restore stdout and stderr
 910         if [ -z "$inside_subtest" ]; then
 911                 error "bug in the test script: test_expect_success without test_begin_subtest"
 912         fi
 913         inside_subtest=
 914         test "$#" = 1 ||
 915         error "bug in the test script: not 1 parameters to test_expect_success"
 916
 917         if ! test_skip "$test_subtest_name"
 918         then
 919                 test_run_ "$1"
 920                 run_ret="$?"
 921                 # test_run_ may update missing external prerequisites
 922                 test_check_missing_external_prereqs_ "$@" ||
 923                 if [ "$run_ret" = 0 -a "$eval_ret" = 0 ]
 924                 then
 925                         test_ok_
 926                 else
 927                         test_failure_ "$1"
 928                 fi
 929         fi
 930 }
 931
 932 test_expect_code () {
 933         exec 1>&6 2>&7          # Restore stdout and stderr
 934         if [ -z "$inside_subtest" ]; then
 935                 error "bug in the test script: test_expect_code without test_begin_subtest"
 936         fi
 937         inside_subtest=
 938         test "$#" = 2 ||
 939         error "bug in the test script: not 2 parameters to test_expect_code"
 940
 941         if ! test_skip "$test_subtest_name"
 942         then
 943                 test_run_ "$2"
 944                 run_ret="$?"
 945                 # test_run_ may update missing external prerequisites,
 946                 test_check_missing_external_prereqs_ "$@" ||
 947                 if [ "$run_ret" = 0 -a "$eval_ret" = "$1" ]
 948                 then
 949                         test_ok_
 950                 else
 951                         test_failure_ "exit code $eval_ret, expected $1" "$2"
 952                 fi
 953         fi
 954 }
 955
 956 # This is not among top-level (test_expect_success)
 957 # but is a prefix that can be used in the test script, like:
 958 #
 959 #       test_expect_success 'complain and die' '
 960 #           do something &&
 961 #           do something else &&
 962 #           test_must_fail git checkout ../outerspace
 963 #       '
 964 #
 965 # Writing this as "! git checkout ../outerspace" is wrong, because
 966 # the failure could be due to a segv.  We want a controlled failure.
 967
 968 test_must_fail () {
 969         "$@"
 970         test $? -gt 0 -a $? -le 129 -o $? -gt 192
 971 }
 972
 973 # test_cmp is a helper function to compare actual and expected output.
 974 # You can use it like:
 975 #
 976 #       test_expect_success 'foo works' '
 977 #               echo expected >expected &&
 978 #               foo >actual &&
 979 #               test_cmp expected actual
 980 #       '
 981 #
 982 # This could be written as either "cmp" or "diff -u", but:
 983 # - cmp's output is not nearly as easy to read as diff -u
 984 # - not all diff versions understand "-u"
 985
 986 test_cmp() {
 987         $GIT_TEST_CMP "$@"
 988 }
 989
 990 # This function can be used to schedule some commands to be run
 991 # unconditionally at the end of the test to restore sanity:
 992 #
 993 #       test_expect_success 'test core.capslock' '
 994 #               git config core.capslock true &&
 995 #               test_when_finished "git config --unset core.capslock" &&
 996 #               hello world
 997 #       '
 998 #
 999 # That would be roughly equivalent to
1000 #
1001 #       test_expect_success 'test core.capslock' '
1002 #               git config core.capslock true &&
1003 #               hello world
1004 #               git config --unset core.capslock
1005 #       '
1006 #
1007 # except that the greeting and config --unset must both succeed for
1008 # the test to pass.
1009
1010 test_when_finished () {
1011         test_cleanup="{ $*
1012                 } && (exit \"\$eval_ret\"); eval_ret=\$?; $test_cleanup"
1013 }
1014
1015 test_done () {
1016         GIT_EXIT_OK=t
1017         test_results_dir="$TEST_DIRECTORY/test-results"
1018         mkdir -p "$test_results_dir"
1019         test_results_path="$test_results_dir/$this_test"
1020
1021         echo "total $test_count" >> $test_results_path
1022         echo "success $test_success" >> $test_results_path
1023         echo "fixed $test_fixed" >> $test_results_path
1024         echo "broken $test_broken" >> $test_results_path
1025         echo "failed $test_failure" >> $test_results_path
1026         echo "" >> $test_results_path
1027
1028         [ -n "$EMACS_SERVER" ] && test_emacs '(kill-emacs)'
1029
1030         if [ "$test_failure" = "0" ]; then
1031             if [ "$test_broken" = "0" ]; then
1032                 rm -rf "$remove_tmp"
1033             fi
1034             exit 0
1035         else
1036             exit 1
1037         fi
1038 }
1039
1040 emacs_generate_script () {
1041         # Construct a little test script here for the benefit of the user,
1042         # (who can easily run "run_emacs" to get the same emacs environment
1043         # for investigating any failures).
1044         cat <<EOF >"$TMP_DIRECTORY/run_emacs"
1045 #!/bin/sh
1046 export PATH=$PATH
1047 export NOTMUCH_CONFIG=$NOTMUCH_CONFIG
1048
1049 # Here's what we are using here:
1050 #
1051 # --quick               Use minimal customization. This implies --no-init-file,
1052 #                       --no-site-file and (emacs 24) --no-site-lisp
1053 #
1054 # --directory           Ensure that the local elisp sources are found
1055 #
1056 # --load                Force loading of notmuch.el and test-lib.el
1057
1058 exec ${TEST_EMACS} --quick \
1059         --directory "$NOTMUCH_BUILDDIR/emacs" --load notmuch.el \
1060         --directory "$NOTMUCH_SRCDIR/test" --load test-lib.el \
1061         "\$@"
1062 EOF
1063         chmod a+x "$TMP_DIRECTORY/run_emacs"
1064 }
1065
1066 test_emacs () {
1067         # test dependencies beforehand to avoid the waiting loop below
1068         missing_dependencies=
1069         test_require_external_prereq dtach || missing_dependencies=1
1070         test_require_external_prereq emacs || missing_dependencies=1
1071         test_require_external_prereq ${TEST_EMACSCLIENT} || missing_dependencies=1
1072         test -z "$missing_dependencies" || return
1073
1074         if [ -z "$EMACS_SERVER" ]; then
1075                 emacs_tests="$NOTMUCH_SRCDIR/test/${this_test_bare}.el"
1076                 if [ -f "$emacs_tests" ]; then
1077                         load_emacs_tests="--eval '(load \"$emacs_tests\")'"
1078                 else
1079                         load_emacs_tests=
1080                 fi
1081                 server_name="notmuch-test-suite-$$"
1082                 # start a detached session with an emacs server
1083                 # user's TERM (or 'vt100' in case user's TERM is known dumb
1084                 # or unknown) is given to dtach which assumes a minimally
1085                 # VT100-compatible terminal -- and emacs inherits that
1086                 TERM=$SMART_TERM dtach -n "$TEST_TMPDIR/emacs-dtach-socket.$$" \
1087                         sh -c "stty rows 24 cols 80; exec '$TMP_DIRECTORY/run_emacs' \
1088                                 --no-window-system \
1089                                 $load_emacs_tests \
1090                                 --eval '(setq server-name \"$server_name\")' \
1091                                 --eval '(server-start)' \
1092                                 --eval '(orphan-watchdog $$)'" || return
1093                 EMACS_SERVER="$server_name"
1094                 # wait until the emacs server is up
1095                 until test_emacs '()' >/dev/null 2>/dev/null; do
1096                         sleep 1
1097                 done
1098         fi
1099
1100         # Clear test-output output file.  Most Emacs tests end with a
1101         # call to (test-output).  If the test code fails with an
1102         # exception before this call, the output file won't get
1103         # updated.  Since we don't want to compare against an output
1104         # file from another test, so start out with an empty file.
1105         rm -f OUTPUT
1106         touch OUTPUT
1107
1108         ${TEST_EMACSCLIENT} --socket-name="$EMACS_SERVER" --eval "(notmuch-test-progn $*)"
1109 }
1110
1111 test_python() {
1112     # Note: if there is need to print debug information from python program,
1113     # use stdout = os.fdopen(6, 'w') or stderr = os.fdopen(7, 'w')
1114     PYTHONPATH="$NOTMUCH_SRCDIR/bindings/python${PYTHONPATH:+:$PYTHONPATH}" \
1115         $NOTMUCH_PYTHON -B - > OUTPUT
1116 }
1117
1118 test_ruby() {
1119     MAIL_DIR=$MAIL_DIR $NOTMUCH_RUBY -I "$NOTMUCH_BUILDDIR/bindings/ruby"> OUTPUT
1120 }
1121
1122 test_C () {
1123     local exec_file test_file
1124     exec_file="test${test_count}"
1125     test_file="${exec_file}.c"
1126     cat > ${test_file}
1127     ${TEST_CC} ${TEST_CFLAGS} -I${NOTMUCH_SRCDIR}/test -I${NOTMUCH_SRCDIR}/lib -o ${exec_file} ${test_file} -L${NOTMUCH_BUILDDIR}/lib/ -lnotmuch -ltalloc
1128     echo "== stdout ==" > OUTPUT.stdout
1129     echo "== stderr ==" > OUTPUT.stderr
1130     ./${exec_file} "$@" 1>>OUTPUT.stdout 2>>OUTPUT.stderr
1131     notmuch_dir_sanitize OUTPUT.stdout OUTPUT.stderr | notmuch_exception_sanitize > OUTPUT
1132 }
1133
1134 make_shim () {
1135     local base_name test_file shim_file
1136     base_name="$1"
1137     test_file="${base_name}.c"
1138     shim_file="${base_name}.so"
1139     cat > ${test_file}
1140     ${TEST_CC} ${TEST_CFLAGS} ${TEST_SHIM_CFLAGS} -I${NOTMUCH_SRCDIR}/test -I${NOTMUCH_SRCDIR}/lib -o ${shim_file} ${test_file} ${TEST_SHIM_LDFLAGS}
1141 }
1142
1143 notmuch_with_shim () {
1144     local base_name shim_file
1145     base_name="$1"
1146     shift
1147     shim_file="${base_name}.so"
1148     LD_PRELOAD=${LD_PRELOAD:+:$LD_PRELOAD}:./${shim_file} notmuch-shared "$@"
1149 }
1150
1151 # Creates a script that counts how much time it is executed and calls
1152 # notmuch.  $notmuch_counter_command is set to the path to the
1153 # generated script.  Use notmuch_counter_value() function to get the
1154 # current counter value.
1155 notmuch_counter_reset () {
1156         notmuch_counter_command="$TMP_DIRECTORY/notmuch_counter"
1157         if [ ! -x "$notmuch_counter_command" ]; then
1158                 notmuch_counter_state_path="$TMP_DIRECTORY/notmuch_counter.state"
1159                 cat >"$notmuch_counter_command" <<EOF || return
1160 #!/bin/sh
1161
1162 read count < "$notmuch_counter_state_path"
1163 echo \$((count + 1)) > "$notmuch_counter_state_path"
1164
1165 exec notmuch "\$@"
1166 EOF
1167                 chmod +x "$notmuch_counter_command" || return
1168         fi
1169
1170         echo 0 > "$notmuch_counter_state_path"
1171 }
1172
1173 # Returns the current notmuch counter value.
1174 notmuch_counter_value () {
1175         if [ -r "$notmuch_counter_state_path" ]; then
1176                 read count < "$notmuch_counter_state_path"
1177         else
1178                 count=0
1179         fi
1180         echo $count
1181 }
1182
1183 test_reset_state_ () {
1184         test -z "$test_init_done_" && test_init_
1185
1186         test_subtest_known_broken_=
1187         test_subtest_missing_external_prereq_=()
1188 }
1189
1190 # called once before the first subtest
1191 test_init_ () {
1192         test_init_done_=t
1193
1194         # skip all tests if there were external prerequisites missing during init
1195         test_check_missing_external_prereqs_ "all tests in $this_test" && test_done
1196 }
1197
1198
1199 # Where to run the tests
1200 TEST_DIRECTORY=$NOTMUCH_BUILDDIR/test
1201
1202 . "$NOTMUCH_SRCDIR/test/test-lib-common.sh" || exit 1
1203
1204 emacs_generate_script
1205
1206
1207 # Use -P to resolve symlinks in our working directory so that the cwd
1208 # in subprocesses like git equals our $PWD (for pathname comparisons).
1209 cd -P "$TMP_DIRECTORY" || error "Cannot set up test environment"
1210
1211 if test "$verbose" = "t"
1212 then
1213         exec 4>&2 3>&1
1214 else
1215         exec 4>test.output 3>&4
1216 fi
1217
1218 for skp in $NOTMUCH_SKIP_TESTS
1219 do
1220         to_skip=
1221         for skp in $NOTMUCH_SKIP_TESTS
1222         do
1223                 case "$this_test" in
1224                 $skp)
1225                         to_skip=t
1226                         break
1227                 esac
1228                 case "$this_test_bare" in
1229                 $skp)
1230                         to_skip=t
1231                         break
1232                 esac
1233         done
1234         case "$to_skip" in
1235         t)
1236                 say_color skip >&3 "skipping test $this_test altogether"
1237                 say_color skip "skip all tests in $this_test"
1238                 test_done
1239         esac
1240 done
1241
1242 # Provide an implementation of the 'yes' utility
1243 yes () {
1244         if test $# = 0
1245         then
1246                 y=y
1247         else
1248                 y="$*"
1249         fi
1250
1251         while echo "$y"
1252         do
1253                 :
1254         done
1255 }
1256
1257 # Fix some commands on Windows
1258 case $(uname -s) in
1259 *MINGW*)
1260         # Windows has its own (incompatible) sort and find
1261         sort () {
1262                 /usr/bin/sort "$@"
1263         }
1264         find () {
1265                 /usr/bin/find "$@"
1266         }
1267         sum () {
1268                 md5sum "$@"
1269         }
1270         # git sees Windows-style pwd
1271         pwd () {
1272                 builtin pwd -W
1273         }
1274         # no POSIX permissions
1275         # backslashes in pathspec are converted to '/'
1276         # exec does not inherit the PID
1277         ;;
1278 *)
1279         test_set_prereq POSIXPERM
1280         test_set_prereq BSLASHPSPEC
1281         test_set_prereq EXECKEEPSPID
1282         ;;
1283 esac
1284
1285 test -z "$NO_PERL" && test_set_prereq PERL
1286 test -z "$NO_PYTHON" && test_set_prereq PYTHON
1287
1288 # test whether the filesystem supports symbolic links
1289 ln -s x y 2>/dev/null && test -h y 2>/dev/null && test_set_prereq SYMLINKS
1290 rm -f y
1291
1292 # declare prerequisites for external binaries used in tests
1293 test_declare_external_prereq dtach
1294 test_declare_external_prereq emacs
1295 test_declare_external_prereq ${TEST_EMACSCLIENT}
1296 test_declare_external_prereq ${TEST_GDB}
1297 test_declare_external_prereq gpg
1298 test_declare_external_prereq openssl
1299 test_declare_external_prereq gpgsm
1300 test_declare_external_prereq ${NOTMUCH_PYTHON}
1301 test_declare_external_prereq xapian-metadata
1302 test_declare_external_prereq xapian-delve