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)
10 rule show-result ( id : test-result )
12 if ! ( --quiet in $(ARGV) )
14 ECHO $(test-result): $(id) ;
16 $(test-result) = [ CALC $($(test-result)) + 1 ] ;
19 rule check-equal ( id : values * : expected * )
22 if x$(values) = x$(expected)
24 test-result = passed ;
28 ECHO error: "[" $(values) "] != [" $(expected) "]" ;
29 test-result = failed ;
31 show-result $(id) : $(test-result) ;
34 rule mark-order ( id : result * )
40 rule check-order ( id : expected * )
42 check-equal $(id) : $(order) : $(expected) ;
46 # Check variable expansion
52 local v3 = 0 1 2 3 4 5 6 7 8 9 10 ;
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 ;
65 local p2 = dir/sub/name ;
68 check-equal var-product : $(v1)$(v2) : 14 15 16 24 25 26 34 35 36 ;
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 ;
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 ;
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
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 ;
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))" ] ;
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 ;
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) ;
122 local cyg-grist = <grist>$(cyg1) ;
123 check-equal cygwin-grist : $(cyg-grist:W) : <grist>\\cygdrive\\c\\path1.txt ;
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 ;
132 check-equal var-test1 : $(v7[2]:G:L) : <grist2> ;
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)
144 check-equal var-nopathmods : $(:E=//) : // ;
146 # showcases all the idiosyncracies of indexing
147 # key: h = high, l = low, p = positive, m = minus, e = end.
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]) : ;
189 return $(<) - $(>) - $(1) - $(2) - $(3) - $(4) - $(5) - $(6) - $(7) - $(8) - $(9) - $(10) - $(11) - $(12) - $(13) - $(14) - $(15) - $(16) - $(17) - $(18) - $(19) ;
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 ;
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) ;
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 ;
207 rule test-rule ( p1 : p2 : p3 : p4 : p5 : p6 : p7 : p8 : p9 :
208 p10 : p11 : p12 : p13 : p14 : p15 : p16 : p17 : p18 : p19 )
212 return $(p1) - $(p2) - $(p3) - $(p4) - $(p5) - $(p6) - $(p7) - $(p8) - $(p9) - $(p10) - $(p11) - $(p12) - $(p13) - $(p14) - $(p15) - $(p16) - $(p17) - $(p18) - $(p19) ;
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 ;
220 # test rule indirection
222 rule select ( n list * )
224 return $(list[$(n)]) ;
227 rule indirect1 ( rule + : args * )
229 return [ $(rule) $(args) ] ;
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 ;
236 rule reset-x ( new-value )
240 $(x)-x bar ; # invokes reset-x...
241 check-equal rule-reset : $(x) : bar ; # which changes x
243 rule bar-x ( new-value )
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 ;
253 # Cases that look like member calls
254 rule looks.like-a-member ( args * )
259 rule call-non-member ( rule + )
261 return [ $(rule).like-a-member ] ;
264 rule call-non-member-with-args ( rule + )
266 return [ $(rule).like-a-member a2 ] ;
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 ;
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 ;
299 check-equal foreach-local-item : $(result) : 1 + 2 + 3 + ;
300 check-equal foreach-local : $(x) : old ;
309 check-equal foreach-nonlocal-item : $(result) : 1 + 2 + 3 + ;
310 check-equal foreach-nonlocal : $(x) : 3 ;
312 rule call-foreach ( values * )
314 for local x in $(values)
320 check-equal foreach-result : [ call-foreach 1 2 3 ] : 1 ;
326 for local $(varname) in $(v1)
331 check-equal foreach-no-expand : $(result) : old + old + old + ;
335 for local v1 in $(v1)
340 check-equal foreach-order : $(result) : 1 + 2 + 3 + ;
353 check-order if-true : r1 ;
360 check-order if-false : ;
371 check-order if-else-true : r1 ;
382 check-order if-else-false : r2 ;
392 check-equal if-true-result : [ test-rule ] : result ;
397 local values = true ;
400 local v = $(values[$(idx[1])]) ;
409 check-equal if-false-result : [ test-rule ] : result ;
423 check-equal if-else-true-result : [ test-rule ] : r1 ;
437 check-equal if-else-false-result : [ test-rule ] : r2 ;
441 # Check the evaluation of conditions
446 local v1 = "" "" "" ;
451 local v6 = "" "" "" d ;
453 rule test-comparison ( id : equal less greater )
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) ;
466 rule eval-lt ( lhs * : rhs * )
468 if $(lhs) < $(rhs) { return true ; }
469 else { return false ; }
472 test-comparison lt : false true false ;
474 rule eval-gt ( lhs * : rhs * )
476 if $(lhs) > $(rhs) { return true ; }
477 else { return false ; }
480 test-comparison gt : false false true ;
482 rule eval-le ( lhs * : rhs * )
484 if $(lhs) <= $(rhs) { return true ; }
485 else { return false ; }
488 test-comparison le : true true false ;
490 rule eval-ge ( lhs * : rhs * )
492 if $(lhs) >= $(rhs) { return true ; }
493 else { return false ; }
496 test-comparison ge : true false true ;
498 rule eval-eq ( lhs * : rhs * )
500 if $(lhs) = $(rhs) { return true ; }
501 else { return false ; }
504 test-comparison eq : true false false ;
506 rule eval-ne ( lhs * : rhs * )
508 if $(lhs) != $(rhs) { return true ; }
509 else { return false ; }
512 test-comparison ne : false true true ;
514 rule eval-not-lt ( lhs * : rhs * )
516 if ! ( $(lhs) < $(rhs) ) { return true ; }
517 else { return false ; }
520 test-comparison not-lt : true false true ;
522 rule eval-not-gt ( lhs * : rhs * )
524 if ! ( $(lhs) > $(rhs) ) { return true ; }
525 else { return false ; }
528 test-comparison not-gt : true true false ;
530 rule eval-not-le ( lhs * : rhs * )
532 if ! ( $(lhs) <= $(rhs) ) { return true ; }
533 else { return false ; }
536 test-comparison not-le : false false true ;
538 rule eval-not-ge ( lhs * : rhs * )
540 if ! ( $(lhs) >= $(rhs) ) { return true ; }
541 else { return false ; }
544 test-comparison not-ge : false true false ;
546 rule eval-not-eq ( lhs * : rhs * )
548 if ! ( $(lhs) = $(rhs) ) { return true ; }
549 else { return false ; }
552 test-comparison not-eq : false true true ;
554 rule eval-not-ne ( lhs * : rhs * )
556 if ! ( $(lhs) != $(rhs) ) { return true ; }
557 else { return false ; }
560 test-comparison not-ne : true false false ;
562 local v7 = a a a a a a ;
565 local v10 = c a b c c b a a a ;
567 rule test-in ( id : subset not-subset )
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) ;
581 rule eval-in ( lhs * : rhs * )
583 if $(lhs) in $(rhs) { return true ; }
584 else { return false ; }
587 test-in "in" : true false ;
589 rule eval-not-in ( lhs * : rhs * )
591 if ! ( $(lhs) in $(rhs) ) { return true ; }
592 else { return false ; }
595 test-in not-in : false true ;
597 rule test-truth-table ( id : tt tf ft ff )
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) ;
605 rule eval-and ( lhs ? : rhs ? )
607 if $(lhs) && $(rhs) { return true ; }
608 else { return false ; }
611 test-truth-table and : true false false false ;
613 rule eval-or ( lhs ? : rhs ? )
615 if $(lhs) || $(rhs) { return true ; }
616 else { return false ; }
619 test-truth-table or : true true true false ;
621 rule eval-not-and ( lhs ? : rhs ? )
623 if ! ( $(lhs) && $(rhs) ) { return true ; }
624 else { return false ; }
627 test-truth-table not-and : false true true true ;
629 rule eval-not-or ( lhs ? : rhs ? )
631 if ! ( $(lhs) || $(rhs) ) { return true ; }
632 else { return false ; }
635 test-truth-table not-or : false false false true ;
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 ;
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 ;
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 ;
670 # include returns an empty list
671 # rule arguments are available inside include
683 check-equal local-no-init : $(v1) : ;
686 check-equal local-restore : $(v1) : a b c ;
690 check-equal local-init : $(v1) : d e f ;
693 check-equal local-restore-init : $(v1) : a b c ;
697 check-equal local-multiple-no-init : $(v1) - $(v2) : - ;
700 check-equal local-multiple-restore : $(v1) - $(v2) : a b c - f g h ;
703 local v1 v2 = d e f ;
704 check-equal local-multiple-init : $(v1) - $(v2) : d e f - d e f ;
708 local v1 v1 = d e f ;
709 check-equal local-duplicate : $(v1) - $(v1) : d e f - d e f ;
712 check-equal local-duplicate-restore : $(v1) : a b c ;
715 local [ mark-order r1 : v1 ] = [ mark-order r2 : d e f ] ;
716 check-order local-order : r1 r2 ;
724 local var1 = root-module-var ;
732 local rule not_really ( ) { return nothing ; }
735 check-equal module-var-not-root : $(var1) : root-module-var ;
737 check-equal module-rulenames : [ RULENAMES my_module ] : get ;
739 IMPORT_MODULE my_module ;
740 check-equal module-rule-import-module : [ my_module.get ] : module-var ;
742 IMPORT my_module : get : : module-get ;
743 check-equal module-rule-imort : [ module-get ] : module-var ;
745 IMPORT my_module : get : : module-get : LOCALIZE ;
746 check-equal module-rule-imort-localize : [ module-get ] : root-module-var ;
760 local target1 = test-on-target1 ;
761 local target2 = test-on-target2 ;
762 local targets = $(target1) $(target2) ;
765 VAR on $(target1) = value1 ;
766 V2 on $(target2) = value2 ;
768 check-equal on-return : [ on $(target1) return $(VAR) ] : value1 ;
775 check-equal on-rule : [ on $(target1) test-rule ] : value1 ;
777 check-equal on-multiple : [ on $(targets) return $(V2) ] : ;
787 check-equal on-block : [ test-rule ] : value1 ;
789 # FIXME: crazy implementation artifacts:
791 v1 on test-on-target3 = x1 ;
794 v1 on test-on-target3 += x1 ;
796 v2 on test-on-target3 += x2 ;
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 ;
829 local vars = v1 v2 v3 ;
832 check-equal set-set-empty : $(v1) : x1 ;
834 check-equal set-append-empty : $(v2) : x2 ;
836 check-equal set-default-empty : $(v3) : x3 ;
839 check-equal set-set-non-empty : $(v1) : y1 ;
841 check-equal set-append-non-empty : $(v2) : x2 y2 ;
843 check-equal set-default-non-empty : $(v3) : x3 ;
849 check-equal set-set-empty-group : $(v1) - $(v2) - $(v3) : z - z - z ;
855 check-equal set-append-empty-group : $(v1) - $(v2) - $(v3) : z - z - z ;
861 check-equal set-default-empty-group : $(v1) - $(v2) - $(v3) : z - z - z ;
867 check-equal set-set-non-empty-group : $(v1) - $(v2) - $(v3) : z - z - z ;
873 check-equal set-append-non-empty-group : $(v1) - $(v2) - $(v3) : x1 z - x2 z - x3 z ;
879 check-equal set-default-non-empty-group : $(v1) - $(v2) - $(v3) : x1 - x2 - x3 ;
885 check-equal set-set-mixed-group : $(v1) - $(v2) - $(v3) : z - z - z ;
891 check-equal set-append-mixed-group : $(v1) - $(v2) - $(v3) : x1 z - z - x3 z ;
897 check-equal set-default-mixed-group : $(v1) - $(v2) - $(v3) : x1 - z - x3 ;
903 check-equal set-set-duplicate-empty : $(v1) : z ;
906 check-equal set-append-duplicate-empty : $(v1) : z z ;
909 check-equal set-default-duplicate-empty : $(v1) : z ;
913 check-equal set-set-duplicate-non-empty : $(v1) : z ;
916 check-equal set-append-duplicate-non-empty : $(v1) : x1 z z ;
919 check-equal set-default-duplicate-non-empty : $(v1) : x1 ;
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 ;
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 ;
957 local target1 = test-settings-target1 ;
958 local target2 = test-settings-target2 ;
959 local target3 = test-settings-target3 ;
960 local targets = $(target2) $(target3) ;
962 local vars = v1 v2 v3 ;
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 ;
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 ;
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 ;
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 ;
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 ;
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 ;
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 ;
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 ;
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 ;
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 ;
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 ;
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 ;
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 ;
1039 v1 on $(target1) = ;
1040 v1 on $(target1) ?= z ;
1041 check-equal settings-default-set-but-empty : [ on $(target1) return $(v1) ] : ;
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 ;
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 ;
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 ;
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 ;
1081 case * : mark-order r1 ;
1084 check-order switch-match-any : r1 ;
1088 case v2 : mark-order r1 ;
1091 check-order switch-no-match : ;
1095 case $(pattern) : mark-order r1 ;
1098 check-order switch-no-expand : ;
1102 case value : mark-order r1 ;
1103 case * : mark-order r2 ;
1106 check-order switch-match-several : r1 ;
1108 rule test-rule ( value )
1112 case value : return 1 ;
1116 check-equal switch-result-match : [ test-rule value ] : 1 ;
1117 check-equal switch-result-match : [ test-rule v1 ] : ;
1121 case "" : mark-order r1 ;
1122 case * : mark-order r2 ;
1125 check-order switch-empty : r1 ;
1127 local values = v1 v2 v3 ;
1130 case v1 : mark-order r1 ;
1131 case v2 : mark-order r2 ;
1132 case v3 : mark-order r3 ;
1135 check-order switch-multiple : r1 ;
1137 # Test glob matching
1139 switch value { case * : mark-order r1 ; }
1140 check-order switch-glob-star : r1 ;
1142 switch value { case va*e : mark-order r1 ; }
1143 check-order switch-glob-star-1 : r1 ;
1145 switch value { case *a* : mark-order r1 ; }
1146 check-order switch-glob-star-2 : r1 ;
1148 switch value { case *a*ue* : mark-order r1 ; }
1149 check-order switch-glob-star-3 : r1 ;
1151 switch value { case *[eaiou]*ue : mark-order r1 ; }
1152 check-order switch-glob-group : r1 ;
1154 switch value { case *[eaiou]ue : mark-order r1 ; }
1155 check-order switch-glob-group-fail : ;
1157 switch value { case ?a?ue : mark-order r1 ; }
1158 check-order switch-glob-any : r1 ;
1160 switch value { case ?lue : mark-order r1 ; }
1161 check-order switch-glob-any-fail : ;
1169 local value = 1 2 3 ;
1173 mark-order r$(value[1]) ;
1174 value = $(value[2-]) ;
1177 check-order while-exec : r1 r2 r3 ;
1181 local value = 1 2 3 ;
1184 value = $(value[2-]) ;
1189 check-equal while-result : [ test-rule ] : x ;
1196 value = $(value[2-]) ;
1197 local inner = $(value) ;
1200 inner = $(inner[2-]) ;
1206 check-equal while-result-2 : [ test-rule ] : x ;
1217 local z = original ;
1228 check-order break-while-exec : r1 ;
1229 check-equal break-while-cleanup : $(z) : original ;
1231 local values = v1 v2 ;
1236 mark-order r1-$(y) ;
1238 mark-order r2-$(y) ;
1241 check-order break-for-exec : r1-v1 ;
1242 check-equal break-for-cleanup : $(z) : original ;
1244 for local y in $(values)
1247 mark-order r1-$(y) ;
1249 mark-order r2-$(y) ;
1252 check-order break-for-local-exec : r1-v1 ;
1253 check-equal break-for-local-cleanup : $(z) : original ;
1262 for local y in $(values)
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 ;
1287 local z = original ;
1289 while ! [ mark-order r1 : $(done) ]
1298 check-order continue-while-exec : r1 r2 r1 ;
1299 check-equal continue-while-cleanup : $(z) : original ;
1301 local values = v1 v2 ;
1305 mark-order r1-$(y) ;
1307 mark-order r2-$(y) ;
1310 check-order continue-for-exec : r1-v1 r1-v2 ;
1311 check-equal continue-for-cleanup : $(z) : original ;
1313 for local y in $(values)
1316 mark-order r1-$(y) ;
1318 mark-order r2-$(y) ;
1321 check-order continue-for-local-exec : r1-v1 r1-v2 ;
1322 check-equal continue-for-local-cleanup : $(z) : original ;
1327 while ! [ mark-order r1 : $(done) ]
1332 for local y in $(values)
1335 mark-order r3-$(y) ;
1337 mark-order r4-$(y) ;
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 ;
1351 # test CALLER_MODULE and backtrace
1355 local base = [ BACKTRACE ] ;
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"
1369 IMPORT_MODULE module2 : module1 ;
1372 local m = [ CALLER_MODULE ] ;
1373 check-equal caller-module-root : $(m) ;
1381 local m = [ CALLER_MODULE ] ;
1382 check-equal caller-module : module1 : $(m) ;
1386 IMPORT_MODULE module1 ;
1391 # Test NORMALIZE_PATH
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/.." ] ;
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" ] ;
1451 # Test W32_GETREGNAMES
1457 local sound = "Beep" "ExtendedSounds" ;
1458 local r1 = [ W32_GETREGNAMES "HKEY_CURRENT_USER\\Control Panel\\Sound" :
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) ] ;
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 * )
1471 for local x in $(param:L)
1473 if ! x in $(found) &&
1474 $(x) in "addservices" "policies" "deleted device ids" "software"
1485 local CurrentControlSet = "Control" "Enum" "Hardware Profiles" "Services" ;
1486 local r3 = [ W32_GETREGNAMES "HKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet"
1488 check-equal w32_getregnames : $(CurrentControlSet:L) : [ remove-policies
1490 local r4 = [ W32_GETREGNAMES "HKLM\\SYSTEM\\CurrentControlSet" : subkeys ] ;
1491 check-equal w32_getregnames : $(CurrentControlSet:L) : [ remove-policies
1501 local c = "echo value" ;
1502 if $(OS) = VMS { c = "PIPE WRITE SYS$OUTPUT \"value\"" ; }
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 shell : "" 0 : [ SHELL $(c) : no-output : exit-status : strip-eol ] ;
1509 check-equal command : "value\n" : [ COMMAND $(c) ] ;
1510 check-equal command : "" : [ COMMAND $(c) : no-output ] ;
1511 check-equal command : "value\n" 0 : [ COMMAND $(c) : exit-status ] ;
1512 check-equal command : "" 0 : [ COMMAND $(c) : no-output : exit-status ] ;
1516 local expected = "When the shell output buffer splits on whitespace, the whitespace shouldn't be trimmed. end." ;
1517 local buffered = "echo \"$(expected)\"" ;
1518 if $(OS) = VMS { buffered = "PIPE WRITE SYS$OUTPUT \"$(expected)\"" ; }
1519 if $(OS) = NT { buffered = "echo $(expected)" ; }
1521 check-equal shell : "$(expected)\n" : [ SHELL $(buffered) ] ;
1522 check-equal shell : "" : [ SHELL $(buffered) : no-output ] ;
1523 check-equal shell : "$(expected)\n" 0 : [ SHELL $(buffered) : exit-status ] ;
1524 check-equal shell : "$(expected)" 0 : [ SHELL $(buffered) : strip-eol : exit-status ] ;
1525 check-equal shell : "" 0 : [ SHELL $(buffered) : no-output : exit-status ] ;
1526 check-equal shell : "" 0 : [ SHELL $(buffered) : no-output : exit-status : strip-eol ] ;
1527 check-equal shell : "$(expected)" 0 : [ SHELL $(buffered) : strip-eol : exit-status ] ;
1529 check-equal command : "$(expected)\n" : [ COMMAND $(buffered) ] ;
1530 check-equal command : "" : [ COMMAND $(buffered) : no-output ] ;
1531 check-equal command : "$(expected)\n" 0 : [ COMMAND $(buffered) : exit-status ] ;
1532 check-equal command : "$(expected)" 0 : [ COMMAND $(buffered) : strip-eol : exit-status ] ;
1533 check-equal command : "" 0 : [ COMMAND $(buffered) : no-output : exit-status ] ;
1541 # Check that unmatched subst returns an empty list
1542 check-equal subst-nomatch : [ SUBST "abc" "d+" x ] : ;
1544 # Check that a matched subst works
1545 check-equal subst-match : [ SUBST "ddd" "d+" x ] : x ;
1547 # Check that we can get multiple substitutions from a single invocation
1548 check-equal subst-multiple : [ SUBST "x/y/z" "([^/]*)/([^/]*).*" "\\1" $2 "\\1-\\2" ] : x y x-y ;
1563 EXIT $(passed) passed $(failed) failed : $(status) ;