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