tools/build/make_check/Makefile

   1 # $FreeBSD$
   2
   3 .MAKE.MODE=     normal
   4
   5 # Failure is handled by the invoker, don't kill other legs of a parallel build.
   6 MAKE_JOB_ERROR_TOKEN=no
   7
   8 # Test for broken LHS expansion.
   9 # This *must* cause make(1) to detect a recursive variable, and fail as such.
  10 .if make(lhs_expn)
  11 FOO=            ${BAR}
  12 BAR${NIL}=      ${FOO}
  13 FOO${BAR}=      ${FOO}
  14 .endif
  15
  16 DATA1=  helllo
  17 DATA2:= ${DATA1}
  18 DATA3=  ${DATA2:S/ll/rr/g}
  19 DATA4:= ${DATA2:S/ll/rr/g}
  20 DATA2?= allo
  21 DATA5:= ${DATA2:S/ll/ii/g} ${DATA1:S/ll/rr/g}
  22 DATA2=  yello
  23 DATA1:= ${DATA5:S/l/r/g}
  24 NIL=
  25
  26 SMAKE=  MAKEFLAGS= ${MAKE} -C ${.CURDIR}
  27
  28 all:
  29         @echo '1..16'
  30         @${SMAKE} C_check || { ${MAKE} -C ${.CURDIR} failure ; }
  31         @echo "ok 1 - C_check # Test of -C flag existence detected no regression."
  32         @echo 1:${DATA1} 2:${DATA2} 3:${DATA3} 4:${DATA4} 5:${DATA5} | \
  33                 diff -u ${.CURDIR}/regress.variables.out - || \
  34                 ${SMAKE} failure
  35         @echo "ok 2 - test_variables # Test variables detected no regression, output matches."
  36         @${SMAKE} double 2>/dev/null || ${SMAKE} failure
  37         @echo "ok 3 - test_targets # Test targets detected no regression."
  38         @${SMAKE} sysvmatch || ${SMAKE} failure
  39         @echo "ok 4 - sysvmatch # Test sysvmatch detected no regression."
  40         @! ${SMAKE} lhs_expn && true || ${SMAKE} failure
  41         @echo "ok 5 lhs_expn # Test lhs_expn detected no regression."
  42         @${SMAKE} notdef || ${SMAKE} failure
  43         @echo "ok 6 - notdef # Test notdef detected no regression."
  44         @${SMAKE} modifiers || ${SMAKE} failure
  45         @echo "ok 7 - modifiers # Test modifiers detected no regression."
  46         @${SMAKE} arith_expr || ${SMAKE} failure
  47         @echo "ok 8 arith_expr # Test arith_expr detected no regression."
  48         @${SMAKE} PATH_exists || ${SMAKE} failure
  49         @echo "ok 9 PATH_exists # Test PATH_exists detected no regression."
  50         @${SMAKE} double_quotes || ${SMAKE} failure
  51         @echo "ok 10 double_quotes # Test double_quotes detected no regression."
  52         @! ${SMAKE} double_quotes2 >/dev/null 2>&1 && true || ${SMAKE} failure
  53         @echo "ok 11 double_quotes2 # Test double_quotes2 detected no regression."
  54         @${SMAKE} pass_cmd_vars || ${SMAKE} failure
  55         @echo "ok 12 pass_cmd_vars # Test pass_cmd_vars detected no regression."
  56         @${SMAKE} plus_flag || ${SMAKE} failure
  57         @echo "ok 13 plus_flag # Test plus_flag detected no regression."
  58         @! ${SMAKE} shell >/dev/null 2>&1 && true || ${SMAKE} failure
  59         @echo "ok 14 shell # Test shell detected no regression."
  60         @${SMAKE} shell_1 || ${SMAKE} failure
  61         @echo "ok 15 shell_1 # Test shell_1 detected no regression."
  62 .if !defined(.PARSEDIR)
  63         @${SMAKE} shell_2 || ${SMAKE} failure
  64         @echo "ok 16 shell_2 # Test shell_2 detected no regression."
  65 .endif
  66
  67 .if make(C_check)
  68 C_check:
  69 .endif
  70
  71 .if make(double)
  72 # Doubly-defined targets.  make(1) will warn, but use the "right" one.  If it
  73 # switches to using the "non-right" one, it breaks things worse than a little
  74 # regression test.
  75 double:
  76         @true
  77
  78 double:
  79         @false
  80 .endif
  81
  82 .if make(sysvmatch)
  83 # Some versions of FreeBSD make(1) do not handle a nil LHS in sysvsubst.
  84 sysvmatch:
  85         @echo EMPTY ${NIL:=foo} LHS | \
  86                 diff -u ${.CURDIR}/regress.sysvmatch.out - || false
  87 .endif
  88
  89 # A bogus target for the lhs_expn test;  If this is reached, then the make(1)
  90 # program has not errored out because of the recursion caused by not expanding
  91 # the left-hand-side's embedded variables above.
  92 lhs_expn:
  93         @true
  94
  95 .if make(notdef)
  96 # make(1) claims to only evaluate a conditional as far as is necessary
  97 # to determine its value; that was not always the case.
  98 .undef notdef
  99 notdef:
 100 .if defined(notdef) && ${notdef:M/}
 101 .endif
 102 .endif
 103
 104 .if make(modifiers)
 105 .if defined(.PARSEDIR)
 106 # check if bmake can expand plain variables
 107 .MAKE.EXPAND_VARIABLES= yes
 108 x!= ${SMAKE} -V .CURDIR:H
 109 modifiers:
 110 .if ${.CURDIR:H} != "$x"
 111         @false
 112 .endif
 113 .else
 114 # See if make(1) supports the C modifier.
 115 modifiers: dollarV
 116         @if ${SMAKE} -V .CURDIR:C/.// 2>&1 >/dev/null | \
 117             grep -q "Unknown modifier 'C'"; then \
 118                 false; \
 119         fi
 120
 121 # check that make -V '${VAR}' works
 122 V_expn != V_OK=ok ${SMAKE} -r -f /dev/null -V '$${V_OK}'
 123 dollarV:
 124 .if ${V_expn} == ""
 125         @false
 126 .endif
 127 .endif
 128 .endif
 129
 130 .if make(arith_expr)
 131 arith_expr:
 132 # See if arithmetic expression parsing is broken.
 133 # The different spacing below is intentional.
 134 VALUE=  0
 135 .if (${VALUE} < 0)||(${VALUE}>0)
 136 .endif
 137 .endif
 138
 139 .if make(PATH_exists)
 140 PATH_exists:
 141 .PATH: ${.CURDIR}
 142 .if !exists(${.CURDIR}/) || !exists(${.CURDIR}/.) || !exists(${.CURDIR}/..)
 143 .error exists() failed
 144 .endif
 145 .endif
 146
 147 .if make(double_quotes)
 148 VALUE=  foo ""
 149 double_quotes:
 150 .if ${VALUE:S/$//} != ${VALUE}
 151 .error "" reduced to "
 152 .endif
 153 .endif
 154
 155 .if make(double_quotes2)
 156 double_quotes2:
 157         @cat /dev/null ""
 158 .endif
 159
 160 #
 161 # Check passing of variable via MAKEFLAGS
 162 #
 163 .if make(pass_cmd_vars)
 164 pass_cmd_vars:
 165         @${SMAKE} CMD1=cmd1 CMD2=cmd2 pass_cmd_vars_1
 166         @${SMAKE} CMD1=cmd1 CMD2=cmd2 pass_cmd_vars_2
 167         @${SMAKE} CMD1=cmd1 CMD2=cmd2 pass_cmd_vars_3
 168         @${SMAKE} CMD1=cmd1 CMD2=cmd2 pass_cmd_vars_4
 169 .endif
 170
 171 #
 172 # Check that the variable definition arrived from the calling make
 173 #
 174 .if make(pass_cmd_vars_1)
 175 # These values should get overridden by the commandline
 176 CMD1=oops1
 177 CMD2=oops2
 178 pass_cmd_vars_1:
 179         @:
 180
 181 .if ${CMD1} != cmd1 || ${CMD2} != cmd2
 182 .error variables not passed through MAKEFLAGS
 183 .endif
 184 .endif
 185
 186 .if make(pass_cmd_vars_2)
 187 # Check that we cannot override the passed variables
 188 CMD1=foo1
 189 CMD2=foo2
 190
 191 .if ${CMD1} != cmd1 || ${CMD2} != cmd2
 192 .error MAKEFLAGS-passed variables overridden
 193 .endif
 194
 195 pass_cmd_vars_2:
 196         @:
 197 .endif
 198
 199 .if make(pass_cmd_vars_3)
 200 # Check that we can override the passed variables on the next sub-make's
 201 # command line
 202
 203 pass_cmd_vars_3:
 204         @${SMAKE} CMD1=foo1 pass_cmd_vars_3_1
 205 .endif
 206
 207 .if make(pass_cmd_vars_3_1)
 208 .if ${CMD1} != foo1 || ${CMD2} != cmd2
 209 .error MAKEFLAGS-passed variables not overridden on command line
 210 .endif
 211 pass_cmd_vars_3_1:
 212         @:
 213 .endif
 214
 215 .if make(pass_cmd_vars_4)
 216 # Ensure that a variable assignment passed via MAKEFLAGS may be overwritten
 217 # by evaluating the .MAKEFLAGS target.
 218
 219 .MAKEFLAGS: CMD1=baz1
 220
 221 pass_cmd_vars_4:
 222         @${SMAKE} pass_cmd_vars_4_1
 223
 224 .if ${CMD1} != baz1 || ${CMD2} != cmd2
 225 .error MAKEFLAGS-passed variables not overridden via .MAKEFLAGS target
 226 .endif
 227
 228 .endif
 229 .if make(pass_cmd_vars_4_1)
 230 .if ${CMD1} != baz1 || ${CMD2} != cmd2
 231 .error MAKEFLAGS-passed variables not overridden via .MAKEFLAGS target (2)
 232 .endif
 233 pass_cmd_vars_4_1:
 234         @:
 235 .endif
 236
 237 #
 238 # Test whether make supports the '+' flag (meaning: execute even with -n)
 239 #
 240 .if make(plus_flag)
 241 OUT != ${SMAKE} -n plus_flag_1
 242 .if ${OUT:M/tmp} != "/tmp"
 243 .error make doesn't handle + flag
 244 .endif
 245 plus_flag:
 246         @:
 247 .endif
 248 .if make(plus_flag_1)
 249 plus_flag_1:
 250         +@cd /tmp; pwd
 251 .endif
 252
 253 .if make(shell)
 254 # Test if make fully supports the .SHELL specification.
 255 .SHELL: path=/nonexistent
 256 A!= echo ok
 257 shell:
 258 .endif
 259
 260 .if make(shell_1)
 261 # Test if setting the shell by name only works. Because we have no ksh
 262 # in the base system we test that we can set sh and csh. We try only exact
 263 # matching names and do not exercise the rather strange matching algorithm.
 264 shell_1:
 265         @${SMAKE} shell_1_csh
 266         @${SMAKE} shell_1_sh
 267 .endif
 268 .if make(shell_1_csh)
 269 .SHELL: name="csh"
 270 shell_1_csh:
 271         @ps -ax -opid,command | awk '$$1=="'$$$$'" { print $$2 }' | grep -E -q '^(/bin/)?csh$$'
 272 .endif
 273 .if make(shell_1_sh)
 274 .SHELL: name="sh"
 275 shell_1_sh:
 276         @ps -ax -opid,command | awk '$$1=="'$$$$'" { print $$2 }' | grep -E -q '^(/bin/)?sh$$'
 277 .endif
 278
 279 .if make(shell_2)
 280 # Test if we can replace the shell specification. We do this by using
 281 # a shell scripts that prints us its arguments and standard input as the shell
 282 shell_2: shell_test
 283         @${SMAKE} -B shell_2B | \
 284                 diff -u ${.CURDIR}/regress.shell_2B.out - || false
 285         @${SMAKE} -j1 shell_2j | \
 286                 diff -u ${.CURDIR}/regress.shell_2j.out - || false
 287 .endif
 288
 289 .if make(shell_2B)
 290 .SHELL: name="echo" path="${.OBJDIR}/shell_test" quiet="be quiet" echo="be verbose" filter="be verbose" echoFlag="x" errFlag="y" hasErrCtl=y check="check errors" ignore="ignore errors"
 291
 292 shell_2B:
 293         -@funny $$
 294         funnier $$
 295 .endif
 296
 297 .if make(shell_2j)
 298 .SHELL: name="echo" path="${.OBJDIR}/shell_test" quiet="be quiet" echo="be verbose" filter="be verbose" echoFlag="x" errFlag="y" hasErrCtl=y check="check errors" ignore="ignore errors"
 299
 300 shell_2j:
 301         -@funny $$
 302         funnier $$
 303 .endif
 304
 305 failure:
 306         @echo "not ok # Test failed: regression detected.  See above."
 307         @false
 308
 309 CLEANFILES= shell_test
 310
 311 .include <bsd.obj.mk>