* Revised locale initialization to interpret

        environment variable locale values according to XPG4, and to
        recognize the LC_ALL and LC_MESSAGES values over that of LANG.
        Also added many Windows Registry locale values to those
        recognized by msgcat.  Revised tests and docs.  Bumped to
        version 1.3.  Thanks to Bruno Haible for the report and
        assistance crafting the solution.  [Bug 525522, 525525]

1 files changed, 512 insertions, 371 deletions

diff --git a/tests/msgcat.test b/tests/msgcat.test
index 633c869..2ea01cd 100644
--- a/tests/msgcat.test
+++ b/tests/msgcat.test
@@ -1,330 +1,457 @@
-# Commands covered: ::msgcat::mc ::msgcat::mclocale
-#                   ::msgcat::mcpreferences ::msgcat::mcload
-#                   ::msgcat::mcset ::msgcat::mcmset ::msgcat::mcunknown
-#
-# This file contains a collection of tests for the msgcat script library.
+# This file contains a collection of tests for the msgcat package.
 # Sourcing this file into Tcl runs the tests and
 # generates output for errors.  No output means no errors were found.
 #
 # Copyright (c) 1998 Mark Harrison.
 # Copyright (c) 1998-1999 by Scriptics Corporation.
+# Contributions from Don Porter, NIST, 2002.  (not subject to US copyright)
 #
 # See the file "license.terms" for information on usage and redistribution
 # of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 #
-# RCS: @(#) $Id: msgcat.test,v 1.10 2000/07/17 22:25:26 ericm Exp $
+# Note that after running these tests, entries will be left behind in the
+# message catalogs for locales foo, foo_BAR, and foo_BAR_baz.
+#
+# RCS: @(#) $Id: msgcat.test,v 1.11 2002/06/17 05:37:39 dgp Exp $
 
-if {[lsearch [namespace children] ::tcltest] == -1} {
-    package require tcltest
-    namespace import -force ::tcltest::*
+package require Tcl 8.2
+if {[catch {package require tcltest 2}]} {
+    puts stderr "Skipping tests in [info script].  tcltest 2 required."
+    return
 }
+if {[catch {package require msgcat 1.3}]} {
+    puts stderr "Skipping tests in [info script].  No msgcat 1.3 found to test."
+    return
+}
+
+namespace eval ::msgcat::test {
+    namespace import ::msgcat::*
+    namespace import ::tcltest::test
+    namespace import ::tcltest::cleanupTests
+    namespace import ::tcltest::temporaryDirectory
+    namespace import ::tcltest::make*
+    namespace import ::tcltest::remove*
 
-if {[catch {package require msgcat 1.0}]} {
-    if {[info exist msgcat1]} {
-	catch {puts "Cannot load msgcat 1.0 package"}
-	return
-    } else {
-	catch {puts "Running msgcat 1.0 tests in slave interp"}
-	set interp [interp create msgcat1]
-	$interp eval [list set msgcat1 "running"]
-	$interp eval [list source [info script]]
-	interp delete $interp
-	return
+    # Tests msgcat-0.*: locale initialization
+
+    proc PowerSet {l} {
+	if {[llength $l] == 0} {return [list [list]]}
+	set element [lindex $l 0]
+	set rest [lrange $l 1 end]
+	set result [list]
+	foreach x [PowerSet $rest] {
+	    lappend result [linsert $x 0 $element]
+	    lappend result $x
+	}
+	return $result
     }
-}
 
-set oldlocale [::msgcat::mclocale]
+    variable envVars {LC_ALL LC_MESSAGES LANG}
+    variable count 0
+    variable body
+    variable result
+    variable setVars
+    foreach setVars [PowerSet $envVars] { 
+	set result [string tolower [lindex $setVars 0]]
+	if {[string length $result] == 0} {
+	    set result c
+	}
+	test msgcat-0.$count {
+	    locale initialization from environment variables
+	} -setup {
+	    variable var
+	    foreach var $envVars {
+		catch {variable $var $::env($var)}
+		catch {unset ::env($var)}
+	    }
+	    foreach var $setVars {
+		set ::env($var) $var
+	    }
+	    interp create [namespace current]::i
+	    i eval [list package ifneeded msgcat [package provide msgcat] \
+		    [package ifneeded msgcat [package provide msgcat]]]
+	    i eval package require msgcat
+	} -cleanup {
+	    interp delete [namespace current]::i
+	    foreach var $envVars {
+		catch {unset ::env($var)}
+		catch {set ::env($var) [set [namespace current]::$var]}
+	    }
+	} -body {i eval msgcat::mclocale} -result $result
+	incr count
+    }
+    catch {unset result}
+    
+    # Could add tests of initialization from Windows registry here.
+    # Use a fake registry package.
 
-# some tests fail in tne environment variable LANG exists and is not C
+    # Tests msgcat-1.*: [mclocale], [mcpreferences]
 
-if {[info exists env(LANG)] && ($env(LANG) != "C")} {
-    set ::tcltest::testConstraints(LANGisC) 0
-} else {
-    set ::tcltest::testConstraints(LANGisC) 1
-}
+    test msgcat-1.3 {mclocale set, single element} -setup {
+	variable locale [mclocale]
+    } -cleanup {
+	mclocale $locale
+    } -body {
+	mclocale en
+    } -result en
 
-#
-# Test the various permutations of mclocale
-# and mcpreferences.
-#
+    test msgcat-1.4 {mclocale get, single element} -setup {
+	variable locale [mclocale]
+	mclocale en
+    } -cleanup {
+	mclocale $locale
+    } -body {
+	mclocale
+    } -result en
 
-test msgcat-1.1 {::msgcat::mclocale default} {LANGisC} {
-    ::msgcat::mclocale
-} {c}
-test msgcat-1.2 {::msgcat::mcpreferences, single element} {LANGisC} {
-    ::msgcat::mcpreferences
-} {c}
-test msgcat-1.3 {::msgcat::mclocale, single element} {
-    ::msgcat::mclocale en
-} {en}
-test msgcat-1.4 {::msgcat::mclocale, single element} {
-    ::msgcat::mclocale
-} {en}
-test msgcat-1.5 {::msgcat::mcpreferences, single element} {
-    ::msgcat::mcpreferences
-} {en}
-test msgcat-1.6 {::msgcat::mclocale, two elements} {
-    ::msgcat::mclocale en_US
-} {en_us}
-test msgcat-1.7 {::msgcat::mclocale, two elements} {
-    ::msgcat::mclocale en_US
-    ::msgcat::mclocale
-} {en_us}
-test msgcat-1.8 {::msgcat::mcpreferences, two elements} {
-    ::msgcat::mcpreferences
-} {en_us en}
-test msgcat-1.9 {::msgcat::mclocale, three elements} {
-    ::msgcat::mclocale en_US_funky
-} {en_us_funky}
-test msgcat-1.10 {::msgcat::mclocale, three elements} {
-    ::msgcat::mclocale
-} {en_us_funky}
-test msgcat-1.11 {::msgcat::mcpreferences, three elements} {
-    ::msgcat::mcpreferences
-} {en_us_funky en_us en}
+    test msgcat-1.5 {mcpreferences, single element} -setup {
+	variable locale [mclocale]
+	mclocale en
+    } -cleanup {
+	mclocale $locale
+    } -body {
+	mcpreferences
+    } -result en
 
-#
-# Test mcset and mc, ensuring that namespace partitioning
-# is working.
-#
+    test msgcat-1.6 {mclocale set, two elements} -setup {
+	variable locale [mclocale]
+    } -cleanup {
+	mclocale $locale
+    } -body {
+	mclocale en_US
+    } -result en_us
 
-test msgcat-2.1 {::msgcat::mcset, global scope} {
-    ::msgcat::mcset  foo_BAR text1 text2
-} {text2}
-test msgcat-2.2 {::msgcat::mcset, global scope, default} {
-    ::msgcat::mcset  foo_BAR text3
-} {text3}
-test msgcat-2.2 {::msgcat::mcset, namespace overlap} {
-    namespace eval bar {::msgcat::mcset  foo_BAR con1 con1bar}
-    namespace eval baz {::msgcat::mcset  foo_BAR con1 con1baz}
-} {con1baz}
-test msgcat-2.3 {::msgcat::mcset, namespace overlap} {
-    ::msgcat::mclocale foo_BAR
-    namespace eval bar {::msgcat::mc con1}
-} {con1bar}
-test msgcat-2.4 {::msgcat::mcset, namespace overlap} {
-    ::msgcat::mclocale foo_BAR
-    namespace eval baz {::msgcat::mc con1}
-} {con1baz}
-test msgcat-2.5 {::msgcat::mcmset, global scope} {
-    ::msgcat::mcmset  foo_BAR {
-        src1 trans1
-        src2 trans2
-    }
-    ::msgcat::mc src1
-} {trans1}
-test msgcat-2.6 {::msgcat::mcmset, namespace overlap} {
-    namespace eval bar {::msgcat::mcmset  foo_BAR {con2 con2bar}}
-    namespace eval baz {::msgcat::mcmset  foo_BAR {con2 con2baz}}
-} {2}
-test msgcat-2.7 {::msgcat::mcmset, namespace overlap} {
-    ::msgcat::mclocale foo_BAR
-    namespace eval baz {::msgcat::mc con2}
-} {con2baz}
+    test msgcat-1.7 {mclocale get, two elements} -setup {
+	variable locale [mclocale]
+	mclocale en_US
+    } -cleanup {
+	mclocale $locale
+    } -body {
+	mclocale
+    } -result en_us
 
+    test msgcat-1.8 {mcpreferences, two elements} -setup {
+	variable locale [mclocale]
+	mclocale en_US
+    } -cleanup {
+	mclocale $locale
+    } -body {
+	mcpreferences
+    } -result {en_us en}
 
-#
-# Test mcset and mc, ensuring that more specific locales
-# (e.g. "en_UK") will search less specific locales
-# (e.g. "en") for translation strings.
-#
-# Do this for the 12 permutations of
-#     locales: {foo foo_BAR foo_BAR_baz}
-#     strings: {ov1 ov2 ov3 ov4}
-#     locale foo         defines ov1, ov2, ov3
-#     locale foo_BAR     defines      ov2, ov3
-#     locale foo_BAR_BAZ defines           ov3
-#     (ov4 is defined in none)
-# So,
-#     ov3 should be resolved in foo, foo_BAR, foo_BAR_baz
-#     ov2 should be resolved in foo, foo_BAR
-#     ov2 should resolve to foo_BAR in foo_BAR_baz
-#     ov1 should be resolved in foo
-#     ov1 should resolve to foo in foo_BAR, foo_BAR_baz
-#     ov4 should be resolved in none, and call mcunknown
-#
+    test msgcat-1.9 {mclocale set, three elements} -setup {
+	variable locale [mclocale]
+    } -cleanup {
+	mclocale $locale
+    } -body {
+	mclocale en_US_funky
+    } -result en_us_funky
 
-test msgcat-3.1 {::msgcat::mcset, overlap} {
-    ::msgcat::mcset foo ov1 ov1_foo
-    ::msgcat::mcset foo ov2 ov2_foo
-    ::msgcat::mcset foo ov3 ov3_foo
-    ::msgcat::mcset foo_BAR ov2 ov2_foo_BAR
-    ::msgcat::mcset foo_BAR ov3 ov3_foo_BAR
-    ::msgcat::mcset foo_BAR_baz ov3 ov3_foo_BAR_baz
-} {ov3_foo_BAR_baz}
-# top level, locale foo
-test msgcat-3.2 {::msgcat::mcset, overlap} {
-    ::msgcat::mclocale foo
-    ::msgcat::mc ov1
-} {ov1_foo}
-test msgcat-3.3 {::msgcat::mcset, overlap} {
-    ::msgcat::mclocale foo
-    ::msgcat::mc ov2
-} {ov2_foo}
-test msgcat-3.4 {::msgcat::mcset, overlap} {
-    ::msgcat::mclocale foo
-    ::msgcat::mc ov3
-} {ov3_foo}
-test msgcat-3.5 {::msgcat::mcset, overlap} {
-    ::msgcat::mclocale foo
-    ::msgcat::mc ov4
-} {ov4}
-# second level, locale foo_BAR
-test msgcat-3.6 {::msgcat::mcset, overlap} {
-    ::msgcat::mclocale foo_BAR
-    ::msgcat::mc ov1
-} {ov1_foo}
-test msgcat-3.7 {::msgcat::mcset, overlap} {
-    ::msgcat::mclocale foo_BAR
-    ::msgcat::mc ov2
-} {ov2_foo_BAR}
-test msgcat-3.8 {::msgcat::mcset, overlap} {
-    ::msgcat::mclocale foo_BAR
-    ::msgcat::mc ov3
-} {ov3_foo_BAR}
-test msgcat-3.9 {::msgcat::mcset, overlap} {
-    ::msgcat::mclocale foo_BAR
-    ::msgcat::mc ov4
-} {ov4}
-# third level, locale foo_BAR_baz
-test msgcat-3.10 {::msgcat::mcset, overlap} {
-    ::msgcat::mclocale foo_BAR_baz
-    ::msgcat::mc ov1
-} {ov1_foo}
-test msgcat-3.11 {::msgcat::mcset, overlap} {
-    ::msgcat::mclocale foo_BAR_baz
-    ::msgcat::mc ov2
-} {ov2_foo_BAR}
-test msgcat-3.12 {::msgcat::mcset, overlap} {
-    ::msgcat::mclocale foo_BAR_baz
-    ::msgcat::mc ov3
-} {ov3_foo_BAR_baz}
-test msgcat-3.13 {::msgcat::mcset, overlap} {
-    ::msgcat::mclocale foo_BAR_baz
-    ::msgcat::mc ov4
-} {ov4}
+    test msgcat-1.10 {mclocale get, three elements} -setup {
+	variable locale [mclocale]
+	mclocale en_US_funky
+    } -cleanup {
+	mclocale $locale
+    } -body {
+	mclocale
+    } -result en_us_funky
 
-#
-# Test mcunknown, first the default operation
-# and then with an overridden definition.
-#
+    test msgcat-1.11 {mcpreferences, three elements} -setup {
+	variable locale [mclocale]
+	mclocale en_US_funky
+    } -cleanup {
+	mclocale $locale
+    } -body {
+	mcpreferences
+    } -result {en_us_funky en_us en}
+
+    # Tests msgcat-2.*: [mcset], [mcmset], namespace partitioning
+
+    test msgcat-2.1 {mcset, global scope} {
+	namespace eval :: ::msgcat::mcset  foo_BAR text1 text2
+    } {text2}
+
+    test msgcat-2.2 {mcset, global scope, default} {
+	namespace eval :: ::msgcat::mcset foo_BAR text3
+    } {text3}
+
+    test msgcat-2.2 {mcset, namespace overlap} {
+	namespace eval baz {::msgcat::mcset  foo_BAR con1 con1baz}
+    } {con1baz}
+
+    test msgcat-2.3 {mcset, namespace overlap} -setup {
+	namespace eval bar {::msgcat::mcset  foo_BAR con1 con1bar}
+	namespace eval baz {::msgcat::mcset  foo_BAR con1 con1baz}
+	variable locale [mclocale]
+	mclocale foo_BAR
+    } -cleanup {
+	mclocale $locale
+    } -body {
+	namespace eval bar {::msgcat::mc con1}
+    } -result con1bar
+
+    test msgcat-2.4 {mcset, namespace overlap} -setup {
+	namespace eval bar {::msgcat::mcset  foo_BAR con1 con1bar}
+	namespace eval baz {::msgcat::mcset  foo_BAR con1 con1baz}
+	variable locale [mclocale]
+	mclocale foo_BAR
+    } -cleanup {
+	mclocale $locale
+    } -body {
+	namespace eval baz {::msgcat::mc con1}
+    } -result con1baz
+
+    test msgcat-2.5 {mcmset, global scope} -setup {
+	namespace eval :: {
+	    ::msgcat::mcmset  foo_BAR {
+	        src1 trans1
+	        src2 trans2
+	    }
+	}
+	variable locale [mclocale]
+	mclocale foo_BAR
+    } -cleanup {
+	mclocale $locale
+    } -body {
+	namespace eval :: {
+	    ::msgcat::mc src1
+	}
+    } -result trans1
 
-test msgcat-4.1 {::msgcat::mcunknown, default} {
-    ::msgcat::mcset foo unk1 "unknown 1"
-} {unknown 1}
-test msgcat-4.2 {::msgcat::mcunknown, default} {
-    ::msgcat::mclocale foo
-    ::msgcat::mc unk1
-} {unknown 1}
-test msgcat-4.3 {::msgcat::mcunknown, default} {
-    ::msgcat::mclocale foo
-    ::msgcat::mc unk2
-} {unk2}
-test msgcat-4.4 {::msgcat::mcunknown, overridden} {
-    rename ::msgcat::mcunknown oldproc
-    proc ::msgcat::mcunknown {dom s} {
-        return "unknown:$dom:$s"
+    test msgcat-2.6 {mcmset, namespace overlap} -setup {
+	namespace eval bar {::msgcat::mcmset  foo_BAR {con2 con2bar}}
+	namespace eval baz {::msgcat::mcmset  foo_BAR {con2 con2baz}}
+	variable locale [mclocale]
+	mclocale foo_BAR
+    } -cleanup {
+	mclocale $locale
+    } -body {
+	namespace eval bar {::msgcat::mc con2}
+    } -result con2bar
+
+    test msgcat-2.7 {mcmset, namespace overlap} -setup {
+	namespace eval bar {::msgcat::mcmset  foo_BAR {con2 con2bar}}
+	namespace eval baz {::msgcat::mcmset  foo_BAR {con2 con2baz}}
+	variable locale [mclocale]
+	mclocale foo_BAR
+    } -cleanup {
+	mclocale $locale
+    } -body {
+	namespace eval baz {::msgcat::mc con2}
+    } -result con2baz
+
+    # Tests msgcat-3.*: [mcset], [mc], catalog "inheritance"
+    #
+    # Test mcset and mc, ensuring that more specific locales
+    # (e.g. en_UK) will search less specific locales
+    # (e.g. en) for translation strings.
+    #
+    # Do this for the 12 permutations of
+    #     locales: {foo foo_BAR foo_BAR_baz}
+    #     strings: {ov1 ov2 ov3 ov4}
+    #     locale foo         defines ov1, ov2, ov3
+    #     locale foo_BAR     defines      ov2, ov3
+    #     locale foo_BAR_BAZ defines           ov3
+    #     (ov4 is defined in none)
+    # So,
+    #     ov3 should be resolved in foo, foo_BAR, foo_BAR_baz
+    #     ov2 should be resolved in foo, foo_BAR
+    #     ov2 should resolve to foo_BAR in foo_BAR_baz
+    #     ov1 should be resolved in foo
+    #     ov1 should resolve to foo in foo_BAR, foo_BAR_baz
+    #     ov4 should be resolved in none, and call mcunknown
+    #
+    variable count 2
+    variable result
+    array set result {
+	foo,ov1 ov1_foo foo,ov2 ov2_foo foo,ov3 ov3_foo foo,ov4 ov4
+	foo_BAR,ov1 ov1_foo foo_BAR,ov2 ov2_foo_BAR foo_BAR,ov3 ov3_foo_BAR
+	foo_BAR,ov4 ov4 foo_BAR_baz,ov1 ov1_foo foo_BAR_baz,ov2 ov2_foo_BAR
+	foo_BAR_baz,ov3 ov3_foo_BAR_baz foo_BAR_baz,ov4 ov4
     }
-    ::msgcat::mclocale foo
-    set result [::msgcat::mc unk1]
-    rename ::msgcat::mcunknown {}
-    rename oldproc ::msgcat::mcunknown
-    set result
-} {unknown 1}
-test msgcat-4.5 {::msgcat::mcunknown, overridden} {
-    rename ::msgcat::mcunknown oldproc
-    proc ::msgcat::mcunknown {dom s} {
-        return "unknown:$dom:$s"
+    variable loc
+    variable string
+    foreach loc {foo foo_BAR foo_BAR_baz} {
+	foreach string {ov1 ov2 ov3 ov4} {
+	    test msgcat-3.$count {mcset, overlap} -setup {
+		mcset foo ov1 ov1_foo
+		mcset foo ov2 ov2_foo
+		mcset foo ov3 ov3_foo
+		mcset foo_BAR ov2 ov2_foo_BAR
+		mcset foo_BAR ov3 ov3_foo_BAR
+		mcset foo_BAR_baz ov3 ov3_foo_BAR_baz
+		variable locale [mclocale]
+		mclocale $loc
+	    } -cleanup {
+		mclocale $locale
+	    } -body {
+		mc $string
+	    } -result $result($loc,$string)
+	    incr count
+	}
     }
-    ::msgcat::mclocale foo
-    set result [::msgcat::mc unk2]
-    rename ::msgcat::mcunknown {}
-    rename oldproc ::msgcat::mcunknown
-    set result
-} {unknown:foo:unk2}
-test msgcat-4.6 {::msgcat::mcunknown, uplevel context} {
-    rename ::msgcat::mcunknown oldproc
-    proc ::msgcat::mcunknown {dom s} {
-        return "unknown:$dom:$s:[info level]"
+    catch {unset result}
+
+    # Tests msgcat-4.*: [mcunknown]
+
+    test msgcat-4.2 {mcunknown, default} -setup {
+	mcset foo unk1 "unknown 1"
+	variable locale [mclocale]
+	mclocale foo
+    } -cleanup {
+	mclocale $locale
+    } -body {
+	mc unk1
+    } -result {unknown 1}
+
+    test msgcat-4.3 {mcunknown, default} -setup {
+	mcset foo unk1 "unknown 1"
+	variable locale [mclocale]
+	mclocale foo
+    } -cleanup {
+	mclocale $locale
+    } -body {
+	mc unk2
+    } -result unk2
+
+    test msgcat-4.4 {mcunknown, overridden} -setup {
+	rename ::msgcat::mcunknown SavedMcunknown
+	proc ::msgcat::mcunknown {dom s} {
+            return unknown:$dom:$s
+	}
+	mcset foo unk1 "unknown 1"
+	variable locale [mclocale]
+	mclocale foo
+    } -cleanup {
+	mclocale $locale
+	rename ::msgcat::mcunknown {}
+	rename SavedMcunknown ::msgcat::mcunknown
+    } -body {
+	mc unk1
+    } -result {unknown 1}
+
+    test msgcat-4.5 {mcunknown, overridden} -setup {
+	rename ::msgcat::mcunknown SavedMcunknown
+	proc ::msgcat::mcunknown {dom s} {
+            return unknown:$dom:$s
+	}
+	mcset foo unk1 "unknown 1"
+	variable locale [mclocale]
+	mclocale foo
+    } -cleanup {
+	mclocale $locale
+	rename ::msgcat::mcunknown {}
+	rename SavedMcunknown ::msgcat::mcunknown
+    } -body {
+	mc unk2
+    } -result {unknown:foo:unk2}
+
+    test msgcat-4.6 {mcunknown, uplevel context} -setup {
+	rename ::msgcat::mcunknown SavedMcunknown
+	proc ::msgcat::mcunknown {dom s} {
+            return "unknown:$dom:$s:[expr {[info level] - 1}]"
+	}
+	mcset foo unk1 "unknown 1"
+	variable locale [mclocale]
+	mclocale foo
+    } -cleanup {
+	mclocale $locale
+	rename ::msgcat::mcunknown {}
+	rename SavedMcunknown ::msgcat::mcunknown
+    } -body {
+	mc unk2
+    } -result unknown:foo:unk2:[info level]
+
+    # Tests msgcat-5.*: [mcload]
+
+    variable locales {foo foo_BAR foo_BAR_baz}
+    makeDirectory msgdir
+    foreach loc $locales {
+	makeFile "::msgcat::mcset $loc abc abc-$loc" \
+		[string tolower [file join msgdir $loc.msg]]
+    }
+    variable count 1
+    foreach loc {foo foo_BAR foo_BAR_baz} {
+	test msgcat-5.$count {mcload} -setup {
+	    variable locale [mclocale]
+	    mclocale $loc
+	} -cleanup {
+	    mclocale $locale
+	} -body {
+	    mcload [file join [temporaryDirectory] msgdir]
+	} -result $count
+	incr count
     }
-    ::msgcat::mclocale foo
-    set result [::msgcat::mc unk2]
-    rename ::msgcat::mcunknown {}
-    rename oldproc ::msgcat::mcunknown
-    set result
-} {unknown:foo:unk2:1}
-    
 
-#
-# Test mcload.  Need to set up an environment for
-# these tests by creating a temporary directory and
-# message files.
-#
+    # Even though foo_BAR_notexist does not exist,
+    # foo_BAR and foo should be loaded.
+	test msgcat-5.4 {mcload} -setup {
+	    variable locale [mclocale]
+	    mclocale foo_BAR_notexist
+	} -cleanup {
+	    mclocale $locale
+	} -body {
+	    mcload [file join [temporaryDirectory] msgdir]
+	} -result 2
 
-set locales {en en_US en_US_funky}
+	test msgcat-5.5 {mcload} -setup {
+	    variable locale [mclocale]
+	    mclocale no_FI_notexist
+	} -cleanup {
+	    mclocale $locale
+	} -body {
+	    mcload [file join [temporaryDirectory] msgdir]
+	} -result 0
 
-catch {file mkdir msgdir}
-foreach l $locales {
-    set fd [open [string tolower [file join msgdir $l.msg]] w]
-    puts $fd "::msgcat::mcset $l abc abc-$l"
-    close $fd
-}
+	test msgcat-5.6 {mcload} -setup {
+	    variable locale [mclocale]
+	    mclocale foo
+	} -cleanup {
+	    mclocale $locale
+	} -body {
+	    mc abc
+	} -result abc-foo
 
-test msgcat-5.1 {::msgcat::mcload} {
-    ::msgcat::mclocale en
-    ::msgcat::mcload msgdir
-} {1}
-test msgcat-5.2 {::msgcat::mcload} {
-    ::msgcat::mclocale en_US
-    ::msgcat::mcload msgdir
-} {2}
-test msgcat-5.3 {::msgcat::mcload} {
-    ::msgcat::mclocale en_US_funky
-    ::msgcat::mcload msgdir
-} {3}
-
-# Even though en_US_notexist does not exist,
-# en_US and en should be loaded.
-
-test msgcat-5.4 {::msgcat::mcload} {
-    ::msgcat::mclocale en_US_notexist
-    ::msgcat::mcload msgdir
-} {2}
-test msgcat-5.5 {::msgcat::mcload} {
-    ::msgcat::mclocale no_FI_notexist
-    ::msgcat::mcload msgdir
-} {0}
-test msgcat-5.6 {::msgcat::mcload} {
-    ::msgcat::mclocale en
-    ::msgcat::mc abc
-} {abc-en}
-test msgcat-5.7 {::msgcat::mcload} {
-    ::msgcat::mclocale en_US
-    ::msgcat::mc abc
-} {abc-en_US}
-test msgcat-5.8 {::msgcat::mcload} {
-    ::msgcat::mclocale en_US_funky
-    ::msgcat::mc abc
-} {abc-en_US_funky}
-test msgcat-5.9 {::msgcat::mcload} {
-    rename ::msgcat::mcunknown oldproc
-    proc ::msgcat::mcunknown {dom s} {
-        return "unknown:$dom:$s"
+	test msgcat-5.7 {mcload} -setup {
+	    variable locale [mclocale]
+	    mclocale foo_BAR
+	} -cleanup {
+	    mclocale $locale
+	} -body {
+	    mc abc
+	} -result abc-foo_BAR
+
+	test msgcat-5.8 {mcload} -setup {
+	    variable locale [mclocale]
+	    mclocale foo_BAR_baz
+	} -cleanup {
+	    mclocale $locale
+	} -body {
+	    mc abc
+	} -result abc-foo_BAR_baz
+
+	test msgcat-5.9 {mcload} -setup {
+	    rename ::msgcat::mcunknown SavedMcunknown
+	    proc ::msgcat::mcunknown {dom s} {
+		return unknown:$dom:$s
+	    }
+	    variable locale [mclocale]
+	    mclocale no_FI_notexist
+	} -cleanup {
+	    mclocale $locale
+	    rename ::msgcat::mcunknown {}
+	    rename SavedMcunknown ::msgcat::mcunknown
+	} -body {
+	    mc abc
+	} -result unknown:no_fi_notexist:abc
+
+
+    foreach loc $locales {
+	removeFile [string tolower [file join msgdir $loc.msg]]
     }
-    ::msgcat::mclocale no_FI_notexist
-    set result [::msgcat::mc abc]
-    rename ::msgcat::mcunknown {}
-    rename oldproc ::msgcat::mcunknown
-    set result
-} {unknown:no_fi_notexist:abc}
-
-# cleanup temp files
-foreach l $locales {
-    file delete [string tolower [file join msgdir $l.msg]]
-}
-# Clean out the msg catalogs
-file delete msgdir
+    removeDirectory msgdir
 
+    # Tests msgcat-6.*: [mcset], [mc] namespace inheritance
 #
 # Test mcset and mc, ensuring that resolution for messages
 # proceeds from the current ns to its parent and so on to the 
@@ -332,7 +459,7 @@ file delete msgdir
 #
 # Do this for the 12 permutations of
 #     locales: foo
-#     namespaces: ::foo ::foo::bar ::foo::bar::baz
+#     namespaces: foo foo::bar foo::bar::baz
 #     strings: {ov1 ov2 ov3 ov4}
 #     namespace ::foo            defines ov1, ov2, ov3
 #     namespace ::foo::bar       defines      ov2, ov3
@@ -347,82 +474,96 @@ file delete msgdir
 #     ov4 should be resolved in none, and call mcunknown
 #
 
-namespace eval ::foo {
-    ::msgcat::mcset foo ov1 "ov1_foo"
-    ::msgcat::mcset foo ov2 "ov2_foo"
-    ::msgcat::mcset foo ov3 "ov3_foo"
+    variable result
+    array set result {
+	foo,ov1 ov1_foo foo,ov2 ov2_foo foo,ov3 ov3_foo foo,ov4 ov4
+	foo::bar,ov1 ov1_foo foo::bar,ov2 ov2_foo_bar
+	foo::bar,ov3 ov3_foo_bar foo::bar,ov4 ov4 foo::bar::baz,ov1 ov1_foo
+	foo::bar::baz,ov2 ov2_foo_bar foo::bar::baz,ov3 ov3_foo_bar_baz
+	foo::bar::baz,ov4 ov4
+    }
+    variable count 1
+    variable ns
+    foreach ns {foo foo::bar foo::bar::baz} {
+	foreach string {ov1 ov2 ov3 ov4} {
+	    test msgcat-6.$count {mcset, overlap} -setup {
+		namespace eval foo {
+		    ::msgcat::mcset foo ov1 ov1_foo
+		    ::msgcat::mcset foo ov2 ov2_foo
+		    ::msgcat::mcset foo ov3 ov3_foo
+		    namespace eval bar {
+			::msgcat::mcset foo ov2 ov2_foo_bar
+			::msgcat::mcset foo ov3 ov3_foo_bar
+			namespace eval baz {
+			    ::msgcat::mcset foo ov3 "ov3_foo_bar_baz"
+			}
+		    }
+		    
+		}
+		variable locale [mclocale]
+		mclocale foo
+	    } -cleanup {
+		mclocale $locale
+		namespace delete foo
+	    } -body {
+		namespace eval $ns [list ::msgcat::mc $string]
+	    } -result $result($ns,$string)
+	    incr count
+	}
+    }
+
+    # Tests msgcat-7.*: [mc] extra args processed by [format]
+
+    test msgcat-7.1 {mc extra args go through to format} -setup {
+	mcset foo format1 "this is a test"
+	mcset foo format2 "this is a %s"
+	mcset foo format3 "this is a %s %s"
+	variable locale [mclocale]
+	mclocale foo
+    } -cleanup {
+	mclocale $locale
+    } -body {
+	mc format1 "good test"
+    } -result "this is a test"
+
+    test msgcat-7.2 {mc extra args go through to format} -setup {
+	mcset foo format1 "this is a test"
+	mcset foo format2 "this is a %s"
+	mcset foo format3 "this is a %s %s"
+	variable locale [mclocale]
+	mclocale foo
+    } -cleanup {
+	mclocale $locale
+    } -body {
+	mc format2 "good test"
+    } -result "this is a good test"
+
+    test msgcat-7.3 {mc errors from format are propagated} -setup {
+	mcset foo format1 "this is a test"
+	mcset foo format2 "this is a %s"
+	mcset foo format3 "this is a %s %s"
+	variable locale [mclocale]
+	mclocale foo
+    } -cleanup {
+	mclocale $locale
+    } -body {
+	catch {mc format3 "good test"}
+    } -result 1
+
+    test msgcat-7.4 {mc, extra args are given to unknown} -setup {
+	mcset foo format1 "this is a test"
+	mcset foo format2 "this is a %s"
+	mcset foo format3 "this is a %s %s"
+	variable locale [mclocale]
+	mclocale foo
+    } -cleanup {
+	mclocale $locale
+    } -body {
+	mc "this is a %s" "good test"
+    } -result "this is a good test"
+
+    cleanupTests
 }
-namespace eval ::foo::bar {
-    ::msgcat::mcset foo ov2 "ov2_foo_bar"
-    ::msgcat::mcset foo ov3 "ov3_foo_bar"
-}    
-namespace eval ::foo::bar::baz {
-    ::msgcat::mcset foo ov3 "ov3_foo_bar_baz"
-}    
-::msgcat::mclocale foo
-
-# namespace ::foo
-test msgcat-6.1 {::msgcat::mc, namespace resolution} {
-    namespace eval ::foo {::msgcat::mc ov1}
-} {ov1_foo}
-test msgcat-6.2 {::msgcat::mc, namespace resolution} {
-    namespace eval ::foo {::msgcat::mc ov2}
-} {ov2_foo}
-test msgcat-6.3 {::msgcat::mc, namespace resolution} {
-    namespace eval ::foo {::msgcat::mc ov3}
-} {ov3_foo}
-test msgcat-6.4 {::msgcat::mc, namespace resolution} {
-    namespace eval ::foo {::msgcat::mc ov4}
-} {ov4}
-# namespace ::foo::bar
-test msgcat-6.5 {::msgcat::mc, namespace resolution} {
-    namespace eval ::foo::bar {::msgcat::mc ov1}
-} {ov1_foo}
-test msgcat-6.6 {::msgcat::mc, namespace resolution} {
-    namespace eval ::foo::bar {::msgcat::mc ov2}
-} {ov2_foo_bar}
-test msgcat-6.7 {::msgcat::mc, namespace resolution} {
-    namespace eval ::foo::bar {::msgcat::mc ov3}
-} {ov3_foo_bar}
-test msgcat-6.8 {::msgcat::mc, namespace resolution} {
-    namespace eval ::foo::bar {::msgcat::mc ov4}
-} {ov4}
-# namespace ::foo
-test msgcat-6.9 {::msgcat::mc, namespace resolution} {
-    namespace eval ::foo::bar::baz {::msgcat::mc ov1}
-} {ov1_foo}
-test msgcat-6.10 {::msgcat::mc, namespace resolution} {
-    namespace eval ::foo::bar::baz {::msgcat::mc ov2}
-} {ov2_foo_bar}
-test msgcat-6.11 {::msgcat::mc, namespace resolution} {
-    namespace eval ::foo::bar::baz {::msgcat::mc ov3}
-} {ov3_foo_bar_baz}
-test msgcat-6.12 {::msgcat::mc, namespace resolution} {
-    namespace eval ::foo::bar::baz {::msgcat::mc ov4}
-} {ov4}
-
-namespace delete ::foo::bar::baz ::foo::bar ::foo
-
-::msgcat::mclocale foo
-::msgcat::mcset foo format1 "this is a test"
-::msgcat::mcset foo format2 "this is a %s"
-::msgcat::mcset foo format3 "this is a %s %s"
-
-test msgcat-7.1 {::msgcat::mc, extra args go through to format} {
-    ::msgcat::mc format1 "good test"
-} "this is a test"
-test msgcat-7.2 {::msgcat::mc, extra args go through to format} {
-    ::msgcat::mc format2 "good test"
-} "this is a good test"
-test msgcat-7.3 {::msgcat::mc, errors from format are propagated} {
-    catch {::msgcat::mc format3 "good test"}
-} 1
-test msgcat-7.4 {::msgcat::mc, extra args are given to unknown} {
-    ::msgcat::mc "this is a %s" "good test"
-} "this is a good test"
-
-# Reset the locale
-::msgcat::mclocale $oldlocale
-
-::tcltest::cleanupTests
+namespace delete ::msgcat::test
 return
+