Index: tests/info-method.test
===================================================================
diff -u -r3b5d2f4e0bc018420ebea39e54ad3212ade2a5bd -r7c2e28b93b02c29f19dc1f58642c5a29a894d24e
--- tests/info-method.test	(.../info-method.test)	(revision 3b5d2f4e0bc018420ebea39e54ad3212ade2a5bd)
+++ tests/info-method.test	(.../info-method.test)	(revision 7c2e28b93b02c29f19dc1f58642c5a29a894d24e)
@@ -7,7 +7,7 @@
 # Test info superclass with closure and patterns (with and without
 # wildcards, prefixed or not, success or not).
 #
-nx::Test case info-superclass {
+nx::test case info-superclass {
   nx::Class create C
   nx::Class create D -superclass C
 
@@ -59,25 +59,25 @@
 # Test "info method", base cases
 #
 
-nx::Test case info-method-base {
+nx::test case info-method-base {
   nx::Object create o {
-    :alias set ::set
+    :object alias set ::set
   }
 
   nx::Class create C {
     :method m {x} {return proc-[self proc]}
-    :class method mpo {} {return instproc-[self proc]}
+    :object method mpo {} {return instproc-[self proc]}
     :method m-with-assertions {} {return proc-[self proc]} -precondition 1 -postcondition 2
     
     :forward addOne expr 1 +
-    :class forward add1 expr 1 +
-    :class forward fpo ::o
+    :object forward add1 expr 1 +
+    :object forward fpo ::o
     
     :property -accessor public s 
-    :class property -accessor public spo
+    :object property -accessor public spo
     
     :alias a ::set
-    :class alias apo ::puts
+    :object alias apo ::puts
   }
   C create c1
   
@@ -91,56 +91,56 @@
   ? {c1 info lookup method addOne} "::nsf::classes::C::addOne"
   ? {c1 info lookup method m} "::nsf::classes::C::m"
   ? {c1 info lookup method s} "::nsf::classes::C::s"
-  c1 method foo {} {puts foo}
-  ? {c1 info method definition foo} "::c1 public method foo {} {puts foo}"
+  c1 object method foo {} {puts foo}
+  ? {c1 info object method definition foo} "::c1 public object method foo {} {puts foo}"
   ? {c1 info lookup method foo} "::c1::foo"
   
   ? {C info method registrationhandle m} "::nsf::classes::C::m"
-  ? {C class info method registrationhandle mpo} "::C::mpo"
+  ? {C info object method registrationhandle mpo} "::C::mpo"
   
   ? {C info method definition m} {::C public method m x {return proc-[self proc]}}
-  ? {C class info method definition mpo} {::C public class method mpo {} {return instproc-[self proc]}}
+  ? {C info object method definition mpo} {::C public object method mpo {} {return instproc-[self proc]}}
   if {$::nsf::config(assertions)} {
     ? {C info method definition m-with-assertions} \
 	{::C public method m-with-assertions {} {return proc-[self proc]} -precondition 1 -postcondition 2}
   } else {
     ? {C info method definition m-with-assertions} \
 	{::C public method m-with-assertions {} {return proc-[self proc]}}
   }
-  ? {C info method parameter m} {x}
-  ? {nx::Class info method parameter method} \
-      {name arguments:parameter,0..* -returns body -precondition -postcondition}
-  ? {nx::Object info method parameter alias} \
+  ? {C info method parameters m} {x}
+  ? {nx::Class info method parameters method} \
+      {name arguments:parameter,0..* -checkalways:switch -returns body -precondition -postcondition}
+  ? {nx::Class info method parameters alias} \
       {methodName -returns {-frame default} cmd}
   # raises currently an error
-  ? {catch {C info method parameter a}} 1
+  ? {catch {C info method parameters a}} 1
   
   ? {C info method definition addOne} "::C public forward addOne expr 1 +"
-  ? {C class info method definition add1} "::C public class forward add1 expr 1 +"
-  ? {C class info method definition fpo} "::C public class forward fpo ::o"
+  ? {C info object method definition add1} "::C public object forward add1 expr 1 +"
+  ? {C info object method definition fpo} "::C public object forward fpo ::o"
   
   ? {C info method definition s} "::C public setter s"
-  ? {C class info method definition spo} "::C public class setter spo"
+  ? {C info object method definition spo} "::C public object setter spo"
   
   ? {C info method definition a} "::C public alias a ::set"
-  ? {C class info method definition apo} "::C public class alias apo ::puts"
+  ? {C info object method definition apo} "::C public object alias apo ::puts"
   
   ? {::nx::Object info lookup methods -source application} ""
   ? {::nx::Class info lookup methods -source application} ""
 
-  set object_methods "alias cget configure contains copy delete destroy eval filter forward info method mixin move private property protected public require variable volatile"
-  set class_methods "alias cget class configure contains copy create delete destroy eval filter forward info method mixin move new private property protected public require variable volatile"
+  set object_methods "cget configure contains copy delete destroy eval info move object private protected public require volatile"
+  set class_methods "alias cget configure contains copy create delete destroy eval filter forward info method mixin move new object private property protected public require variable volatile"
 
-  ? {lsort [::nx::Object info lookup methods -source baseclasses]} $class_methods
-  ? {lsort [::nx::Class info lookup methods -source baseclasses]} $class_methods
+  ? {lsort [::nx::Object info lookup methods -source system]} $class_methods
+  ? {lsort [::nx::Class info lookup methods -source system]} $class_methods
   ? {lsort [::nx::Object info lookup methods -source all]} $class_methods
   ? {lsort [::nx::Class info lookup methods -source all]} $class_methods
   ? {lsort [::nx::Object info lookup methods]} $class_methods
   ? {lsort [::nx::Class info lookup methods]} $class_methods
   ? {lsort [C info lookup methods -source application]} "add1 apo fpo mpo spo"
   ? {lsort [c1 info lookup methods -source application]} "a addOne foo m m-with-assertions s"
-  ? {lsort [C info lookup methods -source baseclasses]} $class_methods
-  ? {lsort [c1 info lookup methods -source baseclasses]} $object_methods
+  ? {lsort [C info lookup methods -source system]} $class_methods
+  ? {lsort [c1 info lookup methods -source system]} $object_methods
 
   ::nx::configure defaultMethodCallProtection true
   #
@@ -152,47 +152,47 @@
     :protected method bar1 args {;}
     :method bar2 args {;}
     :public method foo args {;}
-    :public class method foo args {;}
+    :public object method foo args {;}
   }
 
-  ? {lsort [MC info methods -methodtype scripted -callprotection public]} "foo"
-  ? {lsort [MC info methods -methodtype scripted -callprotection protected]} "bar1 bar2"
-  ? {lsort [MC info methods -methodtype scripted -callprotection all]} "bar1 bar2 foo"
+  ? {lsort [MC info methods -type scripted -callprotection public]} "foo"
+  ? {lsort [MC info methods -type scripted -callprotection protected]} "bar1 bar2"
+  ? {lsort [MC info methods -type scripted -callprotection all]} "bar1 bar2 foo"
   
 
   ::nsf::method::property ::MC foo call-protected true
   ::nsf::method::property ::MC bar2 call-protected false
   
-  ? {lsort [MC info methods -methodtype scripted -callprotection public]} "bar2"
-  ? {lsort [MC info methods -methodtype scripted -callprotection protected]} "bar1 foo"
-  ? {lsort [MC info methods -methodtype scripted -callprotection all]} "bar1 bar2 foo"
+  ? {lsort [MC info methods -type scripted -callprotection public]} "bar2"
+  ? {lsort [MC info methods -type scripted -callprotection protected]} "bar1 foo"
+  ? {lsort [MC info methods -type scripted -callprotection all]} "bar1 bar2 foo"
   ::nx::configure defaultMethodCallProtection false
 }
 
 #
 # Test visability of obj-objects 
 #
 
-nx::Test case visability-sub-objects {
+nx::test case visability-sub-objects {
   ::nx::Object create o {
     ::nx::Object create [::nx::self]::sub {
-      :method foo {} {;}
+      :object method foo {} {;}
     }
-    :public alias soAlias ::o::sub
+    :public object alias soAlias ::o::sub
   }
   # 
   # per default, we see the alias and the subobject
   #
-  ? {o info methods} "soAlias sub"
-  ? {o info method type soAlias} "alias"
+  ? {o info object methods} "soAlias sub"
+  ? {o info object method type soAlias} "alias"
 
   # the subobject can be hidden via private (see protection.test)
 }
 
 #
 # Test visability of aliased Objects
 #
-nx::Test case visability-aliased-object {
+nx::test case visability-aliased-object {
   ::nx::Object create ::I
   ::nx::Class create C {
     :public alias i ::I
@@ -230,7 +230,7 @@
 ::nx::configure defaultMethodCallProtection false
 
 
-nx::Test case method-returns {
+nx::test case method-returns {
   
   #
   # A test object covering basic cases, adopted from returns.test
@@ -243,37 +243,37 @@
     # alias to tcl-cmd (no param defs for in-parameters)
     :alias incr -returns integer -frame object ::incr
     :forward ++ -returns integer ::expr 1 +
-    :public class method instances {} -returns object,1..n {:info instances}
+    :public object method instances {} -returns object,1..n {:info instances}
     :create c1 {
-      :public method foo {} -returns integer {;}
-      :public method "bar baz" {} -returns integer {;}
-      :public method "bar boo" {} -returns integer {;}
+      :public object method foo {} -returns integer {;}
+      :public object method "bar baz" {} -returns integer {;}
+      :public object method "bar boo" {} -returns integer {;}
     }
   }
 
   ? {C info method returns bar-ok1} "integer"
   ? {C info method returns bar-nok} "integer"
   ? {C info method returns incr} "integer"
   ? {C info method returns ++} "integer"
-  ? {C class info method returns instances} "object,1..n"
-  ? {c1 info method returns foo} "integer"
-  ? {c1 info method returns "bar baz"} "integer"
-  ? {c1 info method returns "bar boo"} "integer"
+  ? {C info object method returns instances} "object,1..n"
+  ? {c1 info object method returns foo} "integer"
+  ? {c1 info object method returns "bar baz"} "integer"
+  ? {c1 info object method returns "bar boo"} "integer"
   #
   # Ensemble object ...
   #
-  ? {c1 info method returns bar} ""
+  ? {c1 info object method returns bar} ""
   #
   # Non-existing method ...
   #
-  ? {c1 info method returns baf} ""
+  ? {c1 info object method returns baf} ""
   #
   # Non-existing submethod ...
   #
-  ? {c1 info method returns "bar baf"} ""
+  ? {c1 info object method returns "bar baf"} ""
 }
 
-nx::Test case method-definition-with-returns {
+nx::test case method-definition-with-returns {
   #
   # A test object covering basic cases, adopted from returns.test
   #
@@ -285,10 +285,10 @@
     # alias to tcl-cmd (no param defs for in-parameters)
     :alias incr -returns integer -frame object ::incr
     :forward ++ -returns integer ::expr 1 +
-    :public class method instances {} -returns object,1..n {;}
+    :public object method instances {} -returns object,1..n {;}
     :create c1 {
-      :public method foo {} -returns integer {;}
-      :method "bar baz" {} -returns integer {;}
+      :public object method foo {} -returns integer {;}
+      :object method "bar baz" {} -returns integer {;}
     }
   }
 
@@ -298,15 +298,15 @@
   ? {C info method definition incr} "::C public alias incr -frame object -returns integer ::incr"
   ? {C info method definition ++} "::C public forward ++ -returns integer ::expr 1 +"
 
-  ? {C class info method definition instances} \
-      "::C public class method instances {} -returns object,1..n {;}"
+  ? {C info object method definition instances} \
+      "::C public object method instances {} -returns object,1..n {;}"
 
-  ? {c1 info method definition foo} "::c1 public method foo {} -returns integer {;}"
-  ? {c1 info method definition "bar baz"} "::c1 public method {bar baz} {} -returns integer {;}"
+  ? {c1 info object method definition foo} "::c1 public object method foo {} -returns integer {;}"
+  ? {c1 info object method definition "bar baz"} "::c1 public object method {bar baz} {} -returns integer {;}"
 
 }
 
-nx::Test case copy-with-returns {
+nx::test case copy-with-returns {
     nx::Class create C {
     # scripted method without paramdefs for in-parameters
     :method bar-ok1 {a b} -returns integer {;}
@@ -315,20 +315,20 @@
     # alias to tcl-cmd (no param defs for in-parameters)
     :alias incr -returns integer -frame object ::incr
     :forward ++ -returns integer ::expr 1 +
-    :public class method instances {} -returns object,1..n {;}
+    :public object method instances {} -returns object,1..n {;}
     :create c1 {
-      :public method foo {} -returns integer {;}
-      :method "bar baz" {} -returns integer {;}
+      :public object method foo {} -returns integer {;}
+      :object method "bar baz" {} -returns integer {;}
     }
   }
 
   c1 copy c2
 
-  ? {c2 info method returns foo} [c1 info method returns foo]
-  ? {c2 info method definition foo} [lreplace [c1 info method definition foo] 0 0 ::c2]
-  ? {c2 info method returns "bar baz"} [c1 info method returns "bar baz"]
-  ? {c2 info method definition "bar baz"} [lreplace [c1 info method definition "bar baz"] 0 0 ::c2]
-  ? {c2 info method returns "bar boo"} [c1 info method returns "bar boo"]
+  ? {c2 info object method returns foo} [c1 info object method returns foo]
+  ? {c2 info object method definition foo} [lreplace [c1 info object method definition foo] 0 0 ::c2]
+  ? {c2 info object method returns "bar baz"} [c1 info object method returns "bar baz"]
+  ? {c2 info object method definition "bar baz"} [lreplace [c1 info object method definition "bar baz"] 0 0 ::c2]
+  ? {c2 info object method returns "bar boo"} [c1 info object method returns "bar boo"]
 
   C copy CC
   
@@ -342,8 +342,8 @@
   #
   # ? {CC info method returns incr} [C info method returns incr]
   # ? {CC info method returns ++} [C info method returns ++]
-  ? {CC class info method returns instances} [C class info method returns instances]
-  ? {CC class info method definition instances} [lreplace [C class info method definition instances] 0 0 ::CC]
+  ? {CC info object method returns instances} [C info object method returns instances]
+  ? {CC info object method definition instances} [lreplace [C info object method definition instances] 0 0 ::CC]
 }
 
 #
@@ -354,7 +354,7 @@
 ::nx::configure defaultMethodCallProtection $dmcFlag
 # --
 
-nx::Test case callable {
+nx::test case callable {
     # define the same method for Object and Class
     ::nx::Object method bar {} {return Object.bar}
     ::nx::Class method bar {} {return Class.bar}
@@ -364,36 +364,36 @@
     ? {o info lookup methods bar} bar
     ? {o bar} Object.bar
 
-    o mixin ::nx::Class
+    o object mixin ::nx::Class
     ? {o info precedence} "::nx::Class ::nx::Object"
     ? {o info lookup method bar} "::nsf::classes::nx::Class::bar"
     ? {o info lookup methods bar} bar
     ? {o info lookup methods create} ""
     ? {o info lookup method create} ""
     ? {o bar} Class.bar
 
-    ? {o method foo {} {return o.foo}} "::o::foo"
-    ? {o alias is ::nsf::is} "::o::is"
-    #? {o property x} {variable definition for 'x' (without value and accessor) is useless}
-    ? {o property x} "::o::x"
-    ? {o property -accessor public x} "::o::x"
-    ? {lsort [o info methods]} "foo is x"
+    ? {o object method foo {} {return o.foo}} "::o::foo"
+    ? {o object alias is ::nsf::is} "::o::is"
+    #? {o object property x} {variable definition for 'x' (without value and accessor) is useless}
+    ? {o object property x} ""
+    ? {o object property -accessor public x} "::o::x"
+    ? {lsort [o info object methods]} "foo is x"
 
-    #? {o property A} {variable definition for 'A' (without value and accessor) is useless}
-    ? {o property A} ::o::A
-    ? {o property -accessor public A} ::o::A
-    ? {o forward fwd ::set} ::o::fwd
-    ? {lsort [o info methods]} "A foo fwd is x"
+    #? {o object property A} {variable definition for 'A' (without value and accessor) is useless}
+    ? {o object property A} ""
+    ? {o object property -accessor public A} ::o::A
+    ? {o object forward fwd ::set} ::o::fwd
+    ? {lsort [o info object methods]} "A foo fwd is x"
 
-    o method f args ::nx::next
+    o object method f args ::nx::next
     ? {o info lookup methods create} ""
-    ? {o info lookup methods filter} "filter"
-    ? {o info lookup method filter} "::nsf::classes::nx::Object::filter"
-    ? {o filter f} "f"
-    ? {o filter guard f { 1 == 1 }} ""
-    ? {o info filter guard f} " 1 == 1 "
-    ? {o filter guard f} " 1 == 1 "
-    o filter ""
+    ? {o info lookup methods configure} configure
+    ? {o info lookup method configure} "::nsf::classes::nx::Object::configure"
+    ? {o object filter f} "f"
+    ? {o object filter guard f { 1 == 1 }} ""
+    ? {o info object filter guard f} " 1 == 1 "
+    ? {o object filter guard f} " 1 == 1 "
+    o object filter ""
 
     nx::Class create Foo
     ? {Foo method f args ::nx::next} "::nsf::classes::Foo::f"
@@ -407,26 +407,26 @@
     ? {Foo info filter methods -guards} "{f -guard {2 == 2}} f2"
     ? {Foo filter {}} ""
 
-    ? {Foo class method f args ::nx::next} "::Foo::f"
-    ? {Foo class method f2 args ::nx::next} "::Foo::f2"
-    ? {Foo class filter {f f2}} "f f2"
-    ? {Foo class info filter methods} "f f2"
-    ? {Foo class filter guard f {2 == 2}} ""
-    ? {Foo class info filter guard f} "2 == 2"
-    ? {Foo class info filter methods -guards f} "{f -guard {2 == 2}}"
-    ? {Foo class info filter methods -guards f2} "f2"
-    ? {Foo class info filter methods -guards} "{f -guard {2 == 2}} f2"
-    ? {Foo class filter {}} ""
+    ? {Foo object method f args ::nx::next} "::Foo::f"
+    ? {Foo object method f2 args ::nx::next} "::Foo::f2"
+    ? {Foo object filter {f f2}} "f f2"
+    ? {Foo info object filter methods} "f f2"
+    ? {Foo object filter guard f {2 == 2}} ""
+    ? {Foo info object filter guard f} "2 == 2"
+    ? {Foo info object filter methods -guards f} "{f -guard {2 == 2}}"
+    ? {Foo info object filter methods -guards f2} "f2"
+    ? {Foo info object filter methods -guards} "{f -guard {2 == 2}} f2"
+    ? {Foo object filter {}} ""
     Foo destroy 
 
     nx::Class create Fly
-    o mixin add Fly
-    ? {o info mixin classes} "::Fly ::nx::Class"
-    ? {o mixin guard ::Fly {1}} ""
-    ? {o info mixin classes -guards} "{::Fly -guard 1} ::nx::Class"
-    ? {o info mixin classes -guards Fly} "{::Fly -guard 1}"
-    o mixin delete ::Fly
-    ? {o info mixin classes} "::nx::Class"
+    o object mixin add Fly
+    ? {o info object mixin classes} "::Fly ::nx::Class"
+    ? {o object mixin guard ::Fly {1}} ""
+    ? {o info object mixin classes -guards} "{::Fly -guard 1} ::nx::Class"
+    ? {o info object mixin classes -guards Fly} "{::Fly -guard 1}"
+    o object mixin delete ::Fly
+    ? {o info object mixin classes} "::nx::Class"
 
     nx::Class create Foo
     Foo mixin add ::nx::Class
@@ -438,27 +438,27 @@
     Foo mixin delete ::Fly
     ? {Foo info mixin classes} "::nx::Class"
 
-    Foo class mixin add ::nx::Class
-    Foo class mixin add Fly
-    ? {Foo class info mixin classes} "::Fly ::nx::Class"
-    ? {Foo class mixin guard ::Fly {1}} ""
-    ? {Foo class info mixin classes -guards} "{::Fly -guard 1} ::nx::Class"
-    ? {Foo class info mixin classes -guards Fly} "{::Fly -guard 1}"
+    Foo object mixin add ::nx::Class
+    Foo object mixin add Fly
+    ? {Foo info object mixin classes} "::Fly ::nx::Class"
+    ? {Foo object mixin guard ::Fly {1}} ""
+    ? {Foo info object mixin classes -guards} "{::Fly -guard 1} ::nx::Class"
+    ? {Foo info object mixin classes -guards Fly} "{::Fly -guard 1}"
 
-    Foo class mixin delete ::Fly
-    ? {Foo class info mixin classes} "::nx::Class"
+    Foo object mixin delete ::Fly
+    ? {Foo info object mixin classes} "::nx::Class"
 
     ? {Foo info lookup methods create} "create"
     ? {Foo info lookup method create} "::nsf::classes::nx::Class::create"
     
-    ? {o mixin ""} ""
+    ? {o object mixin ""} ""
 }
 
 
 #
 # test info slot objects / info lookup slots
 #
-nx::Test case info-slots {
+nx::test case info-slots {
 
   nx::Class create C {
     :property a
@@ -468,99 +468,119 @@
   nx::Class create D -superclass C {
     :property {b 2}
     :property c
-    :class property -accessor public {a2 ""}
+    :object property -accessor public {a2 ""}
     :method "sub foo" args {;}
     :create d1 {
-      :property -accessor public {a3 ""}
+      :object property -accessor public {a3 ""}
     }
   }
 
-  ? {C info slot objects} "::C::slot::a ::C::slot::b"
-  ? {D info slot objects} "::D::slot::b ::D::slot::c"
-  ? {D info slot objects -closure -source application} "::D::slot::b ::D::slot::c ::C::slot::a"
+  ? {C info slots} "::C::slot::a ::C::slot::b"
+  ? {D info slots} "::D::slot::b ::D::slot::c"
+  ? {D info slots -closure -source application} "::D::slot::b ::D::slot::c ::C::slot::a"
   ? {d1 info lookup slots -source application} "::d1::per-object-slot::a3 ::D::slot::b ::D::slot::c ::C::slot::a"
 
-  ? {D class info slot objects} "::D::per-object-slot::a2"
-  ? {d1 info slot objects} "::d1::per-object-slot::a3"
-  ? {C class info slot objects} ""
+  ? {D info object slots} "::D::per-object-slot::a2"
+  ? {d1 info object slots} "::d1::per-object-slot::a3"
+  ? {C info object slots} ""
 }
 
 #
 # test info slot objects / info lookup slots
 #
-nx::Test case slots {
+nx::test case slots {
 
   nx::Class create C {
     :property a
     :property {b 1}
+    :property -accessor private {x 100}
+    :object property -accessor private {y 100}
   }
   
   nx::Class create D -superclass C {
     :property {b 2}
     :property c
-    :class property -accessor public a2
+    :object property -accessor public a2
     :method "sub foo" args {;}
+    :create d1
   }
 
-  ? {D info lookup slots} "::D::per-object-slot::a2 ::nx::Class::slot::superclass ::nx::Class::slot::object-mixin ::nx::Class::slot::mixin ::nx::Class::slot::object-filter ::nx::Class::slot::filter ::nx::Object::slot::volatile ::nx::Object::slot::noinit ::nx::Object::slot::__initcmd ::nx::Object::slot::class"
+  ? {lsort [D info lookup slots]} "::D::per-object-slot::a2 ::nx::Class::slot::filter ::nx::Class::slot::mixin ::nx::Class::slot::superclass ::nx::Object::slot::__initblock ::nx::Object::slot::class ::nx::Object::slot::noinit ::nx::Object::slot::object-filter ::nx::Object::slot::object-mixin ::nx::Object::slot::volatile"
 
+  ? {D info lookup slots superclass} "::nx::Class::slot::superclass"
+  ? {D info lookup slots ::nx::Class::slot::superclass} "::nx::Class::slot::superclass"
+  ? {D info lookup slots a2} "::D::per-object-slot::a2"
+  ? {D info lookup slots ::D::per-object-slot::a2} "::D::per-object-slot::a2"
+
+  ? {d1 info lookup slots b} "::D::slot::b"
+  ? {d1 info lookup slots ::D::slot::b} "::D::slot::b"
+
   C create c1
   ? {c1 info precedence} "::C ::nx::Object"
   ? {C info heritage} "::nx::Object"
-  ? {C info slot objects -closure -source application} "::C::slot::a ::C::slot::b"
-  ? {C info slot objects -closure} "::C::slot::a ::C::slot::b ::nx::Object::slot::volatile ::nx::Object::slot::noinit ::nx::Object::slot::mixin ::nx::Object::slot::__initcmd ::nx::Object::slot::class ::nx::Object::slot::filter"
+  ? {C info slots -closure -source application} "::C::slot::____C.x ::C::slot::a ::C::slot::b"
+  ? {lsort [C info slots -closure]} \
+      "::C::slot::____C.x ::C::slot::a ::C::slot::b ::nx::Object::slot::__initblock ::nx::Object::slot::class ::nx::Object::slot::noinit ::nx::Object::slot::object-filter ::nx::Object::slot::object-mixin ::nx::Object::slot::volatile"
 
-  ? {C info slot objects} "::C::slot::a ::C::slot::b"
+  ? {C info slots} "::C::slot::____C.x ::C::slot::a ::C::slot::b"
 
-  # Test patterns for "info slot objects"
+  ? {C info slots x} "::C::slot::____C.x"
+  ? {C info slots ::C::slot::____C.x} "::C::slot::____C.x"
+
+  ? {C info lookup slots y} "::C::per-object-slot::____C.y"
+  ? {C info lookup slots ::C::per-object-slot::____C.y} "::C::per-object-slot::____C.y"
+
+  # Test patterns for "info slots"
   # Partial name, no metachars
-  ? {C info slot objects -closure mixin} "::nx::Object::slot::mixin"
+  ? {C info slots -closure object-mixin} "::nx::Object::slot::object-mixin"
   # Partial name with metachars
-  ? {C info slot objects -closure *in*} \
-      "::nx::Object::slot::noinit ::nx::Object::slot::mixin ::nx::Object::slot::__initcmd"
+  ? {C info slots -closure *in*} \
+      "::nx::Object::slot::__initblock ::nx::Object::slot::noinit ::nx::Object::slot::object-mixin"
   # Fully qualified name, no metachars
-  ? {C info slot objects -closure ::nx::Object::slot::mixin} "::nx::Object::slot::mixin"
+  ? {C info slots -closure ::nx::Object::slot::object-mixin} "::nx::Object::slot::object-mixin"
   # Fully qualified name, with metachars
-  # The following command returns the same as "C info slot objects"
-  ? {C info slot objects -closure ::C::*} "::C::slot::a ::C::slot::b"
+  # The following command returns the same as "C info slots"
+  ? {C info slots -closure ::C::*} "::C::slot::____C.x ::C::slot::a ::C::slot::b"
   # The following command returns the slots of D inherited from
-  # C. Slot "b" is shadoed by D.
-  ? {D info slot objects -closure ::C::*} "::C::slot::a"
+  # C. Slot "b" is shadowed by D.
+  ? {D info slots -closure ::C::*} "::C::slot::____C.x ::C::slot::a"
   
   # Test patterns for "info lookup slots"
   # Partial name, no metachars
-  ? {c1 info lookup slots mixin} "::nx::Object::slot::mixin"
+  ? {c1 info lookup slots object-mixin} "::nx::Object::slot::object-mixin"
   # Partial name with metachars
   ? {c1 info lookup slots *in*} \
-      "::nx::Object::slot::noinit ::nx::Object::slot::mixin ::nx::Object::slot::__initcmd"
+      "::nx::Object::slot::__initblock ::nx::Object::slot::noinit ::nx::Object::slot::object-mixin"
   # Fully qualified name, no metachars
-  ? {c1 info lookup slots ::nx::Object::slot::mixin} "::nx::Object::slot::mixin"
+  ? {c1 info lookup slots ::nx::Object::slot::object-mixin} "::nx::Object::slot::object-mixin"
   # Fully qualified name, with metachars
-  ? {c1 info lookup slots ::C::*} "::C::slot::a ::C::slot::b"
+  ? {c1 info lookup slots ::C::*} "::C::slot::____C.x ::C::slot::a ::C::slot::b"
 
   D create d1
-  ? {D info slot objects} "::D::slot::b ::D::slot::c"
-  ? {D info slot objects -closure -source application} "::D::slot::b ::D::slot::c ::C::slot::a"
+  ? {D info slots} "::D::slot::b ::D::slot::c"
+  ? {D info slots -closure -source application} "::D::slot::b ::D::slot::c ::C::slot::____C.x ::C::slot::a"
 
-  ? {::nx::Object info method parameter info} ""
+  ? {::nx::Object info method parameters info} ""
 
   ? {d1 info precedence} "::D ::C ::nx::Object"
-  ? {d1 info lookup slots} "::D::slot::b ::D::slot::c ::C::slot::a ::nx::Object::slot::volatile ::nx::Object::slot::noinit ::nx::Object::slot::mixin ::nx::Object::slot::__initcmd ::nx::Object::slot::class ::nx::Object::slot::filter"
+  ? {lsort [d1 info lookup slots]} \
+      "::C::slot::____C.x ::C::slot::a ::D::slot::b ::D::slot::c ::nx::Object::slot::__initblock ::nx::Object::slot::class ::nx::Object::slot::noinit ::nx::Object::slot::object-filter ::nx::Object::slot::object-mixin ::nx::Object::slot::volatile"
 
+
   # Fully qualified name, with metachars
   # The following command returns the slots of D inherited from
-  # C. Slot "b" is shadoed by D.
-  ? {d1 info lookup slots ::C::*} "::C::slot::a"
+  # C. Slot "b" is shadowed by D.
+  ? {d1 info lookup slots ::C::*} "::C::slot::____C.x ::C::slot::a"
 }
 
 #
 # test info submethod and method handles for submethods
 #
-nx::Test case info-submethod {
+nx::test case info-submethod {
 
   nx::Object create o {
-    :method "foo a" {} {return a}
-    :method "foo b" {x:int y:upper} {return b}
+    :object method "foo a" {} {return a}
+    :object method "foo b" {x:int y:upper} {return b}
   }
   nx::Object create o2
   
@@ -569,53 +589,53 @@
     :method "bar b" {x:int y:upper} {return b}
     :method "bar baz x" {x:int y:upper} {return x}
     :method "bar baz y" {x:int y:upper} {return y}
-    :class method "foo x" {z:int} {return z}
-    :class method "foo y" {z:int} {return z}
+    :object method "foo x" {z:int} {return z}
+    :object method "foo y" {z:int} {return z}
   }
 
   # query definition on submethod
-  ? {o info method definition "foo b"}  {::o public method {foo b} {x:int y:upper} {return b}}
+  ? {o info object method definition "foo b"}  {::o public object method {foo b} {x:int y:upper} {return b}}
 
   # query definition on submethod with handle
-  ? {o info method definition "::o::foo b"}  {::o public method {foo b} {x:int y:upper} {return b}}
+  ? {o info object method definition "::o::foo b"}  {::o public object method {foo b} {x:int y:upper} {return b}}
 
   # query definition on submethod with handle
-  ? {o info method definition "::o::foo b"}  {::o public method {foo b} {x:int y:upper} {return b}}
+  ? {o info object method definition "::o::foo b"}  {::o public object method {foo b} {x:int y:upper} {return b}}
 
   # query definition on submethod with handle called on different object
-  ? {o2 info method definition "::o::foo b"}  {::o public method {foo b} {x:int y:upper} {return b}}
+  ? {o2 info object method definition "::o::foo b"}  {::o public object method {foo b} {x:int y:upper} {return b}}
 
   # query definition on handle of ensemble object called on different object
-  ? {o2 info method definition "::o::foo::b"} {::o::foo public method b {x:int y:upper} {return b}}
+  ? {o2 info object method definition "::o::foo::b"} {::o::foo public object method b {x:int y:upper} {return b}}
 
   # query definition on submethod with handle called on class
-  ? {o2 info method definition "::o::foo b"}  {::o public method {foo b} {x:int y:upper} {return b}}
+  ? {o2 info object method definition "::o::foo b"}  {::o public object method {foo b} {x:int y:upper} {return b}}
 
   # query definition on handle of ensemble object called on class
-  ? {o2 info method definition "::o::foo::b"} {::o::foo public method b {x:int y:upper} {return b}}
+  ? {o2 info object method definition "::o::foo::b"} {::o::foo public object method b {x:int y:upper} {return b}}
 
   # query definition on submethod of class
   ? {::nx::Object info method definition "info lookup methods"} \
       {::nx::Object public alias {info lookup methods} ::nsf::methods::object::info::lookupmethods}
 
   # query definition on submethod of class with handle
-  ? {o info method definition "::nsf::classes::nx::Object::info lookup methods"} \
+  ? {o info object method definition "::nsf::classes::nx::Object::info lookup methods"} \
       {::nx::Object public alias {info lookup methods} ::nsf::methods::object::info::lookupmethods}
 
   # query definition on handle of ensemble object of class
-  ? {o info method definition "::nx::Object::slot::__info::lookup::methods"} \
-      {::nx::Object::slot::__info::lookup public alias methods ::nsf::methods::object::info::lookupmethods}
+  ? {o info object method definition "::nx::Object::slot::__info::lookup::methods"} \
+      {::nx::Object::slot::__info::lookup public object alias methods ::nsf::methods::object::info::lookupmethods}
 
-  ? {lsort [o info method submethods dummy]} ""
-  ? {lsort [o info method submethods foo]} "a b"
-  ? {lsort [o info method submethods "foo a"]} ""
+  ? {lsort [o info object method submethods dummy]} ""
+  ? {lsort [o info object method submethods foo]} "a b"
+  ? {lsort [o info object method submethods "foo a"]} ""
   ? {lsort [C info method submethods "bar"]} "a b baz"
   ? {lsort [C info method submethods "bar a"]} ""
   ? {lsort [C info method submethods "bar baz"]} "x y"
   ? {lsort [C info method submethods "bar baz y"]} ""
 
-  ? {lsort [C class info method submethods "foo"]} "x y"
-  ? {lsort [C class info method submethods "foo x"]} ""
+  ? {lsort [C info object method submethods "foo"]} "x y"
+  ? {lsort [C info object method submethods "foo x"]} ""
 
   #
   # method handles for ensemble methods
@@ -627,48 +647,48 @@
   #
   # test whether the handles for ensemble methods work
   #
-  ? {C info method parameter [C info method registrationhandle "bar"]} ""
-  ? {C info method parameter [C info method registrationhandle "bar b"]} "x:int y:upper"
-  ? {C info method parameter [C info method registrationhandle "bar baz y"]} "x:int y:upper"
+  ? {C info method parameters [C info method registrationhandle "bar"]} ""
+  ? {C info method parameters [C info method registrationhandle "bar b"]} "x:int y:upper"
+  ? {C info method parameters [C info method registrationhandle "bar baz y"]} "x:int y:upper"
   
   #
   # check methods paths as method specifications
   #
   ? {C info method definition "bar b"} {::C public method {bar b} {x:int y:upper} {return b}}
   ? {C info method definition "::nsf::classes::C::bar b"}  {::C public method {bar b} {x:int y:upper} {return b}}
-  ? {o2 info method definition "::nsf::classes::C::bar b"} {::C public method {bar b} {x:int y:upper} {return b}}
+  ? {o2 info object method definition "::nsf::classes::C::bar b"} {::C public method {bar b} {x:int y:upper} {return b}}
 
   #
   # test class modifier on handles
   #
-  ? {C class info method registrationhandle "foo"}   {::C::foo}
-  ? {C class info method registrationhandle "foo x"} {::C::foo x}
+  ? {C info object method registrationhandle "foo"}   {::C::foo}
+  ? {C info object method registrationhandle "foo x"} {::C::foo x}
 
   #
   # info method definition with method paths
   #
-  ? {C class info method definition "::C::foo x"} {::C public class method {foo x} z:int {return z}}
-  ? {C info method definition "::C::foo x"}        {::C public class method {foo x} z:int {return z}}
-  ? {o2 info method definition "::C::foo x"}       {::C public class method {foo x} z:int {return z}}
+  ? {C info object method definition "::C::foo x"}  {::C public object method {foo x} z:int {return z}}
+  ? {C info method definition "::C::foo x"}         {::C public object method {foo x} z:int {return z}}
+  ? {o2 info object method definition "::C::foo x"} {::C public object method {foo x} z:int {return z}}
   
   ? {C info method definition "bar baz y"} \
       {::C public method {bar baz y} {x:int y:upper} {return y}}
   ? {C info method definition "::nsf::classes::C::bar baz y"} \
       {::C public method {bar baz y} {x:int y:upper} {return y}}
 
   #
-  # test "info method parameter"
+  # test "info method parameters"
   #
-  ? {nx::Object info method parameter "info lookup methods"} \
-      "-callprotection -incontext:switch -methodtype -nomixins:switch -path:switch -source pattern:optional"
+  ? {nx::Object info method parameters "info lookup methods"} \
+      "-callprotection -incontext:switch -type -nomixins:switch -path:switch -source pattern:optional"
   ? {nx::Object info method syntax "info lookup methods"} \
-      "?-callprotection all|public|protected|private? ?-incontext? ?-methodtype all|scripted|builtin|alias|forwarder|object|setter|nsfproc? ?-nomixins? ?-path? ?-source all|application|baseclasses? ?pattern?"
+      "/cls/ info lookup methods ?-callprotection all|public|protected|private? ?-incontext? ?-type all|scripted|builtin|alias|forwarder|object|setter|nsfproc? ?-nomixins? ?-path? ?-source all|application|system? ?/pattern/?"
 
-  ? {o info method parameter "foo b"} "x:int y:upper"
+  ? {o info object method parameters "foo b"} "x:int y:upper"
 
-  ? {nx::Object info method parameter ::nx::Object::slot::__info::lookup::methods} \
-      "-callprotection -incontext:switch -methodtype -nomixins:switch -path:switch -source pattern:optional"
-  ? {o info method parameter "::o::foo::b"} "x:int y:upper"
+  ? {nx::Object info method parameters ::nx::Object::slot::__info::lookup::methods} \
+      "-callprotection -incontext:switch -type -nomixins:switch -path:switch -source pattern:optional"
+  ? {o info object method parameters "::o::foo::b"} "x:int y:upper"
 
   ? {nx::Object info method registrationhandle "info"} "::nsf::classes::nx::Object::info"
   ? {nx::Object info method registrationhandle "info lookup methods"} \
@@ -677,13 +697,13 @@
   ? {nx::Object info method registrationhandle "::nsf::classes::nx::Object::info lookup methods"} \
       "::nsf::classes::nx::Object::info lookup methods"
 
-  ? {o info method registrationhandle "foo b"} "::o::foo b"
+  ? {o info object method registrationhandle "foo b"} "::o::foo b"
 }
 
 #
 # test info slot parameter|parametersyntax 
 #
-nx::Test case info-slot-parametersyntax {
+nx::test case info-slot-parametersyntax {
 
   nx::Class create C {
     :property a
@@ -693,49 +713,49 @@
   nx::Class create D -superclass C {
     :property {b 2}
     :property c
-    :class property -accessor public a2
+    :object property -accessor public a2
     :method "sub foo" args {;}
   }
 
   C new
-  ? {C info parameter syntax} "?-a value? ?-b value? ?-volatile? ?-noinit? ?-mixin mixinreg ...? ?-class class? ?-filter filterreg ...? ?__initcmd?"
-  ? {C info parameter syntax a} "?-a value?"
+  ? {C info configure syntax} "/::C/ ?-a /value/? ?-b /value/? ?-volatile? ?-noinit? ?-object-mixin /mixinreg .../? ?-class /class/? ?-object-filter /filterreg .../? ?/__initblock/?"
+#  ? {C info configure syntax a} "/::C/ ?-a /value/?"
 
-  ? {C info parameter definitions} "-a {-b 1} -volatile:alias,slot=::nx::Object::slot::volatile,slotassign,noarg -noinit:alias,method=::nsf::methods::object::noinit,noarg -mixin:mixinreg,alias,0..n -class:class,alias,method=::nsf::methods::object::class -filter:filterreg,alias,0..n __initcmd:initcmd,optional,noleadingdash"
+  ? {C info configure parameters } "-a {-b 1} -volatile:alias,slot=::nx::Object::slot::volatile,slotassign,noarg -noinit:alias,method=::nsf::methods::object::noinit,noarg -object-mixin:mixinreg,alias,method=::nx::Object::slot::__object::mixin,0..n -class:class,alias,method=::nsf::methods::object::class -object-filter:filterreg,alias,method=::nx::Object::slot::__object::filter,0..n __initblock:cmd,optional,noleadingdash"
 
-  ? {C info parameter list} "-a -b -volatile -noinit -mixin -class -filter __initcmd"
-  ? {C info parameter names} "a b volatile noinit mixin class filter __initcmd"
-  ? {lsort [C info slot objects -closure]} "::C::slot::a ::C::slot::b ::nx::Object::slot::__initcmd ::nx::Object::slot::class ::nx::Object::slot::filter ::nx::Object::slot::mixin ::nx::Object::slot::noinit ::nx::Object::slot::volatile"
+#  ? {C info parameter list} "-a -b -volatile -noinit -object-mixin -class -object-filter __initblock"
+#  ? {C info parameter names} "a b volatile noinit object-mixin class object-filter __initblock"
+  ? {lsort [C info slots -closure]} "::C::slot::a ::C::slot::b ::nx::Object::slot::__initblock ::nx::Object::slot::class ::nx::Object::slot::noinit ::nx::Object::slot::object-filter ::nx::Object::slot::object-mixin ::nx::Object::slot::volatile"
 
-  ? {C info parameter definitions b} "{-b 1}"
-  ? {D info parameter definitions b} "{-b 2}"
-  ? {D info slot objects -closure b} "::D::slot::b"
-  ? {D info slot objects -closure a} "::C::slot::a"
-  ? {D info slot objects -closure class} "::nx::Object::slot::class"
+  ? {C info configure parameters b} "{-b 1}"
+  ? {D info configure parameters b} "{-b 2}"
+  ? {D info slots -closure b} "::D::slot::b"
+  ? {D info slots -closure a} "::C::slot::a"
+  ? {D info slots -closure class} "::nx::Object::slot::class"
 
-  ? {D info parameter list} "-b -c -a -volatile -noinit -mixin -class -filter __initcmd"
-  ? {D info parameter names} "b c a volatile noinit mixin class filter __initcmd"
+#  ? {D info parameter list} "-b -c -a -volatile -noinit -object-mixin -class -object-filter __initblock"
+#  ? {D info parameter names} "b c a volatile noinit object-mixin class object-filter __initblock"
 }
 
 #
 # test "info methods -path"
 #
-nx::Test case info-methods-path {
+nx::test case info-methods-path {
   #
   # test case on base class
   #
   ? {::nx::Object info methods "info"} "info"
   ? {::nx::Object info methods -path "info"} ""
   ? {lsort [::nx::Object info methods -path "info lookup *"]} \
-      "{info lookup filter} {info lookup method} {info lookup methods} {info lookup parameter definitions} {info lookup parameter list} {info lookup parameter names} {info lookup parameter syntax} {info lookup slots}"
-  ? {lsort [::nx::Object info methods -path "info *method*"]} \
-      "{info filter methods} {info lookup method} {info lookup methods} {info method} {info methods}"
+      "{info lookup configure parameters} {info lookup configure syntax} {info lookup filter} {info lookup method} {info lookup methods} {info lookup slots} {info lookup variables}"
+  ? {lsort [::nx::Object info methods -path "info *parameter*"]} \
+      "{info lookup configure parameters} {info object method parameters} {info parameter default} {info parameter name} {info parameter syntax} {info parameter type} {info variable parameter}"
   ? {lsort [::nx::Object info methods "slots"]} ""
   ? {lsort [::nx::Object info methods "*slots*"]} ""
   ? {lsort [::nx::Object info methods -path "*slot*"]} \
-      "{info lookup slots} {info slot definitions} {info slot names} {info slot objects}"
+      "{info lookup slots} {info object slots}"
   ? {lsort [::nx::Object info methods -path "*filter*"]} \
-      "filter {info filter guard} {info filter methods} {info lookup filter}"
+      "{info lookup filter} {info object filter guard} {info object filter methods} {object filter}"
 
   ::nx::Class create C {
     :public method "string length" {s} {puts length}
@@ -778,20 +798,21 @@
 #
 # Test parameter syntax for a methods and cmds
 #
-nx::Test case parametersyntax {
+nx::test case parametersyntax {
   # a true method
-  ? {::nx::Object info method syntax method} "name arguments ?-returns value? body ?-precondition value? ?-postcondition value?"
+  ? {::nx::Class info method syntax method} \
+      "/cls/ method /name/ /arguments/ ?-checkalways? ?-returns /value/? /body/ ?-precondition /value/? ?-postcondition /value/?"
   # a forwarder to ::nsf::relation; definition comes via array ::nsf::parametersyntax
-  ? {::nx::Object info method syntax mixin} "?classes?|?add class?|?delete class?"
+  ? {::nx::Class info method syntax mixin} "/cls/ mixin ?/class .../?|?add /class/?|?delete /class/?"
 
-  ? {::nx::Object info method syntax ::nx::next} "?arguments?"
-  ? {::nx::Object info method syntax ::nsf::xotclnext} "?--noArgs? ?arg ...?"
+  ? {::nx::Class info method syntax ::nx::next} "/cls/ next ?/arguments/?"
+  ? {::nx::Class info method syntax ::nsf::xotclnext} "/cls/ xotclnext ?--noArgs? ?/arg .../?"
 }
 
 #
 # Test info heritage, base cases
 #
-nx::Test case info-heritage {
+nx::test case info-heritage {
   Class create A
   Class create B -superclass A
   Class create BB -superclass B
@@ -838,7 +859,7 @@
 #
 # Test transitive per-class mixins
 #
-nx::Test case info-heritage-transitive {
+nx::test case info-heritage-transitive {
   Class create O
   Class create A -superclass O
   Class create B -superclass A
@@ -879,7 +900,7 @@
 #
 # Test circular mixins
 #
-nx::Test case info-heritage-circular {
+nx::test case info-heritage-circular {
   Class create O
   Class create A -superclass O
   Class create B -superclass A
@@ -940,7 +961,7 @@
 #
 # Mixin the same class twice, once per-class and one per-object.
 #
-nx::Test case info-heritage-simple-multimix {
+nx::test case info-heritage-simple-multimix {
   Class create Agent
   Class create MovementTest
   Class create MovementLog
@@ -951,7 +972,7 @@
   ? {Agent info heritage} "::MovementTest ::nx::Object"
   ? {a1 info precedence} "::MovementTest ::Agent ::nx::Object"
 
-  a1 mixin {MovementTest MovementLog}
+  a1 object mixin {MovementTest MovementLog}
 
   ? {Agent info heritage} "::MovementTest ::nx::Object"
   ? {a1 info precedence} "::MovementTest ::MovementLog ::Agent ::nx::Object"
@@ -961,7 +982,7 @@
 # Mixin several classes at several class levels and on the object
 # level
 #
-nx::Test case info-heritage-multimix {
+nx::test case info-heritage-multimix {
   Class create A
   Class create B -superclass A
   Class create M1
@@ -972,14 +993,17 @@
   B create b1
   ? {B info heritage} "::A ::nx::Object"
   ? {b1 info precedence} "::B ::A ::nx::Object"
+  ? {b1 info precedence ::M*} ""
 
   A mixin {M1 M2}
   ? {B info heritage} "::M1 ::M2 ::A ::nx::Object"
   ? {b1 info precedence} "::M1 ::M2 ::B ::A ::nx::Object"
+  ? {b1 info precedence ::M*} "::M1 ::M2"
+  ? {b1 info precedence ::X*} ""
   
-  b1 mixin {M1 M1 M4}
+  b1 object mixin {M1 M1 M4}
   ? {b1 info precedence} "::M1 ::M4 ::M2 ::B ::A ::nx::Object"
-  ? {b1 info mixin classes} "::M1 ::M4"
+  ? {b1 info object mixin classes} "::M1 ::M4"
 
   B mixin {M3 M1 M1 M4}
   ? {B info heritage} "::M3 ::M1 ::M4 ::M2 ::A ::nx::Object"
@@ -989,7 +1013,7 @@
 #
 # per-object mixin with implied classes
 #
-nx::Test case info-heritage-multimix {
+nx::test case info-heritage-multimix {
   Class create A
   Class create B -superclass A
   Class create C
@@ -999,9 +1023,9 @@
   ? {c1 info precedence} "::C ::nx::Object"
 
   # ::A is an implied class
-  c1 mixin B
+  c1 object mixin B
   ? {c1 info precedence} "::B ::A ::C ::nx::Object"
-  ? {c1 info mixin classes -heritage} "::B ::A"
+  ? {c1 info object mixin classes -heritage} "::B ::A"
 
   # ::A is as well implied by ::PCM
   C mixin PCM
@@ -1013,13 +1037,13 @@
 
   # ::A is not ordered after ::B but after ::PCM
   ? {c1 info precedence} "::B ::PCM ::A ::C ::nx::Object"
-  ? {c1 info mixin classes -heritage} "::B ::PCM ::A"
+  ? {c1 info object mixin classes -heritage} "::B ::PCM ::A"
 }
 
 #
 # transitive per-class mixins with implied classes
 #
-nx::Test case info-heritage-transitive-pcm {
+nx::test case info-heritage-transitive-pcm {
   Class create A
   Class create B -superclass A
   Class create C -superclass B
@@ -1107,7 +1131,7 @@
 #
 # ::nsf::method::ishandle
 #
-nx::Test case method-isregistered {
+nx::test case method-isregistered {
   
   ? {::nsf::method::registered c} ""
   ? {::nsf::method::registered info} ""
@@ -1121,18 +1145,18 @@
 
     ? [list ::nsf::method::registered $h1] ::C
 
-    :class method bar {} {return bar}
-    set h2 [:class info method registrationhandle bar]
-    ? [list [self] class info method registrationhandle bar] "::C::bar"
+    :object method bar {} {return bar}
+    set h2 [:info object method registrationhandle bar]
+    ? [list [self] info object method registrationhandle bar] "::C::bar"
 
     ? [list ::nsf::method::registered $h2] ::C
   }
 
   Object create o {
-    :method bar {} {return bar}
-    set h1 [:info method registrationhandle bar]
+    :object method bar {} {return bar}
+    set h1 [:info object method registrationhandle bar]
     ? [list set _ $h1] "::o::bar"
-    ? [list [self] info method registrationhandle bar] "::o::bar"
+    ? [list [self] info object method registrationhandle bar] "::o::bar"
 
     ? [list ::nsf::method::registered $h1] ::o
   }
@@ -1144,27 +1168,27 @@
 # "handle" alone is the registration handle.
 #
 
-nx::Test case method-origin {
+nx::test case method-origin {
   nx::Class create C
   ? {set implHandle [C public method "foo bar" {x} {;}]} "::C::slot::__foo::bar"
   ? {set regHandle [C info method registrationhandle "foo bar"]} "::nsf::classes::C::foo bar"
   ? {set origin [C info method definitionhandle "foo bar"]} "::C::slot::__foo::bar"
 
-  ? {set implHandle [C public class method "foo bar" {x} {;}]} "::C::foo::bar"
-  ? {set regHandle [C class info method registrationhandle "foo bar"]} "::C::foo bar"
-  ? {set origin [C class info method definitionhandle "foo bar"]} "::C::foo::bar"
+  ? {set implHandle [C public object method "foo bar" {x} {;}]} "::C::foo::bar"
+  ? {set regHandle [C info object method registrationhandle "foo bar"]} "::C::foo bar"
+  ? {set origin [C info object method definitionhandle "foo bar"]} "::C::foo::bar"
 
   Object create o
-  ? {set implHandle [o public method "foo bar" {x} {;}]} "::o::foo::bar"
-  ? {set regHandle [o info method registrationhandle "foo bar"]} "::o::foo bar"
-  ? {set origin [o info method definitionhandle "foo bar"]} "::o::foo::bar"
+  ? {set implHandle [o public object method "foo bar" {x} {;}]} "::o::foo::bar"
+  ? {set regHandle [o info object method registrationhandle "foo bar"]} "::o::foo bar"
+  ? {set origin [o info object method definitionhandle "foo bar"]} "::o::foo::bar"
 }
 
 #
 # test "info methods -closure"
 #
 
-nx::Test case info-methods-closure {
+nx::test case info-methods-closure {
   nx::Class create C {
     :public method c1 {} {...}
     :method c2 {} {...}
@@ -1202,6 +1226,6 @@
 #
 # Test error messages within an ensemble call
 #
-nx::Test case error-in-ensemble {
-  ? {nx::Object info method definition foo 1} {invalid argument '1', maybe too many arguments; should be "::nx::Object info method args|body|definition|exists|registrationhandle|definitionhandle|handle|origin|parameter|syntax|type|precondition|postcondition|submethods|returns name"}
+nx::test case error-in-ensemble {
+  ? {nx::Object info method definition foo 1} {wrong # args: should be "definition name"}
 }
\ No newline at end of file