tests/m4sh.at

   1 #                                                       -*- Autotest -*-
   2
   3 AT_BANNER([M4sh.])
   4
   5 # Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software
   6 # Foundation, Inc.
   7 #
   8 # This program is free software; you can redistribute it and/or modify
   9 # it under the terms of the GNU General Public License as published by
  10 # the Free Software Foundation; either version 2, or (at your option)
  11 # any later version.
  12 #
  13 # This program is distributed in the hope that it will be useful,
  14 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 # GNU General Public License for more details.
  17 #
  18 # You should have received a copy of the GNU General Public License
  19 # along with this program; if not, write to the Free Software
  20 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21 # 02110-1301, USA.
  22
  23 ## ---------------- ##
  24 ## LINENO support.  ##
  25 ## ---------------- ##
  26
  27 AT_SETUP([LINENO])
  28
  29 # We cannot unset LINENO with Zsh, yet this test case relies on
  30 # unsetting LINENO to compare its result when (i) LINENO is supported
  31 # and when (ii) it is not.
  32 # So just skip if the shell is ZSH.
  33 AT_CHECK([test -n "${ZSH_VERSION+set}" && exit 77], ignore)
  34
  35 # AT_DATA_LINENO(FILE-NAME,
  36 #                UNSET-LINENO = true | false, COUNTER, COUNTER-RE)
  37 # ----------------------------------------------------------------
  38 # Produce the FILE-NAME M4sh script which uses the COUNTER LINENO or
  39 # _oline_, which we can recognized via COUNTER-RE.  Unset LINENO is
  40 # UNSET-LINENO.
  41 #
  42 # Use COUNTER, COUNTER-RE = [__LINENO__], [LINENO]
  43 #  or                     = [__OLINE__],  [_oline__]
  44 #
  45 # instead of the obvious $LINENO and __oline__, because they would
  46 # be replaced in the test suite itself, even before creating these
  47 # scripts.  For the same reason, grep for LINENO and _oline__ (sic).
  48 #
  49 # UNSET-LINENO is a shell condition to make sure the scripts have the
  50 # same number of lines in the output, so that their outputs be identical.
  51 m4_define([AT_DATA_LINENO],
  52 [AT_DATA([$1.tas],
  53 [[AS@&t@_INIT
  54 if $2; then
  55   AS@&t@_UNSET([LINENO])
  56 fi
  57 _AS@&t@_PREPARE
  58 echo "Line: $3"
  59 grep 'Line: .*$4' $[0] >/dev/null ||
  60   AS@&t@_ERROR([cannot find original script])
  61 exit 0
  62 ]])
  63 # If occurrences of $LINENO or __oline__ were wanted, create them.
  64 sed 's/__LINENO__/$''LINENO/g;s/__OLINE__/__''oline__/g' $1.tas >$1.as
  65 AT_CHECK([autom4te -l m4sh $1.as -o $1])
  66 ])# AT_DATA_LINENO
  67
  68 # `_oline_', once processed and ran, produces our reference.
  69 # We check that we find ourselves by looking at a string which is
  70 # available only in the original script: `_oline_'.
  71 AT_DATA_LINENO([reference], [false], [__OLINE__], [_oline__])
  72 AT_CHECK([./reference], 0, [stdout])
  73
  74 # The reference:
  75 mv stdout expout
  76
  77 # Now using a maybe-functioning LINENO, with different call conventions.
  78 # Be sure to be out of the PATH.
  79 AT_CHECK([mkdir test || exit 77])
  80
  81 AT_DATA_LINENO([test/test-1], [false], [__LINENO__], [LINENO])
  82 AT_CHECK([./test/test-1],                          0, [expout])
  83 AT_CHECK([(PATH=test$PATH_SEPARATOR$PATH; export PATH; exec test-1)],
  84                                                    0, [expout])
  85 AT_CHECK([sh ./test/test-1],                       0, [expout])
  86
  87 # Now using a disabled LINENO, with different call conventions.
  88 AT_DATA_LINENO([test/test-2], [true], [__LINENO__], [LINENO])
  89 AT_CHECK([./test/test-2],                          0, [expout])
  90 AT_CHECK([(PATH=test$PATH_SEPARATOR$PATH; export PATH; exec test-2)],
  91                                                    0, [expout])
  92 AT_CHECK([sh ./test/test-2],                       0, [expout])
  93
  94 AT_CLEANUP
  95
  96
  97
  98 ## ------------ ##
  99 ## AS_DIRNAME.  ##
 100 ## ------------ ##
 101
 102 # Build nested dirs.
 103 AT_SETUP([AS@&t@_DIRNAME])
 104
 105 AT_DATA_M4SH([script.as],
 106 [[AS_INIT
 107
 108 # The EXPR variant is allowed to fail if `expr' was considered as too
 109 # weak for us, in which case `as_expr=false'.
 110 m4_define([DIRNAME_TEST],
 111 [dir=`AS_DIRNAME([$1])`
 112 test "$dir" = "$2" || (test -n "$3" && test "$dir" = "$3") ||
 113   echo "dirname($1) = $dir instead of $2" >&2
 114
 115 if test "$as_expr" != false; then
 116   dir=`_AS_DIRNAME_EXPR([$1])`
 117   test "$dir" = "$2" || (test -n "$3" && test "$dir" = "$3") ||
 118     echo "dirname_expr($1) = $dir instead of $2" >&2
 119 fi
 120
 121 dir=`_AS_DIRNAME_SED([$1])`
 122 test "$dir" = "$2" || (test -n "$3" && test "$dir" = "$3") ||
 123   echo "dirname_sed($1) = $dir instead of $2" >&2])
 124
 125 DIRNAME_TEST([/],               [/])
 126 DIRNAME_TEST([//],              [//],   [/])
 127 DIRNAME_TEST([///],             [/])
 128 DIRNAME_TEST([//1],             [//],   [/])
 129 DIRNAME_TEST([/1],              [/])
 130 DIRNAME_TEST([./1],             [.])
 131 DIRNAME_TEST([../../2],         [../..])
 132 DIRNAME_TEST([//1/],            [//],   [/])
 133 DIRNAME_TEST([/1/],             [/])
 134 DIRNAME_TEST([./1/],            [.])
 135 DIRNAME_TEST([../../2],         [../..])
 136 DIRNAME_TEST([//1/3],           [//1])
 137 DIRNAME_TEST([/1/3],            [/1])
 138 DIRNAME_TEST([./1/3],           [./1])
 139 DIRNAME_TEST([../../2/3],       [../../2])
 140 DIRNAME_TEST([//1/3///],        [//1])
 141 DIRNAME_TEST([/1/3///],         [/1])
 142 DIRNAME_TEST([./1/3///],        [./1])
 143 DIRNAME_TEST([../../2/3///],    [../../2])
 144 DIRNAME_TEST([//1//3/],         [//1])
 145 DIRNAME_TEST([/1//3/],          [/1])
 146 DIRNAME_TEST([./1//3/],         [./1])
 147 DIRNAME_TEST([../../2//3/],     [../../2])
 148 AS_EXIT(0)
 149 ]])
 150
 151 AT_CHECK_M4SH
 152 AT_CHECK([./script])
 153
 154 AT_CLEANUP
 155
 156
 157
 158 ## --------- ##
 159 ## AS_ECHO.  ##
 160 ## --------- ##
 161
 162 # Build nested dirs.
 163 AT_SETUP([AS@&t@_ECHO and AS@&t@_ECHO_N])
 164
 165 AT_DATA_M4SH([script.as],
 166 [[AS_INIT
 167
 168 m4_define([ECHO_TEST],
 169 [echo=`AS_ECHO(['$1'])`
 170 test "X$echo" = 'X$1' ||
 171   echo "AS@&t@_ECHO('"'$1'"') outputs '$echo'" >&2
 172
 173 echo=`AS_ECHO_N(['$1'])`
 174 test "X$echo" = 'X$1' ||
 175   echo "AS@&t@_ECHO_N('"'$1'"') outputs '$echo'" >&2])
 176
 177 ECHO_TEST([-])
 178 ECHO_TEST([--])
 179 ECHO_TEST([---...---])
 180 ECHO_TEST([      ])
 181 ECHO_TEST([-e])
 182 ECHO_TEST([-E])
 183 ECHO_TEST([-n])
 184 ECHO_TEST([-n -n])
 185 ECHO_TEST([-e -n])
 186 ECHO_TEST([ab\ncd])
 187 ECHO_TEST([abcd\c])
 188 ECHO_TEST([\a\b\c\f\n\r\t\v\"\])
 189 ECHO_TEST([ab
 190 cd
 191 e])
 192 ECHO_TEST([
 193  ])
 194 ECHO_TEST([
 195 \c])
 196 AS_EXIT(0)
 197 ]])
 198
 199 AT_CHECK_M4SH
 200 AT_CHECK([./script])
 201
 202 AT_CLEANUP
 203
 204
 205
 206 ## ------------- ##
 207 ## AS_BASENAME.  ##
 208 ## ------------- ##
 209
 210 # Build nested dirs.
 211 AT_SETUP([AS@&t@_BASENAME])
 212
 213 AT_DATA_M4SH([script.as],
 214 [[AS_INIT
 215
 216 m4_define([BASENAME_TEST],
 217 [base=`AS_BASENAME([$1])`
 218 test "$base" = "$2" ||
 219   echo "basename($1) = $base instead of $2" >&2
 220
 221 base=`_AS_BASENAME_SED([$1])`
 222 test "$base" = "$2" ||
 223   echo "basename_sed($1) = $base instead of $2" >&2])
 224
 225 BASENAME_TEST([//1],             [1])
 226 BASENAME_TEST([/1],              [1])
 227 BASENAME_TEST([./1],             [1])
 228 BASENAME_TEST([../../2],         [2])
 229 BASENAME_TEST([//1/],            [1])
 230 BASENAME_TEST([/1/],             [1])
 231 BASENAME_TEST([./1/],            [1])
 232 BASENAME_TEST([../../2],         [2])
 233 BASENAME_TEST([//1/3],           [3])
 234 BASENAME_TEST([/1/3],            [3])
 235 BASENAME_TEST([./1/3],           [3])
 236 BASENAME_TEST([../../2/3],       [3])
 237 BASENAME_TEST([//1/3///],        [3])
 238 BASENAME_TEST([/1/3///],         [3])
 239 BASENAME_TEST([./1/3///],        [3])
 240 BASENAME_TEST([../../2/3///],    [3])
 241 BASENAME_TEST([//1//3/],         [3])
 242 BASENAME_TEST([/1//3/],          [3])
 243 BASENAME_TEST([./1//3/],         [3])
 244 BASENAME_TEST([a.c],             [a.c])
 245 BASENAME_TEST([a.c/],            [a.c])
 246 BASENAME_TEST([/a.c/],           [a.c])
 247 BASENAME_TEST([/1/a.c],          [a.c])
 248 BASENAME_TEST([/1/a.c/],         [a.c])
 249 BASENAME_TEST([/1/../a.c],       [a.c])
 250 BASENAME_TEST([/1/../a.c/],      [a.c])
 251 BASENAME_TEST([./1/a.c],         [a.c])
 252 BASENAME_TEST([./1/a.c/],        [a.c])
 253 AS_EXIT(0)
 254 ]])
 255
 256 AT_CHECK_M4SH
 257 AT_CHECK([./script])
 258
 259 AT_CLEANUP
 260
 261
 262
 263 ## ------------ ##
 264 ## AS_MKDIR_P.  ##
 265 ## ------------ ##
 266
 267 # Build nested dirs.
 268 AT_SETUP([AS@&t@_MKDIR_P])
 269
 270 AT_DATA_M4SH([script.as],
 271 [[AS_INIT
 272
 273 pwd=`pwd`
 274 set -e
 275 # Absolute
 276 AS_MKDIR_P(["$pwd/1/2/3/4/5/6"])
 277 test -d "$pwd/1/2/3/4/5/6" ||
 278   AS_ERROR([$pwd/1/2/3/4/5/6 has not been properly created])
 279 # Relative
 280 AS_MKDIR_P(["a/b/c/d/e/f"])
 281 test -d a/b/c/d/e/f ||
 282   AS_ERROR([a/b/c/d/e/f has not been properly created])
 283 AS_EXIT(0)
 284 ]])
 285
 286 AT_CHECK_M4SH
 287 AT_CHECK([./script])
 288
 289 AT_CLEANUP
 290
 291
 292
 293
 294 ## -------------------- ##
 295 ## AS_VERSION_COMPARE.  ##
 296 ## -------------------- ##
 297
 298 # Build nested dirs.
 299 AT_SETUP([AS@&t@_VERSION_COMPARE])
 300
 301 AT_DATA_M4SH([script.as],
 302 [[AS_INIT
 303
 304 m4_define([VERSION_COMPARE_TEST],
 305 [AS_VERSION_COMPARE([$1], [$3], [result='<'], [result='='], [result='>'])
 306 test "X$result" = "X$2" ||
 307   AS_ERROR([version $1 $result $3; should be $1 $2 $3])
 308 m4_if([$1], <,
 309 [AS_VERSION_COMPARE([$3], [$1], [result='<'], [result='='], [result='>'])
 310 test "X$result" = "X>" ||
 311   AS_ERROR([version $3 $result $1; should be $3 > $1])])])
 312
 313 VERSION_COMPARE_TEST([], =, [])
 314 VERSION_COMPARE_TEST([1.0], =, [1.0])
 315 VERSION_COMPARE_TEST([alpha-1.0], =, [alpha-1.0])
 316
 317 # These tests are taken from libc/string/tst-svc.expect.
 318 tst_svc_expect='
 319   000 001 00 00a 01 01a 0 0a 2.8 2.8-0.4 20 21 22 212 CP037 CP345 CP1257
 320   foo foo-0.4 foo-0.4a foo-0.4b foo-0.5 foo-0.10.5 foo-3.01 foo-3.0
 321   foo-3.0.0 foo-3.0.1 foo-3.2 foo-3.10 foo00 foo0
 322 '
 323 test1=''
 324 for test2 in $tst_svc_expect; do
 325   VERSION_COMPARE_TEST([$test1], <, [$test2])
 326   test1=$test2
 327 done
 328
 329 AS_EXIT(0)
 330 ]])
 331
 332 AT_CHECK_M4SH
 333 AT_CHECK([./script])
 334
 335 AT_CLEANUP
 336
 337
 338
 339
 340 ## ----------------------------- ##
 341 ## Negated classes in globbing.  ##
 342 ## ----------------------------- ##
 343
 344 # It is known that `[^...]' is not universally supported, but it is
 345 # unknown for `[!...]'.
 346
 347 AT_SETUP([Negated classes in globbing])
 348
 349 AT_DATA_M4SH([script.as],
 350 [[AS_INIT
 351
 352 case 'with!two!bangs' in
 353   *[[!a-z]]*) ;;
 354            *) AS_ERROR([[`*[!a-z]*' didn't match `with!two!bangs']]);;
 355 esac
 356
 357 case without in
 358   *[[!a-z]]*) AS_ERROR([[`*[!a-z]*' matched `without']]);;
 359 esac
 360 ]])
 361
 362 AT_CHECK_M4SH
 363 AT_CHECK([./script])
 364
 365 AT_CLEANUP
 366
 367
 368
 369
 370 ## ------------------- ##
 371 ## Functions Support.  ##
 372 ## ------------------- ##
 373
 374 # Hypothesis: the shell we are running, after having checked for
 375 # $LINENO support, supports functions.
 376
 377 AT_SETUP([Functions Support])
 378
 379 AT_DATA_M4SH([script.as],
 380 [[AS_INIT
 381 _AS_LINENO_PREPARE
 382
 383 func_return () {
 384   (exit $1)
 385 }
 386
 387 func_success () {
 388   func_return 0
 389 }
 390
 391 func_failure () {
 392   func_return 1
 393 }
 394
 395 if func_success; then
 396   if func_failure; then
 397     AS_ERROR([func_failure passed])
 398   fi
 399 else
 400   AS_ERROR([func_success failed])
 401 fi
 402 ]])
 403
 404 AT_CHECK_M4SH
 405 AT_CHECK([./script])
 406
 407 AT_CLEANUP
 408
 409
 410
 411
 412 ## ------------------------------ ##
 413 ## Functions and return Support.  ##
 414 ## ------------------------------ ##
 415
 416 # Hypothesis: the shell we are running, after having checked for
 417 # $LINENO support, supports functions, and the `return' keyword.
 418
 419 AT_SETUP([Functions and return Support])
 420
 421 AT_DATA_M4SH([script.as],
 422 [[AS_INIT
 423 _AS_LINENO_PREPARE
 424
 425 func_success () {
 426   return 0
 427 }
 428
 429 func_failure () {
 430   return 1
 431 }
 432
 433 if func_success; then
 434   if func_failure; then
 435     AS_ERROR([func_failure passed])
 436   fi
 437 else
 438   AS_ERROR([func_success failed])
 439 fi
 440 ]])
 441
 442 AT_CHECK_M4SH
 443 AT_CHECK([./script])
 444
 445 AT_CLEANUP
 446
 447
 448 ## ------------------------------------ ##
 449 ## AS_REQUIRE_SHELL_FN and m4_require.  ##
 450 ## ------------------------------------ ##
 451
 452 # Hypothesis: M4sh expands the requirements of AS_REQUIRE_SHELL_FN
 453 # in the main diversion, and not in M4SH-INIT.
 454
 455 AT_SETUP([AS@&t@_REQUIRE_SHELL_FN and m4@&t@_require])
 456
 457 AT_DATA_M4SH([script.as], [[dnl
 458 AS_INIT
 459
 460 m4_defun([in_m4_sh_init], still_in_m4sh_init=yes)
 461 m4_defun([not_in_m4_sh_init], still_in_m4sh_init=no)
 462
 463 m4_defun([error_if_emitted_in_m4sh_init], [
 464   if test x$still_in_m4sh_init = xyes; then
 465     AS_ERROR([requirement emitted in M4SH-INIT])
 466   fi
 467 ])
 468
 469 m4_defun([TEST_FUNC_BODY], [
 470 m4_require([error_if_emitted_in_m4sh_init])
 471 : echo in shell function, with parameter = [$]1
 472 ])
 473
 474
 475 m4_defun([test_init], [
 476 AS_REQUIRE([in_m4_sh_init])
 477 AS_REQUIRE_SHELL_FN([test_func], [TEST_FUNC_BODY])
 478 AS_REQUIRE([not_in_m4_sh_init])
 479 ])
 480
 481 test_init
 482 test_func parameter1
 483 ]])
 484
 485 AT_CHECK_M4SH
 486 AT_CHECK([./script])
 487
 488 AT_CLEANUP
 489
 490
 491 ## -------------- ##
 492 ## AS_HELP_STRING ##
 493 ## -------------- ##
 494
 495 # I'm not totally certain that we want to enforce the defaults here,
 496 # but at least it is being tested.
 497
 498 AT_SETUP([AS@&t@_HELP_STRING])
 499
 500 AT_DATA_M4SH([script.as],
 501 [[AS_INIT
 502 _AS_LINENO_PREPARE
 503
 504 echo "AS_HELP_STRING([--an-option],[some text])"
 505 echo "AS_HELP_STRING([--another-much-longer-option],
 506 [some other text which should wrap at our default of 80 characters.])"
 507 echo "AS_HELP_STRING([--fooT=barT], [foo bar])"
 508 echo "AS_HELP_STRING([--foo@<][:@=bar@:][>@], [foo bar])"
 509 echo "AS_HELP_STRING([--foo@<][:@=bar@:][>@123456789], [foo bar])"
 510 echo "AS_HELP_STRING([--foo@<][:@=bar@:][>@1234567890], [foo bar])"
 511 echo "AS_HELP_STRING([--foo@<][:@=bar@:][>@12345678901], [foo bar])"
 512 echo "AS_HELP_STRING([--foo@<][:@=bar@:][>@123456789012], [foo bar])"
 513 echo "AS_HELP_STRING([--foo@<][:@=bar@:][>@1234567890123], [foo bar])"
 514 echo "AS_HELP_STRING([--foo@<][:@=bar@:][>@],
 515 [some other text which should wrap at our default of 80 characters.])"
 516 echo "AS_HELP_STRING([--foo@<][:@=bar@:][>@123456789],
 517 [some other text which should wrap at our default of 80 characters.])"
 518 echo "AS_HELP_STRING([--foo@<][:@=bar@:][>@1234567890],
 519 [some other text which should wrap at our default of 80 characters.])"
 520 echo "AS_HELP_STRING([--foo@<][:@=bar@:][>@12345678901],
 521 [some other text which should wrap at our default of 80 characters.])"
 522 echo "AS_HELP_STRING([--foo@<][:@=bar@:][>@123456789012],
 523 [some other text which should wrap at our default of 80 characters.])"
 524 echo "AS_HELP_STRING([--foo@<][:@=bar@:][>@1234567890123],
 525 [some other text which should wrap at our default of 80 characters.])"
 526 echo "AS_HELP_STRING([--foo@<][:@=bar@:][>@],
 527 [some other @<][:@ex@:][>@ which should wrap at our default of 80 characters.])"
 528 echo "AS_HELP_STRING([--foo@<][:@=bar@:][>@123456789],
 529 [some other @<][:@ex@:][>@ which should wrap at our default of 80 characters.])"
 530 echo "AS_HELP_STRING([--foo@<][:@=bar@:][>@1234567890],
 531 [some other @<][:@ex@:][>@ which should wrap at our default of 80 characters.])"
 532 echo "AS_HELP_STRING([--foo@<][:@=bar@:][>@12345678901],
 533 [some other @<][:@ex@:][>@ which should wrap at our default of 80 characters.])"
 534 echo "AS_HELP_STRING([--foo@<][:@=bar@:][>@123456789012],
 535 [some other @<][:@ex@:][>@ which should wrap at our default of 80 characters.])"
 536 echo "AS_HELP_STRING([--foo@<][:@=bar@:][>@1234567890123],
 537 [some other @<][:@ex@:][>@ which should wrap at our default of 80 characters.])"
 538 ]])
 539
 540 AT_CHECK_M4SH
 541 AT_CHECK([./script], [0],
 542 [[  --an-option             some text
 543   --another-much-longer-option
 544                           some other text which should wrap at our default of
 545                           80 characters.
 546   --fooT=barT             foo bar
 547   --foo[=bar]             foo bar
 548   --foo[=bar]123456789    foo bar
 549   --foo[=bar]1234567890   foo bar
 550   --foo[=bar]12345678901  foo bar
 551   --foo[=bar]123456789012 foo bar
 552   --foo[=bar]1234567890123
 553                           foo bar
 554   --foo[=bar]             some other text which should wrap at our default of
 555                           80 characters.
 556   --foo[=bar]123456789    some other text which should wrap at our default of
 557                           80 characters.
 558   --foo[=bar]1234567890   some other text which should wrap at our default of
 559                           80 characters.
 560   --foo[=bar]12345678901  some other text which should wrap at our default of
 561                           80 characters.
 562   --foo[=bar]123456789012 some other text which should wrap at our default of
 563                           80 characters.
 564   --foo[=bar]1234567890123
 565                           some other text which should wrap at our default of
 566                           80 characters.
 567   --foo[=bar]             some other [ex] which should wrap at our default of
 568                           80 characters.
 569   --foo[=bar]123456789    some other [ex] which should wrap at our default of
 570                           80 characters.
 571   --foo[=bar]1234567890   some other [ex] which should wrap at our default of
 572                           80 characters.
 573   --foo[=bar]12345678901  some other [ex] which should wrap at our default of
 574                           80 characters.
 575   --foo[=bar]123456789012 some other [ex] which should wrap at our default of
 576                           80 characters.
 577   --foo[=bar]1234567890123
 578                           some other [ex] which should wrap at our default of
 579                           80 characters.
 580 ]])
 581
 582 AT_CLEANUP
 583
 584
 585 ## ------------------- ##
 586 ## AS_IF and AS_CASE.  ##
 587 ## ------------------- ##
 588
 589 AT_SETUP([AS@&t@_IF and AS@&t@_CASE])
 590
 591 AT_DATA_M4SH([script.as], [[dnl
 592 AS_INIT
 593 # Syntax checks: cope with empty arguments.
 594 AS_IF([:], [], [echo wrong])
 595 AS_IF([:], [echo one], [echo wrong])
 596 AS_IF([false], [echo wrong], [echo two])
 597 AS_IF([false], [echo wrong])
 598 # n-ary version
 599 AS_IF([false], [echo wrong],
 600       [:], [echo three])
 601 AS_IF([false], [echo wrong],
 602       [:], [echo four],
 603       [echo wrong])
 604 AS_IF([false], [echo wrong],
 605       [false], [echo wrong])
 606 AS_IF([false], [echo wrong],
 607       [false], [echo wrong],
 608       [echo five])
 609 AS_IF([false], [echo wrong],
 610       [false], [echo wrong],
 611       [:], [echo six],
 612       [echo wrong])
 613 AS_CASE([foo])
 614 AS_CASE([foo], [echo seven])
 615 AS_CASE([foo],
 616         [foo], [echo eight],
 617         [echo wrong])
 618 AS_CASE([foo],
 619         [foo], [echo nine],
 620         [*],   [echo wrong])
 621 AS_CASE([foo],
 622         [bar], [echo wrong],
 623         [foo], [echo ten],
 624         [*],   [echo wrong])
 625
 626 # check that require works correctly
 627 m4_for([n], 1, 9, [],
 628 [m4_defun([FOO]n, [foo]n[=]n)dnl
 629 m4_defun([BAR]n,
 630          [m4_require([FOO]]n[)dnl
 631 bar]n[=]n)[]dnl
 632 ])
 633
 634 AS_IF([:], [BAR1])
 635 echo "foo1=$foo1 bar1=$bar1"
 636 AS_IF([:], [], [BAR2])
 637 echo "foo2=$foo2 bar2=$bar2"
 638 AS_IF([false], [BAR3])
 639 echo "foo3=$foo3 bar3=$bar3"
 640 AS_IF([false], [], [BAR4])
 641 echo "foo4=$foo4 bar4=$bar4"
 642 AS_CASE([x], [x], [BAR5])
 643 echo "foo5=$foo5 bar5=$bar5"
 644 AS_CASE([x], [y], [BAR6])
 645 echo "foo6=$foo6 bar6=$bar6"
 646 AS_CASE([x],
 647         [x], [:],
 648         [BAR7])
 649 echo "foo7=$foo7 bar7=$bar7"
 650 AS_CASE([x],
 651         [y], [:],
 652         [BAR8])
 653 echo "foo8=$foo8 bar8=$bar8"
 654 AS_CASE([x],
 655         [y], [:],
 656         [x], [BAR9])
 657 echo "foo9=$foo9 bar9=$bar9"
 658 ]])
 659
 660 AT_CHECK_M4SH
 661 AT_CHECK([./script], [0], [[one
 662 two
 663 three
 664 four
 665 five
 666 six
 667 seven
 668 eight
 669 nine
 670 ten
 671 foo1=1 bar1=1
 672 foo2=2 bar2=
 673 foo3=3 bar3=
 674 foo4=4 bar4=4
 675 foo5=5 bar5=5
 676 foo6=6 bar6=
 677 foo7=7 bar7=
 678 foo8=8 bar8=8
 679 foo9=9 bar9=9
 680 ]])
 681
 682 AT_CLEANUP
 683
 684
 685 ## --------------- ##
 686 ## AS_LITERAL_IF.  ##
 687 ## --------------- ##
 688
 689 AT_SETUP([AS@&t@_LITERAL_IF])
 690
 691 AT_DATA_M4SH([script.as], [[dnl
 692 AS_INIT
 693 echo AS_LITERAL_IF([lit], [ok], [ERR]) 1
 694 echo AS_LITERAL_IF([l$it], [ERR], [ok]) 2
 695 echo AS_LITERAL_IF([l``it], [ERR], [ok]) 3
 696 m4_define([mac], [lit])
 697 echo AS_LITERAL_IF([mac], [ok], [ERR]) 4
 698 echo AS_LITERAL_IF([mac($, ``)], [ok], [ERR]) 5
 699 m4_define([mac], [l$it])
 700 echo AS_LITERAL_IF([mac], [ERR], [ok]) 6
 701 m4_define([mac], [l`it])
 702 echo AS_LITERAL_IF([mac], [ERR], [ok]) 7
 703 ]])
 704
 705 AT_CHECK_M4SH
 706 AT_CHECK([./script], [],
 707 [[ok 1
 708 ok 2
 709 ok 3
 710 ok 4
 711 ok 5
 712 ok 6
 713 ok 7
 714 ]])
 715
 716 AT_CLEANUP