2005-09-01 Atsushi Enomoto <atsushi@ximian.com>

[mono.git] / mcs / class / corlib / Mono.Globalization.Unicode / TestDriver.cs

diff --git a/mcs/class/corlib/Mono.Globalization.Unicode/TestDriver.cs b/mcs/class/corlib/Mono.Globalization.Unicode/TestDriver.cs
index 6f19771c156ef8e713baf05d2dd88f8b4db9f7c2..b51bfa3ca3ae9a47b74d3c53f618037fe55e1f61 100644 (file)
--- a/mcs/class/corlib/Mono.Globalization.Unicode/TestDriver.cs
+++ b/mcs/class/corlib/Mono.Globalization.Unicode/TestDriver.cs
@@ -15,12 +15,24 @@ namespace Mono.Globalization.Unicode
                {
                        if (args.Length > 0 && args [0] == "--generate")
                                new TestDriver ().Generate ();
+                       if (args.Length > 0 && args [0] == "--check")
+                               new TestDriver ().CheckCultures ();
                        else
                                new TestDriver ().Run ();
                }
 
+               void CheckCultures ()
+               {
+                       foreach (CultureInfo ci in CultureInfo.GetCultures (
+                               CultureTypes.AllCultures))
+                               Console.WriteLine ("Culture {0}({1}) : OK: {2}", ci.LCID, ci.Name, new SimpleCollator (ci));
+               }
+
                void Run ()
                {
+LastIndexOf ("\u30D1\u30FC", "\u30A2", CompareOptions.IgnoreNonSpace);
+return;
+                       /*
                        DumpSortKey ("AE");
                        DumpSortKey ("\u00C6");
                        DumpSortKey ("ABCABC", 5, 1, CompareOptions.IgnoreCase);
@@ -40,12 +52,14 @@ namespace Mono.Globalization.Unicode
                        Compare ("AB\u01c0C", "A\u01c0B\u01c0C", CompareOptions.IgnoreSymbols);
                        Compare ("A\u0304", "\u0100"); // diacritical weight addition
                        Compare ("ABCABC", 5, 1, "c", 0, 1, CompareOptions.IgnoreCase);
+                       Compare ("-d:NET_1_1", 0, 1, "-", 0, 1, CompareOptions.None);
 
                        IndexOf ("ABC", '1', CompareOptions.None);
                        IndexOf ("ABCABC", 'c', CompareOptions.IgnoreCase);
                        IndexOf ("ABCABC", '\uFF22', CompareOptions.IgnoreCase | CompareOptions.IgnoreWidth);
                        IndexOf ("ABCDE", '\u0117', CompareOptions.IgnoreNonSpace | CompareOptions.IgnoreCase);
                        IndexOf ("ABCABC", 'B', 1, 5, CompareOptions.IgnoreCase);
+                       IndexOf ("\u00E6", 'a', CompareOptions.None);
 
                        LastIndexOf ("ABC", '1', CompareOptions.None);
                        LastIndexOf ("ABCABC", 'c', CompareOptions.IgnoreCase);
@@ -56,11 +70,25 @@ namespace Mono.Globalization.Unicode
                        IsPrefix ("BC", "c", CompareOptions.IgnoreCase);
                        IsPrefix ("C", "c", CompareOptions.IgnoreCase);
                        IsPrefix ("EDCBA", "\u0117", CompareOptions.IgnoreNonSpace | CompareOptions.IgnoreCase);
+                       IsPrefix ("ABC", "AB", CompareOptions.IgnoreCase);
+                       IsPrefix ("ae", "\u00E6", CompareOptions.None);
+                       IsPrefix ("\u00E6", "ae", CompareOptions.None);
+                       IsPrefix ("\u00E6", "a", CompareOptions.None);
+                       IsPrefix ("\u00E6s", "ae", CompareOptions.None);
+                       IsPrefix ("\u00E6", "aes", CompareOptions.None);
+                       IsPrefix ("--start", "--", CompareOptions.None);
+                       IsPrefix ("-d:NET_1_1", "-", CompareOptions.None);
+                       IsPrefix ("-d:NET_1_1", "@", CompareOptions.None);
 
                        IsSuffix ("ABC", "c", CompareOptions.IgnoreCase);
                        IsSuffix ("BC", "c", CompareOptions.IgnoreCase);
                        IsSuffix ("CBA", "c", CompareOptions.IgnoreCase);
                        IsSuffix ("ABCDE", "\u0117", CompareOptions.IgnoreNonSpace | CompareOptions.IgnoreCase);
+                       IsSuffix ("\u00E6", "a", CompareOptions.None);
+                       IsSuffix ("\u00E6", "e", CompareOptions.None);
+                       IsSuffix ("\u00E6", "ae", CompareOptions.None);
+                       IsSuffix ("ae", "\u00E6", CompareOptions.None);
+                       IsSuffix ("e", "\u00E6", CompareOptions.None);
 
                        IndexOf ("ABC", "1", CompareOptions.None);
                        IndexOf ("ABCABC", "c", CompareOptions.IgnoreCase);
@@ -69,6 +97,8 @@ namespace Mono.Globalization.Unicode
                        IndexOf ("ABCABC", "BC", CompareOptions.IgnoreCase);
                        IndexOf ("BBCBBC", "BC", CompareOptions.IgnoreCase);
                        IndexOf ("ABCDEF", "BCD", 0, 3, CompareOptions.IgnoreCase);
+                       IndexOf ("-ABC", "-", CompareOptions.None);
+                       IndexOf ("--ABC", "--", CompareOptions.None);
 
                        LastIndexOf ("ABC", "1", CompareOptions.None);
                        LastIndexOf ("ABCABC", "c", CompareOptions.IgnoreCase);
@@ -77,17 +107,38 @@ namespace Mono.Globalization.Unicode
                        LastIndexOf ("ABCABC", "BC", CompareOptions.IgnoreCase);
                        LastIndexOf ("BBCBBC", "BC", CompareOptions.IgnoreCase);
                        LastIndexOf ("original", "rig", CompareOptions.None);
-                       Console.WriteLine ("original".LastIndexOf ("rig"));
+                       LastIndexOf ("\u00E6", "ae", CompareOptions.None);
+                       LastIndexOf ("-ABC", "-", CompareOptions.None);
+                       LastIndexOf ("--ABC", "--", CompareOptions.None);
+                       */
 
                        coll = new SimpleCollator (new CultureInfo ("hu"));
                        DumpSortKey ("ZSAZS1");
+                       IsSuffix ("zs", "z", CompareOptions.None);
+                       IsSuffix ("zs", "s", CompareOptions.None);
+                       IsSuffix ("zs", "zs", CompareOptions.None);
+                       IsSuffix ("sz", "z", CompareOptions.None);
+                       IsSuffix ("sz", "s", CompareOptions.None);
+                       IsSuffix ("--ABC", "--", CompareOptions.None);
+                       IsSuffix ("ABC--", "--", CompareOptions.None);
+
+/*
+                       coll = new SimpleCollator (new CultureInfo (""));
+                       Compare ("c\u00F4te", "cot\u00E9");
+                       DumpSortKey ("c\u00F4te");
+                       DumpSortKey ("cot\u00E9");
+                       coll = new SimpleCollator (new CultureInfo ("fr"));
+                       Compare ("c\u00F4te", "cot\u00E9");
+                       DumpSortKey ("c\u00F4te");
+                       DumpSortKey ("cot\u00E9");
+*/
                }
 
                void Generate ()
                {
                        // dump sortkey for every single character.
                        for (int i = 0; i <= char.MaxValue; i++) {
-                               byte [] data = coll.GetSortKey (new string ((char) i, 1)).KeyData;
+                               byte [] data = coll.GetSortKey (new string ((char) i, 1), CompareOptions.StringSort).KeyData;
                                if (data.Length == 5 && data [0] == 1 && data [1] == 1 &&
                                        data [2] == 1 && data [3] == 1 && data [4] == 0)
                                        continue;
@@ -140,7 +191,7 @@ namespace Mono.Globalization.Unicode
 
                void IsPrefix (string s1, string s2, CompareOptions opt)
                {
-                       Console.Error.WriteLine ("IsPrefix ({3}): {0} {1} / {2}",
+                       Console.Error.WriteLine ("prefix ({3}): {0} {1} / {2}",
                                coll.IsPrefix (s1, s2, opt), s1, s2, opt);
                }
 
@@ -156,6 +207,12 @@ namespace Mono.Globalization.Unicode
                                coll.LastIndexOf (s1, s2, opt), s1, s2, opt);
                }
 
+               void LastIndexOf (string s1, string s2, int idx, int len, CompareOptions opt)
+               {
+                       Console.Error.WriteLine ("sLast ({3},{4},{5}): {0} {1} / {2}",
+                               coll.LastIndexOf (s1, s2, idx, len, opt), s1, s2, opt, idx, len);
+               }
+
                void IsSuffix (string s1, string s2, CompareOptions opt)
                {
                        Console.Error.WriteLine ("suffix ({3}): {0} {1} / {2}",