both t/*_namespace.t test run to completion.

build/Makefile.in

@@ -97,6 +97,7 @@ TEST_FILES = \
   t/cmd_lreverse.t \
   t/cmd_lset.t \
   t/cmd_lsort.t \
+  t/cmd_namespace.t \
   t/cmd_regexp.t \
   t/cmd_return.t \
   t/cmd_set.t \
@@ -117,11 +118,12 @@ TEST_FILES = \
   t/tcl_command_subst.t \
   t/tcl_glob.t \
   t/tcl_misc.t \
+  t/tcl_namespace.t \
   t/tcl_var_subst.t
 
 # These t/*.t files are not yet runnable. Keep a list around so we know
 # what to work on.
-# t/cmd_namespace.t t/cmd_proc.t t/tcl_namespace.t
+# t/cmd_proc.t
 
 Makefile: Configure.pl build/Makefile.in
 	$(PERL) Configure.pl

t/cmd_namespace.t

@@ -14,113 +14,113 @@ eval_is {namespace asdf} \
 
 eval_is {namespace children a b c} \
   {wrong # args: should be "namespace children ?name? ?pattern?"} \
-  {namespace children: too many args}
+  {namespace children: too many args} {TODO NQPRX}
 
 eval_is {namespace children what?} \
   {namespace "what?" not found in "::"} \
-  {namespace children: unknown namespace}
+  {namespace children: unknown namespace} {TODO NQPRX}
 
-is [namespace children]        {::tcl} {namespace children: no args}
-is [namespace children ::]     {::tcl} {namespace children: ::}
-is [namespace children :: *c*] {::tcl} {namespace children: matched pattern}
+is [namespace children]        {::tcl} {namespace children: no args} {TODO NQPRX}
+is [namespace children ::]     {::tcl} {namespace children: ::} {TODO NQPRX}
+is [namespace children :: *c*] {::tcl} {namespace children: matched pattern} {TODO NQPRX}
 is [namespace children :: a]   {}    {namespace children: unmatched pattern}
 
 namespace eval bob {}
 namespace eval Bob {}
 namespace eval audreyt { namespace eval Matt {} }
 
 is [lsort [namespace children ::]] {::Bob ::audreyt ::bob ::tcl} \
-  {namespace children}
-is [namespace children ::audreyt] ::audreyt::Matt  {namespace chlidren: nested}
+  {namespace children} {TODO NQPRX}
+is [namespace children ::audreyt] ::audreyt::Matt  {namespace chlidren: nested} {TODO NQPRX}
 is [namespace eval ::audreyt {namespace children}] ::audreyt::Matt \
-  {namespace children in namespace eval}
+  {namespace children in namespace eval} {TODO NQPRX}
 
 
 eval_is {namespace qualifiers} \
   {wrong # args: should be "namespace qualifiers string"} \
-  {namespace qualifiers: no args}
+  {namespace qualifiers: no args} {TODO NQPRX}
 
 eval_is {namespace qualifiers string string} \
   {wrong # args: should be "namespace qualifiers string"} \
-  {namespace qualifiers: too many args}
+  {namespace qualifiers: too many args} {TODO NQPRX}
 
-is [namespace qualifiers ::a::b::c]   ::a::b   {namespace qualifiers: simple}
-is [namespace qualifiers :::a:::b::c] :::a:::b {namespace qualifiers: extra colons}
+is [namespace qualifiers ::a::b::c]   ::a::b   {namespace qualifiers: simple} {TODO NQPRX}
+is [namespace qualifiers :::a:::b::c] :::a:::b {namespace qualifiers: extra colons} {TODO NQPRX}
 
 
 eval_is {namespace tail} \
   {wrong # args: should be "namespace tail string"} \
-  {namespace tail: no args}
+  {namespace tail: no args} {TODO NQPRX}
 
 eval_is {namespace tail string string} \
   {wrong # args: should be "namespace tail string"} \
-  {namespace tail: too many args}
+  {namespace tail: too many args} {TODO NQPRX}
 
 is [namespace tail ::] {} {namespace tail: main}
 is [namespace tail {}] {} {namespace tail: empty}
-is [namespace tail ::foo::bar::baz] baz {namespace tail: simple}
-is [namespace tail :::foo:::bar:::baz] baz {namespace tail: extra colons}
+is [namespace tail ::foo::bar::baz] baz {namespace tail: simple} {TODO NQPRX}
+is [namespace tail :::foo:::bar:::baz] baz {namespace tail: extra colons} {TODO NQPRX}
 
 
 eval_is {namespace exists} \
   {wrong # args: should be "namespace exists name"} \
-  {namespace exists: no args}
+  {namespace exists: no args} {TODO NQPRX}
 
 eval_is {namespace exists a a} \
   {wrong # args: should be "namespace exists name"} \
-  {namespace exists: too many args}
+  {namespace exists: too many args} {TODO NQPRX}
 
-eval_is {namespace exists a}  0 {namespace exists: failure}
-is [namespace exists {}] 1 {namespace exists: global implicit}
-is [namespace exists ::] 1 {namespace exists: global explicit}
+eval_is {namespace exists a}  0 {namespace exists: failure} {TODO NQPRX}
+is [namespace exists {}] 1 {namespace exists: global implicit} {TODO NQPRX}
+is [namespace exists ::] 1 {namespace exists: global explicit} {TODO NQPRX}
 
 
 eval_is {namespace eval foo} \
   {wrong # args: should be "namespace eval name arg ?arg...?"} \
-  {namespace eval: too few args}
+  {namespace eval: too few args} {TODO NQPRX}
 
 namespace eval foo {
     proc bar {} {return ok}
     namespace eval bar {
         proc baz {} {return ok}
     }
 }
-is [namespace exists foo] 1 {namespace eval foo: namespace exists}
-is [foo::bar]      ok       {namespace eval foo: proc}
-is [foo::bar::baz] ok       {namespace eval foo: namespace eval bar: proc}
+is [namespace exists foo] 1 {namespace eval foo: namespace exists} {TODO NQPRX}
+eval_is {foo::bar}      ok       {namespace eval foo: proc} {TODO NQPRX}
+eval_is {foo::bar::baz} ok       {namespace eval foo: namespace eval bar: proc} {TODO NQPRX}
 
-is [namespace eval foo {set a ok; set a}] ok {namespace eval: return value}
-is [namespace eval {}  {set a ok; set a}] ok {namespace eval: implicit global}
+is [namespace eval foo {set a ok; set a}] ok {namespace eval: return value} {TODO NQPRX}
+is [namespace eval {}  {set a ok; set a}] ok {namespace eval: implicit global} {TODO NQPRX}
 
 proc alias {one two} {
     namespace eval {} [list upvar 0 $one $two]
 }
 set   foo ok
 alias foo bar
-is [set bar] ok {namespace eval + proc + upvar}
+eval_is {set bar} ok {namespace eval + proc + upvar} {TODO NQPRX}
 
 eval_is {namespace delete monkeypants} \
   {unknown namespace "monkeypants" in namespace delete command} \
-  {don't silently fail on invalid namespaces}
+  {don't silently fail on invalid namespaces} {TODO NQPRX}
 
 namespace delete foo
-eval_is {namespace exists foo} 0 {namespace delete}
+eval_is {namespace exists foo} 0 {namespace delete} {TODO NQPRX}
 
 eval_is {namespace current foo} \
   {wrong # args: should be "namespace current"} \
-  {namespace current: too many args}
+  {namespace current: too many args} {TODO NQPRX}
 
-is [namespace current]                      ::    {namespace current: global}
-is [namespace eval foo {namespace current}] ::foo {namespace current: ::foo}
+is [namespace current]                      ::    {namespace current: global} {TODO NQPRX}
+is [namespace eval foo {namespace current}] ::foo {namespace current: ::foo} {TODO NQPRX}
 
 
 eval_is {namespace parent foo bar} \
   {wrong # args: should be "namespace parent ?name?"} \
-  {namespace parent: too many args}
+  {namespace parent: too many args} {TODO NQPRX}
 
 is [namespace parent ""]                   {} {namespace parent: ::}
-is [namespace parent foo]                  :: {namespace parent: ::foo (explicit)}
-is [namespace eval foo {namespace parent}] :: {namespace parent: ::foo (implicit)}
+is [namespace parent foo]                  :: {namespace parent: ::foo (explicit)} {TODO NQPRX}
+is [namespace eval foo {namespace parent}] :: {namespace parent: ::foo (implicit)} {TODO NQPRX}
 
 namespace eval perl6 {
   proc passthrough {val} {
@@ -130,18 +130,18 @@ namespace eval perl6 {
     passthrough 3
   }
 }
-is [perl6::pi] 3 \
-  {do procs in namespace default to that namespace when looking for commands?}
+eval_is {perl6::pi} 3 \
+  {do procs in namespace default to that namespace when looking for commands?} {TODO NQPRX}
 
 namespace eval perl6 {
   namespace export pi
 }
 namespace import perl6::pi
-eval_is {pi} 3 {simple import test}
+eval_is {pi} 3 {simple import test} {TODO NQPRX}
 
 eval_is {
   namespace which -command incr
-} {::incr} {simple namespace which}
+} {::incr} {simple namespace which} {TODO NQPRX}
 
 # we can't do this test until all the file commands work
 # ([file delete] in particular)

t/tcl_namespace.t

@@ -1,29 +1,31 @@
 # Copyright (C) 2006-2007, The Parrot Foundation.
 
 source lib/test_more.tcl
-plan 6
+plan 5; # +1 skip
 
-is [::set a ok]      {ok} {explicit global command}
-is [:::::::set b ok] {ok} {explicit global command, extra colons}
+eval_is {::set a ok}      {ok} {explicit global command} {TODO NQPRX}
+eval_is {:::::::set b ok} {ok} {explicit global command, extra colons} {TODO NQPRX}
 
+if 0 { ## PARSEFAIL NQPRX
 proc ::: {} {return ok}
 is [{}] ok {command name, all colons}
+}
 
 eval_is {
   :set c ok
 } {invalid command name ":set"}\
-{not enough colons, explicit global command}
+{not enough colons, explicit global command} {TODO NQPRX}
 
 eval_is {
   foo::bar
 } {invalid command name "foo::bar"} \
-{invalid ns command}
+{invalid ns command} {TODO NQPRX}
 
 eval_is {
   proc test {} {return ok1}
   set a [namespace eval lib {test}]
   proc ::lib::test {} {return ok2}
   list $a [namespace eval lib {test}]
-} {ok1 ok2} {relative namespace}
+} {ok1 ok2} {relative namespace} {TODO NQPRX}
 
 # vim: filetype=tcl: