Index: tests/destroy.test
===================================================================
diff -u -re884c2b0d63fa1b5a691e866ccff8d4094a2a8e4 -r74211c75224617bc0d78cd2a6a2a89d1e4a834d1
--- tests/destroy.test	(.../destroy.test)	(revision e884c2b0d63fa1b5a691e866ccff8d4094a2a8e4)
+++ tests/destroy.test	(.../destroy.test)	(revision 74211c75224617bc0d78cd2a6a2a89d1e4a834d1)
@@ -1,14 +1,13 @@
 # -*- Tcl -*-
 package require nx
-::nx::configure defaultMethodCallProtection false
 package require nx::test
+nx::test configure -count 10
 
-namespace import ::nx::*
-Test parameter count 10
+::nx::configure defaultMethodCallProtection false
 
 ::nsf::method::alias ::nx::Object set -frame object ::set
 
-Class create O -superclass Object {
+nx::Class create O -superclass nx::Object {
   :method init {} {
     set ::ObjectDestroy 0
     set ::firstDestroy 0
@@ -24,8 +23,8 @@
 # classical simple case
 #
 set case "simple destroy (1)"
-Test case simple-destroy-1
-Class create C -superclass O
+nx::test case simple-destroy-1
+nx::Class create C -superclass O
 C method destroy {} {incr ::firstDestroy; puts stderr "  *** [current] destroy"; next}
 C method foo {} {
   puts stderr "==== $::case [current]"
@@ -48,8 +47,8 @@
 # simple case, destroy does not propagate, c1 survives
 #
 set case "simple destroy (2), destroy blocks"
-Test case simple-destroy-2
-Class create C -superclass O
+nx::test case simple-destroy-2
+nx::Class create C -superclass O
 C method destroy {} {incr ::firstDestroy; puts stderr "  *** [current] destroy block"}
 C method foo {} {
   puts stderr "==== $::case [current]"
@@ -72,8 +71,8 @@
 # simple object recreate
 #
 set case "recreate"
-Test case recreate
-Class create C -superclass O
+nx::test case recreate
+nx::Class create C -superclass O
 C method destroy {} {incr ::firstDestroy; puts stderr "  *** [current] destroy"; next}
 C method foo {} {
   puts stderr "==== $::case [current]"
@@ -96,9 +95,9 @@
 # .. like simple case above
 #
 set case "cmd rename empty (1)"
-Test case rename-empty-1
-Object create o
-Class create C -superclass O
+nx::test case rename-empty-1
+nx::Object create o
+nx::Class create C -superclass O
 C method destroy {} {incr ::firstDestroy; puts stderr "  *** [current] destroy"; next}
 C method foo {} {
   puts stderr "==== $::case [current]"
@@ -123,8 +122,8 @@
 # this is the situation like above, as long xotcl's rename is used.
 #
 set case "cmd rename empty (2)"
-Test case rename-empty-2
-Class create C -superclass O
+nx::test case rename-empty-2
+nx::Class create C -superclass O
 C method destroy {} {incr ::firstDestroy; puts stderr "  *** [current] destroy block"}
 C method foo {} {
   puts stderr "==== $::case [current]"
@@ -149,9 +148,9 @@
 # xotcl's rename invokes a move 
 #
 set case "cmd rename object to current"
-Test case rename-to-current
-Object create o
-Class create C -superclass O
+nx::test case rename-to-current
+nx::Object create o
+nx::Class create C -superclass O
 C method destroy {} {incr ::firstDestroy; puts stderr "  *** [current] destroy"; next}
 C method foo {} {
   puts stderr "==== $::case [current]"
@@ -175,9 +174,9 @@
 # xotcl's rename invokes a move 
 #
 set case "cmd rename proc to current"
-Test case rename-proc-to-current
+nx::test case rename-proc-to-current
 proc o args {}
-Class create C -superclass O
+nx::Class create C -superclass O
 C method destroy {} {incr ::firstDestroy; puts stderr "  *** [current] destroy"; next}
 C method foo {} {
   puts stderr "==== $::case [current]"
@@ -200,9 +199,9 @@
 #
 
 set case "delete parent namespace (1)"
-Test case delete-parent-namespace
+nx::test case delete-parent-namespace
 namespace eval ::test {
-  Class create C -superclass O
+  nx::Class create C -superclass O
   C method destroy {} {incr ::firstDestroy; puts stderr "  *** [current] destroy"; next}
   C method foo {} {
     puts stderr "==== $::case [current]"
@@ -240,10 +239,10 @@
 # propagate.  
 #
 set case "delete parent namespace (2)"
-Test case delete-parent-namespace-2
+nx::test case delete-parent-namespace-2
 namespace eval ::test {
   ? {namespace exists test::C} 0 "exists test::C"
-  Class create C -superclass O
+  nx::Class create C -superclass O
   C method destroy {} {incr ::firstDestroy; puts stderr "  *** [current] destroy block"}
   C method foo {} {
     puts stderr "==== $::case [current]"
@@ -276,9 +275,9 @@
 # already deleted, while a method of it is excuted
 #
 set case "delete parent object (1)"
-Test case delete-parent-object
-Object create o
-Class create C -superclass O
+nx::test case delete-parent-object
+nx::Object create o
+nx::Class create C -superclass O
 C method destroy {} {incr ::firstDestroy; puts stderr "  *** [current] destroy"; next}
 C method foo {} {
   puts stderr "==== $::case [current]"
@@ -308,9 +307,9 @@
 # is deleted.
 #
 set case "delete parent object (2)"
-Test case delete-parent-object-2
-Object create o
-Class create C -superclass O
+nx::test case delete-parent-object-2
+nx::Object create o
+nx::Class create C -superclass O
 C method destroy {} {incr ::firstDestroy; puts stderr "  *** [current] destroy block"}
 C method foo {} {
   puts stderr "==== $::case [current]"
@@ -336,9 +335,9 @@
 # xotcl 1.6 crashed on this test
 #
 set case "redefine current object as proc"
-Test case redefine-current-object-as-proc
-Object create o
-Class create C -superclass O
+nx::test case redefine-current-object-as-proc
+nx::Object create o
+nx::Class create C -superclass O
 C method destroy {} {incr ::firstDestroy; puts stderr "  *** [current] destroy"; next}
 C method foo {} {
   puts stderr "==== $::case [current]"
@@ -364,8 +363,8 @@
 # delete the active class
 #
 set case "delete active class"
-Test case delete-active-class
-Class create C -superclass O
+nx::test case delete-active-class
+nx::Class create C -superclass O
 C method destroy {} {incr ::firstDestroy; puts stderr "  *** [current] destroy"; next}
 C method foo {} {
   puts stderr "==== $::case [current]"
@@ -394,8 +393,8 @@
 # delete active object nested in class
 #
 set case "delete active object nested in class"
-Test case delete-active-object-nested-in-class
-Class create C -superclass O
+nx::test case delete-active-object-nested-in-class
+nx::Class create C -superclass O
 C method destroy {} {incr ::firstDestroy; puts stderr "  *** [current] destroy"; next}
 C method foo {} {
   puts stderr "==== $::case [current]"
@@ -422,25 +421,25 @@
 ? "set ::ObjectDestroy" 1 "ObjectDestroy called"
 
 #
-Test case nesting-destroy {
-  Object create x
-  Object create x::y
+nx::test case nesting-destroy {
+  nx::Object create x
+  nx::Object create x::y
   x destroy
   ? {::nsf::object::exists x} 0 "parent object gone"
   ? {::nsf::object::exists x::y} 0 "child object gone"
 }
 
-Test case deleting-aliased-object1 {
-  Object create o
-  Object create o2
+nx::test case deleting-aliased-object1 {
+  nx::Object create o
+  nx::Object create o2
   # behave like an ensemble: aliased object has self of the caller
   ::nsf::object::property o2 perobjectdispatch 1
   ::nsf::method::alias o a o2
   ? {o a} ::o2 "call object via alias"
-  ? {o info method type a} alias
+  ? {o info object method type a} alias
   ## the ensemble-object needs per-object methods
-  o2 method info args {:info {*}$args}
-  o2 method set args {:set {*}$args}
+  o2 object method info args {:info {*}$args}
+  o2 object method set args {:set {*}$args}
   ::nsf::object::property o2 keepcallerself 1
   ? {o a info vars} "" "call info on aliased object"
   ? {o set x 10} 10   "set variable on object"
@@ -454,20 +453,20 @@
   ? {o a info vars} {target "o2" of alias a apparently disappeared} "2nd call on deleted object"
 }
 
-Test case deleting-aliased-object2 {
-  Object create o
-  Object create o2
+nx::test case deleting-aliased-object2 {
+  nx::Object create o
+  nx::Object create o2
   # The methods of the aliased object have their own self
   ::nsf::method::alias o a o2
   puts stderr ===5
   ? {o a} ::o2 "call object via alias"
   puts stderr ===6
 
-  ? {o info method type a} alias
+  ? {o info object method type a} alias
   # In order to avoid recursive calls, we have to provide the
   # selector for the method definitions in nx::Object
-  o2 method info args {: ::nsf::classes::nx::Object::info {*}$args}
-  o2 method set args {: ::nsf::classes::nx::Object::set {*}$args}
+  o2 object method info args {: ::nsf::classes::nx::Object::info {*}$args}
+  o2 object method set args {: ::nsf::classes::nx::Object::set {*}$args}
 
   ? {o a info vars} ""   "call info on aliased object"
   ? {o set x 10} 10     "set variable on object o"
@@ -483,9 +482,9 @@
 }
 
 set case "deleting object with alias to object"
-Test case deleting-object-with-alias-to-object
-Object create o
-Object create o3
+nx::test case deleting-object-with-alias-to-object
+nx::Object create o
+nx::Object create o3
 ::nsf::method::alias o x o3
 o destroy
 ? {::nsf::object::exists o} 0 "parent object gone"
@@ -494,9 +493,9 @@
 ? {::nsf::object::exists o3} 0 "aliased object destroyed"
 
 set case "create an alias, and delete cmd via aggregation"
-Test case create-alias-delete-via-aggregation
-Object create o
-Object create o3
+nx::test case create-alias-delete-via-aggregation
+nx::Object create o
+nx::Object create o3
 ::nsf::method::alias o x o3
 #o::x destroy
 o3 destroy
@@ -508,12 +507,12 @@
 #
 # create an alias, and recreate obj
 #
-Test case create-alias-and-recreate-obj {
-  Object create o
-  Object create o3
-  o alias x o3
-  Object create o3
-  o3 method set args {: ::nsf::classes::nx::Object::set {*}$args}
+nx::test case create-alias-and-recreate-obj {
+  nx::Object create o
+  nx::Object create o3
+  o object alias x o3
+  nx::Object create o3
+  o3 object method set args {: ::nsf::classes::nx::Object::set {*}$args}
   o x set a 13
   ? {o x set a} 13 "aliased object works after recreate"
 }
@@ -522,20 +521,20 @@
 # create an alias on the class level, double aliasing, delete aliased
 # object
 #
-Test case create-alias-on-class-delete-aliased-obj {
-  Class create C
-  Object create o
-  Object create o3
+nx::test case create-alias-on-class-delete-aliased-obj {
+  nx::Class create C
+  nx::Object create o
+  nx::Object create o3
 
   ::nsf::object::property o keepcallerself 1
   ::nsf::object::property o3 keepcallerself 1
   ::nsf::object::property o perobjectdispatch 1
   ::nsf::object::property o3 perobjectdispatch 1
-  o alias a o3
+  o object alias a o3
   C alias b o
 
-  o3 method set args {: ::nsf::classes::nx::Object::set {*}$args}
-  o method set args {: ::nsf::classes::nx::Object::set {*}$args}
+  o3 object method set args {: ::nsf::classes::nx::Object::set {*}$args}
+  o object method set args {: ::nsf::classes::nx::Object::set {*}$args}
 
   C create c1
   ? {c1 b set B 2} 2 "call 1st level"
@@ -551,11 +550,11 @@
 #
 # create an alias on the class level, double aliasing, destroy class
 #
-Test case create-alias-on-class-destroy-class {
-  Class create C
-  Object create o
-  Object create o3
-  o alias a o3
+nx::test case create-alias-on-class-destroy-class {
+  nx::Class create C
+  nx::Object create o
+  nx::Object create o3
+  o object alias a o3
   C alias b o
   C create c1
   C destroy
@@ -567,12 +566,12 @@
 # test cases where preexisting namespaces are re-used
 #
 
-Test case module {
+nx::test case module {
   # create a namespace with an object/class in it
-  namespace eval ::module { Object create foo }
+  namespace eval ::module { nx::Object create foo }
   
   # reuse the namespace for a class/object
-  Class create ::module
+  nx::Class create ::module
 
   ? {::nsf::is class ::module} 1
 
@@ -582,23 +581,23 @@
   ? {::nsf::is class ::module} 0
 }
 
-Test case namespace-import {
+nx::test case namespace-import {
 
   namespace eval ::module {
-    Class create Foo {
+    nx::Class create Foo {
       :create foo
     }
     namespace export Foo foo
   }
-  Class create ::module {
+  nx::Class create ::module {
     :create mod1
   }
   ? {::nsf::is class ::module::Foo} 1
   ? {::nsf::is class ::module::foo} 0
   ? {::nsf::object::exists ::module::foo} 1
   ? {::nsf::is class ::module} 1
 
-  Object create ::o { :require namespace }
+  nx::Object create ::o { :require namespace }
   namespace eval ::o {namespace import ::module::*}
 
   ? {::nsf::is class ::o::Foo} 1
@@ -619,9 +618,10 @@
 
 # to avoid CallDirectly, we could activate this line
 ::nx::Class create M {:method dealloc args {next}}
-Test case delete-parent-namespace-dealloc
+
+nx::test case delete-parent-namespace-dealloc
 namespace eval ::test {
-  Class create C -superclass O
+  nx::Class create C -superclass O
   C method destroy {} {incr ::firstDestroy; puts stderr "  *** [current] destroy"; next}
   C method foo {} {
     puts stderr "==== $::case [current]"
@@ -640,6 +640,7 @@
     ? "set ::ObjectDestroy" 0 "$::case destroy not yet called"
   }
 }
+
 test::C create test::c1
 test::c1 foo
 ? {::nsf::object::exists test::c1} 0  "object still exists after proc"
@@ -650,7 +651,7 @@
 ? {namespace exists ::test} 1  "parent ::test namespace still exists after proc"
 ? {namespace exists ::xotcl::classes::test::C} 0  "namespace ::xotcl::classes::test::C still exists after proc"
 
-Test case destroy-during-init {
+nx::test case destroy-during-init {
   # create class
   nx::Class create Foo {
     :public method bar {} {return 1}
@@ -715,7 +716,7 @@
   ::nx::Object filter ""
 }
 
-Test case nested-ordered-composite {
+nx::test case nested-ordered-composite {
   # The following test case an explicit deletion/redefinition of an
   # toplevel object (o1) will cause the implicit deletion of a nested
   # object o1::o2. The object o2 has as well several included objects,
@@ -726,7 +727,7 @@
   # confronted with the deletion of indirectly deleted items (deleted by
   # the deletion of the ordered composite).
 
-  Class create C {
+  nx::Class create C {
     :property os
     :public method destroy {} {
       #puts stderr "[self] destroy ${:os}"
@@ -750,9 +751,9 @@
   for {set i 0} {$i < 10} {incr i} {
     set os [list]
     for {set j 0} {$j < 10} {incr j} {lappend os ::o1::o2::[incr c]}
-    Object create ::o1
-    Object create ::o1::o2
-    foreach o $os {Object create $o}
+    nx::Object create ::o1
+    nx::Object create ::o1::o2
+    foreach o $os {nx::Object create $o}
     C create ::o1::o2::oc1 -os $os
     ? {llength [o1 info children]} 1
     ? {llength [o1::o2 info children]} 11
@@ -770,9 +771,9 @@
   for {set i 0} {$i < 10} {incr i} {
     set os [list]
     for {set j 0} {$j < 20} {incr j} {lappend os ::o1::o2::[incr c]}
-    Object create ::o1
-    Object create ::o1::o2
-    foreach o $os {Object create $o}
+    nx::Object create ::o1
+    nx::Object create ::o1::o2
+    foreach o $os {nx::Object create $o}
     C create ::o1::o2::oc1 -os $os
     ? {llength [o1 info children]} 1
     ? {llength [o1::o2 info children]} 21
@@ -783,9 +784,9 @@
   for {set i 0} {$i < 10} {incr i} {
     set os [list]
     for {set j 0} {$j < 20} {incr j} {lappend os ::o1::o2::[incr c]}
-    Object create ::o1
-    Object create ::o1::o2
-    foreach o $os {Object create $o}
+    nx::Object create ::o1
+    nx::Object create ::o1::o2
+    foreach o $os {nx::Object create $o}
     C create ::o1::o2::ocX -os {}
     C create ::o1::o2::ocY -os $os
     ? {llength [o1 info children]} 1
@@ -800,10 +801,10 @@
 #
 package req nx::serializer
 
-nx::Test case class-object-property {
+nx::test case class-object-property {
 
-  Class create C {
-    :class property -accessor public x
+  nx::Class create C {
+    :object property -accessor public x
     :property a:int
   }
 
@@ -829,13 +830,16 @@
   ? {::nsf::object::exists ::C} 0
 }
 
-nx::Test case unset-traces-during-cleanup {
+nx::test case unset-traces-during-cleanup {
   global i
   set i [interp create]
   $i eval {
     package req nx
     nx::Object create o {
       set :x 100
+      # The following line is tricky: the trailing ";#" 
+      # is used to trim the undesirable extra arguments 
+      # from the trace command.
       ::trace add variable :x unset "[list set ::X ${:x}];#"
     }
   }
@@ -849,7 +853,7 @@
   unset i
 }
 
-nx::Test case unset-traces-during-cleanup-with-destroy {
+nx::test case unset-traces-during-cleanup-with-destroy {
   #
   # Make sure that a very-late destroy (in the unset trace) does not
   # fire ... and does not cause any side effects.
@@ -859,11 +863,14 @@
   $i eval {
     package req nx
     nx::Object create o {
-      :public method destroy args {
+      :public object method destroy args {
 	incr ::X
 	next
       } 
       set :x 100
+      # The following line is tricky: the trailing ";#" 
+      # is used to trim the undesirable extra arguments 
+      # from the trace command.
       ::trace add variable :x unset "[list ::incr ::X]; [list [self] destroy];#"
     }
   }
@@ -877,7 +884,7 @@
   unset i
 }
 
-nx::Test case unset-traces-during-cleanup-with-destroy-2 {
+nx::test case unset-traces-during-cleanup-with-destroy-2 {
   #
   # We are safe when trying to delete the base class/metaclass ...
   #
@@ -887,6 +894,9 @@
     package req nx
     nx::Object create o {
       set :x _
+      # The following line is tricky: the trailing ";#" 
+      # is used to trim the undesirable extra arguments 
+      # from the trace command.
       ::trace add variable :x unset "[list catch [list ::nx::Object destroy] msg1]; [list catch [list ::nx::Class destroy] msg2]; set ::MSG \[list \$msg1 \$msg2\];#"
     }
   }
@@ -900,7 +910,7 @@
   unset i
 }
 
-nx::Test case unset-traces-during-cleanup-with-reset {
+nx::test case unset-traces-during-cleanup-with-reset {
   #
   # Check for leaks ...
   #
@@ -910,6 +920,9 @@
     package req nx
     nx::Object create o {
       set :x 100
+      # The following line is tricky: the trailing ";#" 
+      # is used to trim the undesirable extra arguments 
+      # from the trace command.
       ::trace add variable :x unset "[list ::nsf::var::set [self] x ${:x}];#"
     }
   }
@@ -926,9 +939,9 @@
 #
 # Exercise renaming of cmds which are used as methods
 #
-nx::Test case rename-cached-method {
+nx::test case rename-cached-method {
   # Create a class with a namespace
-  nx::Class create A {:public class method foo args {}}
+  nx::Class create A {:public object method foo args {}}
   #
   # Add a proc named "new" to the namespace of the class.
   # This is not recommended, but we can't avoid it.
@@ -978,7 +991,7 @@
 #
 # Create a cyclical class dependency and delete it manually
 #
-nx::Test case cyclical-dependency {
+nx::test case cyclical-dependency {
   nx::Object create o1
   ? {nx::Class create o1::C} ::o1::C
   ? {nsf::relation o1 class o1::C} ::o1::C
@@ -996,7 +1009,7 @@
 #
 # Create a cyclical superclass dependency and delete it manually
 #
-nx::Test case cyclical-dependency {
+nx::test case cyclical-dependency {
   nx::Class create C 
   nx::Class create C::*
   ? {nsf::relation C superclass {C::* nx::Object}} ""