Index: library/xotcl/tests/speedtest.xotcl
===================================================================
diff -u -rd679ea5694ec3aad76b06767bb23287965304db9 -r45e24b34c85bf0fc3e14db5250550100bd07ff31
--- library/xotcl/tests/speedtest.xotcl	(.../speedtest.xotcl)	(revision d679ea5694ec3aad76b06767bb23287965304db9)
+++ library/xotcl/tests/speedtest.xotcl	(.../speedtest.xotcl)	(revision 45e24b34c85bf0fc3e14db5250550100bd07ff31)
@@ -2,26 +2,26 @@
 #memory trace on
 package prefer latest
 package require XOTcl 2.0; namespace import ::xotcl::*
-package require nx::test; namespace import nx::Test
+package require nx::test
 
-Test new -msg {test multiple dashed args o0} \
+nx::test new -msg {test multiple dashed args o0} \
     -cmd {Object create o0 [list -set a -a1] [list -set b "-b 1 -y 2"]} \
     -expected ::o0 \
     -post {o0 destroy}
-Test new -msg {test multiple dashed args o1} \
+nx::test new -msg {test multiple dashed args o1} \
     -cmd {Object create o1 -proc foo args {return 1} [list -set a -a1] [list -set b "-b 1 -y 2"]} \
     -expected ::o1 \
     -post {o1}
-Test new -msg {test multiple dashed args o2} \
+nx::test new -msg {test multiple dashed args o2} \
     -cmd {Object create o2 {-proc foo args {return 1}} {-set -a -t1} {-set b "-b 1 -y 2"}} \
     -expected ::o2 \
     -post {o2 destroy}
-Test new -msg {test multiple dashed args o3} \
+nx::test new -msg {test multiple dashed args o3} \
     -cmd {Object create o3 -proc foo args {return 1} {-set -a -t1} {-set b "-b 1 -y 2"}} \
     -expected ::o3 \
     -post {o3 destroy}     
 
-Test parameter count 1000
+nx::test configure -count 1000
 
 @ @File {description {
   Regression and speed test for various ways to achieve a similar
@@ -201,368 +201,368 @@
 D instproc init args {}
 D d
 
-#Test new -cmd {llength [c info children]} -count 1 -expected 999
-#Test new -cmd {set x [llength [c info children]]} -count 1 -expected 999
-Test new -cmd {llength [c info children]} -count 1 -expected $ccount
-Test new -cmd {set x [llength [c info children]]} -count 1 -expected $ccount
+#nx::test new -cmd {llength [c info children]} -count 1 -expected 999
+#nx::test new -cmd {set x [llength [c info children]]} -count 1 -expected 999
+nx::test new -cmd {llength [c info children]} -count 1 -expected $ccount
+nx::test new -cmd {set x [llength [c info children]]} -count 1 -expected $ccount
 
-Test new -cmd {set x [llength [Object info instances]]} -count 1 -expected $ocount
-Test new -cmd {llength [Object info instances]} -count 1 -expected $ocount
+nx::test new -cmd {set x [llength [Object info instances]]} -count 1 -expected $ocount
+nx::test new -cmd {llength [Object info instances]} -count 1 -expected $ocount
 
-Test new -cmd {d istype D} -expected 1
+nx::test new -cmd {d istype D} -expected 1
 
-Test new -cmd {c setViaInstvar 100} -expected 100
-Test new -cmd {c setViaSetMethod 100} -expected 100
-Test new -cmd {c setViaParameter 100} -expected 100
+nx::test new -cmd {c setViaInstvar 100} -expected 100
+nx::test new -cmd {c setViaSetMethod 100} -expected 100
+nx::test new -cmd {c setViaParameter 100} -expected 100
 
-Test new -cmd {c existsViaInstvar}
-Test new -cmd {c existsViaMyInstvar}
-Test new -cmd {c existsViaExistsMethod}
-Test new -cmd {c existsViaMyExistsMethod}
-Test new -cmd {c existsViaDotExistsMethod}
-Test new -cmd {c existsViaResolver}
-Test new -cmd {c exists v}
-Test new -cmd {c notExistsViaInstvar}  -expected 0
-Test new -cmd {c notExistsViaExistsMethod} -expected 0
-Test new -cmd {c exists xxx}  -expected 0
+nx::test new -cmd {c existsViaInstvar}
+nx::test new -cmd {c existsViaMyInstvar}
+nx::test new -cmd {c existsViaExistsMethod}
+nx::test new -cmd {c existsViaMyExistsMethod}
+nx::test new -cmd {c existsViaDotExistsMethod}
+nx::test new -cmd {c existsViaResolver}
+nx::test new -cmd {c exists v}
+nx::test new -cmd {c notExistsViaInstvar}  -expected 0
+nx::test new -cmd {c notExistsViaExistsMethod} -expected 0
+nx::test new -cmd {c exists xxx}  -expected 0
 
-Test new -cmd {c existsAndReturnValue1}  -expected 100
-Test new -cmd {c existsAndReturnValue3}  -expected 100
+nx::test new -cmd {c existsAndReturnValue1}  -expected 100
+nx::test new -cmd {c existsAndReturnValue3}  -expected 100
 
-Test new -cmd {c testAndSetViaInstvar 100} -expected 100
-Test new -cmd {c testAndSetViaSetMethod 100} -expected 100
+nx::test new -cmd {c testAndSetViaInstvar 100} -expected 100
+nx::test new -cmd {c testAndSetViaSetMethod 100} -expected 100
 
-Test new -cmd {c readViaInstvar} -expected 99
-Test new -cmd {c readViaSetMethod} -expected 99
-Test new -cmd {c readViaParameter} -expected 99
-Test new -cmd {c readViaSetMethodNoSelf} -expected 99
+nx::test new -cmd {c readViaInstvar} -expected 99
+nx::test new -cmd {c readViaSetMethod} -expected 99
+nx::test new -cmd {c readViaParameter} -expected 99
+nx::test new -cmd {c readViaSetMethodNoSelf} -expected 99
 
-Test new -cmd {c readTwiceViaInstvar} -expected 99
-Test new -cmd {c readTwiceViaSetMethod} -expected 99
-Test new -cmd {c readTwiceViaParameter} -expected 99
-Test new -cmd {c readTwiceViaSetMethodNoSelf} -expected 99
+nx::test new -cmd {c readTwiceViaInstvar} -expected 99
+nx::test new -cmd {c readTwiceViaSetMethod} -expected 99
+nx::test new -cmd {c readTwiceViaParameter} -expected 99
+nx::test new -cmd {c readTwiceViaSetMethodNoSelf} -expected 99
 
-Test new -cmd {c readTwovarsViaInstvar} -expected 98
-Test new -cmd {c readTwovarsViaSetMethod} -expected 98
-Test new -cmd {c readTwovarsViaParameter} -expected 98
-Test new -cmd {c readTwovarsViaSetMethodNoSelf} -expected 98
+nx::test new -cmd {c readTwovarsViaInstvar} -expected 98
+nx::test new -cmd {c readTwovarsViaSetMethod} -expected 98
+nx::test new -cmd {c readTwovarsViaParameter} -expected 98
+nx::test new -cmd {c readTwovarsViaSetMethodNoSelf} -expected 98
 
-Test new -cmd {c instvarAlias}
+nx::test new -cmd {c instvarAlias}
 
-Test new -cmd {c incr v} -post {c set v 1} -expected 101
-Test new -cmd {c unset v; set r [c exists v]; c set v 1; set r} -expected 0
+nx::test new -cmd {c incr v} -post {c set v 1} -expected 101
+nx::test new -cmd {c unset v; set r [c exists v]; c set v 1; set r} -expected 0
 
-Test new -cmd {llength [Object info instances]} -count 1 -expected $ocount
-Test new -cmd {set x [llength [Object info instances]]} -count 1 -expected $ocount
+nx::test new -cmd {llength [Object info instances]} -count 1 -expected $ocount
+nx::test new -cmd {set x [llength [Object info instances]]} -count 1 -expected $ocount
 
-Test new -cmd {c explicitReturn}
-Test new -cmd {c implicitReturn}
-Test new -cmd {c explicitReturnFromVar}
-Test new -cmd {c implicitReturnFromVar}
+nx::test new -cmd {c explicitReturn}
+nx::test new -cmd {c implicitReturn}
+nx::test new -cmd {c explicitReturnFromVar}
+nx::test new -cmd {c implicitReturnFromVar}
 
-Test new -cmd {llength [Object info instances]} -count 1 -expected $ocount
-Test new -cmd {set x [llength [Object info instances]]} -count 1 -expected $ocount
+nx::test new -cmd {llength [Object info instances]} -count 1 -expected $ocount
+nx::test new -cmd {set x [llength [Object info instances]]} -count 1 -expected $ocount
 
-Test new -cmd {c childNodeNamespace} -expected ::c::13
-Test new -cmd {llength [Object info instances]} -count 1 -expected $ocount
-Test new -cmd {c childNodeNamespaceCreate} -expected ::c::13
-Test new -cmd {llength [Object info instances]} -expected $ocount
-Test new -cmd {c createVolatileRc} -expected 2
+nx::test new -cmd {c childNodeNamespace} -expected ::c::13
+nx::test new -cmd {llength [Object info instances]} -count 1 -expected $ocount
+nx::test new -cmd {c childNodeNamespaceCreate} -expected ::c::13
+nx::test new -cmd {llength [Object info instances]} -expected $ocount
+nx::test new -cmd {c createVolatileRc} -expected 2
 
 # should be still the same number as above
-Test new -count 1 -cmd {llength [Object info instances]} -expected $ocount
+nx::test new -count 1 -cmd {llength [Object info instances]} -expected $ocount
 
-Test new -cmd {Object new -volatile} -expected ::nsf::__\#F9 -count 2000 \
+nx::test new -cmd {Object new -volatile} -expected ::nsf::__\#F9 -count 2000 \
     -post {foreach o [Object info instances ::nsf::__*] {$o destroy}} 
 
 # should be still the same number as above
-Test new -count 1 -cmd {llength [Object info instances]} -expected $ocount
+nx::test new -count 1 -cmd {llength [Object info instances]} -expected $ocount
 
-Test new -cmd {Object new} -expected ::nsf::__\#lQ  -count 2000 \
+nx::test new -cmd {Object new} -expected ::nsf::__\#lQ  -count 2000 \
     -post {foreach o [Object info instances ::nsf::__*] {$o destroy}} 
 
 # should be still the same number as above
-Test new -count 1 -cmd {llength [Object info instances]} -expected $ocount
+nx::test new -count 1 -cmd {llength [Object info instances]} -expected $ocount
 
-Test new -cmd {Object new -childof o} -expected ::o::__\#0Hh \
+nx::test new -cmd {Object new -childof o} -expected ::o::__\#0Hh \
     -pre {Object o} -post {o destroy}
 
 # should be still the same number as above
-Test new -count 1 -cmd {llength [Object info instances]} -expected $ocount
+nx::test new -count 1 -cmd {llength [Object info instances]} -expected $ocount
 
-Test new -count 1000 -pre {::set ::count 0} \
+nx::test new -count 1000 -pre {::set ::count 0} \
     -cmd {Object create [incr ::count]} \
     -expected ::1 \
     -post {::unset ::count}
-Test new -count 1000 -pre {::set ::count 0} \
+nx::test new -count 1000 -pre {::set ::count 0} \
     -cmd {[incr ::count] destroy} \
     -post {::unset ::count} \
     -expected ""
 #
-Test new -count 1 -cmd {llength [Object info instances]} -expected $ocount
+nx::test new -count 1 -cmd {llength [Object info instances]} -expected $ocount
 # we create another object
 set ocount [expr {$ocount + 1}]
-Test new -cmd {Object create x} -expected ::x
-Test new -count 1 -cmd {llength [Object info instances]} -expected $ocount
+nx::test new -cmd {Object create x} -expected ::x
+nx::test new -count 1 -cmd {llength [Object info instances]} -expected $ocount
 
-Test new -cmd {Object create x -set a -1 -set b ,, -set c a--} \
+nx::test new -cmd {Object create x -set a -1 -set b ,, -set c a--} \
     -expected ::x
-Test new -count 1 -cmd {llength [Object info instances]} -expected $ocount
+nx::test new -count 1 -cmd {llength [Object info instances]} -expected $ocount
 
-Test new -cmd {expr {[c array names n 5] ne ""}}
+nx::test new -cmd {expr {[c array names n 5] ne ""}}
 
-Test new -count 1 -cmd {llength [Object info instances]} -expected $ocount
-Test new -cmd {info exists c::n(5)}
-Test new -count 1 -cmd {llength [Object info instances]} -expected $ocount
-Test new -cmd {c exists n(5)}
+nx::test new -count 1 -cmd {llength [Object info instances]} -expected $ocount
+nx::test new -cmd {info exists c::n(5)}
+nx::test new -count 1 -cmd {llength [Object info instances]} -expected $ocount
+nx::test new -cmd {c exists n(5)}
 
-Test new -cmd {llength [c info children]} -expected $ccount
-Test new -cmd {c info children ::c::5}  -expected ::c::5
-Test new -cmd {c info children 5}  -expected ::c::5
-Test new -cmd {c info children 5*}  -expected ::c::5
+nx::test new -cmd {llength [c info children]} -expected $ccount
+nx::test new -cmd {c info children ::c::5}  -expected ::c::5
+nx::test new -cmd {c info children 5}  -expected ::c::5
+nx::test new -cmd {c info children 5*}  -expected ::c::5
 
-Test new -count 1 -cmd {llength [Object info instances]} -expected $ocount
+nx::test new -count 1 -cmd {llength [Object info instances]} -expected $ocount
 
-Test new -cmd {Object info instances ::c::5*} -expected ::c::5
-Test new -cmd {Object info instances ::c::5} -expected ::c::5
-Test new -cmd {Object info instances ::c::5000} -expected ""
+nx::test new -cmd {Object info instances ::c::5*} -expected ::c::5
+nx::test new -cmd {Object info instances ::c::5} -expected ::c::5
+nx::test new -cmd {Object info instances ::c::5000} -expected ""
 
-Test new -count 100 -pre {set ::c::l ""} \
+nx::test new -count 100 -pre {set ::c::l ""} \
     -cmd {lappend ::c::l 1} \
     -post {c unset l}
 
-Test new \
+nx::test new \
     -count 100 \
     -cmd {c mixinappend M1} \
     -expected ::M1 \
     -post {c mixin ""}
 
-Test new \
+nx::test new \
     -count 100 \
     -cmd  {c ma M1} \
     -expected ::M1 \
     -post {c mixin ""}
 
-Test new \
+nx::test new \
     -count 100 \
     -cmd  {c mixin add M1} \
     -expected "::M1" \
     -post {c mixin ""}
 
-Test new \
+nx::test new \
     -count 100 \
     -cmd {c mixinappend M1; c mixinappend M2} \
     -expected {::M1 ::M2} \
     -post {c mixin ""}
 
-Test new \
+nx::test new \
     -count 100 \
     -cmd {c ma M1; c ma M2} \
     -expected {::M1 ::M2} \
     -post {c mixin ""}
 
-Test new \
+nx::test new \
     -count 100 \
     -pre {Class D; Class E; Object o -mixin {D E}} \
     -cmd {o info mixin D} \
     -expected {::D} \
     -post {foreach o {D E o} {$o destroy}}
 
-Test new \
+nx::test new \
     -count 100 \
     -pre {Class D; Class E; Object o -mixin {D E}} \
     -cmd {o info mixin E} \
     -expected {::E} \
     -post {foreach o {D E o} {$o destroy}}
 
-Test new \
+nx::test new \
     -count 100 \
     -pre {Class D; Class E; Object o -mixin {D E}} \
     -cmd {o info mixin ::E*} \
     -expected {::E} \
     -post {foreach o {D E o} {$o destroy}}
 
-Test new \
+nx::test new \
     -count 100 \
     -pre {Class D; Class E; Class E1; Object o -mixin {D E E1}} \
     -cmd {o info mixin ::E*} \
     -expected {::E ::E1} \
     -post {foreach o {D E E1 o} {$o destroy}}
 
-Test new \
+nx::test new \
     -count 100 \
     -pre {Class D; Class E; Class X -instmixin {D E}} \
     -cmd {X info instmixin D} \
     -expected {::D} \
     -post {foreach o {D E X} {$o destroy}}
 
-Test new \
+nx::test new \
     -count 100 \
     -pre {Class D; Class E; Class X -instmixin {D E}} \
     -cmd {X info instmixin E} \
     -expected {::E} \
     -post {foreach o {D E X} {$o destroy}}
 
-Test new \
+nx::test new \
     -count 100 \
     -pre {Class D; Class E; Class E1; Class X -instmixin {D E E1}} \
     -cmd {X info instmixin ::E*} \
     -expected {::E ::E1} \
     -post {foreach o {D E E1 X} {$o destroy}}
 
-Test new \
+nx::test new \
     -count 100 \
     -pre {Class D; Class E; Class X -instmixin {D E}} \
     -cmd {X info instmixin ::E*} \
     -expected {::E} \
     -post {foreach o {D E X} {$o destroy}}
 
-Test new \
+nx::test new \
     -count 100 \
     -pre {Class D; Class E; Class X} \
     -cmd {X instmixin {D E}; X instmixin delete ::E; X info instmixin} \
     -expected {::D} \
     -post {foreach o {D E X} {$o destroy}}
 
-Test new \
+nx::test new \
     -count 100 \
     -pre {Class D; Class E; Class X} \
     -cmd {X instmixin {D E}; X instmixin delete E; X info instmixin} \
     -expected {::D} \
     -post {foreach o {D E X} {$o destroy}}
 
-Test new \
+nx::test new \
     -count 100 \
     -pre {Class D; Class E; Class E1; Class X} \
     -cmd {X instmixin {D E E1}; catch {X instmixin delete ::E*}; X info instmixin} \
     -expected {::D} \
     -post {foreach o {D E E1 X} {$o destroy}}
 
-Test new \
+nx::test new \
     -count 100 \
     -pre {Class D; Class E; Class E1; Class X} \
     -cmd {X instmixin {D E E1}; catch {X instmixin delete E*}; X info instmixin} \
     -expected {::D} \
     -post {foreach o {D E E1 X} {$o destroy}}
 
-Test new \
+nx::test new \
     -cmd {C instfilter f; C info instfilter} \
     -expected f \
     -post {C instfilter ""}
 
-Test new -pre {set s \#hallo} -cmd {string match "\#*" $s}
-Test new -pre {set s \#hallo} -cmd {regexp {^\#} $s}
-Test new -pre {set s \#hallo} -cmd {expr {[string first "\#" $s] == 0}}
-Test new -pre {set s \#hallo} -cmd {expr {[string range $s 0 0] == "\#"}}
+nx::test new -pre {set s \#hallo} -cmd {string match "\#*" $s}
+nx::test new -pre {set s \#hallo} -cmd {regexp {^\#} $s}
+nx::test new -pre {set s \#hallo} -cmd {expr {[string first "\#" $s] == 0}}
+nx::test new -pre {set s \#hallo} -cmd {expr {[string range $s 0 0] == "\#"}}
 
-Test new -pre {set s \#hallo} -cmd {regexp {^\#.*a} $s}
-Test new -pre {set s \#hallo} -cmd {regexp {^\#.*a.*o} $s}
-Test new -pre {set s \#hallo} -cmd {regexp {^\#.*a(.*)o} $s}
-Test new -pre {set s \#hallo} -cmd {regexp {^\#.*a(.*)o} $s _}
-Test new -pre {set s \#hallo} -cmd {regexp {^\#.*a(.*)o} $s _ out}
+nx::test new -pre {set s \#hallo} -cmd {regexp {^\#.*a} $s}
+nx::test new -pre {set s \#hallo} -cmd {regexp {^\#.*a.*o} $s}
+nx::test new -pre {set s \#hallo} -cmd {regexp {^\#.*a(.*)o} $s}
+nx::test new -pre {set s \#hallo} -cmd {regexp {^\#.*a(.*)o} $s _}
+nx::test new -pre {set s \#hallo} -cmd {regexp {^\#.*a(.*)o} $s _ out}
 
-Test new -msg {call proc of subobject directly} \
+nx::test new -msg {call proc of subobject directly} \
     -pre {C c2; C c2::o; c2::o proc f a {incr a}} \
     -cmd {c2::o::f 10} -expected 11 -count 5000 \
     -post {c2 destroy}
-Test new -msg {call proc of subobject via dispatch} \
+nx::test new -msg {call proc of subobject via dispatch} \
     -pre {C c2; C c2::o; c2::o proc f a {incr a}} \
     -cmd {c2::o f 10} -expected 11 -count 5000 \
     -post {c2 destroy}
-#Test new -msg {call proc of object and subobject via dispatch} \
+#nx::test new -msg {call proc of object and subobject via dispatch} \
 #    -pre {C c2; C c2::o; c2::o proc f a {incr a}} \
 #    -cmd {c2 o f 10} -expected 11 -count 5000 \
 #    -post {c2 destroy}
 
-Test new -msg {dispatch subobject directy via [self]} \
+nx::test new -msg {dispatch subobject directy via [self]} \
     -pre {C c2; C c2::o; c2::o proc f a {incr a}; c2 proc t a {[self]::o f $a}} \
     -cmd {c2 t 12} -expected 13 -count 5000 \
     -post {c2 destroy}
-#Test new -msg {dispatch subobject via my} \
+#nx::test new -msg {dispatch subobject via my} \
 #    -pre {C c2; C c2::o; c2::o proc f a {incr a}; c2 proc t a {my o f $a}} \
 #    -cmd {c2 t 12} -expected 13 -count 5000 \
 #    -post {c2 destroy}
 
 
 ###### insttclcmd tests
 set cnt 10000
-#Test new -msg {call insttclcmd (append) and check created variable} \
+#nx::test new -msg {call insttclcmd (append) and check created variable} \
     -pre {Object o} \
     -cmd {o append X 1; o exists X} -expected 1 \
     -post {o destroy}
-#Test new -msg {call tclcmd (regexep) and check created variable} \
+#nx::test new -msg {call tclcmd (regexep) and check created variable} \
     -pre {Object o; o tclcmd regexp} \
     -cmd {o regexp (a) a _ x; o exists x} -expected 1 -count $cnt \
     -post {o destroy}
-Test new -msg {call forwarder for (append) and check created variable} \
+nx::test new -msg {call forwarder for (append) and check created variable} \
     -pre {Object o; o forward append -objscope} \
     -cmd {o append X 1; o exists X} -expected 1 \
     -post {o destroy}
-Test new -msg {call forwarder (regexep) and check created variable} \
+nx::test new -msg {call forwarder (regexep) and check created variable} \
     -pre {Object o; o forward regexp -objscope} \
     -cmd {o regexp (a) a _ x; o exists x} -expected 1 -count $cnt \
     -post {o destroy}
-Test new -msg {call forwarder to another obj} \
+nx::test new -msg {call forwarder to another obj} \
     -pre {Object o; Object t; o forward set t set; t set x 100} \
     -cmd {o set x} -expected 100 -count $cnt \
     -post {o destroy}
 
 set cnt 100000
-Test new -msg {call handcoded incr} \
+nx::test new -msg {call handcoded incr} \
     -pre {Class C; C create o; o set x 1} \
     -cmd {o incr x 77} -expected 78 -count $cnt \
     -post {o destroy}
-Test new -msg {call incr via instforward} \
+nx::test new -msg {call incr via instforward} \
     -pre {Class C; C instforward ::incr -objscope; C create o; o set x 1} \
     -cmd {o incr x 77} -expected 78 -count $cnt \
     -post {o destroy}
-Test new -msg {call incr via forward} \
+nx::test new -msg {call incr via forward} \
     -pre {Class C; C create o; o forward ::incr -objscope; o set x 1} \
     -cmd {o incr x 77} -expected 78 -count $cnt \
     -post {o destroy}
 set cnt 10000
-Test new -msg {call obj with namespace via forward} \
+nx::test new -msg {call obj with namespace via forward} \
     -pre {Object n; Object n::x; Object o -forward ::n::x} \
     -cmd {o x self} -expected ::n::x -count $cnt \
     -post {o destroy}
-Test new -msg {call obj with namespace via instforward} \
+nx::test new -msg {call obj with namespace via instforward} \
     -pre {Object n; Object n::x; Class C; C create o; C instforward ::n::x} \
     -cmd {o x self} -expected ::n::x -count $cnt \
     -post {o destroy}
-Test new -msg {call obj with namespace via instforward and mixinclass} \
+nx::test new -msg {call obj with namespace via instforward and mixinclass} \
     -pre {Object n; Object n::x; Class M -instforward ::n::x; 
       Class C -instmixin M; C create o } \
     -cmd {o x self} -expected ::n::x -count $cnt \
     -post {o destroy}
-Test new -msg {call obj with namespace via instforward and next from proc} \
+nx::test new -msg {call obj with namespace via instforward and next from proc} \
     -pre {
       Object n; Object n::x; 
       Class C -instforward ::n::x; 
       C create o -proc x args {next} } \
     -cmd {o x self} -expected ::n::x -count $cnt \
     -post {o destroy}
-Test new -msg {call obj with namespace via instforward and next from instproc} \
+nx::test new -msg {call obj with namespace via instforward and next from instproc} \
     -pre {
       Object n; Object n::x; 
       Class C -instforward ::n::x; 
       Class D -superclass C -instproc x args {next};
       D create o } \
     -cmd {o x self} -expected ::n::x -count $cnt \
     -post {o destroy}
-Test new -msg {call obj with namespace via mixin and instforward and next} \
+nx::test new -msg {call obj with namespace via mixin and instforward and next} \
     -pre {Object n; Object n::x; 
       Class M -instforward ::n::x; 
       Class N -superclass M -instproc x args {next};
       Class C -instmixin N; C create o} \
     -cmd {o x self} -expected ::n::x -count $cnt \
     -post {o destroy}
-Test new -msg {return -code break} \
+nx::test new -msg {return -code break} \
     -pre {Class A -instproc br {} {return -code break}; A create a1} \
     -cmd {catch {a1 br}} -expected 3 -count 2 \
     -post {A destroy; a1 destroy}
 
 
-Test run; exit
+nx::test run; exit