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                 # test_emacs may update missing external prerequisites
 596                 test_check_missing_external_prereqs_ "$test_subtest_name" && return
 597
 598                 # Report success/failure.
 599                 result=$(cat OUTPUT)
 600                 if [ "$result" = t ]
 601                 then
 602                         test_ok_
 603                 else
 604                         test_failure_ "${result}"
 605                 fi
 606         else
 607                 # Restore state after the (non) test.
 608                 exec 1>&6 2>&7          # Restore stdout and stderr
 609                 inside_subtest=
 610         fi
 611 }
 612
 613 NOTMUCH_NEW ()
 614 {
 615     notmuch new "${@}" | grep -v -E -e '^Processed [0-9]*( total)? file|Found [0-9]* total file'
 616 }
 617
 618 NOTMUCH_DUMP_TAGS ()
 619 {
 620     # this relies on the default format being batch-tag, otherwise some tests will break
 621     notmuch dump --include=tags "${@}" | sed '/^#/d' | sort
 622 }
 623
 624 notmuch_drop_mail_headers ()
 625 {
 626     $NOTMUCH_PYTHON -c '
 627 import email, sys
 628 msg = email.message_from_file(sys.stdin)
 629 for hdr in sys.argv[1:]: del msg[hdr]
 630 print(msg.as_string(False))
 631 ' "$@"
 632 }
 633
 634 notmuch_exception_sanitize ()
 635 {
 636     perl -pe 's/(A Xapian exception occurred at .*[.]cc?):([0-9]*)/\1:XXX/'
 637 }
 638
 639 notmuch_search_sanitize ()
 640 {
 641     perl -pe 's/("?thread"?: ?)("?)................("?)/\1\2XXX\3/'
 642 }
 643
 644 notmuch_search_files_sanitize ()
 645 {
 646     notmuch_dir_sanitize
 647 }
 648
 649 notmuch_dir_sanitize ()
 650 {
 651     sed -e "s,$MAIL_DIR,MAIL_DIR," -e "s,${PWD},CWD,g" "$@"
 652 }
 653
 654 NOTMUCH_SHOW_FILENAME_SQUELCH='s,filename:.*/mail,filename:/XXX/mail,'
 655 notmuch_show_sanitize ()
 656 {
 657     sed -e "$NOTMUCH_SHOW_FILENAME_SQUELCH"
 658 }
 659 notmuch_show_sanitize_all ()
 660 {
 661     sed \
 662         -e 's| filename:.*| filename:XXXXX|' \
 663         -e 's| id:[^ ]* | id:XXXXX |' | \
 664         notmuch_date_sanitize
 665 }
 666
 667 notmuch_json_show_sanitize ()
 668 {
 669     sed \
 670         -e 's|"id": "[^"]*",|"id": "XXXXX",|g' \
 671         -e 's|"Date": "Fri, 05 Jan 2001 [^"]*0000"|"Date": "GENERATED_DATE"|g' \
 672         -e 's|"filename": "signature.asc",||g' \
 673         -e 's|"filename": \["/[^"]*"\],|"filename": \["YYYYY"\],|g' \
 674         -e 's|"timestamp": 97.......|"timestamp": 42|g' \
 675         -e 's|"content-length": [1-9][0-9]*|"content-length": "NONZERO"|g'
 676 }
 677
 678 notmuch_emacs_error_sanitize ()
 679 {
 680     local command
 681     command=$1
 682     shift
 683     for file in "$@"; do
 684         echo "=== $file ==="
 685         cat "$file"
 686     done | sed \
 687         -e 's/^\[.*\]$/[XXX]/' \
 688         -e "s|^\(command: \)\{0,1\}/.*/$command|\1YYY/$command|"
 689 }
 690
 691 notmuch_date_sanitize ()
 692 {
 693     sed \
 694         -e 's/^Date: Fri, 05 Jan 2001 .*0000/Date: GENERATED_DATE/'
 695 }
 696
 697 notmuch_uuid_sanitize ()
 698 {
 699     sed 's/[0-9a-f]\{8\}-[0-9a-f]\{4\}-[0-9a-f]\{4\}-[0-9a-f]\{4\}-[0-9a-f]\{12\}/UUID/g'
 700 }
 701
 702 notmuch_built_with_sanitize ()
 703 {
 704     sed 's/^built_with[.]\(.*\)=.*$/built_with.\1=something/'
 705 }
 706
 707 notmuch_passwd_sanitize()
 708 {
 709     ${NOTMUCH_PYTHON} -c'
 710 import os, sys, pwd, socket
 711
 712 pw = pwd.getpwuid(os.getuid())
 713 user = pw.pw_name
 714 name = pw.pw_gecos.partition(",")[0]
 715 fqdn = socket.getaddrinfo(socket.gethostname(), 0, 0, socket.SOCK_STREAM, 0, socket.AI_CANONNAME)[0][3]
 716
 717 for l in sys.stdin:
 718     if user:
 719         l = l.replace(user, "USERNAME")
 720     if fqdn:
 721         l = l.replace(fqdn, "FQDN").replace(".(none)","")
 722     if name:
 723         l = l.replace(name, "USER_FULL_NAME")
 724     sys.stdout.write(l)
 725 '
 726 }
 727
 728 notmuch_config_sanitize ()
 729 {
 730     notmuch_dir_sanitize | notmuch_built_with_sanitize
 731 }
 732
 733 notmuch_show_part ()
 734 {
 735     awk '/^\014part}/{ f=0 }; { if (f) { print $0 } } /^\014part{ ID: '"$1"'/{ f=1 }'
 736 }
 737
 738 # End of notmuch helper functions
 739
 740 # Use test_set_prereq to tell that a particular prerequisite is available.
 741 #
 742 # The prerequisite can later be checked for by using test_have_prereq.
 743 #
 744 # The single parameter is the prerequisite tag (a simple word, in all
 745 # capital letters by convention).
 746
 747 test_set_prereq () {
 748         satisfied="$satisfied$1 "
 749 }
 750 satisfied=" "
 751
 752 test_have_prereq () {
 753         case $satisfied in
 754         *" $1 "*)
 755                 : yes, have it ;;
 756         *)
 757                 ! : nope ;;
 758         esac
 759 }
 760
 761 declare -A test_missing_external_prereq_
 762 declare -A test_subtest_missing_external_prereq_
 763
 764 # declare prerequisite for the given external binary
 765 test_declare_external_prereq () {
 766         local binary
 767         binary="$1"
 768         test "$#" = 2 && name=$2 || name="$binary(1)"
 769
 770         if ! hash $binary 2>/dev/null; then
 771                 test_missing_external_prereq_["${binary}"]=t
 772                 eval "
 773 $binary () {
 774         test_subtest_missing_external_prereq_[\"${name}\"]=t
 775         false
 776 }"
 777         fi
 778 }
 779
 780 # Explicitly require external prerequisite.  Useful when binary is
 781 # called indirectly (e.g. from emacs).
 782 # Returns success if dependency is available, failure otherwise.
 783 test_require_external_prereq () {
 784         local binary
 785         binary="$1"
 786         if [[ ${test_missing_external_prereq_["${binary}"]} == t ]]; then
 787                 # dependency is missing, call the replacement function to note it
 788                 eval "$binary"
 789         else
 790                 true
 791         fi
 792 }
 793
 794 # You are not expected to call test_ok_ and test_failure_ directly, use
 795 # the text_expect_* functions instead.
 796
 797 test_ok_ () {
 798         if test "$test_subtest_known_broken_" = "t"; then
 799                 test_known_broken_ok_
 800                 return
 801         fi
 802         test_success=$(($test_success + 1))
 803         if test -n "$NOTMUCH_TEST_QUIET"; then
 804                 return 0
 805         fi
 806         say_color pass "%-6s" "PASS"
 807         echo " $test_subtest_name"
 808 }
 809
 810 test_failure_ () {
 811         print_test_description
 812         if test "$test_subtest_known_broken_" = "t"; then
 813                 test_known_broken_failure_ "$@"
 814                 return
 815         fi
 816         test_failure=$(($test_failure + 1))
 817         test_failure_message_ "FAIL" "$test_subtest_name" "$@"
 818         test "$immediate" = "" || { GIT_EXIT_OK=t; exit 1; }
 819         return 1
 820 }
 821
 822 test_failure_message_ () {
 823         say_color error "%-6s" "$1"
 824         echo " $2"
 825         shift 2
 826         if [ "$#" != "0" ]; then
 827                 echo "$@" | sed -e 's/^/        /'
 828         fi
 829         if test "$verbose" != "t"; then cat test.output; fi
 830 }
 831
 832 test_known_broken_ok_ () {
 833         test_reset_state_
 834         test_fixed=$(($test_fixed+1))
 835         say_color pass "%-6s" "FIXED"
 836         echo " $test_subtest_name"
 837 }
 838
 839 test_known_broken_failure_ () {
 840         test_reset_state_
 841         test_broken=$(($test_broken+1))
 842         if [ -z "$NOTMUCH_TEST_QUIET" ]; then
 843                 test_failure_message_ "BROKEN" "$test_subtest_name" "$@"
 844         else
 845                 test_failure_message_ "BROKEN" "$test_subtest_name"
 846         fi
 847         return 1
 848 }
 849
 850 test_debug () {
 851         test "$debug" = "" || eval "$1"
 852 }
 853
 854 test_run_ () {
 855         test_cleanup=:
 856         if test "$verbose" != "t"; then exec 4>test.output 3>&4; fi
 857         eval >&3 2>&4 "$1"
 858         eval_ret=$?
 859         eval >&3 2>&4 "$test_cleanup"
 860         return 0
 861 }
 862
 863 test_skip () {
 864         test_count=$(($test_count+1))
 865         to_skip=
 866         for skp in $NOTMUCH_SKIP_TESTS
 867         do
 868                 case $this_test.$test_count in
 869                 $skp)
 870                         to_skip=t
 871                         break
 872                 esac
 873                 case $this_test_bare.$test_count in
 874                 $skp)
 875                         to_skip=t
 876                         break
 877                 esac
 878         done
 879         case "$to_skip" in
 880         t)
 881                 test_report_skip_ "$@"
 882                 ;;
 883         *)
 884                 test_check_missing_external_prereqs_ "$@"
 885                 ;;
 886         esac
 887 }
 888
 889 test_check_missing_external_prereqs_ () {
 890         if [[ ${#test_subtest_missing_external_prereq_[@]} != 0 ]]; then
 891                 say_color skip >&1 "missing prerequisites: "
 892                 echo ${!test_subtest_missing_external_prereq_[@]} >&1
 893                 test_report_skip_ "$@"
 894         else
 895                 false
 896         fi
 897 }
 898
 899 test_report_skip_ () {
 900         test_reset_state_
 901         say_color skip >&3 "skipping test:"
 902         echo " $@" >&3
 903         say_color skip "%-6s" "SKIP"
 904         echo " $1"
 905 }
 906
 907 test_subtest_known_broken () {
 908         test_subtest_known_broken_=t
 909 }
 910
 911 test_expect_success () {
 912         exec 1>&6 2>&7          # Restore stdout and stderr
 913         if [ -z "$inside_subtest" ]; then
 914                 error "bug in the test script: test_expect_success without test_begin_subtest"
 915         fi
 916         inside_subtest=
 917         test "$#" = 1 ||
 918         error "bug in the test script: not 1 parameters to test_expect_success"
 919
 920         if ! test_skip "$test_subtest_name"
 921         then
 922                 test_run_ "$1"
 923                 run_ret="$?"
 924                 # test_run_ may update missing external prerequisites
 925                 test_check_missing_external_prereqs_ "$test_subtest_name" ||
 926                 if [ "$run_ret" = 0 -a "$eval_ret" = 0 ]
 927                 then
 928                         test_ok_
 929                 else
 930                         test_failure_ "$1"
 931                 fi
 932         fi
 933 }
 934
 935 test_expect_code () {
 936         exec 1>&6 2>&7          # Restore stdout and stderr
 937         if [ -z "$inside_subtest" ]; then
 938                 error "bug in the test script: test_expect_code without test_begin_subtest"
 939         fi
 940         inside_subtest=
 941         test "$#" = 2 ||
 942         error "bug in the test script: not 2 parameters to test_expect_code"
 943
 944         if ! test_skip "$test_subtest_name"
 945         then
 946                 test_run_ "$2"
 947                 run_ret="$?"
 948                 # test_run_ may update missing external prerequisites,
 949                 test_check_missing_external_prereqs_ "$test_subtest_name" ||
 950                 if [ "$run_ret" = 0 -a "$eval_ret" = "$1" ]
 951                 then
 952                         test_ok_
 953                 else
 954                         test_failure_ "exit code $eval_ret, expected $1" "$2"
 955                 fi
 956         fi
 957 }
 958
 959 # This is not among top-level (test_expect_success)
 960 # but is a prefix that can be used in the test script, like:
 961 #
 962 #       test_expect_success 'complain and die' '
 963 #           do something &&
 964 #           do something else &&
 965 #           test_must_fail git checkout ../outerspace
 966 #       '
 967 #
 968 # Writing this as "! git checkout ../outerspace" is wrong, because
 969 # the failure could be due to a segv.  We want a controlled failure.
 970
 971 test_must_fail () {
 972         "$@"
 973         test $? -gt 0 -a $? -le 129 -o $? -gt 192
 974 }
 975
 976 # test_cmp is a helper function to compare actual and expected output.
 977 # You can use it like:
 978 #
 979 #       test_expect_success 'foo works' '
 980 #               echo expected >expected &&
 981 #               foo >actual &&
 982 #               test_cmp expected actual
 983 #       '
 984 #
 985 # This could be written as either "cmp" or "diff -u", but:
 986 # - cmp's output is not nearly as easy to read as diff -u
 987 # - not all diff versions understand "-u"
 988
 989 test_cmp() {
 990         $GIT_TEST_CMP "$@"
 991 }
 992
 993 # This function can be used to schedule some commands to be run
 994 # unconditionally at the end of the test to restore sanity:
 995 #
 996 #       test_expect_success 'test core.capslock' '
 997 #               git config core.capslock true &&
 998 #               test_when_finished "git config --unset core.capslock" &&
 999 #               hello world
1000 #       '
1001 #
1002 # That would be roughly equivalent to
1003 #
1004 #       test_expect_success 'test core.capslock' '
1005 #               git config core.capslock true &&
1006 #               hello world
1007 #               git config --unset core.capslock
1008 #       '
1009 #
1010 # except that the greeting and config --unset must both succeed for
1011 # the test to pass.
1012
1013 test_when_finished () {
1014         test_cleanup="{ $*
1015                 } && (exit \"\$eval_ret\"); eval_ret=\$?; $test_cleanup"
1016 }
1017
1018 test_done () {
1019         GIT_EXIT_OK=t
1020         test_results_dir="$TEST_DIRECTORY/test-results"
1021         mkdir -p "$test_results_dir"
1022         test_results_path="$test_results_dir/$this_test"
1023
1024         echo "total $test_count" >> $test_results_path
1025         echo "success $test_success" >> $test_results_path
1026         echo "fixed $test_fixed" >> $test_results_path
1027         echo "broken $test_broken" >> $test_results_path
1028         echo "failed $test_failure" >> $test_results_path
1029         echo "" >> $test_results_path
1030
1031         [ -n "$EMACS_SERVER" ] && test_emacs '(kill-emacs)'
1032
1033         if [ "$test_failure" = "0" ]; then
1034             if [ "$test_broken" = "0" ]; then
1035                 rm -rf "$remove_tmp"
1036             fi
1037             exit 0
1038         else
1039             exit 1
1040         fi
1041 }
1042
1043 emacs_generate_script () {
1044         # Construct a little test script here for the benefit of the user,
1045         # (who can easily run "run_emacs" to get the same emacs environment
1046         # for investigating any failures).
1047         cat <<EOF >"$TMP_DIRECTORY/run_emacs"
1048 #!/bin/sh
1049 export PATH=$PATH
1050 export NOTMUCH_CONFIG=$NOTMUCH_CONFIG
1051
1052 # Here's what we are using here:
1053 #
1054 # --quick               Use minimal customization. This implies --no-init-file,
1055 #                       --no-site-file and (emacs 24) --no-site-lisp
1056 #
1057 # --directory           Ensure that the local elisp sources are found
1058 #
1059 # --load                Force loading of notmuch.el and test-lib.el
1060
1061 exec ${TEST_EMACS} --quick \
1062         --directory "$NOTMUCH_BUILDDIR/emacs" --load notmuch.el \
1063         --directory "$NOTMUCH_SRCDIR/test" --load test-lib.el \
1064         "\$@"
1065 EOF
1066         chmod a+x "$TMP_DIRECTORY/run_emacs"
1067 }
1068
1069 test_emacs () {
1070         # test dependencies beforehand to avoid the waiting loop below
1071         missing_dependencies=
1072         test_require_external_prereq dtach || missing_dependencies=1
1073         test_require_external_prereq emacs || missing_dependencies=1
1074         test_require_external_prereq ${TEST_EMACSCLIENT} || missing_dependencies=1
1075         test -z "$missing_dependencies" || return
1076
1077         if [ -z "$EMACS_SERVER" ]; then
1078                 emacs_tests="$NOTMUCH_SRCDIR/test/${this_test_bare}.el"
1079                 if [ -f "$emacs_tests" ]; then
1080                         load_emacs_tests="--eval '(load \"$emacs_tests\")'"
1081                 else
1082                         load_emacs_tests=
1083                 fi
1084                 server_name="notmuch-test-suite-$$"
1085                 # start a detached session with an emacs server
1086                 # user's TERM (or 'vt100' in case user's TERM is known dumb
1087                 # or unknown) is given to dtach which assumes a minimally
1088                 # VT100-compatible terminal -- and emacs inherits that
1089                 TERM=$SMART_TERM dtach -n "$TEST_TMPDIR/emacs-dtach-socket.$$" \
1090                         sh -c "stty rows 24 cols 80; exec '$TMP_DIRECTORY/run_emacs' \
1091                                 --no-window-system \
1092                                 $load_emacs_tests \
1093                                 --eval '(setq server-name \"$server_name\")' \
1094                                 --eval '(server-start)' \
1095                                 --eval '(orphan-watchdog $$)'" || return
1096                 EMACS_SERVER="$server_name"
1097                 # wait until the emacs server is up
1098                 until test_emacs '()' >/dev/null 2>/dev/null; do
1099                         sleep 1
1100                 done
1101         fi
1102
1103         # Clear test-output output file.  Most Emacs tests end with a
1104         # call to (test-output).  If the test code fails with an
1105         # exception before this call, the output file won't get
1106         # updated.  Since we don't want to compare against an output
1107         # file from another test, so start out with an empty file.
1108         rm -f OUTPUT
1109         touch OUTPUT
1110
1111         ${TEST_EMACSCLIENT} --socket-name="$EMACS_SERVER" --eval "(notmuch-test-progn $*)"
1112 }
1113
1114 test_python() {
1115     # Note: if there is need to print debug information from python program,
1116     # use stdout = os.fdopen(6, 'w') or stderr = os.fdopen(7, 'w')
1117     PYTHONPATH="$NOTMUCH_SRCDIR/bindings/python${PYTHONPATH:+:$PYTHONPATH}" \
1118         $NOTMUCH_PYTHON -B - > OUTPUT
1119 }
1120
1121 test_ruby() {
1122     MAIL_DIR=$MAIL_DIR $NOTMUCH_RUBY -I "$NOTMUCH_BUILDDIR/bindings/ruby"> OUTPUT
1123 }
1124
1125 test_C () {
1126     local exec_file test_file
1127     exec_file="test${test_count}"
1128     test_file="${exec_file}.c"
1129     cat > ${test_file}
1130     ${TEST_CC} ${TEST_CFLAGS} -I${NOTMUCH_SRCDIR}/test -I${NOTMUCH_SRCDIR}/lib -o ${exec_file} ${test_file} -L${NOTMUCH_BUILDDIR}/lib/ -lnotmuch -ltalloc
1131     echo "== stdout ==" > OUTPUT.stdout
1132     echo "== stderr ==" > OUTPUT.stderr
1133     ./${exec_file} "$@" 1>>OUTPUT.stdout 2>>OUTPUT.stderr
1134     notmuch_dir_sanitize OUTPUT.stdout OUTPUT.stderr | notmuch_exception_sanitize > OUTPUT
1135 }
1136
1137 make_shim () {
1138     local base_name test_file shim_file
1139     base_name="$1"
1140     test_file="${base_name}.c"
1141     shim_file="${base_name}.so"
1142     cat > ${test_file}
1143     ${TEST_CC} ${TEST_CFLAGS} ${TEST_SHIM_CFLAGS} -I${NOTMUCH_SRCDIR}/test -I${NOTMUCH_SRCDIR}/lib -o ${shim_file} ${test_file} ${TEST_SHIM_LDFLAGS}
1144 }
1145
1146 notmuch_with_shim () {
1147     local base_name shim_file
1148     base_name="$1"
1149     shift
1150     shim_file="${base_name}.so"
1151     LD_PRELOAD=${LD_PRELOAD:+:$LD_PRELOAD}:./${shim_file} notmuch-shared "$@"
1152 }
1153
1154 # Creates a script that counts how much time it is executed and calls
1155 # notmuch.  $notmuch_counter_command is set to the path to the
1156 # generated script.  Use notmuch_counter_value() function to get the
1157 # current counter value.
1158 notmuch_counter_reset () {
1159         notmuch_counter_command="$TMP_DIRECTORY/notmuch_counter"
1160         if [ ! -x "$notmuch_counter_command" ]; then
1161                 notmuch_counter_state_path="$TMP_DIRECTORY/notmuch_counter.state"
1162                 cat >"$notmuch_counter_command" <<EOF || return
1163 #!/bin/sh
1164
1165 read count < "$notmuch_counter_state_path"
1166 echo \$((count + 1)) > "$notmuch_counter_state_path"
1167
1168 exec notmuch "\$@"
1169 EOF
1170                 chmod +x "$notmuch_counter_command" || return
1171         fi
1172
1173         echo 0 > "$notmuch_counter_state_path"
1174 }
1175
1176 # Returns the current notmuch counter value.
1177 notmuch_counter_value () {
1178         if [ -r "$notmuch_counter_state_path" ]; then
1179                 read count < "$notmuch_counter_state_path"
1180         else
1181                 count=0
1182         fi
1183         echo $count
1184 }
1185
1186 test_reset_state_ () {
1187         test -z "$test_init_done_" && test_init_
1188
1189         test_subtest_known_broken_=
1190         test_subtest_missing_external_prereq_=()
1191 }
1192
1193 # called once before the first subtest
1194 test_init_ () {
1195         test_init_done_=t
1196
1197         # skip all tests if there were external prerequisites missing during init
1198         test_check_missing_external_prereqs_ "all tests in $this_test" && test_done
1199 }
1200
1201
1202 # Where to run the tests
1203 TEST_DIRECTORY=$NOTMUCH_BUILDDIR/test
1204
1205 . "$NOTMUCH_SRCDIR/test/test-lib-common.sh" || exit 1
1206
1207 emacs_generate_script
1208
1209
1210 # Use -P to resolve symlinks in our working directory so that the cwd
1211 # in subprocesses like git equals our $PWD (for pathname comparisons).
1212 cd -P "$TMP_DIRECTORY" || error "Cannot set up test environment"
1213
1214 if test "$verbose" = "t"
1215 then
1216         exec 4>&2 3>&1
1217 else
1218         exec 4>test.output 3>&4
1219 fi
1220
1221 for skp in $NOTMUCH_SKIP_TESTS
1222 do
1223         to_skip=
1224         for skp in $NOTMUCH_SKIP_TESTS
1225         do
1226                 case "$this_test" in
1227                 $skp)
1228                         to_skip=t
1229                         break
1230                 esac
1231                 case "$this_test_bare" in
1232                 $skp)
1233                         to_skip=t
1234                         break
1235                 esac
1236         done
1237         case "$to_skip" in
1238         t)
1239                 say_color skip >&3 "skipping test $this_test altogether"
1240                 say_color skip "skip all tests in $this_test"
1241                 test_done
1242         esac
1243 done
1244
1245 # Provide an implementation of the 'yes' utility
1246 yes () {
1247         if test $# = 0
1248         then
1249                 y=y
1250         else
1251                 y="$*"
1252         fi
1253
1254         while echo "$y"
1255         do
1256                 :
1257         done
1258 }
1259
1260 # Fix some commands on Windows
1261 case $(uname -s) in
1262 *MINGW*)
1263         # Windows has its own (incompatible) sort and find
1264         sort () {
1265                 /usr/bin/sort "$@"
1266         }
1267         find () {
1268                 /usr/bin/find "$@"
1269         }
1270         sum () {
1271                 md5sum "$@"
1272         }
1273         # git sees Windows-style pwd
1274         pwd () {
1275                 builtin pwd -W
1276         }
1277         # no POSIX permissions
1278         # backslashes in pathspec are converted to '/'
1279         # exec does not inherit the PID
1280         ;;
1281 *)
1282         test_set_prereq POSIXPERM
1283         test_set_prereq BSLASHPSPEC
1284         test_set_prereq EXECKEEPSPID
1285         ;;
1286 esac
1287
1288 test -z "$NO_PERL" && test_set_prereq PERL
1289 test -z "$NO_PYTHON" && test_set_prereq PYTHON
1290
1291 # test whether the filesystem supports symbolic links
1292 ln -s x y 2>/dev/null && test -h y 2>/dev/null && test_set_prereq SYMLINKS
1293 rm -f y
1294
1295 # declare prerequisites for external binaries used in tests
1296 test_declare_external_prereq dtach
1297 test_declare_external_prereq emacs
1298 test_declare_external_prereq ${TEST_EMACSCLIENT}
1299 test_declare_external_prereq ${TEST_GDB}
1300 test_declare_external_prereq gpg
1301 test_declare_external_prereq openssl
1302 test_declare_external_prereq gpgsm
1303 test_declare_external_prereq ${NOTMUCH_PYTHON}
1304 test_declare_external_prereq xapian-metadata
1305 test_declare_external_prereq xapian-delve