diplodocus.org Git - nmh/blob - test/mhmail/test-mhmail

   1 #!/bin/sh
   2 ######################################################
   3 #
   4 # Test mhmail
   5 #
   6 ######################################################
   7
   8 set -e
   9
  10 if test -z "${MH_OBJ_DIR}"; then
  11     srcdir=`dirname $0`/../..
  12     MH_OBJ_DIR=`cd $srcdir && pwd`; export MH_OBJ_DIR
  13 fi
  14
  15 . "${srcdir}/test/post/test-post-common.sh"
  16
  17 # Find MIME type string, using mimetypeproc if configured with it.
  18 MIMETYPEPROC=`mhparam mimetypeproc`
  19 content_type_string() {
  20   if test -z "$MIMETYPEPROC"; then
  21     echo "text/plain; name=\"`basename $1`\"; charset=\"us-ascii\""
  22   else
  23     # 1) Excise leading filename followed by : and any whitespace.
  24     # 2) Insert semicolon if there isn't one before the first space.
  25     #    OpenBSD file --mime spits out things like "text/plain charset=...".
  26     # 3) Wrap charset value in double quotes.  Assume that it isn't already.
  27     printf "%s %s%s" \
  28       `$MIMETYPEPROC $1 | sed -e 's/.*: *//' -e 's/\([^;]\) /\1; /' \
  29          -e 's/\(charset=\)\(.*\)/\1"\2"/'` "; name=\"`basename $1`\""
  30   fi
  31 }
  32
  33 # Customize test_post () for use with mhmail.
  34 # $1 is expected output file, provided by caller
  35 # $2 is mhmail switches, except for -body
  36 # $3 of -b signifies use -body switch, | signifies provide body on stdin
  37 # $4 contains the message body.
  38 test_mhmail ()
  39 {
  40     pid=`"${MH_OBJ_DIR}/test/fakesmtp" "$actual" $localport`
  41
  42     if [ $3 = '|' ]; then
  43         printf '%s' "$4" | mhmail recipient@example.com $2 \
  44                         -server 127.0.0.1 -port $localport
  45     else
  46         mhmail recipient@example.com $2 -body "$4" \
  47              -server 127.0.0.1 -port $localport
  48     fi
  49
  50     #
  51     # It's hard to calculate the exact Date: header post is going to
  52     # use, so we'll just use sed to remove the actual date so we can easily
  53     # compare it against our "correct" output.  And same for
  54     # Message-ID.
  55     #
  56
  57     sed -e 's/^Date:.*/Date:/' \
  58         -e 's/^Resent-Date:.*/Resent-Date:/' \
  59         -e 's/^Message-ID:.*/Message-ID:/' "$actual" > "$actual".nodate
  60     rm -f "$actual"
  61
  62     check "$actual".nodate "$1"
  63 }
  64
  65 expected=$MH_TEST_DIR/test-mhmail$$.expected
  66 expected_err=$MH_TEST_DIR/test-mhmail$$.expected_err
  67 actual=$MH_TEST_DIR/test-mhmail$$.actual
  68 actual_err=$MH_TEST_DIR/test-mhmail$$.actual_err
  69
  70
  71 # check -help
  72 # Verified behavior consistent with compiled sendmail.
  73 cat >$expected <<EOF
  74 Usage: mhmail [-t(o)] addrs ... [switches]
  75   switches are:
  76   -at(tach) file [-at(tach) file] ...
  77   -b(ody) text
  78   -c(c) addrs ...
  79   -f(rom) addr
  80   -hea(derfield) name:value [-hea(derfield) name:value] ...
  81   -su(bject) text
  82   -r(esent)
  83   -pr(ofile)
  84   -se(nd)
  85   -nose(nd)
  86   -v(ersion)
  87   -hel(p)
  88   and all post(8)/send(1) switches
  89   mhmail with no arguments is equivalent to inc
  90 EOF
  91
  92 mhmail -help >$actual 2>&1
  93 check $expected $actual
  94
  95
  96 # check -version
  97 # Verified same behavior as compiled mhmail.
  98 case `mhmail -v` in
  99   mhmail\ --*) ;;
 100   *          ) printf '%s: mhmail -v generated unexpected output\n' "$0" >&2
 101                failed=`expr ${failed:-0} + 1`;;
 102 esac
 103
 104 # check for missing argument to switches that require them
 105 for switch in attach body cc from headerfield subject to; do
 106   run_test "mhmail recipient -$switch" \
 107            "mhmail: missing argument to -$switch"
 108 done
 109 for switch in attach body cc from headerfield subject to; do
 110   run_test "mhmail recipient -$switch -nosend" \
 111            "mhmail: missing argument to -$switch"
 112 done
 113 for switch in attach body cc from headerfield subject to; do
 114   run_test "mhmail recipient -$switch -server 127.0.0.1" \
 115            "mhmail: missing argument to -$switch"
 116 done
 117
 118
 119 # check with no switches
 120 # That will just run inc, which we don't want to do anything,
 121 # so tell inc to just display its version.
 122 # Verified same behavior as compiled mhmail.
 123 printf 'inc: -version\n' >> $MH
 124 case `mhmail` in
 125   inc\ --*) ;;
 126   *           ) echo "$0: mhmail generated unexpected output" >&2
 127                 failed=`expr ${failed:-0} + 1`;;
 128 esac
 129
 130
 131 # check -nosend
 132 # Not supported by compiled mhmail.
 133 mhmail -nosend recipient@example.com -from sender1@localhost \
 134   -server 127.0.0.1 -port $localport -body '' >"$actual" 2>"$actual_err"
 135
 136 cat > "$expected" <<EOF
 137 To: recipient@example.com
 138 From: sender1@localhost
 139
 140
 141 EOF
 142
 143 cat > "$expected_err" <<EOF
 144 EOF
 145
 146 check "$expected" "$actual"
 147 check "$expected_err" "$actual_err"
 148 [ ${failed:-0} -eq 0 ] || exit ${failed:-0}
 149
 150
 151 # check -send
 152 # Not supported by compiled mhmail.
 153 cat > "$expected" <<EOF
 154 EHLO nosuchhost.example.com
 155 MAIL FROM:<sender2@localhost>
 156 RCPT TO:<recipient@example.com>
 157 DATA
 158 To: recipient@example.com
 159 From: sender2@localhost
 160 Date:
 161
 162 message
 163 .
 164 QUIT
 165 EOF
 166
 167 test_mhmail "$expected" "-from sender2@localhost -nosend -send" '|' message
 168 [ ${failed:-0} -eq 0 ] || exit ${failed:-0}
 169
 170
 171 # check -from
 172 # Verified same behavior as compiled mhmail.
 173 cat > "$expected" <<EOF
 174 EHLO nosuchhost.example.com
 175 MAIL FROM:<sender3@localhost>
 176 RCPT TO:<recipient@example.com>
 177 DATA
 178 To: recipient@example.com
 179 From: sender3@localhost
 180 Date:
 181
 182 message
 183 .
 184 QUIT
 185 EOF
 186
 187 test_mhmail "$expected" "-from sender3@localhost" '|' message
 188 [ ${failed:-0} -eq 0 ] || exit ${failed:-0}
 189
 190
 191 # check -from and -body
 192 # Verified same behavior as compiled mhmail.
 193 cat > "$expected" <<EOF
 194 EHLO nosuchhost.example.com
 195 MAIL FROM:<sender4@localhost>
 196 RCPT TO:<recipient@example.com>
 197 DATA
 198 To: recipient@example.com
 199 From: sender4@localhost
 200 Date:
 201
 202 body
 203 .
 204 QUIT
 205 EOF
 206
 207 test_mhmail "$expected" "-from sender4@localhost" -b body
 208 [ ${failed:-0} -eq 0 ] || exit ${failed:-0}
 209
 210
 211 # check -from and -cc
 212 # Verified same behavior as compiled mhmail.
 213 cat > "$expected" <<EOF
 214 EHLO nosuchhost.example.com
 215 MAIL FROM:<sender5@localhost>
 216 RCPT TO:<recipient@example.com>
 217 RCPT TO:<recipient2@example.com>
 218 DATA
 219 To: recipient@example.com
 220 Cc: recipient2@example.com
 221 From: sender5@localhost
 222 Date:
 223
 224 message
 225 .
 226 QUIT
 227 EOF
 228
 229 test_mhmail "$expected" \
 230     "-from sender5@localhost -cc recipient2@example.com" '|' message
 231 [ ${failed:-0} -eq 0 ] || exit ${failed:-0}
 232
 233
 234 # check -from and multiple -cc addresses
 235 # Verified same behavior as compiled mhmail.
 236 cat > "$expected" <<EOF
 237 EHLO nosuchhost.example.com
 238 MAIL FROM:<sender6@localhost>
 239 RCPT TO:<recipient@example.com>
 240 RCPT TO:<recipient2@example.com>
 241 RCPT TO:<recipient3@example.com>
 242 RCPT TO:<recipient4@example.com>
 243 DATA
 244 To: recipient@example.com
 245 Cc: recipient2@example.com, recipient3@example.com,
 246     recipient4@example.com
 247 From: sender6@localhost
 248 Date:
 249
 250 message
 251 .
 252 QUIT
 253 EOF
 254
 255 test_mhmail "$expected" \
 256     '-from sender6@localhost -cc recipient2@example.com '\
 257 'recipient3@example.com recipient4@example.com' '|' message
 258 [ ${failed:-0} -eq 0 ] || exit ${failed:-0}
 259
 260
 261 # check -from and -subject
 262 # Verified same behavior as compiled mhmail.
 263 cat > "$expected" <<EOF
 264 EHLO nosuchhost.example.com
 265 MAIL FROM:<sender7@localhost>
 266 RCPT TO:<recipient@example.com>
 267 DATA
 268 To: recipient@example.com
 269 Subject: Test
 270 From: sender7@localhost
 271 Date:
 272
 273 message
 274 .
 275 QUIT
 276 EOF
 277
 278 test_mhmail "$expected" '-from sender7@localhost -subject Test' '|' message
 279 [ ${failed:-0} -eq 0 ] || exit ${failed:-0}
 280
 281
 282 # check -from and -profile
 283 # Show that -profile causes mhmail to 1) read the profile and
 284 # 2) use send(1) by added a send switch to the profile and
 285 # verifying that it gets used.
 286 # Not supported by compiled mhmail.
 287 printf 'send: -msgid\n' >> $MH
 288
 289 cat > "$expected" <<EOF
 290 EHLO nosuchhost.example.com
 291 MAIL FROM:<sender8@localhost>
 292 RCPT TO:<recipient@example.com>
 293 DATA
 294 To: recipient@example.com
 295 From: sender8@localhost
 296 Date:
 297 Message-ID:
 298
 299 message
 300 .
 301 QUIT
 302 EOF
 303
 304 test_mhmail "$expected" '-from sender8@localhost -profile' '|' message
 305 [ ${failed:-0} -eq 0 ] || exit ${failed:-0}
 306
 307
 308 # check repeated -from and -subject switches
 309 # Verified same behavior as compiled mhmail.
 310 cat > "$expected" <<EOF
 311 EHLO nosuchhost.example.com
 312 MAIL FROM:<sender9@localhost>
 313 RCPT TO:<recipient@example.com>
 314 DATA
 315 To: recipient@example.com
 316 Subject: Subject2
 317 From: sender9@localhost
 318 Date:
 319
 320 message
 321 .
 322 QUIT
 323 EOF
 324
 325 test_mhmail "$expected" '-from sender9@localhost -from sender9@localhost '\
 326 '-subject Subject1 -subject Subject2' -b message
 327 [ ${failed:-0} -eq 0 ] || exit ${failed:-0}
 328
 329 # check repeated -body switches
 330 # Verified same behavior as compiled mhmail.
 331 cat > "$expected" <<EOF
 332 EHLO nosuchhost.example.com
 333 MAIL FROM:<sender10@localhost>
 334 RCPT TO:<recipient@example.com>
 335 DATA
 336 To: recipient@example.com
 337 From: sender10@localhost
 338 Date:
 339
 340 body2
 341 .
 342 QUIT
 343 EOF
 344
 345 test_mhmail "$expected" "-from sender10@localhost -body body1" -b body2
 346 [ ${failed:-0} -eq 0 ] || exit ${failed:-0}
 347
 348
 349 # check multiple -cc switches
 350 # Verified same behavior as compiled mhmail.
 351 cat > "$expected" <<EOF
 352 EHLO nosuchhost.example.com
 353 MAIL FROM:<sender11@localhost>
 354 RCPT TO:<recipient@example.com>
 355 RCPT TO:<cc1@example.com>
 356 RCPT TO:<cc2@example.com>
 357 DATA
 358 To: recipient@example.com
 359 Cc: cc1@example.com, cc2@example.com
 360 From: sender11@localhost
 361 Date:
 362
 363 message
 364 .
 365 QUIT
 366 EOF
 367
 368 test_mhmail "$expected" \
 369   '-from sender11@localhost -cc cc1@example.com -cc cc2@example.com' -b message
 370 [ ${failed:-0} -eq 0 ] || exit ${failed:-0}
 371
 372
 373 # check separated -cc arguments
 374 # Verified same behavior as compiled mhmail.
 375 cat > "$expected" <<EOF
 376 EHLO nosuchhost.example.com
 377 MAIL FROM:<sender12@localhost>
 378 RCPT TO:<recipient@example.com>
 379 RCPT TO:<cc1@example.com>
 380 RCPT TO:<cc2@example.com>
 381 DATA
 382 To: recipient@example.com
 383 Cc: cc1@example.com, cc2@example.com
 384 Subject: Test
 385 From: sender12@localhost
 386 Date:
 387
 388 message
 389 .
 390 QUIT
 391 EOF
 392
 393 test_mhmail "$expected" \
 394   '-from sender12@localhost -cc cc1@example.com -subject '\
 395 'Test cc2@example.com' -b message
 396 [ ${failed:-0} -eq 0 ] || exit ${failed:-0}
 397
 398
 399 # check -cc switch followed by -to switch
 400 # Verified same behavior as compiled mhmail.
 401 cat > "$expected" <<EOF
 402 EHLO nosuchhost.example.com
 403 MAIL FROM:<sender13@localhost>
 404 RCPT TO:<recipient@example.com>
 405 RCPT TO:<recipient2@example.com>
 406 RCPT TO:<cc1@example.com>
 407 DATA
 408 To: recipient@example.com, recipient2@example.com
 409 Cc: cc1@example.com
 410 Subject: Test
 411 From: sender13@localhost
 412 Date:
 413
 414 message
 415 .
 416 QUIT
 417 EOF
 418
 419 test_mhmail "$expected" \
 420   "-from sender13@localhost -cc cc1@example.com -subject Test \
 421    -to recipient2@example.com" \
 422   -b message
 423 [ ${failed:-0} -eq 0 ] || exit ${failed:-0}
 424
 425
 426 # check with no newline on stdin
 427 # Shows different behavior than compiled mhmail, which was silent in this case.
 428 cat > "$expected" <<EOF
 429 EOF
 430
 431 cat > "$expected_err" <<EOF
 432 mhmail: empty message not sent, use -body '' to force.
 433 EOF
 434
 435 set +e
 436 printf '' | mhmail recipient@example.com -server 127.0.0.1 -port $localport \
 437   >"$actual" 2>"$actual_err"
 438 set -e
 439
 440 check "$expected" "$actual"
 441 check "$expected_err" "$actual_err"
 442 [ ${failed:-0} -eq 0 ] || exit ${failed:-0}
 443
 444
 445 # check with one newline on stdin
 446 # Verified same behavior as compiled mhmail.
 447 cat > "$expected" <<EOF
 448 EHLO nosuchhost.example.com
 449 MAIL FROM:<sender14@localhost>
 450 RCPT TO:<recipient@example.com>
 451 DATA
 452 To: recipient@example.com
 453 From: sender14@localhost
 454 Date:
 455
 456
 457 .
 458 QUIT
 459 EOF
 460
 461 test_mhmail "$expected" '-from sender14@localhost' '|' '
 462 '
 463 [ ${failed:-0} -eq 0 ] || exit ${failed:-0}
 464
 465
 466 # check with multiple newlines on stdin
 467 # Verified same behavior as compiled mhmail.
 468 cat > "$expected" <<EOF
 469 EHLO nosuchhost.example.com
 470 MAIL FROM:<sender15@localhost>
 471 RCPT TO:<recipient@example.com>
 472 DATA
 473 To: recipient@example.com
 474 From: sender15@localhost
 475 Date:
 476
 477
 478
 479
 480 .
 481 QUIT
 482 EOF
 483
 484 test_mhmail "$expected" '-from sender15@localhost' '|' '
 485
 486
 487 '
 488 [ ${failed:-0} -eq 0 ] || exit ${failed:-0}
 489
 490
 491 # check with text and no trailing newline on stdin
 492 # Verified same behavior as compiled mhmail.
 493 cat > "$expected" <<EOF
 494 EHLO nosuchhost.example.com
 495 MAIL FROM:<sender16@localhost>
 496 RCPT TO:<recipient@example.com>
 497 DATA
 498 To: recipient@example.com
 499 From: sender16@localhost
 500 Date:
 501
 502 no newline in input
 503 .
 504 QUIT
 505 EOF
 506
 507 test_mhmail "$expected" '-from sender16@localhost' '|' 'no newline in input'
 508 [ ${failed:-0} -eq 0 ] || exit ${failed:-0}
 509
 510
 511 # check with text and multiple trailing blank lines on stdin
 512 # Verified same behavior as compiled mhmail.
 513 cat > "$expected" <<EOF
 514 EHLO nosuchhost.example.com
 515 MAIL FROM:<sender17@localhost>
 516 RCPT TO:<recipient@example.com>
 517 DATA
 518 To: recipient@example.com
 519 From: sender17@localhost
 520 Date:
 521
 522 here's some text
 523
 524
 525 .
 526 QUIT
 527 EOF
 528
 529 test_mhmail "$expected" '-from sender17@localhost' '|' "here's some text
 530
 531
 532 "
 533 [ ${failed:-0} -eq 0 ] || exit ${failed:-0}
 534
 535
 536 # check with no newline to -body
 537 # Verified same behavior as compiled mhmail.
 538 cat > "$expected" <<EOF
 539 EHLO nosuchhost.example.com
 540 MAIL FROM:<sender18@localhost>
 541 RCPT TO:<recipient@example.com>
 542 DATA
 543 To: recipient@example.com
 544 From: sender18@localhost
 545 Date:
 546
 547
 548 .
 549 QUIT
 550 EOF
 551
 552 test_mhmail "$expected" '-from sender18@localhost' -b ''
 553 [ ${failed:-0} -eq 0 ] || exit ${failed:-0}
 554
 555
 556 # check with one newline to -body
 557 # Shows different behavior than compiled mhmail, which suppressed the newline.
 558 cat > "$expected" <<EOF
 559 EHLO nosuchhost.example.com
 560 MAIL FROM:<sender19@localhost>
 561 RCPT TO:<recipient@example.com>
 562 DATA
 563 To: recipient@example.com
 564 From: sender19@localhost
 565 Date:
 566
 567
 568
 569 .
 570 QUIT
 571 EOF
 572
 573 test_mhmail "$expected" '-from sender19@localhost' -b '
 574 '
 575 [ ${failed:-0} -eq 0 ] || exit ${failed:-0}
 576
 577
 578 # check with multiple newlines to -body
 579 # Shows different behavior than compiled mhmail, which suppressed one
 580 #   of the newlines.
 581 cat > "$expected" <<EOF
 582 EHLO nosuchhost.example.com
 583 MAIL FROM:<sender20@localhost>
 584 RCPT TO:<recipient@example.com>
 585 DATA
 586 To: recipient@example.com
 587 From: sender20@localhost
 588 Date:
 589
 590
 591
 592
 593
 594 .
 595 QUIT
 596 EOF
 597
 598 test_mhmail "$expected" '-from sender20@localhost' -b '
 599
 600
 601 '
 602 [ ${failed:-0} -eq 0 ] || exit ${failed:-0}
 603
 604
 605 # check with text and no trailing newline to -body
 606 # Verified same behavior as compiled mhmail.
 607 cat > "$expected" <<EOF
 608 EHLO nosuchhost.example.com
 609 MAIL FROM:<sender21@localhost>
 610 RCPT TO:<recipient@example.com>
 611 DATA
 612 To: recipient@example.com
 613 From: sender21@localhost
 614 Date:
 615
 616 no newline in input
 617 .
 618 QUIT
 619 EOF
 620
 621 test_mhmail "$expected" '-from sender21@localhost' -b 'no newline in input'
 622 [ ${failed:-0} -eq 0 ] || exit ${failed:-0}
 623
 624
 625 # check with text and multiple trailing blank lines to -body
 626 # Shows different behavior than compiled mhmail, which suppressed one
 627 #   of the newlines.
 628 cat > "$expected" <<EOF
 629 EHLO nosuchhost.example.com
 630 MAIL FROM:<sender22@localhost>
 631 RCPT TO:<recipient@example.com>
 632 DATA
 633 To: recipient@example.com
 634 From: sender22@localhost
 635 Date:
 636
 637 here's some text
 638
 639
 640 .
 641 QUIT
 642 EOF
 643
 644 test_mhmail "$expected" '-from sender22@localhost' -b "here's some text
 645
 646 "
 647 [ ${failed:-0} -eq 0 ] || exit ${failed:-0}
 648
 649
 650 # check -resent
 651 # Verified same behavior as compiled mhmail.
 652 cat > "$expected" <<EOF
 653 EHLO nosuchhost.example.com
 654 MAIL FROM:<orig_recipient@example.com>
 655 RCPT TO:<recipient@example.com>
 656 DATA
 657 Resent-To: recipient@example.com
 658 Resent-From: orig_recipient@example.com
 659 To: recipient@example.com
 660 From: sender23@localhost
 661 Date:
 662 Resent-Date:
 663
 664 please resend this message, 1
 665 .
 666 QUIT
 667 EOF
 668
 669 test_mhmail "$expected" '-from orig_recipient@example.com -resent' \
 670   -b 'To: recipient@example.com
 671 From: sender23@localhost
 672 Date: Sat Jun 16 18:35:15 -0500
 673
 674 please resend this message, 1'
 675
 676 [ ${failed:-0} -eq 0 ] || exit ${failed:-0}
 677
 678 # check -resent -profile, using stdin
 679 # Not supported by compiled mhmail.
 680 cat > "$expected" <<EOF
 681 EHLO nosuchhost.example.com
 682 MAIL FROM:<orig_recipient@example.com>
 683 RCPT TO:<recipient@example.com>
 684 DATA
 685 To: recipient@example.com
 686 From: sender24@localhost
 687 Date:
 688 Resent-To: recipient@example.com
 689 Resent-From: orig_recipient@example.com
 690 Resent-Date:
 691
 692 please resend this message, 2
 693 .
 694 QUIT
 695 EOF
 696
 697 test_mhmail "$expected" \
 698   '-from orig_recipient@example.com -resent -profile -nomsgid' \
 699   '|' 'To: recipient@example.com
 700 From: sender24@localhost
 701 Date: Sat Jun 16 18:35:15 -0500
 702
 703 please resend this message, 2'
 704
 705 [ ${failed:-0} -eq 0 ] || exit ${failed:-0}
 706
 707
 708 # check -resent -profile, using -b
 709 # Not supported by compiled mhmail.
 710 cat > "$expected" <<EOF
 711 EHLO nosuchhost.example.com
 712 MAIL FROM:<orig_recipient@example.com>
 713 RCPT TO:<recipient@example.com>
 714 DATA
 715 To: recipient@example.com
 716 From: sender25@localhost
 717 Date:
 718 Resent-To: recipient@example.com
 719 Resent-From: orig_recipient@example.com
 720 Resent-Date:
 721
 722 please resend this message, 3
 723 .
 724 QUIT
 725 EOF
 726
 727 test_mhmail "$expected" \
 728   '-from orig_recipient@example.com -resent -profile -nomsgid' \
 729   -b 'To: recipient@example.com
 730 From: sender25@localhost
 731 Date: Sat Jun 16 18:35:15 -0500
 732
 733 please resend this message, 3'
 734
 735 [ ${failed:-0} -eq 0 ] || exit ${failed:-0}
 736
 737
 738 # check -headerfield.
 739 # Not supported by compiled mhmail.
 740 cat > "$expected" <<EOF
 741 EHLO nosuchhost.example.com
 742 MAIL FROM:<sender26@example.com>
 743 RCPT TO:<recipient@example.com>
 744 DATA
 745 To: recipient@example.com
 746 From: sender26@example.com
 747 User-Agent: nmh
 748 Date:
 749
 750 with added header field
 751 .
 752 QUIT
 753 EOF
 754
 755 test_mhmail "$expected" \
 756   '-from sender26@example.com -headerfield User-Agent:nmh' \
 757   -b 'with added header field'
 758
 759 [ ${failed:-0} -eq 0 ] || exit ${failed:-0}
 760
 761
 762 # check multiple -headerfields.
 763 # Not supported by compiled mhmail.
 764 cat > "$expected" <<EOF
 765 EHLO nosuchhost.example.com
 766 MAIL FROM:<sender27@example.com>
 767 RCPT TO:<recipient@example.com>
 768 DATA
 769 To: recipient@example.com
 770 From: sender27@example.com
 771 MIME-Version: 1.0
 772 Content-Type: text/plain;charset=utf-8
 773 Content-Transfer-Encoding: 8bit
 774 Date:
 775
 776 with added header fields
 777 .
 778 QUIT
 779 EOF
 780
 781 test_mhmail "$expected" \
 782   "-from sender27@example.com -headerfield MIME-Version:1.0 \
 783 -headerfield Content-Type:text/plain;charset=utf-8 \
 784 -headerfield Content-Transfer-Encoding:8bit" \
 785   -b 'with added header fields'
 786
 787 [ ${failed:-0} -eq 0 ] || exit ${failed:-0}
 788
 789
 790 # check -attach
 791 # Not supported by compiled mhmail.
 792 cat > "$expected" <<EOF
 793 EHLO nosuchhost.example.com
 794 MAIL FROM:<sender28@example.com>
 795 RCPT TO:<recipient@example.com>
 796 DATA
 797 To: recipient@example.com
 798 From: sender28@example.com
 799 MIME-Version: 1.0
 800 Content-Type: multipart/mixed; boundary="----- =_aaaaaaaaaa0"
 801 Date:
 802 Message-ID:
 803
 804 ------- =_aaaaaaaaaa0
 805 Content-Type: text/plain; charset="us-ascii"
 806
 807 See how easy it is to add an attachment!
 808
 809 ------- =_aaaaaaaaaa0
 810 Content-Type: `content_type_string ${srcdir}/test/mhmail/attachment.txt`
 811 Content-Description: attachment.txt
 812 Content-Disposition: attachment; filename="attachment.txt"
 813
 814 The future disappears into memory, With only a moment between,
 815 Forever dwells in that moment, hope is what remains to be seen
 816 Forever dwells in that moment, hope is what remains to be seen.
 817
 818 ------- =_aaaaaaaaaa0--
 819 .
 820 QUIT
 821 EOF
 822
 823 test_mhmail "$expected" \
 824   "-from sender28@example.com -attach ${srcdir}/test/mhmail/attachment.txt" \
 825   -b 'See how easy it is to add an attachment!'
 826
 827 [ ${failed:-0} -eq 0 ] || exit ${failed:-0}
 828
 829
 830 exit ${failed:-0}