Debian Codegraph @

testsuite/config/base-config.exp

raw
1 ##############################################################################
2 # Modules Revision 3.0
3 # Providing a flexible user environment
4 #
5 # File: config/%M%
6 # Revision: %I%
7 # First Edition: 2020/12/05
8 # Last Mod.: %U%, %G%
9 #
10 # Authors: Xavier Delaruelle, [email protected]
11 #
12 # Description: Testuite initialization
13 # Command:
14 # Sub-Command:
15 #
16 # Comment: %C{
17 # Initialization of the testsuite. Definition of
18 # globally used start procedures for the test
19 # target.
20 # }C%
21 #
22 ##############################################################################
23
24 #
25 # Shell conversion code subprocedures
26 #
27
28 proc shell_err {test_shell {nb_err 1} {re_mode 0}} {
29 if {$re_mode} {
30 set esc "\\"
31 set nb "\\d"
32 } else {
33 set esc ""
34 set nb $nb_err
35 }
36
37 switch -- $test_shell {
38 {sh} - {bash} - {ksh} - {zsh} - {csh} - {tcsh} - {fish} {
39 set answer "test 0 = 1;"
40 }
41 {tcl} {
42 set answer "set _mlstatus 0;"
43 }
44 {cmd} {
45 set answer "set errorlevel=1"
46 }
47 {perl} {
48 set answer "{ no strict 'vars'; ${esc}\$_mlstatus = 0; }"
49 }
50 {python} {
51 set answer "_mlstatus = False"
52 }
53 {ruby} {
54 set answer "_mlstatus = false"
55 }
56 {lisp} {
57 set answer "nil"
58 }
59 {cmake} {
60 set answer "set${esc}(_mlstatus FALSE${esc})"
61 }
62 {r} {
63 set answer "mlstatus <- FALSE"
64 }
65 {pwsh} {
66 set answer "Set-Variable -Name \"_mlstatus\" -Value ${esc}\$false -Scope Global"
67 }
68 default {
69 set answer ""
70 }
71 }
72
73 return $answer
74 }
75
76 proc shell_ok {test_shell {re_mode 0}} {
77 if {$re_mode} {
78 set esc "\\"
79 } else {
80 set esc ""
81 }
82
83 switch -- $test_shell {
84 {sh} - {bash} - {ksh} - {zsh} - {csh} - {tcsh} - {fish} {
85 set answer "test 0;"
86 }
87 {tcl} {
88 set answer "set _mlstatus 1;"
89 }
90 {cmd} {
91 set answer "set errorlevel=0"
92 }
93 {python} {
94 set answer "_mlstatus = True"
95 }
96 {ruby} {
97 set answer "_mlstatus = true"
98 }
99 {perl} {
100 set answer "{ no strict 'vars'; ${esc}\$_mlstatus = 1; }"
101 }
102 {lisp} {
103 set answer "t"
104 }
105 {cmake} {
106 set answer "set${esc}(_mlstatus TRUE${esc})"
107 }
108 {r} {
109 set answer "mlstatus <- TRUE"
110 }
111 {pwsh} {
112 set answer "Set-Variable -Name \"_mlstatus\" -Value ${esc}\$true -Scope Global"
113 }
114 default {
115 set answer ""
116 }
117 }
118
119 return $answer
120 }
121
122 proc shell_text {test_shell val {re_mode 0}} {
123 if {$re_mode} {
124 set esc "\\"
125 } else {
126 set esc ""
127 }
128
129 switch -- $test_shell {
130 {sh} - {bash} - {ksh} - {zsh} - {csh} - {tcsh} - {fish} {
131 foreach word $val {
132 if {[info exists answer]} {
133 append answer "\n"
134 }
135 append answer "echo '$word';"
136 }
137 if {![info exists answer]} {
138 set answer ""
139 }
140 }
141 {tcl} {
142 set answer "set _mlstatus \"$val\";"
143 }
144 {cmd} {
145 foreach word $val {
146 if {[info exists answer]} {
147 append answer "\n"
148 }
149 append answer "echo $word"
150 }
151 if {![info exists answer]} {
152 set answer ""
153 }
154 }
155 {python} {
156 set answer "_mlstatus = '$val'"
157 }
158 {ruby} {
159 set answer "_mlstatus = '$val'"
160 }
161 {perl} {
162 set answer "{ no strict 'vars'; ${esc}\$_mlstatus = '$val'; }"
163 }
164 {lisp} {
165 set answer "${esc}(message \"$val\"${esc})"
166 }
167 {cmake} {
168 set answer "set${esc}(_mlstatus \"$val\"${esc})"
169 }
170 {r} {
171 set answer "mlstatus <- '$val'"
172 }
173 {pwsh} {
174 set answer "Set-Variable -Name \"_mlstatus\" -Value '$val' -Scope Global"
175 }
176 default {
177 set answer ""
178 }
179 }
180
181 if {$re_mode} {
182 # over escape regexp-special characters
183 set answer [regsub -all {([$.+?*\\()&|])} $answer {\\\1}]
184 }
185
186 return $answer
187 }
188
189 proc shell_val {test_shell val {re_mode 0} {alias_val 0}} {
190 if {$val ne "(.*)"} {
191 if {$alias_val && $test_shell in {sh bash ksh zsh fish}} {
192 set test_shell a-$test_shell
193 }
194 switch -- $test_shell {
195 {a-sh} - {a-bash} - {csh} - {tcsh} - {a-ksh} - {a-zsh} - {a-fish} {
196 set val [regsub -all {([\\"'$|<>{}`*? ()!&;\[\]])} $val {\\\1}]
197 }
198 {lisp} - {cmake} {
199 set val [regsub -all {(["])} $val {\\\1}]
200 }
201 {sh} - {bash} - {ksh} - {zsh} {
202 set val [string map {' '\\''} $val]
203 }
204 {fish} - {perl} - {python} - {ruby} {
205 set val [regsub -all {(['])} $val {\\\1}]
206 }
207 {r} {
208 set val [regsub -all {([\\'])} $val {\\\1}]
209 }
210 }
211
212 if {$re_mode} {
213 # over escape regexp-special characters
214 set val [regsub -all {([$.+?*\\()&|])} $val {\\\1}]
215 }
216 }
217
218 return $val
219 }
220
221 proc shell_set {test_shell var val {re_mode 0} {escval 1}} {
222 if {$re_mode} {
223 set esc "\\"
224 } else {
225 set esc ""
226 }
227
228 if {$escval} {
229 set val [shell_val $test_shell $val $re_mode]
230 }
231
232 switch -- $test_shell {
233 {sh} - {bash} - {ksh} - {zsh} {
234 set answer "$var='$val'; export $var;"
235 }
236 {csh} - {tcsh} {
237 set answer "setenv $var $val;"
238 }
239 {fish} {
240 if {$var eq "PATH"} {
241 set val [join [split $val :] {' '}]
242 }
243 set answer "set -xg $var '$val';"
244 }
245 {tcl} {
246 set answer "set ::env${esc}($var${esc}) ${esc}{$val${esc}};"
247 }
248 {cmd} {
249 set answer "set $var=$val"
250 }
251 {perl} {
252 set answer "${esc}\$ENV{'$var'} = '$val';"
253 }
254 {python} {
255 set answer "os.environ${esc}\['$var'${esc}\] = '$val'"
256 }
257 {ruby} {
258 set answer "ENV${esc}\['$var'${esc}\] = '$val'"
259 }
260 {lisp} {
261 set answer "${esc}(setenv \"$var\" \"$val\"${esc})"
262 }
263 {cmake} {
264 set answer "set${esc}(ENV{$var} \"$val\"${esc})"
265 }
266 {r} {
267 set answer "Sys.setenv${esc}('$var'='$val'${esc})"
268 }
269 {pwsh} {
270 set answer "${esc}\$env:$var = '$val'"
271 }
272 default {
273 set answer ""
274 }
275 }
276
277 return $answer
278 }
279
280 proc shell_unset {test_shell var {re_mode 0}} {
281 if {$re_mode} {
282 set esc "\\"
283 } else {
284 set esc ""
285 }
286
287 switch -- $test_shell {
288 {sh} - {bash} - {ksh} - {zsh} {
289 set answer "unset $var;"
290 }
291 {csh} - {tcsh} {
292 set answer "unsetenv $var;"
293 }
294 {fish} {
295 set answer "set -e $var;"
296 }
297 {tcl} {
298 set answer "catch {unset ::env${esc}($var${esc})};"
299 }
300 {cmd} {
301 set answer "set $var="
302 }
303 {perl} {
304 set answer "delete ${esc}\$ENV{'$var'};"
305 }
306 {python} {
307 set answer "os.environ${esc}\['$var'${esc}\] = ''\n"
308 append answer "del os.environ${esc}\['$var'${esc}\]"
309 }
310 {ruby} {
311 set answer "ENV${esc}\['$var'${esc}\] = nil"
312 }
313 {lisp} {
314 set answer "${esc}(setenv \"$var\" nil${esc})"
315 }
316 {cmake} {
317 set answer "unset${esc}(ENV{$var}${esc})"
318 }
319 {r} {
320 set answer "Sys.unsetenv${esc}('$var'${esc})"
321 }
322 {pwsh} {
323 set answer "Remove-Item -Path env:$var -ErrorAction SilentlyContinue"
324 }
325 default {
326 set answer ""
327 }
328 }
329
330 return $answer
331 }
332
333 proc shell_alias {test_shell var val {re_mode 0} {escval 1}} {
334 if {$escval} {
335 set val [shell_val $test_shell $val $re_mode 1]
336 }
337
338 switch -- $test_shell {
339 {sh} - {bash} - {ksh} - {zsh} {
340 set answer "alias $var=$val;"
341 }
342 {csh} - {tcsh} - {fish} {
343 set answer "alias $var $val;"
344 }
345 {cmd} {
346 set answer "doskey $var=$val"
347 }
348 {pwsh} {
349 set answer "function global:$var { $val }"
350 }
351 default {
352 set answer ""
353 }
354 }
355
356 return $answer
357 }
358
359 proc shell_unalias {test_shell var {re_mode 0}} {
360 switch -- $test_shell {
361 {sh} - {bash} - {ksh} - {zsh} {
362 set answer "unalias $var 2>/dev/null || true;"
363 }
364 {csh} - {tcsh} {
365 set answer "unalias $var;"
366 }
367 {fish} {
368 set answer "functions -e $var;"
369 }
370 {cmd} {
371 set answer "doskey $var="
372 }
373 {pwsh} {
374 set answer "Remove-Item -Path function:$var -ErrorAction SilentlyContinue"
375 }
376 default {
377 set answer ""
378 }
379 }
380
381 return $answer
382 }
383
384 proc shell_chdir {test_shell val {re_mode 0}} {
385 if {$re_mode} {
386 set esc "\\"
387 } else {
388 set esc ""
389 }
390
391 switch -- $test_shell {
392 {sh} - {bash} - {ksh} - {zsh} - {csh} - {tcsh} - {fish} {
393 set answer "cd '$val';"
394 }
395 {tcl} {
396 set answer "cd \"$val\";"
397 }
398 {cmd} {
399 set answer "cd $val"
400 }
401 {perl} {
402 set answer "chdir '$val';"
403 }
404 {python} {
405 set answer "os.chdir${esc}('$val'${esc})"
406 }
407 {ruby} {
408 set answer "Dir.chdir${esc}('$val'${esc})"
409 }
410 {lisp} {
411 set answer "${esc}(shell-command-to-string \"cd '$val'\"${esc})"
412 }
413 {r} {
414 set answer "setwd${esc}('$val'${esc})"
415 }
416 {pwsh} {
417 set answer "Set-Location '$val'"
418 }
419 default {
420 set answer ""
421 }
422 }
423
424 return $answer
425 }
426
427 proc shell_xres {test_shell var val {re_mode 0}} {
428 if {$re_mode} {
429 set esc "\\"
430 } else {
431 set esc ""
432 }
433 set xrdb [auto_execok xrdb]
434
435 switch -- $test_shell {
436 {sh} - {bash} - {ksh} - {zsh} - {csh} - {tcsh} - {fish} {
437 if {$val ne ""} {
438 set answer "echo \"$var: $val\" ${esc}| $xrdb -merge;"
439 } else {
440 set answer "$xrdb -merge $var;"
441 }
442 }
443 {tcl} {
444 if {$val ne ""} {
445 set answer "set XRDBPIPE ${esc}\[open \"${esc}|$xrdb -merge\" r${esc}+${esc}\];\n"
446 append answer "puts ${esc}\$XRDBPIPE \"$var: $val\";\n"
447 append answer "close ${esc}\$XRDBPIPE;\n"
448 append answer "unset XRDBPIPE;"
449 } else {
450 set answer "exec $xrdb -merge $var;"
451 }
452 }
453 {perl} {
454 if {$val ne ""} {
455 set answer "open${esc}(XRDBPIPE, \"${esc}|$xrdb -merge\"${esc});\n"
456 append answer "print XRDBPIPE \"$var: $val${esc}\\n\";\n"
457 append answer "close XRDBPIPE;"
458 } else {
459 set answer "system${esc}(\"$xrdb -merge $var\"${esc});"
460 }
461 }
462 {python} {
463 if {$val ne ""} {
464 set answer "subprocess.Popen${esc}(${esc}\['$xrdb', '-merge'${esc}\], stdin=subprocess.PIPE${esc}).communicate${esc}(input=\'$var: $val${esc}\\n\'${esc})"
465 } else {
466 set answer "subprocess.Popen${esc}(${esc}\['$xrdb', '-merge', '$var'${esc}\]${esc})"
467 }
468 }
469 {ruby} {
470 if {$val ne ""} {
471 set answer "Open3.popen2${esc}('$xrdb -merge'${esc}) {${esc}|i,o,t${esc}| i.puts '$var: $val'}"
472 } else {
473 set answer "Open3.popen2${esc}('$xrdb -merge $var'${esc})"
474 }
475 }
476 {lisp} {
477 if {$val ne ""} {
478 set answer "${esc}(shell-command-to-string \"echo $var: $val ${esc}| $xrdb -merge\"${esc})"
479 } else {
480 set answer "${esc}(shell-command-to-string \"$xrdb -merge $var\"${esc})"
481 }
482 }
483 {cmake} {
484 if {$val ne ""} {
485 set answer "execute_process${esc}(COMMAND echo \"$var: $val\" COMMAND $xrdb -merge${esc})"
486 } else {
487 set answer "execute_process${esc}(COMMAND $xrdb -merge $var${esc})"
488 }
489 }
490 {r} {
491 if {$val ne ""} {
492 set answer "system${esc}('$xrdb -merge', input='$var: $val'${esc})"
493 } else {
494 set answer "system${esc}('$xrdb -merge $var'${esc})"
495 }
496 }
497 default {
498 set answer ""
499 }
500 }
501
502 return $answer
503 }
504
505 proc shell_unxres {test_shell var {re_mode 0}} {
506 if {$re_mode} {
507 set esc "\\"
508 } else {
509 set esc ""
510 }
511 set xrdb [auto_execok xrdb]
512
513 switch -- $test_shell {
514 {sh} - {bash} - {ksh} - {zsh} - {csh} - {tcsh} - {fish} {
515 set answer "echo \"$var:\" ${esc}| $xrdb -merge;"
516 }
517 {tcl} {
518 set answer "set XRDBPIPE ${esc}\[open \"${esc}|$xrdb -merge\" r${esc}+${esc}\];\n"
519 append answer "puts ${esc}\$XRDBPIPE \"$var:\";\n"
520 append answer "close ${esc}\$XRDBPIPE;\n"
521 append answer "unset XRDBPIPE;"
522 }
523 {perl} {
524 set answer "open${esc}(XRDBPIPE, \"${esc}|$xrdb -merge\"${esc});\n"
525 append answer "print XRDBPIPE \"$var:${esc}\\n\";\n"
526 append answer "close XRDBPIPE;"
527 }
528 {python} {
529 set answer "subprocess.Popen${esc}(${esc}\['$xrdb', '-merge'${esc}\], stdin=subprocess.PIPE${esc}).communicate${esc}(input=\'$var:${esc}\\n\'${esc})"
530 }
531 {ruby} {
532 set answer "Open3.popen2${esc}('$xrdb -merge'${esc}) {${esc}|i,o,t${esc}| i.puts '$var:'}"
533 }
534 {lisp} {
535 set answer "${esc}(shell-command-to-string \"echo $var: ${esc}| $xrdb -merge\"${esc})"
536 }
537 {cmake} {
538 set answer "execute_process${esc}(COMMAND echo \"$var:\" COMMAND $xrdb -merge${esc})"
539 }
540 {r} {
541 set answer "system${esc}('$xrdb -merge', input='$var:'${esc})"
542 }
543 default {
544 set answer ""
545 }
546 }
547
548 return $answer
549 }
550
551
552 proc shell_out {test_shell out_list {re_mode 0} {auto_status 1}} {
553 set answer_list {}
554 set fixed_list {}
555 array set envvar {}
556 array set envalias {}
557 array set envxres {}
558 array set envunxres {}
559 array set autovar {}
560 set status_set 0
561
562 foreach out $out_list {
563 lassign $out cmd var val extra
564 switch -- $cmd {
565 {set} {
566 if {$extra eq "noescval"} {
567 set escval 0
568 } else {
569 set escval 1
570 }
571 set envvar($var) [shell_set $test_shell $var $val $re_mode $escval]
572 lappend answer_list $envvar($var)
573
574 # automatic specification of ref counter var is removed if set
575 if {[info exists autovar($var)]} {
576 unset autovar($var)
577 }
578 }
579 {setpath} {
580 set envvar($var) [shell_set $test_shell $var $val $re_mode]
581 lappend answer_list $envvar($var)
582
583 # automatically set ref counter variable if not specified
584 set sharevar __MODULES_SHARE_$var
585 if {![info exists envvar($sharevar)]} {
586 if {$re_mode} {
587 set envvar($sharevar) [shell_set $test_shell $sharevar "(.*)" $re_mode]
588 } else {
589 # set a default value when not in re mode
590 set envvar($sharevar) [shell_set $test_shell $sharevar "$val:1" $re_mode]
591 }
592 set autovar($sharevar) 1
593 }
594 }
595 {unset} {
596 set envvar($var) [shell_unset $test_shell $var $re_mode]
597 lappend answer_list $envvar($var)
598
599 # automatic specification of ref counter var is removed if set
600 if {[info exists autovar($var)]} {
601 unset autovar($var)
602 }
603 }
604 {unsetpath} {
605 set envvar($var) [shell_unset $test_shell $var $re_mode]
606 lappend answer_list $envvar($var)
607
608 # automatically set ref counter variable if not specified
609 set sharevar __MODULES_SHARE_$var
610 if {![info exists envvar($sharevar)]} {
611 set envvar($sharevar) [shell_unset $test_shell $sharevar $re_mode]
612 set autovar($sharevar) 1
613 }
614 }
615 {alias} {
616 set ret [shell_alias $test_shell $var $val $re_mode]
617 if {$ret ne ""} {
618 set envalias($var) $ret
619 lappend answer_list $ret
620 }
621 }
622 {unalias} {
623 set ret [shell_unalias $test_shell $var $re_mode]
624 if {$ret ne ""} {
625 set envalias($var) $ret
626 lappend answer_list $ret
627 }
628 }
629 {chdir} {
630 set ret [shell_chdir $test_shell $var $re_mode]
631 if {$ret ne ""} {
632 lappend fixed_list $ret
633 lappend answer_list $ret
634 }
635 }
636 {xres} {
637 set ret [shell_xres $test_shell $var $val $re_mode]
638 if {$ret ne ""} {
639 set envxres($var) $ret
640 lappend answer_list $ret
641 }
642 }
643 {unxres} {
644 set ret [shell_unxres $test_shell $var $re_mode]
645 if {$ret ne ""} {
646 # add element with xres filename as array key for
647 # correct sorting when rendering
648 if {$val ne ""} {
649 if {[info exists envunxres($val)]} {
650 set ret "\n$ret"
651 }
652 append envunxres($val) $ret
653 } else {
654 set envunxres($var) $ret
655 }
656 lappend answer_list $ret
657 }
658 }
659 {text} {
660 lappend fixed_list [shell_text $test_shell $var $re_mode]
661 lappend answer_list [lindex $fixed_list end]
662 set status_set 1
663 }
664 {OK} {
665 lappend fixed_list [shell_ok $test_shell $re_mode]
666 lappend answer_list [lindex $fixed_list end]
667 set status_set 1
668 }
669 {ERR} {
670 lappend fixed_list [shell_err $test_shell 1 $re_mode]
671 lappend answer_list [lindex $fixed_list end]
672 set status_set 1
673 }
674 {ERR2} {
675 lappend fixed_list [shell_err $test_shell 2 $re_mode]
676 lappend answer_list [lindex $fixed_list end]
677 set status_set 1
678 }
679 {out} {
680 lappend fixed_list [join [lrange $out 1 end]]
681 lappend answer_list [lindex $fixed_list end]
682 }
683 default {
684 lappend fixed_list [join $out]
685 lappend answer_list [lindex $fixed_list end]
686 }
687 }
688 }
689
690 # specific order if var have been automatically set
691 if {[array size autovar] || [array size envxres] || [array size\
692 envunxres]} {
693 set answer_list {}
694 foreach var [array names envvar] {
695 lappend answer_list $envvar($var)
696 }
697 foreach var [array names envalias] {
698 lappend answer_list $envalias($var)
699 }
700 if {[array size envxres] || [array size envunxres]} {
701 switch -- $test_shell {
702 {python} {
703 lappend answer_list "import subprocess"
704 }
705 {ruby} {
706 lappend answer_list "require 'open3'"
707 }
708 }
709 }
710 foreach var [array names envxres] {
711 lappend answer_list $envxres($var)
712 }
713 foreach var [array names envunxres] {
714 lappend answer_list $envunxres($var)
715 }
716 set answer_list [concat $answer_list $fixed_list]
717 }
718
719
720 if {$test_shell eq "python"} {
721 set answer_list [concat [list "import os"] $answer_list]
722 }
723
724 # add automatic status if any for shell
725 if {$auto_status && !$status_set && [llength $answer_list]} {
726 lappend answer_list [shell_ok $test_shell $re_mode]
727 }
728
729 set answer [join $answer_list "\n"]
730
731 return $answer
732 }
733
734 proc is_shell_out_list {answer} {
735 set ret 0
736
737 if {[string is list $answer]} {
738 foreach item $answer {
739 if {[llength $item] > 1} {
740 switch -- [lindex $item 0] {
741 set - setpath - unset - unsetpath - alias - unalias - out\
742 - text - OK {
743 set ret 1
744 break
745 }
746 }
747 }
748 }
749 }
750
751 return $ret
752 }
753
754 #
755 # Test subprocedures
756 #
757
758 proc _test_err {test_shell cmd answer failcmd} {
759 global comp_error
760 global verbose
761
762 # newline is expected at end of answer
763 if {$answer ne {} && $answer ne "\n"} {
764 append answer \n
765 }
766 if { $comp_error != "$answer" } {
767 $failcmd "$cmd ($test_shell)"
768 set ol [string length $comp_error]
769 set oe [string length $answer]
770 send_user "ERR\[$ol\]: '$comp_error'#>\n"
771 send_user "EXP\[$oe\]: '$answer'#>\n"
772 return 0;
773 } else {
774 return 1;
775 }
776 }
777
778 proc _test_err_re {test_shell cmd answer force_nl failcmd} {
779 global comp_error
780 global verbose
781
782 # newline is expected at end of answer unless empty or specific regexp set
783 if {$force_nl || ($answer ne {} && $answer ne "\n" && $answer ne "^\$" &&\
784 $answer ne {.*} && ([string index $answer 0] ne {(} || [string index\
785 $answer end] ne {)}))} {
786 append answer \n
787 }
788 set answer "^$answer\$"
789 if { ![regexp -- $answer $comp_error] } {
790 $failcmd "$cmd ($test_shell)"
791 set ol [string length $comp_error]
792 set oe [string length $answer]
793 send_user "ERR\[$ol\]: '$comp_error'#>\n"
794 send_user "EXP\[$oe\]: '$answer'#>\n"
795 return 0;
796 } else {
797 return 1;
798 }
799 }
800
801 proc _test_err_re_sort {test_shell cmd answer failcmd} {
802 global comp_error
803 global verbose
804
805 # newline is expected at end of answer
806 if {$answer ne {} && $answer ne "\n"} {
807 append answer \n
808 }
809
810 set comp_error_sort [join [lsort [split $comp_error \n]] \n]
811 set answer_sort [join [lsort [split $answer \n]] \n]
812 set answer_sort "^$answer_sort\$"
813
814 if {![regexp -- $answer_sort $comp_error_sort]} {
815 $failcmd "$cmd ($test_shell)"
816 set ol [string length $comp_error_sort]
817 set oe [string length $answer_sort]
818 send_user "ERR\[$ol\]: '$comp_error_sort'#>\n"
819 send_user "EXP\[$oe\]: '$answer_sort'#>\n"
820 return 0;
821 } else {
822 return 1;
823 }
824 }
825
826 proc _test_out {test_shell cmd answer failcmd} {
827 global comp_output
828 global verbose
829
830 if {[is_shell_out_list $answer]} {
831 set answer [shell_out $test_shell $answer]
832 } elseif {$answer eq "ERR"} {
833 set answer [shell_err $test_shell]
834 } elseif {$answer eq "ERR2"} {
835 set answer [shell_err $test_shell 2]
836 } elseif {$answer eq "OK"} {
837 # just OK means no output
838 set answer ""
839 }
840 # newline is expected at end of answer
841 if {$answer ne {} && $answer ne "\n"} {
842 append answer \n
843 }
844
845 if { $comp_output != "$answer" } {
846 $failcmd "$cmd ($test_shell)"
847 set ol [string length $comp_output]
848 set oe [string length $answer]
849 send_user "OUT\[$ol\]: '$comp_output'#>\n"
850 send_user "EXP\[$oe\]: '$answer'#>\n"
851 return 0;
852 } else {
853 return 1;
854 }
855 }
856
857 proc _test_out_re {test_shell cmd answer failcmd} {
858 global comp_output
859 global verbose
860
861 if {[is_shell_out_list $answer]} {
862 set answer [shell_out $test_shell $answer 1]
863 } elseif {$answer eq "ERR"} {
864 set answer [shell_err $test_shell 1 1]
865 } elseif {$answer eq "ERR2"} {
866 set answer [shell_err $test_shell 2 1]
867 } elseif {$answer eq "OK"} {
868 # just OK means no output
869 set answer ""
870 }
871 # newline is expected at end of answer
872 if {$answer ne {} && $answer ne "\n" && $answer ne "^\$" && [string index\
873 $answer end] ne "\$"} {
874 append answer \n
875 }
876
877 set answer "^$answer\$"
878 if { ![regexp -- $answer $comp_output] } {
879 $failcmd "$cmd ($test_shell)"
880 set ol [string length $comp_output]
881 set oe [string length $answer]
882 send_user "OUT\[$ol\]: '$comp_output'#>\n"
883 send_user "EXP\[$oe\]: '$answer'#>\n"
884 return 0;
885 } else {
886 return 1;
887 }
888 }
889
890 proc _test_file {test_shell cmd filepath answer failcmd} {
891 global verbose
892
893 catch {
894 set fd [open $filepath]
895 read -nonewline $fd
896 } comp_file
897 catch { close $fd }
898
899 if { $comp_file != "$answer" } {
900 $failcmd "$cmd ($test_shell)"
901 set ol [string length $comp_file]
902 set oe [string length $answer]
903 send_user "FILE\[$ol\]: '$comp_file'#>\n"
904 send_user "EXP\[$oe\]: '$answer'#>\n"
905 return 0;
906 } else {
907 return 1;
908 }
909 }
910
911 proc _test_globlist {test_shell cmd fileglob answer failcmd} {
912 global verbose
913
914 set globlist [lsort [glob -nocomplain $fileglob]]
915
916 if { $globlist ne $answer } {
917 $failcmd "$cmd ($test_shell)"
918 set ol [string length $globlist]
919 set oe [string length $answer]
920 send_user "GLOBLIST\[$ol\]: '$globlist'#>\n"
921 send_user "EXP\[$oe\]: '$answer'#>\n"
922 return 0;
923 } else {
924 return 1;
925 }
926 }
927
928 proc _test_exit {test_shell cmd exitval failcmd} {
929 global comp_exit
930 global verbose
931
932 if { $comp_exit != "$exitval" } {
933 $failcmd "$cmd ($test_shell)"
934 send_user "EXIT: '$comp_exit'#>\n"
935 send_user "EXP: '$exitval'#>\n"
936 return 0;
937 } else {
938 return 1;
939 }
940 }
941
942 proc _test_ok {test_shell cmd} {
943 pass "$cmd ($test_shell)"
944 }
945
946 #
947 # Test procedure for matching with regular expressions
948 #
949
950 proc test_cmd_re {test_shell cmd answer {failcmd {fail}} {launcher {}}} {
951 if {$test_shell eq "ALL"} {
952 global supported_shells
953 foreach shell $supported_shells {
954 test_cmd_re $shell $cmd $answer $failcmd $launcher
955 }
956 } else {
957 _test_sub $test_shell $cmd noinput $launcher
958 if { [_test_out_re $test_shell "$cmd" "$answer" $failcmd] } {
959 _test_ok $test_shell "$cmd"
960 }
961 }
962 }
963
964 #
965 # Test procedure for full text matching
966 #
967
968 proc test_cmd {test_shell cmd answer {exitval 0} {failcmd {fail}} {launcher {}}} {
969 if {$test_shell eq "ALL"} {
970 global supported_shells
971 foreach shell $supported_shells {
972 test_cmd $shell $cmd $answer $exitval $failcmd $launcher
973 }
974 } else {
975 _test_sub $test_shell $cmd noinput $launcher
976 if { [_test_out $test_shell "$cmd" "$answer" $failcmd]
977 && [_test_exit $test_shell "$cmd" "$exitval" $failcmd] } {
978 _test_ok $test_shell "$cmd"
979 }
980 }
981 }
982
983 #
984 # Test procedure for matching with regular expressions in the error output
985 #
986
987 proc testerr_cmd_re {test_shell cmd answer {force_nl 0} {failcmd {fail}} {launcher {}}} {
988 if {$test_shell eq "ALL"} {
989 global supported_shells
990 foreach shell $supported_shells {
991 testerr_cmd_re $shell $cmd $answer $force_nl $failcmd $launcher
992 }
993 } else {
994 _test_sub $test_shell $cmd noinput $launcher
995 if { [_test_err_re $test_shell $cmd $answer $force_nl $failcmd] } {
996 _test_ok $test_shell "$cmd"
997 }
998 }
999 }
1000
1001 #
1002 # Test procedure for matching with regular expressions in the stderr/stdout
1003 #
1004
1005 proc testall_cmd_re {test_shell cmd answer anserr exitval {force_nl 0} {failcmd {fail}} {launcher {}}} {
1006 if {$test_shell eq {ALL}} {
1007 global supported_shells
1008 foreach shell $supported_shells {
1009 testall_cmd_re $shell $cmd $answer $anserr $exitval $force_nl $failcmd $launcher
1010 }
1011 } else {
1012 _test_sub $test_shell $cmd noinput $launcher
1013 if { [_test_out_re $test_shell "$cmd" "$answer" $failcmd]
1014 && [_test_err_re $test_shell "$cmd" "$anserr" $force_nl $failcmd]
1015 && [_test_exit $test_shell "$cmd" "$exitval" $failcmd] } {
1016 _test_ok $test_shell "$cmd"
1017 }
1018 }
1019 }
1020
1021 proc testouterr_cmd_re {test_shell cmd answer anserr {force_nl 0} {failcmd {fail}} {launcher {}}} {
1022 if {$test_shell eq "ALL"} {
1023 global supported_shells
1024 foreach shell $supported_shells {
1025 testouterr_cmd_re $shell $cmd $answer $anserr $force_nl $failcmd $launcher
1026 }
1027 } else {
1028 _test_sub $test_shell $cmd noinput $launcher
1029 if { [_test_out_re $test_shell "$cmd" "$answer" $failcmd]
1030 && [_test_err_re $test_shell $cmd $anserr $force_nl $failcmd] } {
1031 _test_ok $test_shell "$cmd"
1032 }
1033 }
1034 }
1035
1036 #
1037 # Test procedure for full text matching in the error output
1038 #
1039
1040 proc testerr_cmd {test_shell cmd answer {failcmd {fail}} {launcher {}}} {
1041 if {$test_shell eq "ALL"} {
1042 global supported_shells
1043 foreach shell $supported_shells {
1044 testerr_cmd $shell $cmd $answer $failcmd $launcher
1045 }
1046 } else {
1047 _test_sub $test_shell $cmd noinput $launcher
1048 if { [_test_err $test_shell "$cmd" "$answer" $failcmd] } {
1049 _test_ok $test_shell "$cmd"
1050 }
1051 }
1052 }
1053
1054 #
1055 # Test procedure for full text matching with the stderr/stdout and text passed to stdin
1056 #
1057
1058 proc testinouterr_cmd {test_shell cmd input answer anserr {failcmd {fail}} {launcher {}}} {
1059 if {$test_shell eq "ALL"} {
1060 global supported_shells
1061 foreach shell $supported_shells {
1062 testinouterr_cmd $shell $cmd $input $answer $anserr $failcmd $launcher
1063 }
1064 } else {
1065 _test_sub $test_shell $cmd $input $launcher
1066 if { [_test_out $test_shell "$cmd << $input" "$answer" $failcmd]
1067 && [_test_err $test_shell "$cmd << $input" "$anserr" $failcmd] } {
1068 _test_ok $test_shell "$cmd << $input"
1069 }
1070 }
1071 }
1072
1073 #
1074 # Test procedure for full text matching with the stderr/stdout
1075 #
1076
1077 proc testall_cmd {test_shell cmd answer anserr exitval {failcmd {fail}} {launcher {}}} {
1078 if {$test_shell eq {ALL}} {
1079 global supported_shells
1080 foreach shell $supported_shells {
1081 testall_cmd $shell $cmd $answer $anserr $exitval $failcmd $launcher
1082 }
1083 } else {
1084 _test_sub $test_shell $cmd noinput $launcher
1085 if { [_test_out $test_shell "$cmd" "$answer" $failcmd]
1086 && [_test_err $test_shell "$cmd" "$anserr" $failcmd]
1087 && [_test_exit $test_shell "$cmd" "$exitval" $failcmd] } {
1088 _test_ok $test_shell "$cmd"
1089 }
1090 }
1091 }
1092
1093 proc testouterr_cmd {test_shell cmd answer anserr {failcmd {fail}} {launcher {}}} {
1094 if {$test_shell eq "ALL"} {
1095 global supported_shells
1096 foreach shell $supported_shells {
1097 testouterr_cmd $shell $cmd $answer $anserr $failcmd $launcher
1098 }
1099 } else {
1100 _test_sub $test_shell $cmd noinput $launcher
1101 if { [_test_out $test_shell "$cmd" "$answer" $failcmd]
1102 && [_test_err $test_shell "$cmd" "$anserr" $failcmd] } {
1103 _test_ok $test_shell "$cmd"
1104 }
1105 }
1106 }
1107
1108 #
1109 # Test procedure for matching with regular expressions in the stdout and sorted stderr
1110 #
1111
1112 proc testouterr_cmd_re_sort {test_shell cmd answer anserr {failcmd {fail}} {launcher {}}} {
1113 if {$test_shell eq "ALL"} {
1114 global supported_shells
1115 foreach shell $supported_shells {
1116 testouterr_cmd_re_sort $shell $cmd $answer $anserr $failcmd $launcher
1117 }
1118 } else {
1119 _test_sub $test_shell $cmd noinput $launcher
1120 if { [_test_out_re $test_shell "$cmd" "$answer" $failcmd]
1121 && [_test_err_re_sort $test_shell "$cmd" "$anserr" $failcmd] } {
1122 _test_ok $test_shell "$cmd"
1123 }
1124 }
1125 }
1126
1127 #
1128 # Test procedure for full text matching with stdout and specified file
1129 #
1130
1131 proc testoutfile_cmd {test_shell cmd answer filepath ansfile {failcmd {fail}} {launcher {}}} {
1132 if {$test_shell eq "ALL"} {
1133 global supported_shells
1134 foreach shell $supported_shells {
1135 testoutfile_cmd $shell $cmd $answer $filepath $ansfile $failcmd $launcher
1136 }
1137 } else {
1138 _test_sub $test_shell $cmd noinput $launcher
1139 if { [_test_out $test_shell "$cmd" "$answer" $failcmd]
1140 && [_test_file $test_shell "$cmd" "$filepath" "$ansfile" $failcmd] } {
1141 _test_ok $test_shell "$cmd"
1142 }
1143 }
1144 }
1145
1146 proc testouterrfile_cmd {test_shell cmd answer anserr filepath ansfile {failcmd {fail}} {launcher {}}} {
1147 if {$test_shell eq "ALL"} {
1148 global supported_shells
1149 foreach shell $supported_shells {
1150 testouterrfile_cmd $shell $cmd $answer $anserr $filepath $ansfile $failcmd $launcher
1151 }
1152 } else {
1153 _test_sub $test_shell $cmd noinput $launcher
1154 if { [_test_out $test_shell "$cmd" "$answer" $failcmd]
1155 && [_test_err $test_shell "$cmd" "$anserr" $failcmd]
1156 && [_test_file $test_shell "$cmd" "$filepath" "$ansfile" $failcmd] } {
1157 _test_ok $test_shell "$cmd"
1158 }
1159 }
1160 }
1161
1162 proc testouterrfileglob_cmd {test_shell cmd answer anserr fileglob ansfile {failcmd {fail}} {launcher {}}} {
1163 _test_sub $test_shell $cmd noinput $launcher
1164 set filepath [lindex [lsort [glob $fileglob]] end]
1165 if { [_test_out $test_shell "$cmd" "$answer" $failcmd]
1166 && [_test_err $test_shell "$cmd" "$anserr" $failcmd]
1167 && [_test_file $test_shell "$cmd" "$filepath" "$ansfile" $failcmd] } {
1168 _test_ok $test_shell "$cmd"
1169 }
1170 }
1171
1172 #
1173 # Test procedure for full text matching with stdout, stderr and glob file list
1174 #
1175
1176 proc testouterrgloblist_cmd {test_shell cmd answer anserr fileglob ansglob {failcmd {fail}} {launcher {}}} {
1177 if {$test_shell eq {ALL}} {
1178 global supported_shells
1179 foreach shell $supported_shells {
1180 testouterrgloblist_cmd $shell $cmd $answer $anserr $fileglob $ansglob $failcmd $launcher
1181 }
1182 } else {
1183 _test_sub $test_shell $cmd noinput $launcher
1184 if { [_test_out $test_shell $cmd $answer $failcmd]
1185 && [_test_err $test_shell $cmd $anserr $failcmd]
1186 && [_test_globlist $test_shell $cmd $fileglob $ansglob $failcmd] } {
1187 _test_ok $test_shell $cmd
1188 }
1189 }
1190 }
1191
1192 #
1193 # Change and restore file permissions to trigger specific behaviors
1194 #
1195
1196 proc change_file_perms {name perms} {
1197 global verbose file_orig_perms
1198
1199 # backup original file permission to restore them later
1200 set file_orig_perms($name) [file attributes $name -permissions]
1201
1202 if {$verbose} {
1203 send_user "\tChange permissions of file $name ($perms)\n"
1204 }
1205
1206 # lock file by removing read and execution perms
1207 file attributes $name -permissions $perms
1208 }
1209
1210 proc restore_file_perms {name} {
1211 global verbose file_orig_perms
1212
1213 if {$verbose} {
1214 send_user "\tRestore permissions of file $name ($file_orig_perms($name))\n"
1215 }
1216
1217 # restore file original permissions
1218 file attributes $name -permissions $file_orig_perms($name)
1219 }
1220
1221 #
1222 # Change environment setup in consistent way
1223 #
1224
1225 proc unsetenv_var {var} {
1226 if {[info exists ::env($var)]} {
1227 if {$::verbose} {
1228 send_user "\tUnset $var\n"
1229 }
1230 unset ::env($var)
1231 }
1232 }
1233
1234 proc unsetenv_path_var {var} {
1235 unsetenv_var $var
1236 # unset reference counter variable
1237 unsetenv_var __MODULES_SHARE_$var
1238 }
1239
1240 proc setenv_var {var val} {
1241 if {$::verbose} {
1242 send_user "\tSetup $var = '$val'\n"
1243 }
1244 set ::env($var) $val
1245 }
1246
1247 proc setenv_path_var {var args} {
1248 setenv_var $var [join $args ":"]
1249 # set reference counter variable
1250 array set refcnt {}
1251 foreach arg $args {
1252 if {![info exist refcnt($arg)]} {
1253 set refcnt($arg) 1
1254 } else {
1255 incr refcnt($arg)
1256 }
1257 }
1258 # remove elements only added once (not to register them in ref count var)
1259 foreach elt [array names refcnt] {
1260 if {$refcnt($elt) == 1 && $elt ne {}} {
1261 unset refcnt($elt)
1262 }
1263 }
1264 if {[array size refcnt]} {
1265 setenv_var __MODULES_SHARE_$var [join [array get refcnt] ":"]
1266 } else {
1267 unsetenv_var __MODULES_SHARE_$var
1268 }
1269 }
1270
1271 proc unsetenv_loaded_module {} {
1272 unsetenv_var _LMFILES_
1273 unsetenv_var LOADEDMODULES
1274 unsetenv_var __MODULES_LMTAG
1275 }
1276
1277 proc setenv_loaded_module {modlist modfilelist {notaskedmodlist {}}} {
1278 setenv_var _LMFILES_ [join $modfilelist :]
1279 setenv_var LOADEDMODULES [join $modlist :]
1280 if {$notaskedmodlist ne {}} {
1281 foreach mod $notaskedmodlist {
1282 lappend altaglist $mod&auto-loaded
1283 }
1284 setenv_var __MODULES_LMTAG [join $altaglist :]
1285 } else {
1286 unsetenv_var __MODULES_LMTAG
1287 }
1288 }
1289
1290 # when saving variable ignore internal variable used to perform tests
1291 array set skipped_var [list runtests 1 subdir 1 errorInfo 1 test_counts 1\
1292 errorCode 1 comp_error 1 dir 1 test_name 1 comp_output 1 comp_exit 1\
1293 autoinit_mode 1 endpipe 1 saved_var 1 saved_array_var 1 saved_env_var 1\
1294 env 1 skipped_var 1 auto_execs 1 shell 1 exit_status 1]
1295
1296 # save name and value for any global variables
1297 proc save_test_env {} {
1298 # reset dump structs
1299 foreach var [list saved_var saved_array_var saved_env_var] {
1300 global $var
1301 if {[info exists $var]} {
1302 array unset $var
1303 }
1304 }
1305
1306 global env skipped_var
1307
1308 foreach var [info globals] {
1309 if {![info exists skipped_var($var)]} {
1310 if {[array exists ::$var]} {
1311 set saved_var($var) [array get ::$var]
1312 set saved_array_var($var) 1
1313 } else {
1314 set saved_var($var) [set ::$var]
1315 }
1316 }
1317 }
1318 send_user "\tSaved test variables: [array names saved_var]\n"
1319 array set saved_env_var [array get ::env]
1320 send_user "\tSaved test environment variables: [array names\
1321 saved_env_var]\n"
1322 }
1323
1324 # restore test environment to its initial saved state
1325 proc reset_test_env {} {
1326 global saved_var saved_array_var saved_env_var env skipped_var
1327
1328 # reset Tcl global variables
1329 foreach var [info globals] {
1330 if {![info exists skipped_var($var)]} {
1331 # temp variables should be unset
1332 if {![info exists saved_var($var)]} {
1333 lappend unset_list $var
1334 unset ::$var
1335 # initial value should be restored if changed
1336 } elseif {![info exists saved_array_var($var)]} {
1337 if {$saved_var($var) ne [set ::$var]} {
1338 lappend restore_list $var
1339 set ::$var $saved_var($var)
1340 }
1341 } else {
1342 if {$saved_var($var) ne [array get ::$var]} {
1343 lappend restore_list $var
1344 array set ::$var $saved_var($var)
1345 }
1346 }
1347 }
1348 }
1349 # unset saved variables should be restored
1350 foreach var [array names saved_var] {
1351 if {![info exists ::$var]} {
1352 lappend restore_list $var
1353 set ::$var $saved_var($var)
1354 }
1355 }
1356
1357 if {[info exists unset_list]} {
1358 send_user "\tUnset temp variables: $unset_list\n"
1359 }
1360 if {[info exists restore_list]} {
1361 send_user "\tRestore test variable initial values: $restore_list\n"
1362 }
1363
1364 # reset environment variables
1365 foreach var [array names env] {
1366 # temp variables should be unset
1367 if {![info exists saved_env_var($var)]} {
1368 send_user "\tUnset $var\n"
1369 unset env($var)
1370 # initial value should be restored if changed
1371 } else {
1372 if {$saved_env_var($var) ne $env($var)} {
1373 send_user "\tSetup $var = '$saved_env_var($var)'\n"
1374 set env($var) $saved_env_var($var)
1375 }
1376 }
1377 }
1378 # unset saved variables should be restored
1379 foreach var [array names saved_env_var] {
1380 if {![info exists env($var)]} {
1381 send_user "\tSetup $var = '$saved_env_var($var)'\n"
1382 set env($var) $saved_env_var($var)
1383 }
1384 }
1385 }
1386
1387 # is quick test mode enabled
1388 proc is_quick_mode {} {
1389 return [expr {[info exists ::env(QUICKTEST)] && [string is true -strict\
1390 $::env(QUICKTEST)]}]
1391 }
1392
1393 # if quick test mode is running stop processing of current test file after
1394 # removing given fixture paths
1395 proc skip_if_quick_mode {args} {
1396 if {[is_quick_mode]} {
1397 send_user "\tSkipping tests as quick test mode is enabled\n"
1398 file delete -force {*}$args
1399 reset_test_env
1400 return -code 0 -level 2 0
1401 }
1402 }
1403
1404 proc skip_if_os_in {args} {
1405 if {$::os_name in $args} {
1406 send_user "\tSkipping tests for '$::os_name' OS\n"
1407 reset_test_env
1408 return -code 0 -level 2 0
1409 }
1410 }