path: root/tests/m4sugar.at

#							-*- Autotest -*-

AT_BANNER([M4sugar.])

# Copyright (C) 2000-2002, 2005-2012 Free Software Foundation, Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.


# AT_CHECK_M4SUGAR_TEXT(CODE, STDOUT, STDERR)
# -------------------------------------------
# Check that m4sugar CODE expands to STDOUT and emits STDERR.
m4_define([AT_CHECK_M4SUGAR_TEXT],
[
AT_DATA_M4SUGAR([script.4s],
[[m4_init
m4_divert_push([])[]dnl
]$1[[]dnl
m4_divert_pop([])
]])

AT_CHECK_M4SUGAR([-o-],, [$2], [$3])
])# AT_CHECK_M4SUGAR_TEXT


## ------------------ ##
## m4_stack_foreach.  ##
## ------------------ ##

AT_SETUP([m4@&t@_stack])

AT_KEYWORDS([m4@&t@_stack_foreach m4@&t@_stack_foreach_lifo])
AT_KEYWORDS([m4@&t@_stack_foreach_sep m4@&t@_stack_foreach_sep_lifo])
AT_KEYWORDS([m4@&t@_copy m4@&t@_n])

# Test the semantics of macros to walk stacked macro definitions.
AT_CHECK_M4SUGAR_TEXT([[dnl
m4_pushdef([abc], [def])dnl
m4_pushdef([abc], [ghi])dnl
m4_pushdef([abc], [jkl])dnl
m4_stack_foreach([abc], [m4_n])
abc
m4_stack_foreach_lifo([abc], [m4_n])
m4_stack_foreach([abc], [m4_n])
m4_copy([abc], [foo])dnl
m4_stack_foreach([foo], [m4_n])
m4_stack_foreach_lifo([foo], [m4_n])
m4_stack_foreach_sep([abc], [ m4_index([abcdefghijkl],], [)])
m4_define([colon], [:])m4_define([lt], [<])m4_define([gt], [>])dnl
m4_stack_foreach_sep_lifo([abc], [lt], [gt], [colon])
m4_pushdef([xyz], [123])dnl
m4_pushdef([xyz], [456])dnl
m4_define([doit], [[$1](m4_stack_foreach_sep([xyz], [m4_dquote(], [)], [,]))
])dnl
m4_stack_foreach([abc], [doit])]],
[[def
ghi
jkl

jkl
jkl
ghi
def

def
ghi
jkl

def
ghi
jkl

jkl
ghi
def

 3 6 9
<jkl>:<ghi>:<def>
def([123],[456])
ghi([123],[456])
jkl([123],[456])
]])

AT_CLEANUP


## --------- ##
## m4_defn.  ##
## --------- ##

AT_SETUP([m4@&t@_defn])

AT_KEYWORDS([m4@&t@_popdef m4@&t@_undefine m4@&t@_copy m4@&t@_rename
m4@&t@_copy_force m4@&t@_rename_force])

# Ensure that m4sugar dies when dereferencing undefined macros, whether
# this is provided by m4 natively or faked by wrappers in m4sugar.

AT_DATA_M4SUGAR([script.4s],
[[m4_define([good])
m4_defn([good], [oops])
]])

AT_CHECK_M4SUGAR([-o-], 1, [], [stderr])
AT_CHECK([grep good stderr], [1])
AT_CHECK([grep 'm4@&t@_defn: undefined.*oops' stderr], [0], [ignore])

AT_DATA_M4SUGAR([script.4s],
[[m4_define([good])
m4_popdef([good], [oops])
]])

AT_CHECK_M4SUGAR([-o-], 1, [], [stderr])
AT_CHECK([grep good stderr], [1])
AT_CHECK([grep 'm4@&t@_popdef: undefined.*oops' stderr], [0], [ignore])

AT_DATA_M4SUGAR([script.4s],
[[m4_define([good])
m4_undefine([good], [oops])
]])

AT_CHECK_M4SUGAR([-o-], 1, [], [stderr])
AT_CHECK([grep good stderr], [1])
AT_CHECK([grep 'm4@&t@_undefine: undefined.*oops' stderr], [0], [ignore])

# Cannot rename an undefined macro.
AT_DATA_M4SUGAR([script.4s],
[[m4_rename([oops], [good])
]])

AT_CHECK_M4SUGAR([-o-], 1, [], [stderr])
AT_CHECK([grep 'm4@&t@_undefine: undefined.*oops' stderr], [0], [ignore])

# Check that pushdef stacks can be renamed.
AT_CHECK_M4SUGAR_TEXT([[m4_pushdef([a], [1])dnl
m4_pushdef([a], [2])dnl
m4_pushdef([a], m4_defn([m4_divnum]))dnl
a b c
m4_rename([a], [b])dnl
a b c
m4_copy([b], [c])dnl
a b c
m4_popdef([b], [c])dnl
a b c
m4_popdef([b], [c])dnl
a b c
m4_popdef([b], [c])dnl
a b c
dnl m4_copy is intentionally a no-op on undefined source
m4_copy([oops], [dummy])m4_ifdef([dummy], [[oops]])dnl
dnl allow forceful overwrites
m4_define([d], [4])m4_define([e], [5])m4_define([f], [6])dnl
m4_copy_force([d], [e])dnl
m4_rename_force([d], [f])dnl
d e f
m4_popdef([e], [f])dnl
d e f
]], [[0 b c
a 0 c
a 0 0
a 2 2
a 1 1
a b c
d 4 4
d e f
]])

AT_CLEANUP


## ------------ ##
## m4_dumpdef.  ##
## ------------ ##

AT_SETUP([m4@&t@_dumpdef])

AT_KEYWORDS([m4@&t@_dumpdefs])

# Ensure that m4sugar dies when dereferencing undefined macros.

AT_DATA_M4SUGAR([script.4s],
[[m4_define([good], [yep])
m4_dumpdef([good], [oops])
]])

AT_CHECK_M4SUGAR([-o-], 1, [], [stderr])
AT_CHECK([grep '^good:	\[[yep\]]$' stderr], [0], [ignore])
AT_CHECK([grep 'm4@&t@_dumpdef: undefined.*oops' stderr], [0], [ignore])

# Check that pushdef stacks can be dumped.
AT_CHECK_M4SUGAR_TEXT([[m4_divert_push([KILL])
m4_pushdef([a], [1])
m4_pushdef([a], [2])
m4_dumpdef([a])
m4_dumpdefs([oops], [a])
m4_divert_pop([KILL])dnl
]], [],
[[a:	[2]
a:	[2]
a:	[1]
]])

# Check behavior when dumping builtins.  Unfortunately, when using M4 1.4.x
# (or more precisely, when __m4_version__ is undefined), builtins get
# flattened to an empty string.  It takes M4 1.6 to work around this.
AT_DATA_M4SUGAR([script.4s],
[[m4_ifdef([__m4_version__], [_m4_undefine([__m4_version__])])
m4_init
m4_dumpdef([m4_define])
]])

AT_CHECK_M4SUGAR([-o-], [0], [],
[[m4_define:	[]
]])

AT_DATA_M4SUGAR([script.4s],
[[m4_init
m4_ifdef([__m4_version__],
[m4_dumpdef([m4_define])],
[m4_errprintn([m4_define:	<define>])])
]])

AT_CHECK_M4SUGAR([-o-], [0], [],
[[m4_define:	<define>
]])

AT_CLEANUP


## --------- ##
## m4_warn.  ##
## --------- ##

AT_SETUP([m4@&t@_warn])

AT_DATA_M4SUGAR([script.4s],
[[m4_init
m4_defun([cross_warning], [m4_warn([cross], [cross])])

m4_divert([0])dnl
m4_warn([obsolete], [obsolete])dnl
cross_warning[]dnl
m4_warn([syntax], [syntax])dnl
cross_warning[]dnl
m4_warn([syntax], [syntax])dnl
]])

AT_CHECK_M4SUGAR([-o-], 0, [],
[script.4s:4: warning: prefer named diversions
script.4s:7: warning: syntax
script.4s:9: warning: syntax
])

AT_CHECK_M4SUGAR([-o- -Wall], 0, [],
[script.4s:4: warning: prefer named diversions
script.4s:5: warning: obsolete
script.4s:6: warning: cross
script.4s:2: cross_warning is expanded from...
script.4s:6: the top level
script.4s:7: warning: syntax
script.4s:8: warning: cross
script.4s:2: cross_warning is expanded from...
script.4s:8: the top level
script.4s:9: warning: syntax
])

AT_CHECK_M4SUGAR([-o- -Wnone,cross], 0, [],
[script.4s:6: warning: cross
script.4s:2: cross_warning is expanded from...
script.4s:6: the top level
script.4s:8: warning: cross
script.4s:2: cross_warning is expanded from...
script.4s:8: the top level
])

AT_CHECK_M4SUGAR([-o- -Wnone,cross,error], 1, [],
[[script.4s:6: warning: cross
script.4s:2: cross_warning is expanded from...
script.4s:6: the top level
script.4s:8: warning: cross
script.4s:2: cross_warning is expanded from...
script.4s:8: the top level
]])

AT_CLEANUP


## ----------------- ##
## m4_divert_stack.  ##
## ----------------- ##

AT_SETUP([m4@&t@_divert_stack])
AT_KEYWORDS([m4@&t@_divert m4@&t@_divert_push m4@&t@_divert_pop
m4@&t@_undivert m4@&t@_cleardivert m4@&t@_divert_text])

dnl This test names some diversions to avoid a warning.
AT_CHECK_M4SUGAR_TEXT([[m4_define([_m4_divert(ten)], [10])dnl
m4_define([_m4_divert(twenty)], [20])dnl
m4_define([_m4_divert(thirty)], [30])dnl
1.m4_divert_stack
m4_divert_push([ten])2.m4_divert_stack
m4_divert_text([twenty], [3.m4_divert_stack])dnl
m4_divert([thirty])4.m4_divert_stack
m4_divert_pop([thirty])dnl
5.m4_undivert([twenty], [thirty])
m4_pattern_allow([^m4_divert])dnl
]], [[1.script.4s:2: m4@&t@_divert_push:
script.4s:1: m4@&t@_divert: KILL
5.3.script.4s:8: m4@&t@_divert_push: twenty
script.4s:7: m4@&t@_divert_push: ten
script.4s:2: m4@&t@_divert_push:
script.4s:1: m4@&t@_divert: KILL
4.script.4s:9: m4@&t@_divert: thirty
script.4s:2: m4@&t@_divert_push:
script.4s:1: m4@&t@_divert: KILL

2.script.4s:7: m4@&t@_divert_push: ten
script.4s:2: m4@&t@_divert_push:
script.4s:1: m4@&t@_divert: KILL
]])

AT_CHECK_M4SUGAR_TEXT([[dnl
m4_divert_text([3], [three])dnl
m4_divert_text([4], [four])dnl
m4_divert_text([1], [one])dnl
m4_divert_text([2], [two])dnl
m4_cleardivert([2], [3])dnl
]],
[[one
four
]],
[[script.4s:4: warning: prefer named diversions
script.4s:5: warning: prefer named diversions
script.4s:6: warning: prefer named diversions
script.4s:7: warning: prefer named diversions
script.4s:8: warning: prefer named diversions
]])

AT_DATA_M4SUGAR([script.4s],
[[m4_divert_pop
]])
AT_CHECK_M4SUGAR([-o-], [1], [],
[[script.4s:1: error: too many m4@&t@_divert_pop
script.4s:1: the top level
autom4te: m4 failed with exit status: 1
]])

AT_DATA_M4SUGAR([script.4s],
[[m4_init
m4_divert_push([1])
m4_divert_pop([2])
]])
AT_CHECK_M4SUGAR([-o-], [1], [],
[[script.4s:3: error: m4@&t@_divert_pop(2): diversion mismatch:
script.4s:2: m4@&t@_divert_push: 1
script.4s:1: m4@&t@_divert: KILL
script.4s:3: the top level
autom4te: m4 failed with exit status: 1
]])

AT_DATA_M4SUGAR([script.4s],
[[m4_divert([1])
m4_init
m4_divert_push([2])
]])
AT_CHECK_M4SUGAR([-o-], [1], [],
[[script.4s:2: error: m4@&t@_init: unbalanced m4@&t@_divert_push:
script.4s:3: m4@&t@_divert_push: 2
script.4s:2: m4@&t@_divert: KILL
script.4s:2: the top level
autom4te: m4 failed with exit status: 1
]])

AT_CLEANUP


## -------------------- ##
## m4_expansion_stack.  ##
## -------------------- ##

AT_SETUP([m4@&t@_expansion_stack])

AT_CHECK_M4SUGAR_TEXT([[1.m4_expansion_stack
m4_defun([a], [b])dnl
m4_define([c], [d])dnl
m4_defun([d], [2.m4_expansion_stack])dnl
m4_defun([b], [c])dnl
a
3.m4_ifdef([_m4_expansion_stack], [m4_expansion_stack])
]], [[1.script.4s:3: the top level
2.script.4s:6: d is expanded from...
script.4s:7: b is expanded from...
script.4s:4: a is expanded from...
script.4s:8: the top level
3.
]])

AT_CLEANUP


## --------------------------- ##
## m4_require: error message.  ##
## --------------------------- ##

AT_SETUP([m4@&t@_require: error message])
AT_KEYWORDS([m4@&t@_require])

AT_DATA_M4SUGAR([script.4s],
[[m4_defun([foo], [FOO])
m4_require([foo])
]])

AT_CHECK_M4SUGAR([], 1, [],
[[script.4s:2: error: m4@&t@_require(foo): cannot be used outside of an m4_defun'd macro
script.4s:2: the top level
autom4te: m4 failed with exit status: 1
]])
AT_CLEANUP


## ----------------------------------- ##
## m4_require: circular dependencies.  ##
## ----------------------------------- ##

AT_SETUP([m4@&t@_require: circular dependencies])
AT_KEYWORDS([m4@&t@_require])

AT_DATA_M4SUGAR([script.4s],
[[m4_defun([foo], [m4_require([bar])])

m4_defun([bar], [m4_require([foo])])

m4_defun([baz], [m4_require([foo])])

m4_init
m4_divert([0])dnl
baz
]])

AT_CHECK_M4SUGAR([], 1, [],
[[script.4s:9: error: m4@&t@_require: circular dependency of foo
script.4s:3: bar is expanded from...
script.4s:1: foo is expanded from...
script.4s:5: baz is expanded from...
script.4s:9: the top level
autom4te: m4 failed with exit status: 1
]])
AT_CLEANUP


## ---------------------- ##
## m4_require: one-shot.  ##
## ---------------------- ##

AT_SETUP([m4@&t@_require: one-shot initialization])
AT_KEYWORDS([m4@&t@_require])
AT_KEYWORDS([m4@&t@_defun_init m4@&t@_copy m4@&t@_defun_once])

dnl check out m4_defun_init, m4_copy, and odd macro names
AT_CHECK_M4SUGAR_TEXT([[
m4_define([t], [text])dnl
m4_defun_init([a], [[init a
]], [[common a] t])dnl
m4_defun([b], [[b]m4_require([a])])dnl
m4_defun([c], [[c]m4_require([a])])dnl
b
c
a()dnl

m4_defun_init([-], [hello, ], [m4_if([$#], [0], [world], [[$1]])])dnl
m4_copy([-], [.])dnl
m4_indir([.])
m4_indir([.], [goodbye])
m4_indir([-], [again])
]], [[
init a
common a text
b
c
common a text
hello, world
goodbye
hello, again
]])

dnl Check m4_defun_once behavior
AT_CHECK_M4SUGAR_TEXT([[
m4_defun_once([a], [[a]])dnl
m4_defun([b], [[b]m4_require([a])])dnl
m4_defun([c], [[c]a[]m4_require([b])])dnl
c
a
m4_defun_once([d], [[d]m4_require([a])])dnl
d
m4_defun_once([e], [[e]])dnl
m4_defun([f], [[f]m4_require([e])e])dnl
f
]], [[
a
b
c

d
e
f
]])


AT_CLEANUP


## -------------------- ##
## m4_require: nested.  ##
## -------------------- ##

AT_SETUP([m4@&t@_require: nested])
AT_KEYWORDS([m4@&t@_require m4@&t@_defun])

dnl From the m4sugar.m4 discourse: Require chains, top level
AT_CHECK_M4SUGAR_TEXT([[dnl
m4_defun([a], [[a]])dnl aka TEST2a
m4_defun([b], [[b]m4_require([a])])dnl aka TEST3
m4_defun([c], [[c]m4_require([b])])dnl aka TEST2b
m4_defun([d], [[d]m4_require([a])m4_require([c])])dnl aka TEST1
pre
d
d
post
]],
[[pre
a
b
c
d
d
post
]])

dnl From the m4sugar.m4 discourse: Require chains, nested
AT_CHECK_M4SUGAR_TEXT([[dnl
m4_defun([a], [[a]])dnl aka TEST2a
m4_defun([b], [[b]m4_require([a])])dnl aka TEST3
m4_defun([c], [[c]m4_require([b])])dnl aka TEST2b
m4_defun([d], [[d]m4_require([a])m4_require([c])])dnl aka TEST1
m4_defun([wrap],
[pre
d
d
post])dnl
wrap
]],
[[a
b
c
pre
d
d
post
]])

dnl Direct invocation, nested requires, top level
AT_CHECK_M4SUGAR_TEXT([[dnl
m4_defun([a], [[a]])dnl
m4_defun([b], [[b]m4_require([a])])dnl
m4_defun([c], [[c]m4_require([b])])dnl
pre
a
c
a
c
post
]],
[[pre
a
b
c
a
c
post
]])

dnl Direct invocation, nested requires, nested defun.  This is an example
dnl of expansion before requirement, such that b occurs before its
dnl prerequisite a.  This indicates a bug in the macros (but not in
dnl autoconf), so we should be emitting a warning.
AT_CHECK_M4SUGAR_TEXT([[dnl
m4_defun([a], [[a]])dnl
m4_defun([b], [[b]m4_require([a])])dnl
m4_defun([c], [[c]m4_require([b])])dnl
dnl the extra macro layer works around line number differences in older m4
m4_define([foo], [m4_defun([outer],
[pre
a
c
a
c
post])])foo[]dnl
outer
]],
[[a
b
pre
a
c
a
c
post
]],
[[script.4s:15: warning: m4@&t@_require: `a' was expanded before it was required
script.4s:15: http://www.gnu.org/software/autoconf/manual/autoconf.html#Expanded-Before-Required
script.4s:5: b is expanded from...
script.4s:6: c is expanded from...
script.4s:14: outer is expanded from...
script.4s:15: the top level
]])

dnl Direct invocation, expand-before-require but no nested require.  As this
dnl is common in real life, but does not result in out-of-order expansion,
dnl we silently permit this.
AT_CHECK_M4SUGAR_TEXT([[dnl
m4_defun([a], [[a]])dnl
m4_defun([b], [[b]m4_require([a])])dnl
m4_defun([c], [[c]])dnl
m4_defun([d], [[d]m4_require([c])])dnl
pre1
a
b
a
b
post1
m4_defun([outer],
[pre2
c
d
c
d
post2])dnl
outer
m4_defun([e], [[e]])dnl
m4_defun([f], [[f]m4_require([e])])dnl
m4_defun([g], [[g]
e
f])dnl
m4_defun([h], [[h]m4_require([g])])dnl
h
m4_defun([i], [[i]])dnl
m4_defun([j], [[j]
i])dnl
m4_defun([k], [[k]m4_require([i])])dnl
m4_defun([l], [[l]m4_require([k])])dnl
m4_defun([m], [[m]m4_require([j])m4_require([l])])dnl
m
]],
[[pre1
a
b
a
b
post1
pre2
c
d
c
d
post2
g
e
f
h
j
i
k
l
m
]])

AT_CLEANUP


## ------------------------------------------------- ##
## m4_ifval, m4_ifblank, m4_ifset, m4_default, etc.  ##
## ------------------------------------------------- ##

AT_SETUP([m4sugar shorthand conditionals])
AT_KEYWORDS([m4@&t@_ifval m4@&t@_ifblank m4@&t@_ifnblank m4@&t@_ifset
m4@&t@_default m4@&t@_default_quoted m4@&t@_default_nblank
m4@&t@_default_nblank_quoted])

AT_CHECK_M4SUGAR_TEXT([[m4_define([active], [ACTIVE])m4_define([empty])
m4_ifval([active], [yes], [no])
m4_ifval([empty], [yes], [no])
m4_ifval([ ], [yes], [no])
m4_ifval([], [yes], [no])
m4_ifblank([active], [yes], [no])
m4_ifblank([empty], [yes], [no])
m4_ifblank([ ], [yes], [no])
m4_ifblank([], [yes], [no])
m4_ifnblank([active], [yes], [no])
m4_ifnblank([empty], [yes], [no])
m4_ifnblank([ ], [yes], [no])
m4_ifnblank([], [yes], [no])
m4_ifset([active], [yes], [no])
m4_ifset([empty], [yes], [no])
m4_ifset([ ], [yes], [no])
m4_ifset([], [yes], [no])
---
m4_define([demo1], [m4_default([$1], [$2])])dnl
m4_define([demo2], [m4_default_quoted([$1], [$2])])dnl
m4_define([demo3], [m4_default_nblank([$1], [$2])])dnl
m4_define([demo4], [m4_default_nblank_quoted([$1], [$2])])dnl
demo1([active], [default])
demo1([], [active])
demo1([empty], [text])
-demo1([ ], [active])-
demo2([active], [default])
demo2([], [active])
demo2([empty], [text])
-demo2([ ], [active])-
demo3([active], [default])
demo3([], [active])
demo3([empty], [text])
-demo3([ ], [active])-
demo4([active], [default])
demo4([], [active])
demo4([empty], [text])
-demo4([ ], [active])-
]], [[
yes
yes
yes
no
no
no
yes
yes
yes
yes
no
no
yes
no
no
no
---
ACTIVE
ACTIVE

- -
active
active
empty
- -
ACTIVE
ACTIVE

-ACTIVE-
active
active
empty
-active-
]])

AT_CLEANUP

## --------- ##
## m4_cond.  ##
## --------- ##

AT_SETUP([m4@&t@_cond])

AT_CHECK_M4SUGAR_TEXT([[m4_define([side], [m4_errprintn([$1])$1])
m4_cond([side(1)], [1], [a],
        [side(1)], [1], [b],
        [side(1)], [2], [c])
m4_cond([side(2)], [1], [a],
        [side(2)], [1], [b],
        [side(2)], [2], [c],
        [side(2)])
m4_cond([side(3)], [1], [a],
        [side(3)], [1], [b],
        [side(3)], [2], [c],
        [side(3)])
m4_cond([a,a], [a,a], [yes], [no])
m4_cond([[a,a]], [a,a], [yes])
m4_cond([a,a], [a,b], [yes], [no])
m4_cond([a,a], [a,b], [yes])
m4_cond([m4_eval([0xa])])
m4_define([ab], [AB])dnl
m4_cond([a])b
m4_cond([1], [1], [a])b
m4_cond([1], [2], [3], [a])b
]], [[
a
c
3
yes
yes
no

10
AB
AB
AB
]], [[1
2
2
2
3
3
3
3
]])

AT_CLEANUP


## ---------- ##
## m4 lists.  ##
## ---------- ##

AT_SETUP([m4 lists])

AT_KEYWORDS([m4@&t@_car m4@&t@_cdr m4@&t@_argn _m4@&t_cdr])

AT_CHECK_M4SUGAR_TEXT([[dnl
m4_define([a], [A])m4_define([b], [B])m4_define([c], [C])
m4_argn([1], [a], [b], [c])
m4_argn([2], [a], [b], [c])
m4_argn([3], [a], [b], [c])
m4_argn([4], [a], [b], [c])
m4_car([a], [b], [c])
m4_cdr([a], [b], [c])
m4_cdr([a], [b])
m4_cdr([a])
_m4_cdr([a], [b], [c])
_m4_cdr([a], [b])
_m4_cdr([a])
m4_if(m4_cdr([], []), [[]], [good], [bad])
m4_if(m4_cdr([]), [], [good], [bad])
]], [[
a
b
c

a
[b],[c]
[b]

, [b],[c]
, [b]

good
good
]])

AT_DATA_M4SUGAR([script.4s],
[[m4_init
m4_argn([0], [a], [b], [c])
]])
AT_CHECK_M4SUGAR([-o-], [1], [],
[[script.4s:2: error: assert failed: 0 < 0
script.4s:2: the top level
autom4te: m4 failed with exit status: 1
]])

AT_CLEANUP


## ---------- ##
## m4_split.  ##
## ---------- ##

AT_SETUP([m4@&t@_split])

AT_CHECK_M4SUGAR_TEXT(
[[m4_define([active], [ACT, IVE])m4_define([bd], [oops])
m4_split
m4_split([[]])
m4_split([ ])
m4_split([active])
m4_split([ active	active ])end
m4_split([ ], [ ])
m4_split([active], [ ])
m4_split([ active	active ], [ ])end
m4_split([abcde], [bd])
m4_split([abcde], [[bd]])
m4_split([foo=`` bar=''])
m4_split([foo='' bar=``])
dnl these next two are from the manual; keep this in sync if the internal
dnl quoting strings in m4_split are changed
m4_define([a], [A])m4_define([b], [B])m4_define([c], [C])dnl
m4_split([a )}>=- b -=<{( c])
m4_split([a )}@&t@>=- b -=<@&t@{( c])
]],
[[

[[]]
[], []
[active]
[], [active], [active], []end
[], []
[active]
[], [active	active], []end
[abcde]
[a], [c], [e]
[foo=``], [bar='']
[foo=''], [bar=``]
[a], [], [B], [], [c]
[a], [)}>=@&t@-], [b], [-@&t@=<{(], [c]
]])

AT_CLEANUP


## ------- ##
## m4_do.  ##
## ------- ##

AT_SETUP([m4@&t@_do])

AT_CHECK_M4SUGAR_TEXT(
[[m4_define([ab], [1])m4_define([bc], [2])m4_define([abc], [3])dnl
m4_define([AB], [4])m4_define([BC], [5])m4_define([ABC], [6])dnl
m4_do
m4_do([a])
m4_do([a], [b])c
m4_unquote(m4_join([], [a], [b]))c
m4_define([a], [A])m4_define([b], [B])m4_define([c], [C])dnl
m4_do([a], [b])c
m4_unquote(m4_join([], [a], [b]))c
]],
[[
a
abc
3
ABC
3
]])

AT_CLEANUP


## ----------- ##
## m4_append.  ##
## ----------- ##

AT_SETUP([m4@&t@_append])
AT_KEYWORDS([m4@&t@_append_uniq m4@&t@_append_uniq_w])

AT_CHECK_M4SUGAR_TEXT(
[[m4_define([active], [ACTIVE])dnl
m4_append([sentence], [This is an])dnl
m4_append([sentence], [ active ])dnl
m4_append([sentence], [symbol.])dnl
sentence
m4_undefine([active])dnl
sentence
m4_define([active], [ACTIVE])dnl
m4_append([hooks], [m4_define([act1], [act2])])dnl
m4_append([hooks], [m4_define([act2], [active])])dnl
m4_undefine([active])dnl
act1
hooks
act1
dnl Test for bug fixed in 2.62 when separator is active.
m4_define([a], [A])dnl
m4_append_uniq([foo], [-], [a])dnl
m4_append_uniq([foo], [-], [a])dnl
m4_append_uniq([bar], [-], [a])dnl
m4_append_uniq([bar], [~], [a])dnl
m4_append_uniq([bar], [-], [a])dnl
m4_defn([foo])
m4_defn([bar])
foo
bar
m4_append_uniq([blah], [one], [, ], [new], [existing])
m4_append_uniq([blah], [two], [, ], [new], [existing])
m4_append_uniq([blah], [two], [, ], [new], [existing])
m4_append_uniq([blah], [three], [, ], [new], [existing])
m4_append([blah], [two], [, ])dnl
blah
m4_dquote(blah)
m4_append([list], [one], [[, ]])dnl
m4_append([list], [two], [[, ]])dnl
m4_append([list], [three], [[, ]])dnl
list
m4_dquote(list)
m4_append_uniq_w([numbers], [1 1 2])dnl
m4_append_uniq_w([numbers], [ 2 3 ])dnl
numbers
]],
[[This is an ACTIVE symbol.
This is an active symbol.
act1

active
-
-a~
-
-A~
new
new
existing
new
one, two, three, two
[one],[two],[three],[two]
one, two, three
[one, two, three]
1 2 3
]])

AT_DATA_M4SUGAR([script.4s],
[[m4_init[]dnl
m4_append_uniq([str], [a], [ ])
m4_append_uniq([str], [a b], [ ])
m4_divert([])dnl
str
]])

AT_CHECK_M4SUGAR([-o-], 0, [[a a b
]], [[script.4s:3: warning: m4@&t@_append_uniq: `a b' contains ` '
]])

AT_CLEANUP


## --------- ##
## m4_join.  ##
## --------- ##

AT_SETUP([m4@&t@_join])

AT_KEYWORDS([m4@&t@_joinall])

AT_CHECK_M4SUGAR_TEXT(
[[m4_define([active], [ACTIVE])
m4_join
m4_join([|])
m4_join([, ], [one], [two])
m4_dquote(m4_join([, ], [one], [two]))
m4_join([|], [active], [active])
m4_join([|], ,,,[one])
m4_join([|], [one],,,)
m4_join([], ,,,[two])
m4_join([], [two],,,)
m4_join([ active ], [one], , [two])
m4_join([], [one], [two])
m4_joinall([-], [one], [], [two])
m4_joinall([-], [], [], [three], [], [])
m4_joinall([], [one], [], [two])
m4_joinall
m4_joinall([-])
m4_joinall([-], [one])
]],
[[


one, two
[one, two]
active|active
one
one
two
two
one active two
onetwo
one--two
--three--
onetwo


one
]])

AT_CLEANUP


## ----------- ##
## m4_expand.  ##
## ----------- ##

AT_SETUP([m4@&t@_expand])

AT_CHECK_M4SUGAR_TEXT(
[[m4_define([active], [ACTIVE])dnl
m4_expand([#active
active])
m4_expand([[active]])
dnl properly quoted case statements
m4_expand([case a in @%:@(
  *) echo active, ;;
esac
case b in
  *[)] echo active, ;;
esac])
dnl unbalanced underquoted `)', but we manage anyway (gasp!)
m4_expand([case c in #(
  *) echo active, ;;
esac
case d in
  *) echo active, ;;
esac])
dnl unterminated comment/dnl
m4_expand([active # active])
m4_expand([a
dnl])
m4_expand([a
-dnl])
]],
[[#active
ACTIVE
active
case a in #(
  *) echo ACTIVE, ;;
esac
case b in
  *) echo ACTIVE, ;;
esac
case c in #(
  *) echo ACTIVE, ;;
esac
case d in
  *) echo ACTIVE, ;;
esac
ACTIVE # active
a
a
-
]])

AT_CLEANUP


## ------------- ##
## m4_text_box.  ##
## ------------- ##

AT_SETUP([m4@&t@_text_box])

AT_CHECK_M4SUGAR_TEXT([[
m4_text_box([a $1 @&t@b])
m4_text_box([a $1 @&t@b], [$])
m4_text_box([a $1 @&t@b], [,])
]], [[
## ------ ##
## a $1 b ##
## ------ ##
## $$$$$$ ##
## a $1 b ##
## $$$$$$ ##
## ,,,,,, ##
## a $1 b ##
## ,,,,,, ##
]])

AT_CLEANUP

## -------------- ##
## m4_text_wrap.  ##
## -------------- ##

AT_SETUP([m4@&t@_text_wrap])
AT_KEYWORDS([m4@&t@_escape])

# m4_text_wrap is used to display the help strings.  Also, check that
# commas and $ are not swallowed.  This can easily happen because of
# m4-listification.

AT_DATA_M4SUGAR([script.4s],
[[m4_init[]m4_divert([])dnl
m4_define([a], [OOPS])dnl
m4_escape([a[b $c#]d])
m4_if(m4_escape([a[b $c#]d]), [a[b $c#]d], [oops],
      m4_escape([a[b $c#]d]), [a@<:@b @S|@c@%:@@:>@d], [pass], [oops])

m4_text_wrap([Short string */], [   ], [/* ], 20)

m4_text_wrap([Much longer string */], [   ], [/* ], 20)

m4_text_wrap([Short doc.], [          ], [  --short ], 30)

m4_text_wrap([Short doc.], [          ], [  --too-wide], 30)

m4_text_wrap([Super long documentation.], [          ], [  --too-wide], 30)

m4_text_wrap([First, second  , third, [,quoted  space]])
m4_define([xfff], [oops])
m4_text_wrap([Some $1 $2 $3 $4 embedded dollars.], [ $* ], [ $@ ], [0xfff & 20])
]])

AT_DATA([expout],
[[a[b $c#]d
pass

/* Short string */

/* Much longer
   string */

  --short Short doc.

  --too-wide
          Short doc.

  --too-wide
          Super long
          documentation.

First, second , third, [,quoted space]

 $@ Some $1 $2 $3
 $* $4 embedded
 $* dollars.
]])

AT_CHECK_M4SUGAR([-o-], 0, [expout])

AT_CLEANUP

## -------------------- ##
## m4_version_compare.  ##
## -------------------- ##

AT_SETUP([m4@&t@_version_compare])

AT_KEYWORDS([m4@&t@_list_cmp])

AT_CHECK_M4SUGAR_TEXT(
[[m4_version_compare([1.1], [2.0])
m4_version_compare([2.0b], [2.0a])
m4_version_compare([2.0z], [2.0y])
m4_version_compare([1.1.1], [1.1.1a])
m4_version_compare([1.2], [1.1.1a])
m4_version_compare([1.0], [1])
m4_version_compare([1.0a], [1.0a])
m4_version_compare([1.1a], [1.1a.1])
m4_version_compare([1.10], [1.1a])
m4_version_compare([1-1a], [1,1A])
m4_define([a], [oops])dnl
m4_version_compare([1.1a], [1.1A])
m4_version_compare([1z], [1aa])
m4_version_compare([2.61a], [2.61a-248-dc51])
m4_version_compare([2.61b], [2.61a-248-dc51])
m4_version_compare([08], [09])
m4_version_compare([010], [8])
dnl Test that side effects to m4_list_cmp occur exactly once
m4_list_cmp([[0], [0], [0]m4_errprintn([hi])],
            [[0], [0], [0]m4_errprintn([hi])])
m4_list_cmp([[0], [0], [0]m4_errprintn([hi])],
            [[0], [0], [0]m4_errprintn([bye])])
]],
[[-1
1
1
-1
1
0
0
-1
1
0
0
-1
-1
1
-1
1
0
0
]], [[hi
hi
hi
bye
]])

AT_CLEANUP

## ------------------------------ ##
## Standard regular expressions.  ##
## ------------------------------ ##

AT_SETUP([Standard regular expressions])

# AT_CHECK_M4RE(RE-NAME, TEXT, INTENT = `ok' | `')
# ------------------------------------------------
# Check whether RE-NAME (a macro whose definition is a regular expression)
# matches TEXT.  INTENT = `ok' if the match should succeed or else empty.
m4_define([AT_CHECK_M4RE],
[AT_CHECK_M4SUGAR_TEXT(
[[m4_bregexp([$2], ^m4_defn([$1])$, [ok])
]], [$3
])])

AT_CHECK_M4RE([m4_re_word], [ab9_c], [ok])
AT_CHECK_M4RE([m4_re_word], [_9abc], [ok])
AT_CHECK_M4RE([m4_re_word], [9ab_c])

AT_CHECK_M4RE([m4_re_string], [ab9_c], [ok])
AT_CHECK_M4RE([m4_re_string], [_9abc], [ok])
AT_CHECK_M4RE([m4_re_string], [9ab_c], [ok])
AT_CHECK_M4RE([m4_re_string], [9a@_c])

AT_CLEANUP

## ----------- ##
## m4_bmatch.  ##
## ----------- ##

AT_SETUP([m4@&t@_bmatch])

AT_CHECK_M4SUGAR_TEXT(
[[m4_bmatch([abc], [default\])
m4_bmatch([abc], [^a], [yes])
m4_bmatch([abc], [^a], [yes], [no])
m4_bmatch([abc], [^.a], [yes])
m4_bmatch([abc], [^.a], [yes], [no\])
m4_bmatch([abc], [a], [1], [b], [2])
m4_bmatch([abc], [A], [1], [b], [2])
m4_define([ab], [AB])dnl
m4_bmatch([$*], [a])b
m4_bmatch([$*], [\*], [a])b
m4_bmatch([$*], [1], [2], [a])b
]], [[default\
yes
yes

no\
1
2
AB
AB
AB
]])

AT_CLEANUP

## ------------------------ ##
## m4_toupper, m4_tolower.  ##
## ------------------------ ##

AT_SETUP([m4@&t@_toupper and m4@&t@_tolower])

AT_CHECK_M4SUGAR_TEXT(
[[m4_define([abc], [hI])m4_define([ABC], [Hi])
m4_toupper(abc aBc ABC)
m4_tolower(abc aBc ABC)
m4_toupper([abc aBc ABC])
m4_tolower([abc aBc ABC])
m4_echo(m4_toupper(abc aBc ABC))
m4_echo(m4_tolower(abc aBc ABC))
m4_echo(m4_toupper([abc aBc ABC]))
m4_echo(m4_tolower([abc aBc ABC]))
m4_do(m4_toupper(abc aBc ABC))
m4_do(m4_tolower(abc aBc ABC))
m4_do(m4_toupper([abc aBc ABC]))
m4_do(m4_tolower([abc aBc ABC]))
]], [[
HI ABC HI
hi abc hi
ABC ABC ABC
abc abc abc
HI ABC HI
hi abc hi
ABC ABC ABC
abc abc abc
HI Hi HI
hi hI hi
Hi Hi Hi
hI hI hI
]])

AT_CLEANUP

## --------------- ##
## m4_bpatsubsts.  ##
## --------------- ##

AT_SETUP([m4@&t@_bpatsubsts])

AT_CHECK_M4SUGAR_TEXT(
[[m4_bpatsubsts([11], [^..$])
m4_bpatsubsts([11], [\(.\)1], [\12])
m4_bpatsubsts([11], [^..$], [], [1], [2])
m4_bpatsubsts([11], [\(.\)1], [\12], [1], [3])
m4_define([a], [oops])m4_define([c], [oops])dnl
m4_define([AB], [good])m4_define([bc], [good])dnl
m4_bpatsubsts([abc], [a], [A], [b], [B], [c])
m4_bpatsubsts([ab], [a])c
m4_bpatsubsts([ab], [c], [C], [a])c
m4_bpatsubsts([$1$*$@], [\$\*], [$#])
]], [[11
21
22
23
good
good
good
$1$#$@
]])

AT_CLEANUP

## -------------- ##
## m4_esyscmd_s.  ##
## -------------- ##

AT_SETUP([m4@&t@_esyscmd_s])
AT_KEYWORDS([m4@&t@_chomp m4@&t@_chomp_all])

AT_CHECK_M4SUGAR_TEXT(
[[m4_define([world], [WORLD])dnl
m4_chomp([abc])
m4_chomp([world

])
m4_esyscmd_s([echo hello world])
m4_esyscmd_s([echo '[goodbye,
cruel world

]'])
]], [[abc
world

hello WORLD
goodbye,
cruel world
]])

AT_CLEANUP

## ---------- ##
## M4 Loops.  ##
## ---------- ##

AT_SETUP([M4 loops])

AT_KEYWORDS([m4@&t@_for m4@&t@_foreach m4@&t@_foreach_w m4@&t@_map_args_w])

AT_CHECK_M4SUGAR_TEXT([[dnl
m4_define([myvar], [outer value])dnl
m4_for([myvar], 1, 3, 1, [ myvar])
m4_for([myvar], 1, 3,  , [ myvar])
m4_for([myvar], 3, 1,-1, [ myvar])
m4_for([myvar], 3, 1,  , [ myvar])
m4_for([myvar], 1, 3, 2, [ myvar])
m4_for([myvar], 3, 1,-2, [ myvar])
m4_for([myvar],-1,-3,-2, [ myvar])
m4_for([myvar],-3,-1, 2, [ myvar])
dnl Make sure we recalculate the bounds correctly:
m4_for([myvar], 1, 3, 3, [ myvar])
m4_for([myvar], 1, 6, 3, [ myvar])
m4_for([myvar],22,-7,-5, [ myvar])
m4_for([myvar],-2,-7,-4, [ myvar])
m4_for([myvar],-7,-2, 4, [ myvar])
dnl Make sure we are not exposed to division truncation:
m4_for([myvar], 2, 5, 2, [ myvar])
m4_for([myvar],-5,-2, 2, [ myvar])
m4_for([myvar], 5, 2,-2, [ myvar])
m4_for([myvar],-2,-5,-2, [ myvar])
dnl Make sure we do not divide by zero:
m4_for([myvar], 1, 1,  , [ myvar])
m4_for([myvar], 1, 1,+2, [ myvar])
m4_for([myvar], 1, 1,-2, [ myvar])
dnl Make sure we do not loop endlessly
m4_for([myval], 1, 1, 0, [ myval])
dnl Make sure to properly parenthesize
m4_for([myvar], 3-5, -2+8, , [ myvar])
m4_for([myvar], -2+8, 3-5, , [ myvar])
m4_for([myvar], 8, 16, 3 * 2, [ myvar])
m4_for([myvar], 8, 16, -3 * -2, [ myvar])
m4_for([myvar], [2<<2], [2<<3], [-3 * (-2)], [ myvar])
dnl Modifying var does not affect the number of iterations
m4_for([myvar], 1, 5, , [ myvar[]m4_define([myvar], 5)])
dnl Make sure we can do nameless iteration
m4_for(, 1, 10, , -)
dnl foreach tests
m4_foreach([myvar], [[a], [b, c], [d], [e
],[f]], [ myvar|])
m4_foreach_w([myvar], [a  b c, d,e f
g], [ myvar|])
myvar
m4_map_args_w([a  b c, d,e f
g], [ ], [|])
m4_map_args_w([a b], [\1], [/])
m4_define([dashes], [--])dnl
m4_map_args_w([a b c], [/], [\1], [dashes])
dnl only one side effect expansion, prior to visiting list elements
m4_foreach([i], [[1], [2], [3]m4_errprintn([hi])], [m4_errprintn(i)])dnl
dnl shifting forms an important part of loops
m4_shift3:m4_shift3(1,2,3):m4_shift3(1,2,3,4)
m4_shiftn(3,1,2,3):m4_shiftn(3,1,2,3,4)
]],
[[ 1 2 3
 1 2 3
 3 2 1
 3 2 1
 1 3
 3 1
 -1 -3
 -3 -1
 1
 1 4
 22 17 12 7 2 -3
 -2 -6
 -7 -3
 2 4
 -5 -3
 5 3
 -2 -4
 1
 1
 1
 1
 -2 -1 0 1 2 3 4 5 6
 6 5 4 3 2 1 0 -1 -2
 8 14
 8 14
 8 14
 1 2 3 4 5
----------
 a| b, c| d| e
| f|
 a| b| c,| d,e| f| g|
outer value
 a| b| c,| d,e| f| g|
\1a/\1b/
/a\1--/b\1--/c\1
::4
:4
]], [[hi
1
2
3
]])

dnl bounds checking in m4_for
AT_DATA_M4SUGAR([script.4s],
[[m4_init
m4_divert([0])dnl
m4_for([myvar], 1, 3,-1, [ myvar])
]])
AT_CHECK_M4SUGAR([], 1, [],
[[script.4s:3: error: assert failed: -1 > 0
script.4s:3: the top level
autom4te: m4 failed with exit status: 1
]])

AT_DATA_M4SUGAR([script.4s],
[[m4_init
m4_divert([0])dnl
m4_for([myvar], 1, 2, 0, [ myvar])
]])
AT_CHECK_M4SUGAR([], 1, [],
[[script.4s:3: error: assert failed: 0 > 0
script.4s:3: the top level
autom4te: m4 failed with exit status: 1
]])

AT_DATA_M4SUGAR([script.4s],
[[m4_init
m4_divert([0])dnl
m4_for([myvar], 2, 1, 0, [ myvar])
]])
AT_CHECK_M4SUGAR([], 1, [],
[[script.4s:3: error: assert failed: 0 < 0
script.4s:3: the top level
autom4te: m4 failed with exit status: 1
]])

dnl m4_shiftn also does bounds checking
AT_DATA_M4SUGAR([script.4s],
[[m4_init
m4_divert([0])dnl
m4_shiftn(3,1,2)
]])
AT_CHECK_M4SUGAR([], 1, [],
[[script.4s:3: error: assert failed: 0 < 3 && 3 < 3
script.4s:3: the top level
autom4te: m4 failed with exit status: 1
]])

AT_CLEANUP


## --------------------- ##
## m4_map{,all}{,_sep}.  ##
## --------------------- ##

AT_SETUP([m4@&t@_map])
AT_KEYWORDS([m4@&t@_apply m4@&t@_map_sep m4@&t@_mapall m4@&t@_mapall_sep])
AT_KEYWORDS([m4@&t@_count])

AT_CHECK_M4SUGAR_TEXT([[dnl
m4_map([m4_count], [])
m4_map([ m4_count], [[],
                     [[1]],
                     [[1], [2]]])
m4_mapall([ m4_count], [[],
                        [[1]],
                        [[1], [2]]])
m4_map_sep([m4_eval], [,], [[[1+2]],
                            [[10], [16]]])
m4_count(m4_map_sep([m4_echo], [,], [[], [[1]], [[2]]]))
m4_count(m4_mapall_sep([m4_echo], [,], [[], [[1]], [[2]]]))
m4_map_sep([m4_eval], [[,]], [[[1+2]],
                              [[10], [16]]])
m4_count(m4_map_sep([m4_echo], [[,]], [[], [[1]], [[2]]]))
m4_count(m4_mapall_sep([m4_echo], [[,]], [[], [[1]], [[2]]]))
m4_map([-], [[]])
m4_mapall([-], [[]])
m4_map_sep([-], [:], [[]])
m4_mapall_sep([-], [:], [[]])
m4_define([a], [m4_if([$#], [0], [oops], [$1], [a], [pass], [oops])])dnl
m4_define([a1], [oops])dnl
m4_define([pass1], [oops])dnl
m4_map([a], [[[a]]])1
m4_map([m4_unquote([a])], [m4_dquote([a])])
dnl only one side effect expansion, prior to visiting list elements
m4_map([m4_errprintn], [[[1]], [[2]], [[3]]m4_errprintn([hi])])dnl
m4_map_sep([m4_errprintn], [], [[[1]], [[2]], [[3]]m4_errprintn([hi])])dnl
m4_mapall([m4_errprintn], [[[1]], [[2]], [[3]]m4_errprintn([hi])])dnl
m4_mapall_sep([m4_errprintn], [], [[[1]], [[2]], [[3]]m4_errprintn([hi])])dnl
]],
[[
 1 2
 0 1 2
3,a
2
3
3,a
1
1

-

-
pass1
pass
]], [[hi
1
2
3
hi
1
2
3
hi
1
2
3
hi
1
2
3
]])

AT_CLEANUP


## --------------------------------------- ##
## m4_map_args{,_sep,_pair} and m4_curry.  ##
## --------------------------------------- ##

AT_SETUP([m4@&t@_map_args and m4@&t@_curry])
AT_KEYWORDS([m4@&t@_map_args_sep m4@&t@_map_args_pair m4@&t@_reverse
m4@&t@_map])

dnl First, make sure we can curry in isolation.
AT_CHECK_M4SUGAR_TEXT(
[[m4_curry([m4_echo])([1])
m4_curry([m4_curry], [m4_reverse], [1])([2])([3])
m4_define([add], [m4_eval(([$1]) + ([$2]))])dnl
m4_define([add_one], [m4_curry([add], [1])])dnl
add_one()([4])
]],
[[1
3, 2, 1
5
]])

dnl Now, check that we can map a list of arguments.
AT_CHECK_M4SUGAR_TEXT([[m4_define([active], [ACTIVE])dnl
m4_map_args([ m4_echo])
m4_map_args([ m4_echo], [plain], [active])
m4_map_args([m4_unquote], [plain], [active])
m4_map_args_pair([, m4_reverse], [])
m4_map_args_pair([, m4_reverse], [], [1])
m4_map_args_pair([, m4_reverse], [], [1], [2])
m4_map_args_pair([, m4_reverse], [], [1], [2], [3])
m4_map_args_pair([, m4_reverse], [], [1], [2], [3], [4])
m4_map_args_pair([, m4_reverse], [, m4_dquote], [1])
m4_map_args_pair([, m4_reverse], [, m4_dquote], [1], [2])
m4_map_args_pair([, m4_reverse], [, m4_dquote], [1], [2], [3])
m4_map_args_pair([, m4_reverse], [, m4_dquote], [1], [2], [3], [4])
m4_map_args_sep([<], [>], [:], [1], [2], [3])
m4_map_args_sep([m4_echo(], [)], [ ], [plain], [active])
]],
[[
 plain active
plainACTIVE

, 1
, 2, 1
, 2, 1, 3
, 2, 1, 4, 3
, [1]
, 2, 1
, 2, 1, [3]
, 2, 1, 4, 3
<1>:<2>:<3>
plain active
]])

dnl Finally, put the two concepts together, to show the real power of the API.
AT_CHECK_M4SUGAR_TEXT(
[[m4_define([add], [m4_eval(([$1]) + ([$2]))])dnl
m4_define([list], [[-1], [0], [1]])dnl
dnl list_add_n(value, arg...)
dnl add VALUE to each ARG and output the resulting list
m4_define([list_add_n],
  [m4_shift(m4_map_args([,m4_curry([add], [$1])], m4_shift($@)))])
list_add_n([1], list)
list_add_n([2], list)
]], [[
0,1,2
1,2,3
]])

AT_CLEANUP


## ------------ ##
## m4_combine.  ##
## ------------ ##

AT_SETUP([m4@&t@_combine])

AT_CHECK_M4SUGAR_TEXT([[m4_define([a], [oops])dnl
m4_combine([, ], [[a], [b], [c]], [-], [1], [2], [3])
m4_combine([, ], [[a], [b]], [-])
m4_combine([, ], [[a], [b]], [-], [])
m4_combine([, ], [], [-], [a], [b])
m4_combine([, ], [[]], [-], [a], [b])
m4_combine([ a ], [[-], [+]], [a], [-], [+])
m4_combine([$* ], [[$1], [$2]], [$#], [$@])
]],
[[a-1, a-2, a-3, b-1, b-2, b-3, c-1, c-2, c-3

a-, b-

-a, -b
-a- a -a+ a +a- a +a+
$1$#$@$* $2$#$@
]], [])

AT_CLEANUP


## -------------- ##
## m4_{max,min}.  ##
## -------------- ##

AT_SETUP([m4@&t@_max and m4@&t@_min])

AT_DATA_M4SUGAR([script.4s],
[[m4_max
]])

AT_CHECK_M4SUGAR([], 1, [],
[[script.4s:1: error: too few arguments to m4@&t@_max
script.4s:1: the top level
autom4te: m4 failed with exit status: 1
]])

AT_DATA_M4SUGAR([script.4s],
[[m4_min
]])

AT_CHECK_M4SUGAR([], 1, [],
[[script.4s:1: error: too few arguments to m4@&t@_min
script.4s:1: the top level
autom4te: m4 failed with exit status: 1
]])

AT_CHECK_M4SUGAR_TEXT([[dnl
m4_min(0)
m4_min(0xa)
m4_min(0, 0)
m4_min(0, 1)
m4_min(1, 0)
m4_min(0+1, 1+1)
m4_min(0+1, 1+0)
m4_min(0, 1, 2)
m4_min(2, 1, 0)
m4_min(1m4_for([i], 2, 100, , [,i]))
m4_min(m4_for([i], 100, 2, , [i,])1)
----
m4_max(0)
m4_max(0xa)
m4_max(0, 0)
m4_max(0, 1)
m4_max(1, 0)
m4_max(1+0, 1+1)
m4_max(1+0, 1+0)
m4_max(0, 1, 2)
m4_max(2, 1, 0)
m4_max(1m4_for([i], 2, 100, , [,i]))
m4_max(m4_for([i], 100, 2, , [i,])1)
]],
[[0
10
0
0
0
1
1
0
0
1
1
----
0
10
0
1
1
2
1
2
2
100
100
]], [])

AT_CLEANUP


## ----------- ##
## Recursion.  ##
## ----------- ##

AT_SETUP([recursion])

AT_KEYWORDS([m4@&t@_foreach m4@&t@_foreach_w m4@&t@_case m4@&t@_cond
m4@&t@_bpatsubsts m4@&t@_shiftn m4@&t@_do m4@&t@_dquote_elt m4@&t@_reverse
m4@&t@_map m4@&t@_join m4@&t@_joinall m4@&t@_list_cmp m4@&t@_max m4@&t@_min
m4@&t@_bmatch m4@&t@_map_args m4@&t@_map_args_pair])

dnl This test completes in a reasonable time if m4_foreach is linear,
dnl but thrashes if it is quadratic.  If we are testing with m4 1.4.x,
dnl only the slower foreach.m4 implementation will work.  But if we
dnl are testing with m4 1.6, we can rerun the test with __m4_version__
dnl undefined to exercise the alternate code path.
AT_DATA_M4SUGAR([script.4s],
[[m4_init
m4_divert_push([])[]dnl
m4_len(m4_foreach_w([j], m4_do(m4_for([i], [1], [10000], [], [,i ])), [j ]))
m4_shiftn(9998m4_for([i], [1], [10000], [], [,i]))
m4_len(m4_join([--],, m4_dquote_elt(m4_for([i], [1], [10000], [], [,i])),))
m4_len(m4_joinall([--], m4_map([, m4_echo],
  m4_dquote([1]m4_for([i], [2], [10000], [], [,i])))))
m4_max(m4_min([1]m4_for([i], [2], [10000], [],
  [,i]))m4_for([i], [2], [10000], [], [,i]))
m4_case([10000]m4_for([i], [1], [10000], [], [,i]),[end])
m4_list_cmp(m4_dquote(1m4_for([i], [2], [10000], [], [,i])),
  m4_dquote(m4_reverse(10000m4_for([i], [9999], [1], [], [,i])), [0]))
m4_list_cmp([0], [0m4_for([i], [1], [10000], [], [,0])])
m4_list_cmp([0m4_for([i], [1], [10000], [], [,0])], [0])
m4_for([i], [1], [10000], [], [m4_define(i)])dnl
m4_undefine(1m4_for([i], [2], [10000], [], [,i]))dnl
m4_bpatsubsts([a1]m4_for([i], [1], [10000], [], [,i]), [a2], [A])
m4_bmatch([9997]m4_for([i], [1], [10000], [], [,^i$]))
m4_define([up], [m4_define([$1], m4_incr($1))$1])m4_define([j], 0)dnl
m4_cond(m4_for([i], [1], [10000], [], [[up([j])], [9990], i,]) [oops]) j
m4_count(m4_map_args_pair([,m4_quote], []m4_map_args([,m4_echo]m4_for([i],
  [1], [10000], [], [,i]))))
m4_divert_pop([])
]])

AT_CHECK_M4SUGAR([-o-], [0], [[48894
9999,10000
78896
58894
10000
end
0
0
0
A
^9998$
9990 9990
5001
]])

AT_DATA_M4SUGAR([script.4s],
[[m4_ifdef([__m4_version__],
[m4_undefine([__m4_version__])],
[m4_divert_push([])48894
9999,10000
78896
58894
10000
end
0
0
0
A
^9998$
9990 9990
5001
m4_exit([0])])
m4_init
m4_divert_push([])[]dnl
m4_len(m4_foreach_w([j], m4_do(m4_for([i], [1], [10000], [], [,i ])), [j ]))
m4_shiftn(9998m4_for([i], [1], [10000], [], [,i]))
m4_len(m4_join([--],, m4_dquote_elt(m4_for([i], [1], [10000], [], [,i])),))
m4_len(m4_joinall([--], m4_map([, m4_echo],
  m4_dquote([1]m4_for([i], [2], [10000], [], [,i])))))
m4_max(m4_min([1]m4_for([i], [2], [10000], [],
  [,i]))m4_for([i], [2], [10000], [], [,i]))
m4_case([10000]m4_for([i], [1], [10000], [], [,i]),[end])
m4_list_cmp(m4_dquote(1m4_for([i], [2], [10000], [], [,i])),
  m4_dquote(m4_reverse(10000m4_for([i], [9999], [1], [], [,i])), [0]))
m4_list_cmp([0], [0m4_for([i], [1], [10000], [], [,0])])
m4_list_cmp([0m4_for([i], [1], [10000], [], [,0])], [0])
m4_for([i], [1], [10000], [], [m4_define(i)])dnl
m4_undefine(1m4_for([i], [2], [10000], [], [,i]))dnl
m4_bpatsubsts([a1]m4_for([i], [1], [10000], [], [,i]), [a2], [A])
m4_bmatch([9997]m4_for([i], [1], [10000], [], [,^i$]))
m4_define([up], [m4_define([$1], m4_incr($1))$1])m4_define([j], 0)dnl
m4_cond(m4_for([i], [1], [10000], [], [[up([j])], [9990], i,]) [oops]) j
m4_count(m4_map_args_pair([,m4_quote], []m4_map_args([,m4_echo]m4_for([i],
  [1], [10000], [], [,i]))))
m4_divert_pop([])
]])

AT_CHECK_M4SUGAR([-o-], [0], [[48894
9999,10000
78896
58894
10000
end
0
0
0
A
^9998$
9990 9990
5001
]])

AT_CLEANUP


## ---------- ##
## m4_set_*.  ##
## ---------- ##

AT_SETUP([m4@&t@_set])

AT_KEYWORDS([m4@&t@_set_add m4@&t@_set_add_all m4@&t@_set_contains
m4@&t@_set_contents m4@&t@_set_delete m4@&t@_set_difference m4@&t@_set_dump
m4@&t@_set_empty m4@&t@_set_foreach m4@&t@_set_intersection m4@&t@_set_list
m4@&t@_set_listc m4@&t@_set_map m4@&t@_set_remove m4@&t@_set_size
m4@&t@_set_union])

# Simple tests
AT_CHECK_M4SUGAR_TEXT([[m4_set_contains([a], [1], [yes], [no])
m4_set_add([a], [1], [added], [dup])
m4_set_contains([a], [1], [yes], [no])
m4_set_add([a], [1], [added], [dup])
m4_set_contents([a])
m4_set_remove([a], [1], [removed], [missing])
m4_set_contains([a], [1], [yes], [no])
m4_set_remove([a], [1], [removed], [missing])
m4_set_add([a], [2], [added], [dup])
m4_set_empty([a], [yes], [no])
m4_set_delete([a])
m4_set_empty([a], [yes], [no])
m4_set_add_all([c], [1], [2], [3])
m4_set_add_all([a]m4_set_listc([c]))
m4_set_contents([c], [-])
m4_set_dump([a], [-])
m4_set_contents([a])
m4_set_add_all([a], [1], [2], [3])m4_set_add_all([b], [3], [], [4])
m4_set_difference([a], [b])
m4_set_difference([b], [a])
m4_set_intersection([a], [b])
m4_set_union([a], [b])
m4_define([printodd], [m4_if(m4_eval([$1 & 1]), [1], [:$1])])dnl
m4_set_map([a], [printodd])
m4_set_foreach([a], [i], [m4_if(m4_eval(i & 1), [1], [m4_set_remove([a], i)])])
m4_set_list([a])
m4_set_add([a], [])
m4_set_list([a])
m4_set_remove([a], [2])
m4_dquote(m4_set_list([a]))
m4_set_listc([a])
m4_set_size([a])
m4_set_delete([a])
m4_dquote(m4_set_list([a]))
m4_indir([m4_dquote]m4_set_listc([a]))
m4_set_listc([a])
m4_set_size([a])
]], [[no
added
yes
dup
1
removed
no
missing
added
no

yes


1-2-3
3-2-1


,1,2
,,4
,3
,1,2,3,,4
:1:3

2

2,

[]
,
1

[]


0
]])

# Stress tests - check for unusual names/values
AT_CHECK_M4SUGAR_TEXT([[m4_define([a], [oops])dnl
m4_set_add([a], [a])dnl
m4_set_remove([a], [oops], [yes], [no])
m4_set_add([a,b], [c])dnl
m4_set_add([a,b], [$*[]])dnl
m4_set_add_all([a], [b,c])dnl
m4_set_size([a])
m4_count(m4_set_contents([a], [,]))
m4_count(m4_set_list([a], [,]))
m4_set_dump([a], [,])
m4_set_contents([a,b], [,])
m4_set_list([a,b])
m4_set_foreach([$*[]], [$*[]], [oops])
m4_set_add([$*[]], [])dnl
m4_set_remove([$*[]], [a], [yes], [no])
m4_set_add([$*[]], [a])dnl
m4_set_foreach([$*[]], [$*[]], [-m4_defn([$*[]])m4_indir([$*[]])-])
m4_set_remove([$*[]], [], [yes], [no])
m4_set_add([c], [,])dnl
m4_set_foreach([a,b], [set], [:m4_set_listc(_m4_defn([set])):])
]],[[no
2
1
2
b,c,a
c,$*[]
c,$*[]

no
---aoops-
yes
:,,::,a:
]])

# Stress tests - check for linear scaling (won't necessarily fail if
# quadratic, but hopefully users will complain if it appears to hang)
AT_CHECK_M4SUGAR_TEXT([[dnl
m4_for([i], [1], [10000], [], [m4_set_add([a], i)])dnl
m4_set_add_all([b]m4_for([i], [1], [10000], [], [,i]))dnl
m4_set_remove([a], [1])dnl
m4_set_remove([b], [10000])dnl
m4_set_add_all([a]m4_for([i], [1], [10000], [], [,i]))dnl
m4_for([i], [1], [10000], [], [m4_set_add([b], i)])dnl
m4_len(m4_set_contents([a]))
m4_len(m4_set_foreach([b], [b], [m4_if(m4_eval(b & 1), [1],
  [m4_set_remove([b], b, [-])])]))
m4_set_size([b])
m4_define([prune3x], [m4_if(m4_eval([$1 % 3]), [0],
  [m4_set_remove([a], [$1], [-])])])dnl
m4_len(m4_set_map([a], [prune3x]))
m4_count(m4_shift(m4_set_intersection([a], [b])))
]], [[38894
5000
5000
3333
3334
]])

AT_CLEANUP


## ---------------------- ##
## __file__ and __line__. ##
## ---------------------- ##

AT_SETUP([[__file__ and __line__]])

# Check that __file__ and __line__ work.
# Check that m4__file__ and m4__line__ are not defined
# (and get them to pass by the undefined-macro check).
# Try to not assume too much about AT_CHECK_M4SUGAR_TEXT.
AT_CHECK_M4SUGAR_TEXT([[dnl
m4_pattern_allow([m4__file__])dnl
m4_pattern_allow([m4__line__])dnl
m4__file__
m4__line__
__file__
m4_define([first], __line__)dnl
m4_define([second], __line__)dnl
m4_assert(first + 1 == second)dnl
]], [[m4@&t@__@&t@file__
m4@&t@__@&t@line__
script.4s
]])

AT_CLEANUP