mcs/class/corlib/Mono.Globalization.Unicode/TestDriver.cs

   1 using System;
   2 using System.Globalization;
   3
   4 using Uni = Mono.Globalization.Unicode.MSCompatUnicodeTable;
   5
   6 namespace Mono.Globalization.Unicode
   7 {
   8         class TestDriver
   9         {
  10                 SimpleCollator coll = new SimpleCollator (CultureInfo.InvariantCulture);
  11
  12                 #region Testing bits
  13
  14                 static void Main (string [] args)
  15                 {
  16                         if (args.Length > 0 && args [0] == "--generate")
  17                                 new TestDriver ().Generate ();
  18                         if (args.Length > 0 && args [0] == "--check")
  19                                 new TestDriver ().CheckCultures ();
  20                         else
  21                                 new TestDriver ().Run ();
  22                 }
  23
  24                 void CheckCultures ()
  25                 {
  26                         foreach (CultureInfo ci in CultureInfo.GetCultures (
  27                                 CultureTypes.AllCultures))
  28                                 Console.WriteLine ("Culture {0}({1}) : OK: {2}", ci.LCID, ci.Name, new SimpleCollator (ci));
  29                 }
  30
  31                 void Run ()
  32                 {
  33 //IsSuffix ("\u00E6", "ae", CompareOptions.None);
  34 //IsSuffix ("ae", "\u00E6", CompareOptions.None);
  35 //LastIndexOf ("AE", "A", 1, 2, CompareOptions.None);
  36 //LastIndexOf ("\u00C6", "AE", CompareOptions.None);
  37 Compare ("\u30D0\u30FC\u30B9", "\uFF8A\uFF9E\uFF70\uFF7D", CompareOptions.IgnoreNonSpace);
  38 //return;
  39                         /*
  40                         DumpSortKey ("AE");
  41                         DumpSortKey ("\u00C6");
  42                         DumpSortKey ("ABCABC", 5, 1, CompareOptions.IgnoreCase);
  43                         DumpSortKey ("-");
  44                         DumpSortKey ("--");
  45                         DumpSortKey ("A-B-C");
  46                         DumpSortKey ("A\u0304");
  47                         DumpSortKey ("\u0100");
  48
  49                         Compare ("1", "2");
  50                         Compare ("A", "a");
  51                         Compare ("A", "a", CompareOptions.IgnoreCase);
  52                         Compare ("\uFF10", "0", CompareOptions.IgnoreWidth);
  53                         Compare ("\uFF21", "a", CompareOptions.IgnoreCase | CompareOptions.IgnoreWidth);
  54                         Compare ("12", "1");
  55                         Compare ("AE", "\u00C6");
  56                         Compare ("AB\u01c0C", "A\u01c0B\u01c0C", CompareOptions.IgnoreSymbols);
  57                         Compare ("A\u0304", "\u0100"); // diacritical weight addition
  58                         Compare ("ABCABC", 5, 1, "c", 0, 1, CompareOptions.IgnoreCase);
  59                         Compare ("-d:NET_1_1", 0, 1, "-", 0, 1, CompareOptions.None);
  60
  61                         IndexOf ("ABC", '1', CompareOptions.None);
  62                         IndexOf ("ABCABC", 'c', CompareOptions.IgnoreCase);
  63                         IndexOf ("ABCABC", '\uFF22', CompareOptions.IgnoreCase | CompareOptions.IgnoreWidth);
  64                         IndexOf ("ABCDE", '\u0117', CompareOptions.IgnoreNonSpace | CompareOptions.IgnoreCase);
  65                         IndexOf ("ABCABC", 'B', 1, 5, CompareOptions.IgnoreCase);
  66                         IndexOf ("\u00E6", 'a', CompareOptions.None);
  67
  68                         LastIndexOf ("ABC", '1', CompareOptions.None);
  69                         LastIndexOf ("ABCABC", 'c', CompareOptions.IgnoreCase);
  70                         LastIndexOf ("ABCABC", '\uFF22', CompareOptions.IgnoreCase | CompareOptions.IgnoreWidth);
  71                         LastIndexOf ("ABCDE", '\u0117', CompareOptions.IgnoreNonSpace | CompareOptions.IgnoreCase);
  72
  73                         IsPrefix ("ABC", "c", CompareOptions.IgnoreCase);
  74                         IsPrefix ("BC", "c", CompareOptions.IgnoreCase);
  75                         IsPrefix ("C", "c", CompareOptions.IgnoreCase);
  76                         IsPrefix ("EDCBA", "\u0117", CompareOptions.IgnoreNonSpace | CompareOptions.IgnoreCase);
  77                         IsPrefix ("ABC", "AB", CompareOptions.IgnoreCase);
  78                         IsPrefix ("ae", "\u00E6", CompareOptions.None);
  79                         IsPrefix ("\u00E6", "ae", CompareOptions.None);
  80                         IsPrefix ("\u00E6", "a", CompareOptions.None);
  81                         IsPrefix ("\u00E6s", "ae", CompareOptions.None);
  82                         IsPrefix ("\u00E6", "aes", CompareOptions.None);
  83                         IsPrefix ("--start", "--", CompareOptions.None);
  84                         IsPrefix ("-d:NET_1_1", "-", CompareOptions.None);
  85                         IsPrefix ("-d:NET_1_1", "@", CompareOptions.None);
  86
  87                         IsSuffix ("ABC", "c", CompareOptions.IgnoreCase);
  88                         IsSuffix ("BC", "c", CompareOptions.IgnoreCase);
  89                         IsSuffix ("CBA", "c", CompareOptions.IgnoreCase);
  90                         IsSuffix ("ABCDE", "\u0117", CompareOptions.IgnoreNonSpace | CompareOptions.IgnoreCase);
  91                         IsSuffix ("\u00E6", "a", CompareOptions.None);
  92                         IsSuffix ("\u00E6", "e", CompareOptions.None);
  93                         IsSuffix ("\u00E6", "ae", CompareOptions.None);
  94                         IsSuffix ("ae", "\u00E6", CompareOptions.None);
  95                         IsSuffix ("e", "\u00E6", CompareOptions.None);
  96
  97                         IndexOf ("ABC", "1", CompareOptions.None);
  98                         IndexOf ("ABCABC", "c", CompareOptions.IgnoreCase);
  99                         IndexOf ("ABCABC", "\uFF22", CompareOptions.IgnoreCase | CompareOptions.IgnoreWidth);
 100                         IndexOf ("ABCDE", "\u0117", CompareOptions.IgnoreNonSpace | CompareOptions.IgnoreCase);
 101                         IndexOf ("ABCABC", "BC", CompareOptions.IgnoreCase);
 102                         IndexOf ("BBCBBC", "BC", CompareOptions.IgnoreCase);
 103                         IndexOf ("ABCDEF", "BCD", 0, 3, CompareOptions.IgnoreCase);
 104                         IndexOf ("-ABC", "-", CompareOptions.None);
 105                         IndexOf ("--ABC", "--", CompareOptions.None);
 106
 107                         LastIndexOf ("ABC", "1", CompareOptions.None);
 108                         LastIndexOf ("ABCABC", "c", CompareOptions.IgnoreCase);
 109                         LastIndexOf ("ABCABC", "\uFF22", CompareOptions.IgnoreCase | CompareOptions.IgnoreWidth);
 110                         LastIndexOf ("ABCDE", "\u0117", CompareOptions.IgnoreNonSpace | CompareOptions.IgnoreCase);
 111                         LastIndexOf ("ABCABC", "BC", CompareOptions.IgnoreCase);
 112                         LastIndexOf ("BBCBBC", "BC", CompareOptions.IgnoreCase);
 113                         LastIndexOf ("original", "rig", CompareOptions.None);
 114                         LastIndexOf ("\u00E6", "ae", CompareOptions.None);
 115                         LastIndexOf ("-ABC", "-", CompareOptions.None);
 116                         LastIndexOf ("--ABC", "--", CompareOptions.None);
 117                         */
 118
 119                         coll = new SimpleCollator (new CultureInfo ("hu"));
 120                         DumpSortKey ("ZSAZS1");
 121                         IsSuffix ("zs", "z", CompareOptions.None);
 122                         IsSuffix ("zs", "s", CompareOptions.None);
 123                         IsSuffix ("zs", "zs", CompareOptions.None);
 124                         IsSuffix ("sz", "z", CompareOptions.None);
 125                         IsSuffix ("sz", "s", CompareOptions.None);
 126                         IsSuffix ("--ABC", "--", CompareOptions.None);
 127                         IsSuffix ("ABC--", "--", CompareOptions.None);
 128
 129 /*
 130                         coll = new SimpleCollator (new CultureInfo (""));
 131                         Compare ("c\u00F4te", "cot\u00E9");
 132                         DumpSortKey ("c\u00F4te");
 133                         DumpSortKey ("cot\u00E9");
 134                         coll = new SimpleCollator (new CultureInfo ("fr"));
 135                         Compare ("c\u00F4te", "cot\u00E9");
 136                         DumpSortKey ("c\u00F4te");
 137                         DumpSortKey ("cot\u00E9");
 138 */
 139                 }
 140
 141                 void Generate ()
 142                 {
 143                         // dump sortkey for every single character.
 144                         for (int i = 0; i <= char.MaxValue; i++) {
 145                                 byte [] data = coll.GetSortKey (new string ((char) i, 1), CompareOptions.StringSort).KeyData;
 146                                 if (data.Length == 5 && data [0] == 1 && data [1] == 1 &&
 147                                         data [2] == 1 && data [3] == 1 && data [4] == 0)
 148                                         continue;
 149                                 foreach (byte b in data)
 150                                         Console.Write ("{0:X02} ", b);
 151                                 Console.WriteLine (" : {0:X04}, {1}",
 152                                         i, Char.GetUnicodeCategory ((char) i));
 153                         }
 154                 }
 155
 156                 void Compare (string s1, string s2)
 157                 {
 158                         Compare (s1, s2, CompareOptions.None);
 159                 }
 160
 161                 void Compare (string s1, string s2, CompareOptions opt)
 162                 {
 163                         Console.Error.WriteLine ("compare ({3}): {0} {1} / {2}",
 164                                 coll.Compare (s1, s2, opt), s1, s2, opt);
 165                 }
 166
 167                 void Compare (string s1, int idx1, int len1, string s2, int idx2, int len2, CompareOptions opt)
 168                 {
 169                         Console.Error.WriteLine ("compare ({3} {4} {5} {6} {7}): {0} {1} / {2}",
 170                                 coll.Compare (s1, idx1, len1, s2, idx2, len2, opt), s1, s2,
 171                                         opt, idx1, len1, idx2, len2);
 172                 }
 173
 174                 void IndexOf (string s, char c, CompareOptions opt)
 175                 {
 176                         IndexOf (s, c, 0, s.Length, opt);
 177                 }
 178
 179                 void IndexOf (string s, char c, int idx, int len, CompareOptions opt)
 180                 {
 181                         Console.Error.WriteLine ("cIndex ({3} {4} {5}): {0} {1} / {2}",
 182                                 coll.IndexOf (s, c, idx, len, opt), s, c, opt, idx, len);
 183                 }
 184
 185                 void IndexOf (string s1, string s2, CompareOptions opt)
 186                 {
 187                         IndexOf (s1, s2, 0, s1.Length, opt);
 188                 }
 189
 190                 void IndexOf (string s1, string s2, int idx, int len, CompareOptions opt)
 191                 {
 192                         Console.Error.WriteLine ("sIndex ({3} {4} {5}): {0} {1} / {2}",
 193                                 coll.IndexOf (s1, s2, idx, len, opt), s1, s2, opt, idx, len);
 194                 }
 195
 196                 void IsPrefix (string s1, string s2, CompareOptions opt)
 197                 {
 198                         Console.Error.WriteLine ("prefix ({3}): {0} {1} / {2}",
 199                                 coll.IsPrefix (s1, s2, opt), s1, s2, opt);
 200                 }
 201
 202                 void LastIndexOf (string s, char c, CompareOptions opt)
 203                 {
 204                         Console.Error.WriteLine ("cLast ({3}): {0} {1} / {2}",
 205                                 coll.LastIndexOf (s, c, opt), s, c, opt);
 206                 }
 207
 208                 void LastIndexOf (string s1, string s2, CompareOptions opt)
 209                 {
 210                         Console.Error.WriteLine ("sLast ({3}): {0} {1} / {2}",
 211                                 coll.LastIndexOf (s1, s2, opt), s1, s2, opt);
 212                 }
 213
 214                 void LastIndexOf (string s1, string s2, int idx, int len, CompareOptions opt)
 215                 {
 216                         Console.Error.WriteLine ("sLast ({3},{4},{5}): {0} {1} / {2}",
 217                                 coll.LastIndexOf (s1, s2, idx, len, opt), s1, s2, opt, idx, len);
 218                 }
 219
 220                 void IsSuffix (string s1, string s2, CompareOptions opt)
 221                 {
 222                         Console.Error.WriteLine ("suffix ({3}): {0} {1} / {2}",
 223                                 coll.IsSuffix (s1, s2, opt), s1, s2, opt);
 224                 }
 225
 226                 void DumpSortKey (string s)
 227                 {
 228                         DumpSortKey (s, 0, s.Length, CompareOptions.None);
 229                 }
 230
 231                 void DumpSortKey (string s, int idx, int len, CompareOptions opt)
 232                 {
 233                         byte [] data = coll.GetSortKey (s, idx, len, opt).KeyData;
 234                         foreach (byte b in data)
 235                                 Console.Error.Write ("{0:X02} ", b);
 236                         Console.Error.WriteLine (" : {0} ({1} {2} {3})", s, opt, idx, len);
 237                 }
 238
 239                 #endregion
 240         }
 241 }