mcs/class/corlib/Test/System.Globalization/CompareInfoTest.jvm.cs

   1 // CompareInfoTest.cs - NUnit Test Cases for the
   2 // System.Globalization.CompareInfo class
   3 //
   4 // Dick Porter <dick@ximian.com>
   5 // Atsushi Enomoto <atsushi@ximian.com>
   6 //
   7 // (C) 2003-2005 Novell, Inc.  http://www.novell.com
   8 //
   9
  10 using NUnit.Framework;
  11 using System;
  12 using System.Globalization;
  13
  14 namespace MonoTests.System.Globalization
  15 {
  16
  17 [TestFixture]
  18 public class CompareInfoTest
  19 {
  20         static bool doTest = Environment.GetEnvironmentVariable ("MONO_DISABLE_MANAGED_COLLATION") != "yes";
  21
  22         public CompareInfoTest() {}
  23
  24         [Test]
  25         public void Compare()
  26         {
  27                 string s1 = "foo";
  28
  29                 Assert.AreEqual (0, CultureInfo.InvariantCulture.CompareInfo.Compare ("", ""), "Compare two empty strings");
  30                 Assert.AreEqual (1, CultureInfo.InvariantCulture.CompareInfo.Compare (s1, ""), "Compare string with empty string");
  31                 Assert.AreEqual (-1, CultureInfo.InvariantCulture.CompareInfo.Compare ("", s1), "Compare empty string with string");
  32
  33                 Assert.AreEqual (0, CultureInfo.InvariantCulture.CompareInfo.Compare ("", 0, "", 0), "Compare two empty strings, with 0 offsets");
  34                 Assert.AreEqual (1, CultureInfo.InvariantCulture.CompareInfo.Compare (s1, 0, "", 0), "Compare string with empty string, with 0 offsets");
  35                 Assert.AreEqual (-1, CultureInfo.InvariantCulture.CompareInfo.Compare ("", 0, s1, 0), "Compare empty string with string, with 0 offsets");
  36
  37                 Assert.AreEqual (0, CultureInfo.InvariantCulture.CompareInfo.Compare ("", 0, "".Length, "", 0, "".Length), "Compare two empty strings, with 0 offsets and specified lengths");
  38                 Assert.AreEqual (1, CultureInfo.InvariantCulture.CompareInfo.Compare (s1, 0, s1.Length, "", 0, "".Length), "Compare string with empty string, with 0 offsets and specified lengths");
  39                 Assert.AreEqual (-1, CultureInfo.InvariantCulture.CompareInfo.Compare ("", 0, "".Length, s1, 0, s1.Length), "Compare empty string with string, with 0 offsets and specified lengths");
  40
  41                 Assert.AreEqual (0, CultureInfo.InvariantCulture.CompareInfo.Compare (s1, s1.Length, s1, s1.Length), "Compare two strings, with offsets == string lengths");
  42                 Assert.AreEqual (-1, CultureInfo.InvariantCulture.CompareInfo.Compare (s1, s1.Length, s1, 0), "Compare two strings, with first offset == string length");
  43                 Assert.AreEqual (1, CultureInfo.InvariantCulture.CompareInfo.Compare (s1, 0, s1, s1.Length), "Compare two strings, with second offset == string length");
  44
  45                 Assert.AreEqual (0, CultureInfo.InvariantCulture.CompareInfo.Compare (s1, 0, 0, s1, 0, 0), "Compare two strings, with zero lengths");
  46                 Assert.AreEqual (-1, CultureInfo.InvariantCulture.CompareInfo.Compare (s1, 0, 0, s1, 0, s1.Length), "Compare two strings, with first length zero");
  47                 Assert.AreEqual (1, CultureInfo.InvariantCulture.CompareInfo.Compare (s1, 0, s1.Length, s1, 0, 0), "Compare strings, with second length zero");
  48
  49         }
  50
  51         // Culture-sensitive collation tests
  52
  53         CompareInfo invariant = CultureInfo.InvariantCulture.CompareInfo;
  54         CompareInfo french = new CultureInfo ("fr").CompareInfo;
  55         CompareInfo japanese = new CultureInfo ("ja").CompareInfo;
  56         CompareInfo czech = new CultureInfo ("cs").CompareInfo;
  57         CompareInfo hungarian = new CultureInfo ("hu").CompareInfo;
  58
  59         CompareOptions ignoreCN =
  60                 CompareOptions.IgnoreNonSpace | CompareOptions.IgnoreCase;
  61
  62         void AssertCompare (string message, int result, string s1, string s2)
  63         {
  64                 AssertCompare (message, result, s1, s2, CompareOptions.None);
  65         }
  66
  67         void AssertCompare (string message, int result, string s1, string s2,
  68                 CompareOptions opt)
  69         {
  70                 AssertCompare (message, result, s1, s2, opt, invariant);
  71         }
  72
  73         void AssertCompare (string message, int result, string s1, string s2,
  74                 CompareOptions opt, CompareInfo ci)
  75         {
  76                 int ret = ci.Compare (s1, s2, opt);
  77                 if (result == 0)
  78                         AssertEquals (message, 0, ret);
  79                 else if (result < 0)
  80                         Assert.IsTrue (message + String.Format ("(neg: {0})", ret), ret < 0);
  81                 else
  82                         Assert.IsTrue (message + String.Format ("(pos: {0})", ret), ret > 0);
  83         }
  84
  85         void AssertCompare (string message, int result,
  86                 string s1, int idx1, int len1, string s2, int idx2, int len2)
  87         {
  88                 int ret = invariant.Compare (s1, idx1, len1, s2, idx2, len2);
  89                 if (result == 0)
  90                         AssertEquals (message, 0, ret);
  91                 else if (result < 0)
  92                         Assert.IsTrue (message, ret < 0);
  93                 else
  94                         Assert.IsTrue (message, ret > 0);
  95         }
  96
  97         void AssertCompare (string message, int result,
  98                 string s1, int idx1, int len1, string s2, int idx2, int len2,
  99                 CompareOptions opt, CompareInfo ci)
 100         {
 101                 int ret = ci.Compare (s1, idx1, len1, s2, idx2, len2, opt);
 102                 if (result == 0)
 103                         AssertEquals (message, 0, ret);
 104                 else if (result < 0)
 105                         Assert.IsTrue (message, ret < 0);
 106                 else
 107                         Assert.IsTrue (message, ret > 0);
 108         }
 109
 110         void AssertIndexOf (string message, int expected,
 111                 string source, char target)
 112         {
 113                 AssertEquals (message, expected,
 114                         invariant.IndexOf (source, target));
 115         }
 116
 117         void AssertIndexOf (string message, int expected, string source,
 118                 char target, CompareOptions opt)
 119         {
 120                 AssertEquals (message, expected,
 121                         invariant.IndexOf (source, target, opt));
 122         }
 123
 124         void AssertIndexOf (string message, int expected, string source,
 125                 char target, int idx, int len, CompareOptions opt, CompareInfo ci)
 126         {
 127                 AssertEquals (message, expected,
 128                         ci.IndexOf (source, target, idx, len, opt));
 129         }
 130
 131         void AssertIndexOf (string message, int expected,
 132                 string source, string target)
 133         {
 134                 AssertEquals (message, expected,
 135                         invariant.IndexOf (source, target));
 136         }
 137
 138         void AssertIndexOf (string message, int expected, string source,
 139                 string target, CompareOptions opt)
 140         {
 141                 AssertEquals (message, expected,
 142                         invariant.IndexOf (source, target, opt));
 143         }
 144
 145         void AssertIndexOf (string message, int expected, string source,
 146                 string target, int idx, int len, CompareOptions opt, CompareInfo ci)
 147         {
 148                 AssertEquals (message, expected,
 149                         ci.IndexOf (source, target, idx, len, opt));
 150         }
 151
 152         void AssertLastIndexOf (string message, int expected,
 153                 string source, char target)
 154         {
 155                 AssertEquals (message, expected,
 156                         invariant.LastIndexOf (source, target));
 157         }
 158
 159         void AssertLastIndexOf (string message, int expected, string source,
 160                 char target, CompareOptions opt)
 161         {
 162                 AssertEquals (message, expected,
 163                         invariant.LastIndexOf (source, target, opt));
 164         }
 165
 166         void AssertLastIndexOf (string message, int expected, string source,
 167                 char target, int idx, int len)
 168         {
 169                 AssertEquals (message, expected,
 170                         invariant.LastIndexOf (source, target, idx, len));
 171         }
 172
 173         void AssertLastIndexOf (string message, int expected, string source,
 174                 char target, int idx, int len, CompareOptions opt, CompareInfo ci)
 175         {
 176                 AssertEquals (message, expected,
 177                         ci.LastIndexOf (source, target, idx, len, opt));
 178         }
 179
 180         void AssertLastIndexOf (string message, int expected,
 181                 string source, string target)
 182         {
 183                 AssertEquals (message, expected,
 184                         invariant.LastIndexOf (source, target));
 185         }
 186
 187         void AssertLastIndexOf (string message, int expected, string source,
 188                 string target, CompareOptions opt)
 189         {
 190                 AssertEquals (message, expected,
 191                         invariant.LastIndexOf (source, target, opt));
 192         }
 193
 194         void AssertLastIndexOf (string message, int expected, string source,
 195                 string target, int idx, int len)
 196         {
 197                 AssertEquals (message, expected,
 198                         invariant.LastIndexOf (source, target, idx, len));
 199         }
 200
 201         void AssertLastIndexOf (string message, int expected, string source,
 202                 string target, int idx, int len, CompareOptions opt, CompareInfo ci)
 203         {
 204                 AssertEquals (message, expected,
 205                         ci.LastIndexOf (source, target, idx, len, opt));
 206         }
 207
 208         void AssertIsPrefix (string message, bool expected, string source,
 209                 string target)
 210         {
 211                 Assert.IsTrue (message, expected == invariant.IsPrefix (
 212                         source, target));
 213         }
 214
 215         void AssertIsPrefix (string message, bool expected, string source,
 216                 string target, CompareOptions opt)
 217         {
 218                 Assert.IsTrue (message, expected == invariant.IsPrefix (
 219                         source, target, opt));
 220         }
 221
 222         void AssertIsSuffix (string message, bool expected, string source,
 223                 string target)
 224         {
 225                 Assert.IsTrue (message, expected == invariant.IsSuffix (
 226                         source, target));
 227         }
 228
 229         void AssertIsSuffix (string message, bool expected, string source,
 230                 string target, CompareOptions opt)
 231         {
 232                 Assert.IsTrue (message, expected == invariant.IsSuffix (
 233                         source, target, opt));
 234         }
 235
 236         [Test]
 237 #if NET_2_0
 238         [Category ("NotDotNet")]
 239 #endif
 240         public void CultureSensitiveCompare ()
 241         {
 242                 if (!doTest)
 243                         return;
 244
 245                 AssertCompare ("#1", -1, "1", "2");
 246                 AssertCompare ("#2", 1, "A", "a");
 247                 AssertCompare ("#3", 0, "A", "a", CompareOptions.IgnoreCase);
 248                 AssertCompare ("#6", 1, "12", "1");
 249 // BUG in .NET 2.0: See GetSortKey() test that assures sortkeys for "AE" and
 250 // "\u00C6" are equivalent.
 251                 AssertCompare ("#7", 0, "AE", "\u00C6");
 252                 AssertCompare ("#8", 0, "AB\u01c0C", "A\u01c0B\u01c0C", CompareOptions.IgnoreSymbols);
 253 // BUG in .NET 2.0: ditto.
 254                 AssertCompare ("#9", 0, "A\u0304", "\u0100");
 255                 AssertCompare ("#10", 1, "ABCABC", 5, 1, "1", 0, 1, CompareOptions.IgnoreCase, invariant);
 256                 AssertCompare ("#11", 0, "-d:NET_2_0", 0, 1, "-", 0, 1);
 257
 258 // BUG in .NET 2.0: ditto.
 259                 AssertCompare ("#12", 0, "ae", "\u00E6");
 260                 AssertCompare ("#13", 0, "\u00E6", "ae");
 261                 AssertCompare ("#14", 0, "\u00E6s", 0, 1, "ae", 0, 2);
 262
 263                 // target is "empty" (in culture-sensitive context).
 264 // BUG in .NET 2.0: \u3007 is totally-ignored character as a GetSortKey()
 265 // result, while it is not in Compare().
 266                 AssertCompare ("#17", 0, String.Empty, "\u3007");
 267                 AssertCompare ("#18", 1, "A", "\u3007");
 268                 AssertCompare ("#19", 1, "ABC", "\u3007");
 269
 270                 // shift weight comparison
 271                 AssertCompare ("#20", 1, "--start", "--");
 272                 // expansion
 273 // BUG in .NET 2.0: the same 00C6/00E6 issue.
 274                 AssertCompare ("#21", -1, "\u00E6", "aes");
 275
 276 // bug #78748
 277                 AssertCompare ("#22", -1, "++)", "+-+)");
 278                 AssertCompare ("#23", -1, "+-+)", "+-+-)");
 279                 AssertCompare ("#24", 1, "+-+-)", "++)");
 280                 // BUG in .NET: it returns 1
 281                 AssertCompare ("#25", -1, "+-+-)", "-+-+)");
 282                 AssertCompare ("#26", -1, "+-+)", "-+-+)");
 283                 AssertCompare ("#27", -1, "++)", "-+-+)");
 284         }
 285
 286         [Test]
 287 #if NET_2_0
 288         [Category ("NotDotNet")]
 289 #endif
 290         public void CompareSpecialWeight ()
 291         {
 292                 if (!doTest)
 293                         return;
 294
 295                 // Japanese (in invariant)
 296 // BUG in .NET 2.0 : half-width kana should be bigger.
 297                 AssertCompare ("#1", 1, "\u30D1\u30FC\u30B9", "\uFF8A\uFF9F\uFF70\uFF7D");
 298                 AssertCompare ("#4", 1, "\u3042\u309D", "\u3042\u3042");
 299                 AssertCompare ("#5", 0, "\u3042\u309D", "\u3042\u3042", CompareOptions.IgnoreNonSpace);
 300
 301                 // extender in target
 302 // BUG in .NET 2.0 : an extender should result in bigger sortkey
 303                 AssertCompare ("#7", -1, "\u30D1\u30A2", "\u30D1\u30FC");
 304                 AssertCompare ("#8", 0, "\u30D1\u30A2", "\u30D1\u30FC", CompareOptions.IgnoreNonSpace);
 305                 // extender in source
 306 // BUG in .NET 2.0 : vice versa
 307                 AssertCompare ("#9", 1, "\u30D1\u30FC", "\u30D1\u30A2");
 308                 AssertCompare ("#10", 0, "\u30D1\u30FC", "\u30D1\u30A2", CompareOptions.IgnoreNonSpace);
 309         }
 310
 311         [Test]
 312         public void IndexOfChar ()
 313         {
 314                 if (!doTest)
 315                         return;
 316
 317                 AssertIndexOf ("#1", -1, "ABC", '1');
 318                 AssertIndexOf ("#2", 2, "ABCABC", 'c', CompareOptions.IgnoreCase);
 319                 AssertIndexOf ("#4", 4, "ABCDE", '\u0117', ignoreCN);
 320                 AssertIndexOf ("#5", 1, "ABCABC", 'B', 1, 5, CompareOptions.IgnoreCase, invariant);
 321                 AssertIndexOf ("#6", 4, "ABCABC", 'B', 2, 4, CompareOptions.IgnoreCase, invariant);
 322         }
 323
 324         [Test]
 325         [Category ("NotDotNet")]
 326         public void IndexOfCharMSBug ()
 327         {
 328                 if (!doTest)
 329                         return;
 330
 331                 AssertIndexOf ("#1", 0, "\u00E6", 'a');
 332         }
 333
 334         [Test]
 335         public void LastIndexOfChar ()
 336         {
 337                 if (!doTest)
 338                         return;
 339
 340                 AssertLastIndexOf ("#1", -1, "ABC", '1');
 341                 AssertLastIndexOf ("#2", 5, "ABCABC", 'c', CompareOptions.IgnoreCase);
 342                 AssertLastIndexOf ("#4", 4, "ABCDE", '\u0117', ignoreCN);
 343                 AssertLastIndexOf ("#5", 1, "ABCABC", 'B', 3, 3);
 344                 AssertLastIndexOf ("#6", 4, "ABCABC", 'B', 4, 4);
 345                 AssertLastIndexOf ("#7", -1, "ABCABC", 'B', 5, 1);
 346                 AssertLastIndexOf ("#11", 0, "\\", '\\');
 347                 Assert.AreEqual (0, new CultureInfo ("en").CompareInfo.LastIndexOf ("\\", '\\'), "#11en");
 348                 Assert.AreEqual (0, new CultureInfo ("ja").CompareInfo.LastIndexOf ("\\", '\\'), "#11ja");
 349                 AssertLastIndexOf ("#12", 8, "/system/web", 'w');
 350                 Assert.AreEqual (8, new CultureInfo ("sv").CompareInfo.LastIndexOf ("/system/web", 'w'), "#12sv");
 351         }
 352
 353         [Test]
 354         [Category ("NotDotNet")]
 355         public void LastIndexOfCharMSBug ()
 356         {
 357                 if (!doTest)
 358                         return;
 359
 360                 AssertIndexOf ("#1", 0, "\u00E6", 'a');
 361         }
 362
 363         [Test]
 364 #if NET_2_0
 365         [Category ("NotDotNet")]
 366 #endif
 367         public void IsPrefix ()
 368         {
 369                 if (!doTest)
 370                         return;
 371
 372                 AssertIsPrefix ("#1", false, "ABC", "c", CompareOptions.IgnoreCase);
 373                 AssertIsPrefix ("#2", false, "BC", "c", CompareOptions.IgnoreCase);
 374                 AssertIsPrefix ("#3", true, "C", "c", CompareOptions.IgnoreCase);
 375                 AssertIsPrefix ("#4", true, "EDCBA", "\u0117", ignoreCN);
 376                 AssertIsPrefix ("#5", true, "ABC", "AB", CompareOptions.IgnoreCase);
 377 // BUG in .NET 2.0 : see GetSortKey() test (mentioned above).
 378                 AssertIsPrefix ("#6", true, "ae", "\u00E6", CompareOptions.None);
 379                 AssertIsPrefix ("#7", true, "\u00E6", "ae", CompareOptions.None);
 380
 381 // BUG in .NET 2.0 : see GetSortKey() test (mentioned above).
 382                 AssertIsPrefix ("#8", true, "\u00E6", "a", CompareOptions.None);
 383                 AssertIsPrefix ("#9", true, "\u00E6s", "ae", CompareOptions.None);
 384                 AssertIsPrefix ("#10", false, "\u00E6", "aes", CompareOptions.None);
 385                 AssertIsPrefix ("#11", true, "--start", "--", CompareOptions.None);
 386                 AssertIsPrefix ("#12", true, "-d:NET_1_1", "-", CompareOptions.None);
 387                 AssertIsPrefix ("#13", false, "-d:NET_1_1", "@", CompareOptions.None);
 388                 // U+3007 is completely ignored character.
 389                 AssertIsPrefix ("#14", true, "\uff21\uff21", "\uff21", CompareOptions.None);
 390 // BUG in .NET 2.0 : see \u3007 issue (mentioned above).
 391                 AssertIsPrefix ("#15", true, "\uff21\uff21", "\u3007\uff21", CompareOptions.None);
 392                 AssertIsPrefix ("#16", true, "\uff21\uff21", "\uff21\u3007", CompareOptions.None);
 393                 AssertIsPrefix ("#17", true, "\\b\\a a", "\\b\\a a");
 394                 Assert.IsTrue (new CultureInfo ("en").CompareInfo.IsPrefix ("\\b\\a a", "\\b\\a a"), "#17en");
 395                 Assert.IsTrue (new CultureInfo ("ja").CompareInfo.IsPrefix ("\\b\\a a", "\\b\\a a"), "#17ja");
 396         }
 397
 398         [Test]
 399         public void IsPrefixSpecialWeight ()
 400         {
 401                 if (!doTest)
 402                         return;
 403
 404                 // Japanese (in invariant)
 405                 AssertIsPrefix ("#1", false, "\u30D1\u30FC\u30B9", "\uFF8A\uFF9F\uFF70\uFF7D");
 406                 AssertIsPrefix ("#2-2", false, "\u30D1\u30FC\u30B9", "\uFF8A\uFF9F\uFF70\uFF7D");
 407                 AssertIsPrefix ("#3-2", false, "\uFF80\uFF9E\uFF72\uFF8C\uFF9E",
 408                         "\u30C0\u30A4\u30D6");
 409                 AssertIsPrefix ("#4", false, "\u3042\u309D", "\u3042\u3042");
 410
 411                 // extender in target
 412                 AssertIsPrefix ("#7", false, "\u30D1\u30A2", "\u30D1\u30FC");
 413                 // extender in source
 414                 AssertIsPrefix ("#9", false, "\u30D1\u30FC", "\u30D1\u30A2");
 415
 416                 // empty suffix always matches the source.
 417                 AssertIsPrefix ("#11", true, "", "");
 418                 AssertIsPrefix ("#12", true, "/test.css", "");
 419
 420                 // bug #76243
 421                 AssertIsPrefix ("#13", false, "\u00e4_", "a");
 422         }
 423
 424         [Test]
 425 #if NET_2_0
 426         [Category ("NotDotNet")]
 427 #endif
 428         public void IsSuffix ()
 429         {
 430                 if (!doTest)
 431                         return;
 432
 433                 AssertIsSuffix ("#1", true, "ABC", "c", CompareOptions.IgnoreCase);
 434                 AssertIsSuffix ("#2", true, "BC", "c", CompareOptions.IgnoreCase);
 435                 AssertIsSuffix ("#3", false, "CBA", "c", CompareOptions.IgnoreCase);
 436                 AssertIsSuffix ("#4", true, "ABCDE", "\u0117", CompareOptions.IgnoreNonSpace | CompareOptions.IgnoreCase);
 437                 AssertIsSuffix ("#5", false, "\u00E6", "a", CompareOptions.None);
 438 // BUG in .NET 2.0 : see GetSortKey() test (mentioned above).
 439                 AssertIsSuffix ("#6", true, "\u00E6", "ae", CompareOptions.None);
 440                 AssertIsSuffix ("#7", true, "ae", "\u00E6", CompareOptions.None);
 441                 AssertIsSuffix ("#8", false, "e", "\u00E6", CompareOptions.None);
 442                 // U+3007 is completely ignored character.
 443                 AssertIsSuffix ("#9", true, "\uff21\uff21", "\uff21", CompareOptions.None);
 444 // BUG in .NET 2.0 : see \u3007 issue (mentioned above).
 445                 AssertIsSuffix ("#10", true, "\uff21\uff21", "\u3007\uff21", CompareOptions.None);
 446                 AssertIsSuffix ("#11", true, "\uff21\uff21", "\uff21\u3007", CompareOptions.None);
 447                 // extender in target
 448                 AssertIsSuffix ("#12", false, "\u30D1\u30A2", "\u30D1\u30FC");
 449                 AssertIsSuffix ("#13", true, "\u30D1\u30A2", "\u30D1\u30FC", CompareOptions.IgnoreNonSpace);
 450                 // extender in source
 451                 AssertIsSuffix ("#14", false, "\u30D1\u30FC", "\u30D1\u30A2");
 452                 AssertIsSuffix ("#15", true, "\u30D1\u30FC", "\u30D1\u30A2", CompareOptions.IgnoreNonSpace);
 453                 // optimization sanity check
 454                 AssertIsSuffix ("#16", true,
 455                         "/configuration/system.runtime.remoting",
 456                         "system.runtime.remoting");
 457
 458                 // empty suffix always matches the source.
 459                 AssertIsSuffix ("#17", true, "", "");
 460                 AssertIsSuffix ("#18", true, "/test.css", "");
 461                 AssertIsSuffix ("#19", true, "/test.css", "/test.css");
 462                 AssertIsSuffix ("#20", true, "\\b\\a a", "\\b\\a a");
 463                 Assert.IsTrue (new CultureInfo ("en").CompareInfo.IsSuffix ("\\b\\a a", "\\b\\a a"), "#20en");
 464                 Assert.IsTrue (new CultureInfo ("ja").CompareInfo.IsSuffix ("\\b\\a a", "\\b\\a a"), "#20ja");
 465         }
 466
 467         [Test]
 468         [Category ("NotDotNet")]
 469         [Category ("NotWorking")]
 470         public void IsSuffixMSBug ()
 471         {
 472                 if (!doTest)
 473                         return;
 474
 475                 AssertIsSuffix ("#1", true, "\u00E6", "e", CompareOptions.None);
 476         }
 477
 478         [Test]
 479 #if NET_2_0
 480         [Category ("NotDotNet")]
 481 #endif
 482         public void IndexOfString ()
 483         {
 484                 if (!doTest)
 485                         return;
 486
 487                 AssertIndexOf ("#1", -1, "ABC", "1", CompareOptions.None);
 488                 AssertIndexOf ("#2", 2, "ABCABC", "c", CompareOptions.IgnoreCase);
 489                 AssertIndexOf ("#4", 4, "ABCDE", "\u0117", CompareOptions.IgnoreNonSpace | CompareOptions.IgnoreCase);
 490                 AssertIndexOf ("#5", 1, "ABCABC", "BC", CompareOptions.IgnoreCase);
 491                 AssertIndexOf ("#6", 1, "BBCBBC", "BC", CompareOptions.IgnoreCase);
 492                 AssertIndexOf ("#7", -1, "ABCDEF", "BCD", 0, 3, CompareOptions.IgnoreCase, invariant);
 493                 AssertIndexOf ("#8", 0, "-ABC", "-", CompareOptions.None);
 494                 AssertIndexOf ("#9", 0, "--ABC", "--", CompareOptions.None);
 495                 AssertIndexOf ("#10", -1, "--ABC", "--", 1, 2, CompareOptions.None, invariant);
 496 // BUG in .NET 2.0 : see GetSortKey() test (mentioned above).
 497                 AssertIndexOf ("#11", 0, "AE", "\u00C6", CompareOptions.None);
 498                 // U+3007 is completely ignored character.
 499                 AssertIndexOf ("#12", 0, "\uff21\uff21", "\uff21", CompareOptions.None);
 500 // BUG in .NET 2.0 : see \u3007 issue (mentioned above).
 501                 AssertIndexOf ("#13", 0, "\uff21\uff21", "\u3007\uff21", CompareOptions.None);
 502                 AssertIndexOf ("#14", 0, "\uff21\uff21", "\uff21\u3007", CompareOptions.None);
 503                 AssertIndexOf ("#15", 0, "\uff21\uff21", "\u3007", CompareOptions.None);
 504                 AssertIndexOf ("#15-2", 1, "\u3007\uff21", "\uff21", CompareOptions.None);
 505                 // target is "empty" (in culture-sensitive context).
 506                 AssertIndexOf ("#16", -1, String.Empty, "\u3007");
 507 // BUG in .NET 2.0 : see \u3007 issue (mentioned above).
 508                 AssertIndexOf ("#17", 0, "A", "\u3007");
 509                 AssertIndexOf ("#18", 0, "ABC", "\u3007");
 510
 511                 AssertIndexOf ("#19", 0, "\\b\\a a", "\\b\\a a");
 512                 Assert.AreEqual (0, new CultureInfo ("en").CompareInfo.IndexOf ("\\b\\a a", "\\b\\a a"), "#19en");
 513                 Assert.AreEqual (0, new CultureInfo ("ja").CompareInfo.IndexOf ("\\b\\a a", "\\b\\a a"), "#19ja");
 514         }
 515
 516         [Test]
 517         public void IndexOfSpecialWeight ()
 518         {
 519                 if (!doTest)
 520                         return;
 521
 522                 // Japanese (in invariant)
 523                 AssertIndexOf ("#1", -1, "\u30D1\u30FC\u30B9", "\uFF8A\uFF9F\uFF70\uFF7D");
 524                 // extender in target
 525                 AssertIndexOf ("#1-2", -1, "\u30D1\u30A2", "\u30D1\u30FC");
 526                 // extender in source
 527                 AssertIndexOf ("#2-2", -1, "\u30D1\u30FC\u30B9", "\uFF8A\uFF9F\uFF70\uFF7D");
 528                 AssertIndexOf ("#4", -1, "\u3042\u309D", "\u3042\u3042");
 529         }
 530
 531         [Test]
 532 #if NET_2_0
 533         [Category ("NotDotNet")]
 534 #endif
 535         public void LastIndexOfString ()
 536         {
 537                 if (!doTest)
 538                         return;
 539
 540                 AssertLastIndexOf ("#1", -1, "ABC", "1", CompareOptions.None);
 541                 AssertLastIndexOf ("#2", 5, "ABCABC", "c", CompareOptions.IgnoreCase);
 542                 AssertLastIndexOf ("#4", 4, "ABCDE", "\u0117", CompareOptions.IgnoreNonSpace | CompareOptions.IgnoreCase);
 543                 AssertLastIndexOf ("#5", 4, "ABCABC", "BC", CompareOptions.IgnoreCase);
 544                 AssertLastIndexOf ("#6", 4, "BBCBBC", "BC", CompareOptions.IgnoreCase);
 545                 AssertLastIndexOf ("#7", 1, "original", "rig", CompareOptions.None);
 546 // BUG in .NET 2.0 : see GetSortKey() test (mentioned above).
 547                 AssertLastIndexOf ("#8", 0, "\u00E6", "ae", CompareOptions.None);
 548                 AssertLastIndexOf ("#9", 0, "-ABC", "-", CompareOptions.None);
 549                 AssertLastIndexOf ("#10", 0, "--ABC", "--", CompareOptions.None);
 550                 AssertLastIndexOf ("#11", -1, "--ABC", "--", 2, 2, CompareOptions.None, invariant);
 551                 AssertLastIndexOf ("#12", -1, "--ABC", "--", 4, 2, CompareOptions.None, invariant);
 552 // BUG in .NET 2.0 : see GetSortKey() test (mentioned above).
 553                 AssertLastIndexOf ("#13", 0, "AE", "\u00C6", CompareOptions.None);
 554                 // U+3007 is completely ignored character.
 555                 AssertLastIndexOf ("#14", 1, "\uff21\uff21", "\uff21", CompareOptions.None);
 556 // BUG in .NET 2.0 : see \u3007 issue (mentioned above).
 557                 AssertLastIndexOf ("#15", 1, "\uff21\uff21", "\u3007\uff21", CompareOptions.None);
 558                 AssertLastIndexOf ("#16", 1, "\uff21\uff21", "\uff21\u3007", CompareOptions.None);
 559                 AssertLastIndexOf ("#17", 1, "\uff21\uff21", "\u3007", CompareOptions.None);
 560                 AssertLastIndexOf ("#18", 1, "\u3007\uff21", "\uff21", CompareOptions.None);
 561                 AssertLastIndexOf ("#19", 0, "\\b\\a a", "\\b\\a a");
 562                 Assert.AreEqual (0, new CultureInfo ("en").CompareInfo.LastIndexOf ("\\b\\a a", "\\b\\a a"), "#19en");
 563                 Assert.AreEqual (0, new CultureInfo ("ja").CompareInfo.LastIndexOf ("\\b\\a a", "\\b\\a a"), "#19ja");
 564                 // bug #80612
 565                 AssertLastIndexOf ("#20", 8, "/system/web", "w");
 566                 Assert.AreEqual (8, new CultureInfo ("sv").CompareInfo.LastIndexOf ("/system/web", "w"), "#20sv");
 567         }
 568
 569         [Test]
 570         public void LastIndexOfSpecialWeight ()
 571         {
 572                 if (!doTest)
 573                         return;
 574
 575                 // Japanese (in invariant)
 576                 AssertLastIndexOf ("#1", -1, "\u30D1\u30FC\u30B9", "\uFF8A\uFF9F\uFF70\uFF7D");
 577                 // extender in target
 578                 AssertLastIndexOf ("#1-2", -1, "\u30D1\u30A2", "\u30D1\u30FC");
 579                 // extender in source
 580                 AssertLastIndexOf ("#4", -1, "\u3042\u309D", "\u3042\u3042");
 581         }
 582
 583         [Test]
 584         public void LastIndexOfOrdinalString ()
 585         {
 586                 if (!doTest)
 587                         return;
 588
 589                 AssertLastIndexOf ("#1", -1, "ABC", "1", CompareOptions.Ordinal);
 590                 AssertLastIndexOf ("#2", 5, "ABCABC", "C", CompareOptions.Ordinal);
 591                 AssertLastIndexOf ("#3", -1, "ABCABC", "\uFF22", CompareOptions.Ordinal);
 592                 AssertLastIndexOf ("#4", 4, "ABCABC", "BC", CompareOptions.Ordinal);
 593                 AssertLastIndexOf ("#5", 4, "BBCBBC", "BC", CompareOptions.Ordinal);
 594                 AssertLastIndexOf ("#6", 1, "original", "rig", CompareOptions.Ordinal);
 595                 AssertLastIndexOf ("#7", 0, "\\b\\a a", "\\b\\a a", CompareOptions.Ordinal);
 596         }
 597
 598         [Test]
 599         [Category ("TargetJvmNotWorking")]
 600         // for bug #76702
 601         public void NullCharacter ()
 602         {
 603                 Assert.AreEqual (-1, "MONO".IndexOf ("\0\0\0"), "#1");
 604                 Assert.AreEqual (-1, "MONO".LastIndexOf ("\0\0\0"), "#2");
 605                 Assert.AreEqual (1, "MONO".CompareTo ("\0\0\0"), "#3");
 606         }
 607
 608         [Test]
 609         [Category ("NotDotNet")]
 610         // MS.NET treats it as equivalent, while in IndexOf() it does not match.
 611         public void NullCharacterWeird ()
 612         {
 613                 Assert.AreEqual (-1, "MONO".CompareTo ("MONO\0\0\0"), "#4");
 614         }
 615
 616 #if NET_2_0
 617         [Test]
 618         [Category ("NotDotNet")]
 619         public void OrdinalIgnoreCaseCompare ()
 620         {
 621                 if (!doTest)
 622                         return;
 623
 624                 // matches
 625 // BUG in .NET 2.0 : see GetSortKey() test (mentioned above).
 626                 AssertCompare ("#1", 0, "AE", "\u00C6", CompareOptions.None);
 627 // BUG in .NET 2.0 : It raises inappropriate ArgumentException.
 628                 // should not match since it is Ordinal
 629                 AssertCompare ("#2", -133, "AE", "\u00C6", CompareOptions.OrdinalIgnoreCase);
 630
 631                 AssertCompare ("#3", 1, "AE", "\u00E6", CompareOptions.None);
 632                 // matches
 633                 AssertCompare ("#4", 0, "AE", "\u00E6", CompareOptions.IgnoreCase);
 634                 // should not match since it is Ordinal
 635                 AssertCompare ("#5", -133, "AE", "\u00E6", CompareOptions.OrdinalIgnoreCase);
 636
 637                 AssertCompare ("#6", 0, "AE", "ae", CompareOptions.OrdinalIgnoreCase);
 638                 AssertCompare ("#7", 0, "aE", "ae", CompareOptions.OrdinalIgnoreCase);
 639                 AssertCompare ("#8", 0, "aE", "ae", CompareOptions.OrdinalIgnoreCase);
 640                 AssertCompare ("#9", 0, "ae", "ae", CompareOptions.OrdinalIgnoreCase);
 641                 AssertCompare ("#10", 0, "AE", "AE", CompareOptions.OrdinalIgnoreCase);
 642                 AssertCompare ("#11", 0, "aE", "AE", CompareOptions.OrdinalIgnoreCase);
 643                 AssertCompare ("#12", 0, "aE", "AE", CompareOptions.OrdinalIgnoreCase);
 644                 AssertCompare ("#13", 0, "ae", "AE", CompareOptions.OrdinalIgnoreCase);
 645                 AssertCompare ("#14", 0, "ola", "OLA", CompareOptions.OrdinalIgnoreCase);
 646         }
 647
 648         [Test]
 649         public void OrdinalIgnoreCaseIndexOf ()
 650         {
 651                 AssertIndexOf ("#1-1", 0, "ABC", "abc", CompareOptions.OrdinalIgnoreCase);
 652                 AssertIndexOf ("#1-2", -1, "AEBECE", "\u00E6", CompareOptions.OrdinalIgnoreCase);
 653                 AssertIndexOf ("#1-3", -1, "@_@", "`_`", CompareOptions.OrdinalIgnoreCase);
 654         }
 655
 656         [Test]
 657         public void OrdinalIgnoreCaseIndexOfChar ()
 658         {
 659                 AssertIndexOf ("#2-1", 0, "ABC", 'a', CompareOptions.OrdinalIgnoreCase);
 660                 AssertIndexOf ("#2-2", -1, "AEBECE", '\u00C0', CompareOptions.OrdinalIgnoreCase);
 661                 AssertIndexOf ("#2-3", -1, "@_@", '`', CompareOptions.OrdinalIgnoreCase);
 662         }
 663
 664         [Test]
 665         public void OrdinalIgnoreCaseLastIndexOf ()
 666         {
 667                 AssertLastIndexOf ("#1-1", 0, "ABC", "abc", CompareOptions.OrdinalIgnoreCase);
 668                 AssertLastIndexOf ("#1-2", -1, "AEBECE", "\u00E6", CompareOptions.OrdinalIgnoreCase);
 669                 AssertLastIndexOf ("#1-3", -1, "@_@", "`_`", CompareOptions.OrdinalIgnoreCase);
 670                 AssertLastIndexOf ("#1-4", 1, "ABCDE", "bc", CompareOptions.OrdinalIgnoreCase);
 671                 AssertLastIndexOf ("#1-5", -1, "BBBBB", "ab", CompareOptions.OrdinalIgnoreCase);
 672         }
 673
 674         [Test]
 675         public void OrdinalIgnoreCaseLastIndexOfChar ()
 676         {
 677                 AssertLastIndexOf ("#2-1", 0, "ABC", 'a', CompareOptions.OrdinalIgnoreCase);
 678                 AssertLastIndexOf ("#2-2", -1, "AEBECE", '\u00C0', CompareOptions.OrdinalIgnoreCase);
 679                 AssertLastIndexOf ("#2-3", -1, "@_@", '`', CompareOptions.OrdinalIgnoreCase);
 680         }
 681
 682         [Test] // bug #80865
 683         public void IsPrefixOrdinalIgnoreCase ()
 684         {
 685                 Assert ("aaaa".StartsWith ("A", StringComparison.OrdinalIgnoreCase));
 686         }
 687 #endif
 688 }
 689
 690 }