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