ceph/src/boost/tools/build/test/core-language/test.jam

   1 # Copyright 2011 Steven Watanabe.
   2 # Distributed under the Boost Software License, Version 1.0.
   3 # (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
   4
   5 # Tools
   6
   7 passed = 0 ;
   8 failed = 0 ;
   9
  10 rule show-result ( id : test-result )
  11 {
  12     if ! ( --quiet in $(ARGV) )
  13     {
  14         ECHO $(test-result): $(id) ;
  15     }
  16     $(test-result) = [ CALC $($(test-result)) + 1 ] ;
  17 }
  18
  19 rule check-equal ( id : values * : expected * )
  20 {
  21     local test-result ;
  22     if x$(values) = x$(expected)
  23     {
  24         test-result = passed ;
  25     }
  26     else
  27     {
  28         ECHO error: "[" $(values) "] != [" $(expected) "]" ;
  29         test-result = failed ;
  30     }
  31     show-result $(id) : $(test-result) ;
  32 }
  33
  34 rule mark-order ( id : result * )
  35 {
  36     order += $(id) ;
  37     return $(result) ;
  38 }
  39
  40 rule check-order ( id : expected * )
  41 {
  42     check-equal $(id) : $(order) : $(expected) ;
  43     order = ;
  44 }
  45
  46 # Check variable expansion
  47
  48 {
  49
  50 local v1 = 1 2 3 ;
  51 local v2 = 4 5 6 ;
  52 local v3 = 0 1 2 3 4 5 6 7 8 9 10 ;
  53 local g = g1 g2 ;
  54 local v4 = String/With/Mixed/Case ;
  55 local v5 = path\\with\\backslashes ;
  56 local v6 = <grist>generic/path.txt(member.txt) ;
  57 local v7 = <Grist1>Dir1/File1.cpp(M1.c) <Grist2>Dir2/File2.hpp(M2.c) ;
  58 local v8 = <Grist3>Dir3/File3.c(M3.c) <Grist4>Dir4/File4.h(M4.c) ;
  59 local select1 = GU BL DBST ;
  60 local case1 = L U ;
  61 local vars = 7 8 ;
  62 local sub = 2 1 ;
  63 local p0 = name ;
  64 local p1 = dir/name ;
  65 local p2 = dir/sub/name ;
  66 local j1 = , - ;
  67
  68 check-equal var-product : $(v1)$(v2) : 14 15 16 24 25 26 34 35 36 ;
  69
  70 check-equal var-set-grist : $(v1:G=grist) : <grist>1 <grist>2 <grist>3 ;
  71 check-equal var-set-grist-multi : $(v1:G=$(g)) : <g1>1 <g1>2 <g1>3 <g2>1 <g2>2 <g2>3 ;
  72
  73 check-equal var-lower : $(v4:L) : string/with/mixed/case ;
  74 check-equal var-upper : $(v4:U) : STRING/WITH/MIXED/CASE ;
  75 check-equal var-LU : $(v4:LU) : STRING/WITH/MIXED/CASE ;
  76 check-equal var-slashes : $(v5:T) : path/with/backslashes ;
  77 check-equal var-grist : $(v6:G) : <grist> ;
  78 check-equal var-grist-none : $(v1:G) : "" "" "" ;
  79 check-equal var-base : $(v6:B) : path ;
  80 check-equal var-suffix : $(v6:S) : .txt ;
  81 check-equal var-dir : $(v6:D) : generic ;
  82 check-equal var-member : $(v6:M) : (member.txt) ;
  83 check-equal var-multi : $(v6:$(select1)) : <GRIST> path generic/path.txt ;
  84
  85 check-equal var-join-0 : $(:J=,) : ;
  86 check-equal var-join-1 : $(p0:J=,) : name ;
  87 check-equal var-join-3 : $(v1:J=,) : 1,2,3 ;
  88 check-equal var-set-grist-join : $(v1:G=grist:J=,) : <grist>1,<grist>2,<grist>3 ;
  89 # behavior change.  In the past, a J= modifier would
  90 # cause only the last element of the other modifiers
  91 # to take effect.
  92 check-equal var-set-grist-multi-join : $(v1:G=$(g):J=,) : <g1>1,<g1>2,<g1>3 <g2>1,<g2>2,<g2>3 ;
  93 check-equal var-set-grist-multi-join-multi : $(v1:G=$(g):J=$(j1)) : <g1>1,<g1>2,<g1>3 <g1>1-<g1>2-<g1>3 <g2>1,<g2>2,<g2>3 <g2>1-<g2>2-<g2>3 ;
  94
  95 check-equal var-D=-0 : name : $(p0:D=) ;
  96 check-equal var-D=-1 : name : $(p1:D=) ;
  97 check-equal var-D=-2 : name : $(p2:D=) ;
  98 check-equal var-D-0 : "" : $(p0:D) ;
  99 check-equal var-D-1 : dir : $(p1:D) ;
 100 check-equal var-D-2 : dir/sub : $(p2:D) ;
 101 check-equal var-S-1 : "" : $(p0:S) ;
 102 check-equal var-no-at-file-0 : ($(p0)) : [ MATCH ^@(.*) : "@($(p0))" ] ;
 103 check-equal var-no-at-file-1 : ($(p0)) : [ MATCH @(.*) : "--@($(p0))" ] ;
 104
 105 if $(OS) = CYGWIN
 106 {
 107     local cyg-root = $(:WE=/) ;
 108     local cyg1 = /cygdrive/c/path1.txt ;
 109     check-equal cygwin-to-cygdrive : $(cyg1:W) : C:\\path1.txt ;
 110     local cyg2 = /bin/bash ;
 111     check-equal cygwin-to-windows : $(cyg2:W) : $(cyg-root)\\bin\\bash ;
 112     check-equal cygwin-combine-WT : $(cyg2:WT) : $(cyg-root)\\bin\\bash ;
 113
 114     local cyg3 = /home/boost/devel/trunk/bin.v2/ ; # exactly 31 characters
 115     local win3 = $(cyg-root)\\home\\boost\\devel\\trunk\\bin.v2\\ ;
 116     # This is is the easiest way to demonstrate a bug
 117     # that used to cause undefined behavior.  Longer paths
 118     # resulted in a use-after-free error, which happened
 119     # to work most of the time.
 120     check-equal cygwin-long-WU : $(cyg3:WU) : $(win3:U) ;
 121
 122     local cyg-grist = <grist>$(cyg1) ;
 123     check-equal cygwin-grist : $(cyg-grist:W) : <grist>\\cygdrive\\c\\path1.txt ;
 124
 125     check-equal cygwin-WU : $(cyg2:WU) : $(cyg-root:U)\\BIN\\BASH ;
 126     # behavior change: L now consistently applied after W.
 127     # used to affect all except the drive letter.
 128     check-equal cygwin-WL : $(cyg2:WL) : $(cyg-root:L)\\bin\\bash ;
 129 }
 130
 131 # behavior change
 132 check-equal var-test1 : $(v7[2]:G:L) : <grist2> ;
 133
 134 check-equal var-multi-product-smm : $(v$(vars)[$(sub)]:G=$(g):$(case1)) :
 135     <g1>dir2/file2.hpp(m2.c) <G1>DIR2/FILE2.HPP(M2.C)
 136     <g2>dir2/file2.hpp(m2.c) <G2>DIR2/FILE2.HPP(M2.C)
 137     <g1>dir1/file1.cpp(m1.c) <G1>DIR1/FILE1.CPP(M1.C)
 138     <g2>dir1/file1.cpp(m1.c) <G2>DIR1/FILE1.CPP(M1.C)
 139     <g1>dir4/file4.h(m4.c) <G1>DIR4/FILE4.H(M4.C)
 140     <g2>dir4/file4.h(m4.c) <G2>DIR4/FILE4.H(M4.C)
 141     <g1>dir3/file3.c(m3.c) <G1>DIR3/FILE3.C(M3.C)
 142     <g2>dir3/file3.c(m3.c) <G2>DIR3/FILE3.C(M3.C)
 143 ;
 144 check-equal var-nopathmods : $(:E=//) : // ;
 145
 146 # showcases all the idiosyncracies of indexing
 147 # key: h = high, l = low, p = positive, m = minus, e = end.
 148
 149 check-equal var-subscript-one-p : $(v3[3]) : 2 ;
 150 check-equal var-subscript-one-m : $(v3[-3]) : 8 ;
 151 check-equal var-subscript-one-0 : $(v3[0]) : 0 ;
 152 check-equal var-subscript-one-h : $(v3[20]) : ;
 153 check-equal var-subscript-one-l : $(v3[-20]) : 0 ;
 154 check-equal var-subscript-range-pp : $(v3[2-4]) : 1 2 3 ;
 155 check-equal var-subscript-range-pm : $(v3[2--3]) : 1 2 3 4 5 6 7 8 ;
 156 check-equal var-subscript-range-pe : $(v3[2-]) : 1 2 3 4 5 6 7 8 9 10 ;
 157 check-equal var-subscript-range-ph : $(v3[2-20]) : 1 2 3 4 5 6 7 8 9 10 ;
 158 check-equal var-subscript-range-pl : $(v3[2--20]) : ;
 159 check-equal var-subscript-range-mp : $(v3[-3-10]) : 8 9 ;
 160 check-equal var-subscript-range-mm : $(v3[-4--2]) : 7 8 9 ;
 161 check-equal var-subscript-range-me : $(v3[-4-]) : 7 8 9 10 ;
 162 check-equal var-subscript-range-mh : $(v3[-4-20]) : 7 8 9 10 ;
 163 check-equal var-subscript-range-mh : $(v3[-4--20]) : ;
 164 check-equal var-subscript-range-0p : $(v3[0-2]) : 0 1 2 ;
 165 check-equal var-subscript-range-0m : $(v3[0--4]) : 0 1 2 3 4 5 6 7 8 ;
 166 check-equal var-subscript-range-0e : $(v3[0-]) : 0 1 2 3 4 5 6 7 8 9 10 ;
 167 check-equal var-subscript-range-0h : $(v3[0-20]) : 0 1 2 3 4 5 6 7 8 9 10 ;
 168 check-equal var-subscript-range-0l : $(v3[0--20]) : ;
 169 check-equal var-subscript-range-hp : $(v3[20-4]) : ;
 170 check-equal var-subscript-range-hm : $(v3[20--4]) : ;
 171 check-equal var-subscript-range-he : $(v3[20-]) : ;
 172 check-equal var-subscript-range-hh : $(v3[20-20]) : ;
 173 check-equal var-subscript-range-hl : $(v3[20--20]) : ;
 174 check-equal var-subscript-range-lp : $(v3[-13-4]) : 0 1 2 3 4 5 ;
 175 check-equal var-subscript-range-lm : $(v3[-13--4]) : 0 1 2 3 4 5 6 7 8 9 ;
 176 check-equal var-subscript-range-le : $(v3[-13-]) : 0 1 2 3 4 5 6 7 8 9 10 ;
 177 check-equal var-subscript-range-lh : $(v3[-13-20]) : 0 1 2 3 4 5 6 7 8 9 10 ;
 178 check-equal var-subscript-range-ll : $(v3[-13--13]) : 0 ;
 179 check-equal var-subscript-range-empty : $(v3[4-3]) : ;
 180
 181 }
 182
 183 # Check rules
 184
 185 {
 186
 187 rule test-rule
 188 {
 189     return $(<) - $(>) - $(1) - $(2) - $(3) - $(4) - $(5) - $(6) - $(7) - $(8) - $(9) - $(10) - $(11) - $(12) - $(13) - $(14) - $(15) - $(16) - $(17) - $(18) - $(19) ;
 190 }
 191
 192 check-equal rule-arguments-numbered :
 193     [ test-rule a1 : a2 : a3 : a4 : a5 : a6 : a7 : a8 : a9 : a10 : a11 : a12 : a13 : a14 : a15 : a16 : a17 : a18 : a19 ] :
 194     a1 - a2 - a1 - a2 - a3 - a4 - a5 - a6 - a7 - a8 - a9 - a10 - a11 - a12 - a13 - a14 - a15 - a16 - a17 - a18 - a19 ;
 195
 196 rule test-rule
 197 {
 198     return $(<:L) - $(>:L) - $(1:L) - $(2:L) - $(3:L) - $(4:L) - $(5:L) - $(6:L) - $(7:L) - $(8:L) - $(9:L) - $(10:L) - $(11:L) - $(12:L) - $(13:L) - $(14:L) - $(15:L) - $(16:L) - $(17:L) - $(18:L) - $(19:L) ;
 199 }
 200
 201 # behavior change
 202 check-equal rule-arguments-numbered-lower :
 203     [ test-rule a1 : a2 : a3 : a4 : a5 : a6 : a7 : a8 : a9 : a10 : a11 : a12 : a13 : a14 : a15 : a16 : a17 : a18 : a19 ] :
 204     a1 - a2 - a1 - a2 - a3 - a4 - a5 - a6 - a7 - a8 - a9 - a10 - a11 - a12 - a13 - a14 - a15 - a16 - a17 - a18 - a19 ;
 205
 206
 207 rule test-rule ( p1 : p2 : p3 : p4 : p5 : p6 : p7 : p8 : p9 :
 208                          p10 : p11 : p12 : p13 : p14 : p15 : p16 : p17 : p18 : p19 )
 209
 210
 211 {
 212     return $(p1) - $(p2) - $(p3) - $(p4) - $(p5) - $(p6) - $(p7) - $(p8) - $(p9) - $(p10) - $(p11) - $(p12) - $(p13) - $(p14) - $(p15) - $(p16) - $(p17) - $(p18) - $(p19) ;
 213 }
 214
 215 check-equal rule-arguments-named :
 216     [ test-rule a1 : a2 : a3 : a4 : a5 : a6 : a7 : a8 : a9 : a10 : a11 : a12 : a13 : a14 : a15 : a16 : a17 : a18 : a19 ] :
 217     a1 - a2 - a3 - a4 - a5 - a6 - a7 - a8 - a9 - a10 - a11 - a12 - a13 - a14 - a15 - a16 - a17 - a18 - a19 ;
 218
 219 #
 220 # test rule indirection
 221 #
 222 rule select ( n list * )
 223 {
 224     return $(list[$(n)]) ;
 225 }
 226
 227 rule indirect1 ( rule + : args * )
 228 {
 229     return [ $(rule) $(args) ] ;
 230 }
 231
 232 check-equal rule-indirect-1 : [ indirect1 select 1 : a b c d e ] : a ;
 233 check-equal rule-indirect-2 : [ indirect1 select 2 : a b c d e ] : b ;
 234
 235 x = reset ;
 236 rule reset-x ( new-value )
 237 {
 238     x = $(new-value) ;
 239 }
 240 $(x)-x bar ;                          # invokes reset-x...
 241 check-equal rule-reset : $(x) : bar ; # which changes x
 242
 243 rule bar-x ( new-value )
 244 {
 245     mark-order r3 ;
 246 }
 247
 248 # The arguments are evaluated in forward order
 249 # before the rule name
 250 $(x)-x [ mark-order r1 : [ reset-x reset ] ] : [ mark-order r2 ] ;
 251 check-order rule-order : r1 r2 ;
 252
 253 # Cases that look like member calls
 254 rule looks.like-a-member ( args * )
 255 {
 256     return $(args) ;
 257 }
 258
 259 rule call-non-member ( rule + )
 260 {
 261     return [ $(rule).like-a-member ] ;
 262 }
 263
 264 rule call-non-member-with-args ( rule + )
 265 {
 266     return [ $(rule).like-a-member a2 ] ;
 267 }
 268
 269 check-equal rule-non-member : [ call-non-member looks ] : ;
 270 #check-equal rule-non-member-a1 : [ call-non-member looks a1 ] : looks.a1 ;
 271 check-equal rule-non-member-args : [ call-non-member-with-args looks ] : a2 ;
 272 #check-equal rule-non-member-args-a1 : [ call-non-member-with-args looks a1 ] : looks.a1 a2 ;
 273
 274 }
 275
 276 # Check append
 277
 278 {
 279
 280 local value = [ mark-order r1 : v1 v2 ] [ mark-order r2 : v3 v4 ] ;
 281 check-equal append : $(value) : v1 v2 v3 v4 ;
 282 check-order append-order : r1 r2 ;
 283
 284 }
 285
 286 # Check foreach
 287
 288 {
 289
 290 local v1 = 1 2 3 ;
 291 local x = old ;
 292 local result ;
 293
 294 for local x in $(v1)
 295 {
 296     result += $(x) + ;
 297 }
 298
 299 check-equal foreach-local-item : $(result) : 1 + 2 + 3 + ;
 300 check-equal foreach-local : $(x) : old ;
 301
 302 result = ;
 303
 304 for x in $(v1)
 305 {
 306     result += $(x) + ;
 307 }
 308
 309 check-equal foreach-nonlocal-item : $(result) : 1 + 2 + 3 + ;
 310 check-equal foreach-nonlocal : $(x) : 3 ;
 311
 312 rule call-foreach ( values * )
 313 {
 314     for local x in $(values)
 315     {
 316         return $(x) ;
 317     }
 318 }
 319
 320 check-equal foreach-result : [ call-foreach 1 2 3 ] : 1 ;
 321
 322 result = ;
 323 local varname = x ;
 324 x = old ;
 325
 326 for local $(varname) in $(v1)
 327 {
 328     result += $(x) + ;
 329 }
 330
 331 check-equal foreach-no-expand : $(result) : old + old + old + ;
 332
 333 result = ;
 334
 335 for local v1 in $(v1)
 336 {
 337    result += $(v1) + ;
 338 }
 339
 340 check-equal foreach-order : $(result) : 1 + 2 + 3 + ;
 341
 342 }
 343
 344 # Check if
 345
 346 {
 347
 348 if true
 349 {
 350     mark-order r1 ;
 351 }
 352
 353 check-order if-true : r1 ;
 354
 355 if $(false)
 356 {
 357     mark-order r1 ;
 358 }
 359
 360 check-order if-false : ;
 361
 362 if true
 363 {
 364     mark-order r1 ;
 365 }
 366 else
 367 {
 368     mark-order r2 ;
 369 }
 370
 371 check-order if-else-true : r1 ;
 372
 373 if $(false)
 374 {
 375     mark-order r1 ;
 376 }
 377 else
 378 {
 379     mark-order r2 ;
 380 }
 381
 382 check-order if-else-false : r2 ;
 383
 384 rule test-rule
 385 {
 386     if true
 387     {
 388         return result ;
 389     }
 390 }
 391
 392 check-equal if-true-result : [ test-rule ] : result ;
 393
 394 rule test-rule
 395 {
 396     local idx  = 1 2 ;
 397     local values = true ;
 398     while $(idx)
 399     {
 400         local v = $(values[$(idx[1])]) ;
 401         idx = $(idx[2-]) ;
 402         if $(v)
 403         {
 404             return result ;
 405         }
 406     }
 407 }
 408
 409 check-equal if-false-result : [ test-rule ] : result ;
 410
 411 rule test-rule
 412 {
 413     if true
 414     {
 415         return r1 ;
 416     }
 417     else
 418     {
 419         return r2 ;
 420     }
 421 }
 422
 423 check-equal if-else-true-result : [ test-rule ] : r1 ;
 424
 425 rule test-rule
 426 {
 427     if $(false)
 428     {
 429         return r1 ;
 430     }
 431     else
 432     {
 433         return r2 ;
 434     }
 435 }
 436
 437 check-equal if-else-false-result : [ test-rule ] : r2 ;
 438
 439 }
 440
 441 # Check the evaluation of conditions
 442
 443 {
 444
 445 local test-result ;
 446 local v1 = "" "" "" ;
 447 local v2 = ;
 448 local v3 = a b c ;
 449 local v4 = a b c d ;
 450 local v5 = a b d ;
 451 local v6 = "" "" "" d ;
 452
 453 rule test-comparison ( id : equal less greater )
 454 {
 455     check-equal $(id)-empty-1 : [ eval-$(id) $(v1) : $(v2) ] : $(equal) ;
 456     check-equal $(id)-empty-2 : [ eval-$(id) $(v1) : $(v2) ] : $(equal) ;
 457     check-equal $(id)-equal : [ eval-$(id) $(v3) : $(v3) ] : $(equal) ;
 458     check-equal $(id)-less-1 : [ eval-$(id) $(v3) : $(v4) ] : $(less) ;
 459     check-equal $(id)-less-2 : [ eval-$(id) $(v3) : $(v5) ] : $(less) ;
 460     check-equal $(id)-less-3 : [ eval-$(id) $(v4) : $(v5) ] : $(less) ;
 461     check-equal $(id)-greater-1 : [ eval-$(id) $(v4) : $(v3) ] : $(greater) ;
 462     check-equal $(id)-greater-2 : [ eval-$(id) $(v5) : $(v3) ] : $(greater) ;
 463     check-equal $(id)-greater-3 : [ eval-$(id) $(v5) : $(v4) ] : $(greater) ;
 464 }
 465
 466 rule eval-lt ( lhs * : rhs * )
 467 {
 468     if $(lhs) < $(rhs) { return true ; }
 469     else { return false ; }
 470 }
 471
 472 test-comparison lt : false true false ;
 473
 474 rule eval-gt ( lhs * : rhs * )
 475 {
 476     if $(lhs) > $(rhs) { return true ; }
 477     else { return false ; }
 478 }
 479
 480 test-comparison gt : false false true ;
 481
 482 rule eval-le ( lhs * : rhs * )
 483 {
 484     if $(lhs) <= $(rhs) { return true ; }
 485     else { return false ; }
 486 }
 487
 488 test-comparison le : true true false ;
 489
 490 rule eval-ge ( lhs * : rhs * )
 491 {
 492     if $(lhs) >= $(rhs) { return true ; }
 493     else { return false ; }
 494 }
 495
 496 test-comparison ge : true false true ;
 497
 498 rule eval-eq ( lhs * : rhs * )
 499 {
 500     if $(lhs) = $(rhs) { return true ; }
 501     else { return false ; }
 502 }
 503
 504 test-comparison eq : true false false ;
 505
 506 rule eval-ne ( lhs * : rhs * )
 507 {
 508     if $(lhs) != $(rhs) { return true ; }
 509     else { return false ; }
 510 }
 511
 512 test-comparison ne : false true true ;
 513
 514 rule eval-not-lt ( lhs * : rhs * )
 515 {
 516     if ! ( $(lhs) < $(rhs) ) { return true ; }
 517     else { return false ; }
 518 }
 519
 520 test-comparison not-lt : true false true ;
 521
 522 rule eval-not-gt ( lhs * : rhs * )
 523 {
 524     if ! ( $(lhs) > $(rhs) ) { return true ; }
 525     else { return false ; }
 526 }
 527
 528 test-comparison not-gt : true true false ;
 529
 530 rule eval-not-le ( lhs * : rhs * )
 531 {
 532     if ! ( $(lhs) <= $(rhs) ) { return true ; }
 533     else { return false ; }
 534 }
 535
 536 test-comparison not-le : false false true ;
 537
 538 rule eval-not-ge ( lhs * : rhs * )
 539 {
 540     if ! ( $(lhs) >= $(rhs) ) { return true ; }
 541     else { return false ; }
 542 }
 543
 544 test-comparison not-ge : false true false ;
 545
 546 rule eval-not-eq ( lhs * : rhs * )
 547 {
 548     if ! ( $(lhs) = $(rhs) ) { return true ; }
 549     else { return false ; }
 550 }
 551
 552 test-comparison not-eq : false true true ;
 553
 554 rule eval-not-ne ( lhs * : rhs * )
 555 {
 556     if ! ( $(lhs) != $(rhs) )  { return true ; }
 557     else { return false ; }
 558 }
 559
 560 test-comparison not-ne : true false false ;
 561
 562 local v7 = a a a a a a ;
 563 local v8 = c b ;
 564 local v9 = c d b ;
 565 local v10 = c a b c c b a a a ;
 566
 567 rule test-in ( id : subset not-subset )
 568 {
 569     check-equal $(id)-0-0 : [ eval-$(id) $(v2) : $(v2) ] : $(subset) ;
 570     check-equal $(id)-0-empty : [ eval-$(id) $(v2) : $(v1) ] : $(subset) ;
 571     check-equal $(id)-empty-0 : [ eval-$(id) $(v1) : $(v2) ] : $(not-subset) ;
 572     check-equal $(id)-equal : [ eval-$(id) $(v3) : $(v3) ] : $(subset) ;
 573     check-equal $(id)-simple : [ eval-$(id) $(v3) : $(v4) ] : $(subset) ;
 574     check-equal $(id)-extra : [ eval-$(id) $(v4) : $(v3) ] : $(not-subset) ;
 575     check-equal $(id)-multiple : [ eval-$(id) $(v7) : $(v3) ] : $(subset) ;
 576     check-equal $(id)-unordered : [ eval-$(id) $(v8) : $(v3) ] : $(subset) ;
 577     check-equal $(id)-unordered-extra : [ eval-$(id) $(v9) : $(v3) ] : $(not-subset) ;
 578     check-equal $(id)-unordered-multiple : [ eval-$(id) $(v10) : $(v3) ] : $(subset) ;
 579 }
 580
 581 rule eval-in ( lhs * : rhs * )
 582 {
 583     if $(lhs) in $(rhs) { return true ; }
 584     else { return false ; }
 585 }
 586
 587 test-in "in" : true false ;
 588
 589 rule eval-not-in ( lhs * : rhs * )
 590 {
 591     if ! ( $(lhs) in $(rhs) ) { return true ; }
 592     else { return false ; }
 593 }
 594
 595 test-in not-in : false true ;
 596
 597 rule test-truth-table ( id : tt tf ft ff )
 598 {
 599     check-equal $(id)-tt : [ eval-$(id) 1 : 1 ] : $(tt) ;
 600     check-equal $(id)-tf : [ eval-$(id) 1 : ] : $(tf) ;
 601     check-equal $(id)-ft : [ eval-$(id) : 1 ] : $(ft) ;
 602     check-equal $(id)-ff : [ eval-$(id) : ] : $(ff) ;
 603 }
 604
 605 rule eval-and ( lhs ? : rhs ? )
 606 {
 607     if $(lhs) && $(rhs) { return true ; }
 608     else { return false ; }
 609 }
 610
 611 test-truth-table and : true false false false ;
 612
 613 rule eval-or ( lhs ? : rhs ? )
 614 {
 615     if $(lhs) || $(rhs) { return true ; }
 616     else { return false ; }
 617 }
 618
 619 test-truth-table or : true true true false ;
 620
 621 rule eval-not-and ( lhs ? : rhs ? )
 622 {
 623     if ! ( $(lhs) && $(rhs) ) { return true ; }
 624     else { return false ; }
 625 }
 626
 627 test-truth-table not-and : false true true true ;
 628
 629 rule eval-not-or ( lhs ? : rhs ? )
 630 {
 631     if ! ( $(lhs) || $(rhs) ) { return true ; }
 632     else { return false ; }
 633 }
 634
 635 test-truth-table not-or : false false false true ;
 636
 637 if [ mark-order r1 : test1 ] < [ mark-order r2 : test2 ] { }
 638 check-order lt-order : r1 r2 ;
 639 if [ mark-order r1 : test1 ] > [ mark-order r2 : test2 ] { }
 640 check-order gt-order : r1 r2 ;
 641 if [ mark-order r1 : test1 ] <= [ mark-order r2 : test2 ] { }
 642 check-order le-order : r1 r2 ;
 643 if [ mark-order r1 : test1 ] >= [ mark-order r2 : test2 ] { }
 644 check-order ge-order : r1 r2 ;
 645 if [ mark-order r1 : test1 ] = [ mark-order r2 : test2 ] { }
 646 check-order eq-order : r1 r2 ;
 647 if [ mark-order r1 : test1 ] != [ mark-order r2 : test2 ] { }
 648 check-order ne-order : r1 r2 ;
 649 if [ mark-order r1 : test1 ] in [ mark-order r2 : test2 ] { }
 650 check-order in-order : r1 r2 ;
 651
 652 if [ mark-order r1 : test1 ] && [ mark-order r2 : test2 ] { }
 653 check-order and-order : r1 r2 ;
 654 if [ mark-order r1 ] && [ mark-order r2 : test2 ] { }
 655 check-order and-order-short-circuit : r1 ;
 656
 657 if [ mark-order r1 ] || [ mark-order r2 : test2 ] { }
 658 check-order or-order : r1 r2 ;
 659 if [ mark-order r1 : test1 ] || [ mark-order r2 : test2 ] { }
 660 check-order or-order-short-circuit : r1 ;
 661
 662 }
 663
 664 # Check include
 665
 666 {
 667 #FIXME:
 668 # plain include
 669 # include in module
 670 # include returns an empty list
 671 # rule arguments are available inside include
 672 }
 673
 674 # Check local
 675
 676 {
 677
 678 local v1 = a b c ;
 679 local v2 = f g h ;
 680
 681 {
 682     local v1 ;
 683     check-equal local-no-init : $(v1) : ;
 684 }
 685
 686 check-equal local-restore : $(v1) : a b c ;
 687
 688 {
 689     local v1 = d e f ;
 690     check-equal local-init : $(v1) : d e f ;
 691 }
 692
 693 check-equal local-restore-init : $(v1) : a b c ;
 694
 695 {
 696     local v1 v2 ;
 697     check-equal local-multiple-no-init : $(v1) - $(v2) : - ;
 698 }
 699
 700 check-equal local-multiple-restore : $(v1) - $(v2) : a b c - f g h ;
 701
 702 {
 703     local v1 v2 = d e f ;
 704     check-equal local-multiple-init : $(v1) - $(v2) : d e f - d e f ;
 705 }
 706
 707 {
 708     local v1 v1 = d e f ;
 709     check-equal local-duplicate : $(v1) - $(v1) : d e f - d e f ;
 710 }
 711
 712 check-equal local-duplicate-restore : $(v1) : a b c ;
 713
 714 {
 715     local [ mark-order r1 : v1 ] = [ mark-order r2 : d e f ] ;
 716     check-order local-order : r1 r2 ;
 717 }
 718
 719 }
 720
 721 # Check module
 722
 723 {
 724     local var1 = root-module-var ;
 725     module my_module
 726     {
 727         var1 = module-var ;
 728         rule get ( )
 729         {
 730             return $(var1) ;
 731         }
 732         local rule not_really ( ) { return nothing ; }
 733     }
 734
 735     check-equal module-var-not-root : $(var1) : root-module-var ;
 736
 737     check-equal module-rulenames : [ RULENAMES my_module ] : get ;
 738
 739     IMPORT_MODULE my_module ;
 740     check-equal module-rule-import-module : [ my_module.get ] : module-var ;
 741
 742     IMPORT my_module : get : : module-get ;
 743     check-equal module-rule-imort : [ module-get ] : module-var ;
 744
 745     IMPORT my_module : get : : module-get : LOCALIZE ;
 746     check-equal module-rule-imort-localize : [ module-get ] : root-module-var ;
 747
 748 }
 749
 750 # Check class
 751 {
 752 #FIXME:
 753 # ...
 754 }
 755
 756 # Check on
 757
 758 {
 759
 760 local target1 = test-on-target1 ;
 761 local target2 = test-on-target2 ;
 762 local targets = $(target1) $(target2) ;
 763 local v1 v2 v3 ;
 764
 765 VAR on $(target1) = value1 ;
 766 V2 on $(target2) = value2 ;
 767
 768 check-equal on-return : [ on $(target1) return $(VAR) ] : value1 ;
 769
 770 rule test-rule
 771 {
 772     return $(VAR) ;
 773 }
 774
 775 check-equal on-rule : [ on $(target1) test-rule ] : value1 ;
 776
 777 check-equal on-multiple : [ on $(targets) return $(V2) ] : ;
 778
 779 rule test-rule
 780 {
 781     on $(target1)
 782     {
 783         return $(VAR) ;
 784     }
 785 }
 786
 787 check-equal on-block : [ test-rule ] : value1 ;
 788
 789 # FIXME: crazy implementation artifacts:
 790
 791 v1 on test-on-target3 = x1 ;
 792 on test-on-target3
 793 {
 794     v1 on test-on-target3 += x1 ;
 795     v1 = y1 ;
 796     v2 on test-on-target3 += x2 ;
 797     v2 = y2 ;
 798     v3 = y3 ;
 799 }
 800
 801 check-equal on-swap-old1 : $(v1) : x1 ;
 802 check-equal on-swap-old2 : [ on test-on-target3 return $(v1) ] : y1 ;
 803 check-equal on-swap-new1 : $(v2) : x2 ;
 804 check-equal on-swap-new2 : [ on test-on-target3 return $(v2) ] : y2 ;
 805 check-equal on-no-swap : $(v3) : y3 ;
 806
 807 }
 808
 809 # Check rule
 810
 811 {
 812 #FIXME:
 813 # argument order
 814 # expand rule name
 815 }
 816
 817 # Check rules
 818
 819 {
 820 #FIXME:
 821 }
 822
 823 # Check set
 824
 825 {
 826 local v1 ;
 827 local v2 ;
 828 local v3 ;
 829 local vars = v1 v2 v3 ;
 830
 831 v1 = x1 ;
 832 check-equal set-set-empty : $(v1) : x1 ;
 833 v2 += x2 ;
 834 check-equal set-append-empty : $(v2) : x2 ;
 835 v3 ?= x3 ;
 836 check-equal set-default-empty : $(v3) : x3 ;
 837
 838 v1 = y1 ;
 839 check-equal set-set-non-empty : $(v1) : y1 ;
 840 v2 += y2 ;
 841 check-equal set-append-non-empty : $(v2) : x2 y2 ;
 842 v3 ?= y3 ;
 843 check-equal set-default-non-empty : $(v3) : x3 ;
 844
 845 v1 = ;
 846 v2 = ;
 847 v3 = ;
 848 $(vars) = z ;
 849 check-equal set-set-empty-group : $(v1) - $(v2) - $(v3) : z - z - z ;
 850
 851 v1 = ;
 852 v2 = ;
 853 v3 = ;
 854 $(vars) += z ;
 855 check-equal set-append-empty-group : $(v1) - $(v2) - $(v3) : z - z - z ;
 856
 857 v1 = ;
 858 v2 = ;
 859 v3 = ;
 860 $(vars) ?= z ;
 861 check-equal set-default-empty-group : $(v1) - $(v2) - $(v3) : z - z - z ;
 862
 863 v1 = x1 ;
 864 v2 = x2 ;
 865 v3 = x3 ;
 866 $(vars) = z ;
 867 check-equal set-set-non-empty-group : $(v1) - $(v2) - $(v3) : z - z - z ;
 868
 869 v1 = x1 ;
 870 v2 = x2 ;
 871 v3 = x3 ;
 872 $(vars) += z ;
 873 check-equal set-append-non-empty-group : $(v1) - $(v2) - $(v3) : x1 z - x2 z - x3 z ;
 874
 875 v1 = x1 ;
 876 v2 = x2 ;
 877 v3 = x3 ;
 878 $(vars) ?= z ;
 879 check-equal set-default-non-empty-group : $(v1) - $(v2) - $(v3) : x1 - x2 - x3 ;
 880
 881 v1 = x1 ;
 882 v2 = ;
 883 v3 = x3 ;
 884 $(vars) = z ;
 885 check-equal set-set-mixed-group : $(v1) - $(v2) - $(v3) : z - z - z ;
 886
 887 v1 = x1 ;
 888 v2 = ;
 889 v3 = x3 ;
 890 $(vars) += z ;
 891 check-equal set-append-mixed-group : $(v1) - $(v2) - $(v3) : x1 z - z - x3 z ;
 892
 893 v1 = x1 ;
 894 v2 = ;
 895 v3 = x3 ;
 896 $(vars) ?= z ;
 897 check-equal set-default-mixed-group : $(v1) - $(v2) - $(v3) : x1 - z - x3 ;
 898
 899 vars = v1 v1 ;
 900
 901 v1 = ;
 902 $(vars) = z ;
 903 check-equal set-set-duplicate-empty : $(v1) : z ;
 904 v1 = ;
 905 $(vars) += z ;
 906 check-equal set-append-duplicate-empty : $(v1) : z z ;
 907 v1 = ;
 908 $(vars) ?= z ;
 909 check-equal set-default-duplicate-empty : $(v1) : z ;
 910
 911 v1 = x1 ;
 912 $(vars) = z ;
 913 check-equal set-set-duplicate-non-empty : $(v1) : z ;
 914 v1 = x1 ;
 915 $(vars) += z ;
 916 check-equal set-append-duplicate-non-empty : $(v1) : x1 z z ;
 917 v1 = x1 ;
 918 $(vars) ?= z ;
 919 check-equal set-default-duplicate-non-empty : $(v1) : x1 ;
 920
 921 rule test-rule { v1 = x1 ; }
 922 check-equal set-set-result : [ test-rule ] : x1 ;
 923 rule test-rule { v1 += x1 ; }
 924 check-equal set-append-result : [ test-rule ] : x1 ;
 925 rule test-rule { v1 ?= x1 ; }
 926 check-equal set-default-result : [ test-rule ] : x1 ;
 927
 928 [ mark-order r1 ] = [ mark-order r2 ] ;
 929 check-order set-set-order : r1 r2 ;
 930 [ mark-order r1 ] += [ mark-order r2 ] ;
 931 check-order set-append-order : r1 r2 ;
 932 [ mark-order r1 ] ?= [ mark-order r2 ] ;
 933 check-order set-default-order : r1 r2 ;
 934
 935 }
 936
 937 # Check setcomp
 938
 939 {
 940 #FIXME
 941 # Expand arguments
 942 # Don't expand name
 943 }
 944
 945 # Check setexec
 946
 947 {
 948 #FIXME:
 949 # Don't expand name
 950 # Evaluate bindlist
 951 }
 952
 953 # Check settings ;
 954
 955 {
 956
 957 local target1 = test-settings-target1 ;
 958 local target2 = test-settings-target2 ;
 959 local target3 = test-settings-target3 ;
 960 local targets = $(target2) $(target3) ;
 961
 962 local vars = v1 v2 v3 ;
 963
 964 v1 on $(target1) = x1 ;
 965 check-equal settings-set-empty : [ on $(target1) return $(v1) ] : x1 ;
 966 v2 on $(target1) += x2 ;
 967 check-equal settings-append-empty : [ on $(target1) return $(v2) ] : x2 ;
 968 v3 on $(target1) ?= x3 ;
 969 check-equal settings-default-empty : [ on $(target1) return $(v3) ] : x3 ;
 970
 971 v1 on $(target1) = y1 ;
 972 check-equal settings-set-non-empty : [ on $(target1) return $(v1) ] : y1 ;
 973 v2 on $(target1) += y2 ;
 974 check-equal settings-append-non-empty : [ on $(target1) return $(v2) ] : x2 y2 ;
 975 v3 on $(target1) ?= y3 ;
 976 check-equal settings-default-non-empty : [ on $(target1) return $(v3) ] : x3 ;
 977
 978 $(vars) on setting-target2 = z ;
 979 check-equal settings-set-empty-group : [ on setting-target2 return $(v1) ] - [ on setting-target2 return $(v2) ] - [ on setting-target2 return $(v3) ] : z - z - z ;
 980
 981 $(vars) on setting-target3 += z ;
 982 check-equal settings-append-empty-group : [ on setting-target3 return $(v1) ] - [ on setting-target3 return $(v2) ] - [ on setting-target3 return $(v3) ] : z - z - z ;
 983
 984 $(vars) on setting-target4 ?= z ;
 985 check-equal settings-default-empty-group : [ on setting-target4 return $(v1) ] - [ on setting-target4 return $(v2) ] - [ on setting-target4 return $(v3) ] : z - z - z ;
 986
 987 v1 on $(target1) = x1 ;
 988 v2 on $(target1) = x2 ;
 989 v3 on $(target1) = x3 ;
 990 $(vars) on $(target1) = z ;
 991 check-equal settings-set-non-empty-group : [ on $(target1) return $(v1) ] - [ on $(target1) return $(v2) ] - [ on $(target1) return $(v3) ] : z - z - z ;
 992
 993 v1 on $(target1) = x1 ;
 994 v2 on $(target1) = x2 ;
 995 v3 on $(target1) = x3 ;
 996 $(vars) on $(target1) += z ;
 997 check-equal settings-append-non-empty-group : [ on $(target1) return $(v1) ] - [ on $(target1) return $(v2) ] - [ on $(target1) return $(v3) ] : x1 z - x2 z - x3 z ;
 998
 999 v1 on $(target1) = x1 ;
1000 v2 on $(target1) = x2 ;
1001 v3 on $(target1) = x3 ;
1002 $(vars) on $(target1) ?= z ;
1003 check-equal settings-default-non-empty-group : [ on $(target1) return $(v1) ] - [ on $(target1) return $(v2) ] - [ on $(target1) return $(v3) ] : x1 - x2 - x3 ;
1004
1005 v1 on setting-target5 = x1 ;
1006 v3 on setting-target5 = x3 ;
1007 $(vars) on setting-target5 = z ;
1008 check-equal settings-set-mixed-group : [ on setting-target5 return $(v1) ] - [ on setting-target5 return $(v2) ] - [ on setting-target5 return $(v3) ] : z - z - z ;
1009
1010 v1 on setting-target6 = x1 ;
1011 v3 on setting-target6 = x3 ;
1012 $(vars) on setting-target6 += z ;
1013 check-equal settings-append-mixed-group : [ on setting-target6 return $(v1) ] - [ on setting-target6 return $(v2) ] - [ on setting-target6 return $(v3) ] : x1 z - z - x3 z ;
1014
1015 v1 on setting-target7 = x1 ;
1016 v3 on setting-target7 = x3 ;
1017 $(vars) on setting-target7 ?= z ;
1018 check-equal settings-default-mixed-group : [ on setting-target7 return $(v1) ] - [ on setting-target7 return $(v2) ] - [ on setting-target7 return $(v3) ] : x1 - z - x3 ;
1019
1020 vars = v1 v1 ;
1021
1022 $(vars) on setting-target8 = z ;
1023 check-equal settings-set-duplicate-empty : [ on setting-target8 return $(v1) ] : z ;
1024 $(vars) on setting-target9 += z ;
1025 check-equal settings-append-duplicate-empty : [ on setting-target9 return $(v1) ] : z z ;
1026 $(vars) on setting-target10 ?= z ;
1027 check-equal settings-default-duplicate-empty : [ on setting-target10 return $(v1) ] : z ;
1028
1029 v1 on $(target1) = x1 ;
1030 $(vars) on $(target1) = z ;
1031 check-equal settings-set-duplicate-non-empty : [ on $(target1) return $(v1) ] : z ;
1032 v1 on $(target1) = x1 ;
1033 $(vars) on $(target1) += z ;
1034 check-equal settings-append-duplicate-non-empty : [ on $(target1) return $(v1) ] : x1 z z ;
1035 v1 on $(target1) = x1 ;
1036 $(vars) on $(target1) ?= z ;
1037 check-equal settings-default-duplicate-non-empty : [ on $(target1) return $(v1) ] : x1 ;
1038
1039 v1 on $(target1) = ;
1040 v1 on $(target1) ?= z ;
1041 check-equal settings-default-set-but-empty : [ on $(target1) return $(v1) ] : ;
1042
1043 v1 on $(targets) = multi ;
1044 check-equal settings-set-multi-empty : [ on $(target2) return $(v1) ] - [ on $(target3) return $(v1) ] : multi - multi ;
1045 v2 on $(targets) += multi ;
1046 check-equal settings-append-multi-empty : [ on $(target2) return $(v2) ] - [ on $(target3) return $(v2) ] : multi - multi ;
1047 v3 on $(targets) ?= multi ;
1048 check-equal settings-default-multi-empty : [ on $(target2) return $(v3) ] - [ on $(target3) return $(v3) ] : multi - multi ;
1049
1050 v1 on $(targets) = multi2 ;
1051 check-equal settings-set-multi-empty : [ on $(target2) return $(v1) ] - [ on $(target3) return $(v1) ] : multi2 - multi2 ;
1052 v2 on $(targets) += multi2 ;
1053 check-equal settings-append-multi-empty : [ on $(target2) return $(v2) ] - [ on $(target3) return $(v2) ] : multi multi2 - multi multi2 ;
1054 v3 on $(targets) ?= multi2 ;
1055 check-equal settings-default-multi-empty : [ on $(target2) return $(v3) ] - [ on $(target3) return $(v3) ] : multi - multi ;
1056
1057 rule test-rule { v1 on $(target1) = x1 ; }
1058 check-equal settings-set-result : [ test-rule ] : x1 ;
1059 rule test-rule { v1 on $(target1) += x1 ; }
1060 check-equal settings-append-result : [ test-rule ] : x1 ;
1061 rule test-rule { v1 on $(target1) ?= x1 ; }
1062 check-equal settings-default-result : [ test-rule ] : x1 ;
1063
1064 [ mark-order r1 : var ] on [ mark-order r3 : $(target1) ] = [ mark-order r2 : value ] ;
1065 check-order settings-set-order : r1 r2 r3 ;
1066 [ mark-order r1 : var ] on [ mark-order r3 : $(target1) ] += [ mark-order r2 : value ] ;
1067 check-order settings-append-order : r1 r2 r3 ;
1068 [ mark-order r1 : var ] on [ mark-order r3 : $(target1) ] ?= [ mark-order r2 : value ] ;
1069 check-order settings-default-order : r1 r2 r3 ;
1070
1071 }
1072
1073 # Check switch
1074
1075 {
1076
1077 local pattern = * ;
1078
1079 switch value
1080 {
1081     case * : mark-order r1 ;
1082 }
1083
1084 check-order switch-match-any : r1 ;
1085
1086 switch value
1087 {
1088     case v2 : mark-order r1 ;
1089 }
1090
1091 check-order switch-no-match : ;
1092
1093 switch value
1094 {
1095     case $(pattern) : mark-order r1 ;
1096 }
1097
1098 check-order switch-no-expand : ;
1099
1100 switch value
1101 {
1102     case value : mark-order r1 ;
1103     case * : mark-order r2 ;
1104 }
1105
1106 check-order switch-match-several : r1 ;
1107
1108 rule test-rule ( value )
1109 {
1110     switch $(value)
1111     {
1112         case value : return 1 ;
1113     }
1114 }
1115
1116 check-equal switch-result-match : [ test-rule value ] : 1 ;
1117 check-equal switch-result-match : [ test-rule v1 ] : ;
1118
1119 switch $()
1120 {
1121     case "" : mark-order r1 ;
1122     case * : mark-order r2 ;
1123 }
1124
1125 check-order switch-empty : r1 ;
1126
1127 local values = v1 v2 v3 ;
1128 switch $(values)
1129 {
1130     case v1 : mark-order r1 ;
1131     case v2 : mark-order r2 ;
1132     case v3 : mark-order r3 ;
1133 }
1134
1135 check-order switch-multiple : r1 ;
1136
1137 # Test glob matching
1138
1139 switch value { case * : mark-order r1 ; }
1140 check-order switch-glob-star : r1 ;
1141
1142 switch value { case va*e : mark-order r1 ; }
1143 check-order switch-glob-star-1 : r1 ;
1144
1145 switch value { case *a* : mark-order r1 ; }
1146 check-order switch-glob-star-2 : r1 ;
1147
1148 switch value { case *a*ue* : mark-order r1 ; }
1149 check-order switch-glob-star-3 : r1 ;
1150
1151 switch value { case *[eaiou]*ue : mark-order r1 ; }
1152 check-order switch-glob-group : r1 ;
1153
1154 switch value { case *[eaiou]ue : mark-order r1 ; }
1155 check-order switch-glob-group-fail : ;
1156
1157 switch value { case ?a?ue : mark-order r1 ; }
1158 check-order switch-glob-any : r1 ;
1159
1160 switch value { case ?lue : mark-order r1 ; }
1161 check-order switch-glob-any-fail : ;
1162
1163 }
1164
1165 # Test while
1166
1167 {
1168
1169 local value = 1 2 3 ;
1170
1171 while $(value)
1172 {
1173     mark-order r$(value[1]) ;
1174     value = $(value[2-]) ;
1175 }
1176
1177 check-order while-exec : r1 r2 r3 ;
1178
1179 rule test-rule
1180 {
1181     local value = 1 2 3 ;
1182     while $(value)
1183     {
1184         value = $(value[2-]) ;
1185         return x ;
1186     }
1187 }
1188
1189 check-equal while-result : [ test-rule ] : x ;
1190
1191 rule test-rule
1192 {
1193     local value = 1 2 ;
1194     while $(value)
1195     {
1196         value = $(value[2-]) ;
1197         local inner = $(value) ;
1198         while $(inner)
1199         {
1200             inner = $(inner[2-]) ;
1201             return x ;
1202         }
1203     }
1204 }
1205
1206 check-equal while-result-2 : [ test-rule ] : x ;
1207
1208 }
1209
1210
1211 #
1212 # test break
1213 #
1214
1215 {
1216
1217 local z = original ;
1218 local done ;
1219 while ! $(done)
1220 {
1221     local z = inner ;
1222     mark-order r1 ;
1223     break ;
1224     mark-order r2 ;
1225     done = true ;
1226 }
1227
1228 check-order break-while-exec : r1 ;
1229 check-equal break-while-cleanup : $(z) : original ;
1230
1231 local values = v1 v2 ;
1232
1233 for y in $(values)
1234 {
1235     local z = inner ;
1236     mark-order r1-$(y) ;
1237     break ;
1238     mark-order r2-$(y) ;
1239 }
1240
1241 check-order break-for-exec : r1-v1 ;
1242 check-equal break-for-cleanup : $(z) : original ;
1243
1244 for local y in $(values)
1245 {
1246     local z = inner ;
1247     mark-order r1-$(y) ;
1248     break ;
1249     mark-order r2-$(y) ;
1250 }
1251
1252 check-order break-for-local-exec : r1-v1 ;
1253 check-equal break-for-local-cleanup : $(z) : original ;
1254
1255 local z1 = z1val ;
1256 local z2 = z2val ;
1257 done = ;
1258 while ! $(done)
1259 {
1260     local z1 = z1new ;
1261     mark-order r1 ;
1262     for local y in $(values)
1263     {
1264         local z2 = z2new ;
1265         mark-order r2 ;
1266         break ;
1267         mark-order r3 ;
1268     }
1269     mark-order r4 ;
1270     break ;
1271     mark-order r5 ;
1272     done = true ;
1273 }
1274
1275 check-order break-nested-exec : r1 r2 r4 ;
1276 check-equal break-nested-cleanup1 : $(z1) : z1val ;
1277 check-equal break-nested-cleanup2 : $(z2) : z2val ;
1278
1279 }
1280
1281 #
1282 # test continue
1283 #
1284
1285 {
1286
1287 local z = original ;
1288 local done ;
1289 while ! [ mark-order r1 : $(done) ]
1290 {
1291     local z = inner ;
1292     done = true ;
1293     mark-order r2 ;
1294     continue ;
1295     mark-order r3 ;
1296 }
1297
1298 check-order continue-while-exec : r1 r2 r1 ;
1299 check-equal continue-while-cleanup : $(z) : original ;
1300
1301 local values = v1 v2 ;
1302 for y in $(values)
1303 {
1304     local z = inner ;
1305     mark-order r1-$(y) ;
1306     continue ;
1307     mark-order r2-$(y) ;
1308 }
1309
1310 check-order continue-for-exec : r1-v1 r1-v2 ;
1311 check-equal continue-for-cleanup : $(z) : original ;
1312
1313 for local y in $(values)
1314 {
1315     local z = inner ;
1316     mark-order r1-$(y) ;
1317     continue ;
1318     mark-order r2-$(y) ;
1319 }
1320
1321 check-order continue-for-local-exec : r1-v1 r1-v2 ;
1322 check-equal continue-for-local-cleanup : $(z) : original ;
1323
1324 local z1 = z1val ;
1325 local z2 = z2val ;
1326 done = ;
1327 while ! [ mark-order r1 : $(done) ]
1328 {
1329     local z1 = z1new ;
1330     done = true ;
1331     mark-order r2 ;
1332     for local y in $(values)
1333     {
1334         local z2 = z2new ;
1335         mark-order r3-$(y) ;
1336         continue ;
1337         mark-order r4-$(y) ;
1338     }
1339     mark-order r5 ;
1340     continue ;
1341     mark-order r6 ;
1342 }
1343
1344 check-order continue-nested-exec : r1 r2 r3-v1 r3-v2 r5 r1 ;
1345 check-equal continue-nested-cleanup1 : $(z1) : z1val ;
1346 check-equal continue-nested-cleanup2 : $(z2) : z2val ;
1347
1348 }
1349
1350 #
1351 # test CALLER_MODULE and backtrace
1352 #
1353
1354 {
1355     local base = [ BACKTRACE ] ;
1356     base = $(base[2]) ;
1357     rule backtrace ( )
1358     {
1359         local bt = [ BACKTRACE ] ;
1360         check-equal backtrace-1-file : $(bt) :
1361             test.jam [ CALC $(base) +  4 ] ""       backtrace
1362             test.jam [ CALC $(base) + 28 ] module2. module2.f
1363             test.jam [ CALC $(base) + 19 ] module1. module1.f
1364             test.jam [ CALC $(base) + 32 ] ""       "module scope"
1365         ;
1366     }
1367     module module1
1368     {
1369         IMPORT_MODULE module2 : module1 ;
1370         rule f ( )
1371         {
1372             local m = [ CALLER_MODULE ] ;
1373             check-equal caller-module-root : $(m) ;
1374             module2.f ;
1375         }
1376     }
1377     module module2
1378     {
1379         rule f ( )
1380         {
1381             local m = [ CALLER_MODULE ] ;
1382             check-equal caller-module : module1 : $(m) ;
1383             backtrace ;
1384         }
1385     }
1386     IMPORT_MODULE module1 ;
1387     module1.f ;
1388 }
1389
1390
1391 # Test NORMALIZE_PATH
1392
1393 {
1394 check-equal normalize-path : "."     : [ NORMALIZE_PATH ] ;
1395 check-equal normalize-path : "."     : [ NORMALIZE_PATH "" ] ;
1396 check-equal normalize-path : "."     : [ NORMALIZE_PATH "." ] ;
1397 check-equal normalize-path : ".."    : [ NORMALIZE_PATH ".." ] ;
1398 check-equal normalize-path : "/"     : [ NORMALIZE_PATH "/" ] ;
1399 check-equal normalize-path : "/"     : [ NORMALIZE_PATH "\\" ] ;
1400 check-equal normalize-path : "/"     : [ NORMALIZE_PATH "//" ] ;
1401 check-equal normalize-path : "/"     : [ NORMALIZE_PATH "\\\\" ] ;
1402 check-equal normalize-path : "/"     : [ NORMALIZE_PATH "//\\\\//\\\\" ] ;
1403 check-equal normalize-path : "/"     : [ NORMALIZE_PATH "/." ] ;
1404 check-equal normalize-path : "/"     : [ NORMALIZE_PATH "/./" ] ;
1405 check-equal normalize-path : "/"     : [ NORMALIZE_PATH "\\\\///.///\\\\\\" ] ;
1406 check-equal normalize-path : "."     : [ NORMALIZE_PATH "./././././." ] ;
1407 check-equal normalize-path : "/"     : [ NORMALIZE_PATH "/./././././." ] ;
1408 check-equal normalize-path : "foo"   : [ NORMALIZE_PATH "foo" ] ;
1409 check-equal normalize-path : "foo"   : [ NORMALIZE_PATH "foo/" ] ;
1410 check-equal normalize-path : "foo"   : [ NORMALIZE_PATH "foo\\" ] ;
1411 check-equal normalize-path : "foo"   : [ NORMALIZE_PATH "foo\\\\/////" ] ;
1412 check-equal normalize-path : "foo"   : [ NORMALIZE_PATH "foo\\\\/////././." ] ;
1413 check-equal normalize-path : "foo"   : [ NORMALIZE_PATH "foo\\\\/////./././" ] ;
1414 check-equal normalize-path : "."     : [ NORMALIZE_PATH "foo/.." ] ;
1415 check-equal normalize-path : "."     : [ NORMALIZE_PATH "foo////.." ] ;
1416 check-equal normalize-path : "/"     : [ NORMALIZE_PATH "///foo/\\\\/.." ] ;
1417 check-equal normalize-path : "/"     : [ NORMALIZE_PATH "\\\\\\foo\\//\\.." ] ;
1418 check-equal normalize-path : "."     : [ NORMALIZE_PATH "foo/./.." ] ;
1419 check-equal normalize-path : "."     : [ NORMALIZE_PATH "foo/././././.." ] ;
1420 check-equal normalize-path : "foo"   : [ NORMALIZE_PATH "foo/./././bar/./././.././././baz/./././.." ] ;
1421 check-equal normalize-path : "/foo"  : [ NORMALIZE_PATH "/foo/./././bar/./././.././././baz/./././.." ] ;
1422 check-equal normalize-path : "foo"   : [ NORMALIZE_PATH "foo/./././bar/./././////.././././baz/./././.." ] ;
1423 check-equal normalize-path : "/foo"  : [ NORMALIZE_PATH "/foo/./././bar/./././////.././././baz/./././.." ] ;
1424 check-equal normalize-path : ".."    : [ NORMALIZE_PATH "./.." ] ;
1425 check-equal normalize-path : ".."    : [ NORMALIZE_PATH "././././.." ] ;
1426 check-equal normalize-path : "../.." : [ NORMALIZE_PATH "../.." ] ;
1427 check-equal normalize-path : "../.." : [ NORMALIZE_PATH "./../.." ] ;
1428 check-equal normalize-path : "../.." : [ NORMALIZE_PATH "././././../.." ] ;
1429 check-equal normalize-path : "../.." : [ NORMALIZE_PATH "./.././././.." ] ;
1430 check-equal normalize-path : "../.." : [ NORMALIZE_PATH "././././.././././.." ] ;
1431 check-equal normalize-path : "../.." : [ NORMALIZE_PATH "..//\\\\\\//.." ] ;
1432 check-equal normalize-path : "../.." : [ NORMALIZE_PATH "../..\\\\/\\\\" ] ;
1433 check-equal normalize-path : "."     : [ NORMALIZE_PATH "foo/../bar/../baz/.." ] ;
1434 check-equal normalize-path : "."     : [ NORMALIZE_PATH "foo////..////bar////.//////.////../baz/.." ] ;
1435 check-equal normalize-path : "/"     : [ NORMALIZE_PATH "/foo/../bar/../baz/.." ] ;
1436 check-equal normalize-path : "/"     : [ NORMALIZE_PATH "/foo////..////bar////.//////.////../baz/.." ] ;
1437
1438 # Invalid rooted paths with leading dotdots.
1439 check-equal normalize-path-invalid : : [ NORMALIZE_PATH "/.." ] ;
1440 check-equal normalize-path-invalid : : [ NORMALIZE_PATH "/../" ] ;
1441 check-equal normalize-path-invalid : : [ NORMALIZE_PATH "//\\\\//\\\\/.." ] ;
1442 check-equal normalize-path-invalid : : [ NORMALIZE_PATH "\\\\//\\\\//\\.." ] ;
1443 check-equal normalize-path-invalid : : [ NORMALIZE_PATH "/../.." ] ;
1444 check-equal normalize-path-invalid : : [ NORMALIZE_PATH "/../../.." ] ;
1445 check-equal normalize-path-invalid : : [ NORMALIZE_PATH "/foo/bar/../baz/../../.." ] ;
1446 check-equal normalize-path-invalid : : [ NORMALIZE_PATH "/../for/././../././bar/././../././.." ] ;
1447 check-equal normalize-path-invalid : : [ NORMALIZE_PATH "/../foo/bar" ] ;
1448
1449 }
1450
1451 # Test W32_GETREGNAMES
1452
1453 {
1454
1455 if $(NT)
1456 {
1457     local sound = "Beep" "ExtendedSounds" ;
1458     local r1 = [ W32_GETREGNAMES "HKEY_CURRENT_USER\\Control Panel\\Sound" :
1459         values ] ;
1460     check-equal w32_getregnames : $(sound:L) : [ SORT $(r1:L) ] ;
1461     local r2 = [ W32_GETREGNAMES "HKCU\\Control Panel\\Sound" : values ] ;
1462     check-equal w32_getregnames : $(sound:L) : [ SORT $(r2:L) ] ;
1463
1464     #   Some Windows platforms may have additional keys under
1465     # 'CurrentControlSet' which we then remove here so they would not be
1466     # reported as errors by our test.
1467     local rule remove-policies ( param * )
1468     {
1469         local found ;
1470         local r ;
1471         for local x in $(param:L)
1472         {
1473             if ! x in $(found) &&
1474                 $(x) in "addservices" "policies" "deleted device ids"
1475             {
1476                 found += $(x) ;
1477             }
1478             else
1479             {
1480                 r += $(x) ;
1481             }
1482         }
1483         return $(r) ;
1484     }
1485     local CurrentControlSet = "Control" "Enum" "Hardware Profiles" "Services" ;
1486     local r3 = [ W32_GETREGNAMES "HKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet"
1487         : subkeys ] ;
1488     check-equal w32_getregnames : $(CurrentControlSet:L) : [ remove-policies
1489         $(r3:L) ] ;
1490     local r4 = [ W32_GETREGNAMES "HKLM\\SYSTEM\\CurrentControlSet" : subkeys ] ;
1491     check-equal w32_getregnames : $(CurrentControlSet:L) : [ remove-policies
1492         $(r4:L) ] ;
1493 }
1494
1495 }
1496
1497 # Test SHELL
1498
1499 {
1500
1501 local c = "echo value" ;
1502 if $(OS) = VMS { c = "PIPE WRITE SYS$OUTPUT \"value\"" ; }
1503
1504 check-equal shell : "value\n"   : [ SHELL $(c) ] ;
1505 check-equal shell : ""          : [ SHELL $(c) : no-output ] ;
1506 check-equal shell : "value\n" 0 : [ SHELL $(c) : exit-status ] ;
1507 check-equal shell : ""      0   : [ SHELL $(c) : no-output : exit-status ] ;
1508 check-equal command : "value\n"   : [ COMMAND $(c) ] ;
1509 check-equal command : ""          : [ COMMAND $(c) : no-output ] ;
1510 check-equal command : "value\n" 0 : [ COMMAND $(c) : exit-status ] ;
1511 check-equal command : ""      0   : [ COMMAND $(c) : no-output : exit-status ] ;
1512
1513 }
1514
1515 # Test SUBST
1516
1517 {
1518
1519 # Check that unmatched subst returns an empty list
1520 check-equal subst-nomatch : [ SUBST "abc" "d+" x ] : ;
1521
1522 # Check that a matched subst works
1523 check-equal subst-match : [ SUBST "ddd" "d+" x ] : x ;
1524
1525 # Check that we can get multiple substitutions from a single invocation
1526 check-equal subst-multiple : [ SUBST "x/y/z" "([^/]*)/([^/]*).*" "\\1" $2 "\\1-\\2" ] : x y x-y ;
1527
1528 }
1529
1530 # Test summary
1531
1532 if $(failed) = 0
1533 {
1534     status = 0 ;
1535 }
1536 else
1537 {
1538     status = 1 ;
1539 }
1540
1541 EXIT $(passed) passed $(failed) failed : $(status) ;