tools/build/make_check/Makefile

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