lib/Unicode/Collate/t/test.t

   1 # Before `make install' is performed this script should be runnable with
   2 # `make test'. After `make install' it should work as `perl test.pl'
   3
   4 #########################
   5
   6 BEGIN {
   7     if (ord("A") == 193) {
   8         print "1..0 # Unicode::Collate not ported to EBCDIC\n";
   9         exit 0;
  10     }
  11 }
  12
  13 use Test;
  14 BEGIN { plan tests => 160 };
  15 use Unicode::Collate;
  16 ok(1); # If we made it this far, we're ok.
  17
  18 #########################
  19
  20 my $UCA_Version = "8.0";
  21
  22 ok(Unicode::Collate::UCA_Version, $UCA_Version);
  23 ok(Unicode::Collate->UCA_Version, $UCA_Version);
  24
  25 my $Collator = Unicode::Collate->new(
  26   table => 'keys.txt',
  27   normalization => undef,
  28 );
  29
  30 ok(ref $Collator, "Unicode::Collate");
  31
  32 ok($Collator->UCA_Version,   $UCA_Version);
  33 ok($Collator->UCA_Version(), $UCA_Version);
  34
  35 ok(
  36   join(':', $Collator->sort(
  37     qw/ lib strict Carp ExtUtils CGI Time warnings Math overload Pod CPAN /
  38   ) ),
  39   join(':',
  40     qw/ Carp CGI CPAN ExtUtils lib Math overload Pod strict Time warnings /
  41   ),
  42 );
  43
  44 my $A_acute = pack('U', 0x00C1);
  45 my $acute   = pack('U', 0x0301);
  46
  47 ok($Collator->cmp("A$acute", $A_acute), -1);
  48 ok($Collator->cmp("", ""), 0);
  49 ok(! $Collator->ne("", "") );
  50 ok(  $Collator->eq("", "") );
  51 ok($Collator->cmp("", "perl"), -1);
  52
  53 ##############
  54
  55 eval { require Unicode::Normalize };
  56
  57 if (!$@) {
  58   my $NFD = Unicode::Collate->new(
  59     table => 'keys.txt',
  60     entry => <<'ENTRIES',
  61 0430 ; [.0B01.0020.0002.0430] # CYRILLIC SMALL LETTER A
  62 0410 ; [.0B01.0020.0008.0410] # CYRILLIC CAPITAL LETTER A
  63 04D3 ; [.0B09.0020.0002.04D3] # CYRILLIC SMALL LETTER A WITH DIAERESIS
  64 0430 0308 ; [.0B09.0020.0002.04D3] # CYRILLIC SMALL LETTER A WITH DIAERESIS
  65 04D3 ; [.0B09.0020.0002.04D3] # CYRILLIC SMALL LETTER A WITH DIAERESIS
  66 0430 0308 ; [.0B09.0020.0002.04D3] # CYRILLIC SMALL LETTER A WITH DIAERESIS
  67 04D2 ; [.0B09.0020.0008.04D2] # CYRILLIC CAPITAL LETTER A WITH DIAERESIS
  68 0410 0308 ; [.0B09.0020.0008.04D2] # CYRILLIC CAPITAL LETTER A WITH DIAERESIS
  69 0430 3099 ; [.0B10.0020.0002.04D3] # A WITH KATAKANA VOICED
  70 0430 3099 0308 ; [.0B11.0020.0002.04D3] # A WITH KATAKANA VOICED, DIAERESIS
  71 ENTRIES
  72   );
  73   ok($NFD->eq("A$acute", $A_acute));
  74   ok($NFD->eq("\x{4D3}\x{325}", "\x{430}\x{308}\x{325}"));
  75   ok($NFD->lt("\x{430}\x{308}A", "\x{430}\x{308}B"));
  76   ok($NFD->lt("\x{430}\x{3099}B", "\x{430}\x{308}\x{3099}A"));
  77   ok($NFD->eq("\x{0430}\x{3099}\x{309A}\x{0308}",
  78               "\x{0430}\x{309A}\x{3099}\x{0308}") );
  79 }
  80 else {
  81   ok(1);
  82   ok(1);
  83   ok(1);
  84   ok(1);
  85   ok(1);
  86 }
  87
  88 ##############
  89
  90 my $trad = Unicode::Collate->new(
  91   table => 'keys.txt',
  92   normalization => undef,
  93   ignoreName => qr/HANGUL|HIRAGANA|KATAKANA|BOPOMOFO/,
  94   level => 4,
  95   entry => << 'ENTRIES',
  96  0063 0068 ; [.0893.0020.0002.0063] % "ch" in traditional Spanish
  97  0043 0068 ; [.0893.0020.0008.0043] # "Ch" in traditional Spanish
  98  00DF ; [.09F3.0154.0004.00DF] [.09F3.0020.0004.00DF] # eszet in Germany
  99 ENTRIES
 100 );
 101
 102 ok(
 103   join(':', $trad->sort( qw/ acha aca ada acia acka / ) ),
 104   join(':',              qw/ aca acia acka acha ada / ),
 105 );
 106
 107 ok(
 108   join(':', $Collator->sort( qw/ acha aca ada acia acka / ) ),
 109   join(':',                  qw/ aca acha acia acka ada / ),
 110 );
 111
 112 my $hiragana = "\x{3042}\x{3044}";
 113 my $katakana = "\x{30A2}\x{30A4}";
 114
 115 # HIRAGANA and KATAKANA are ignorable via ignoreName
 116 ok($trad->eq($hiragana, ""));
 117 ok($trad->eq("", $katakana));
 118 ok($trad->eq($hiragana, $katakana));
 119 ok($trad->eq($katakana, $hiragana));
 120
 121 ##############
 122
 123 my $old_level = $Collator->{level};
 124
 125 $Collator->{level} = 2;
 126
 127 ok( $Collator->cmp("ABC","abc"), 0);
 128 ok( $Collator->eq("ABC","abc") );
 129 ok( $Collator->le("ABC","abc") );
 130 ok( $Collator->cmp($hiragana, $katakana), 0);
 131 ok( $Collator->eq($hiragana, $katakana) );
 132 ok( $Collator->ge($hiragana, $katakana) );
 133
 134 # hangul
 135 ok( $Collator->eq("a\x{AC00}b", "a\x{1100}\x{1161}b") );
 136 ok( $Collator->eq("a\x{AE00}b", "a\x{1100}\x{1173}\x{11AF}b") );
 137 ok( $Collator->gt("a\x{AE00}b", "a\x{1100}\x{1173}b\x{11AF}") );
 138 ok( $Collator->lt("a\x{AC00}b", "a\x{AE00}b") );
 139 ok( $Collator->gt("a\x{D7A3}b", "a\x{C544}b") );
 140 ok( $Collator->lt("a\x{C544}b", "a\x{30A2}b") ); # hangul < hiragana
 141
 142 $Collator->{level} = $old_level;
 143
 144 $Collator->{katakana_before_hiragana} = 1;
 145
 146 ok( $Collator->cmp("abc", "ABC"), -1);
 147 ok( $Collator->ne("abc", "ABC") );
 148 ok( $Collator->lt("abc", "ABC") );
 149 ok( $Collator->le("abc", "ABC") );
 150 ok( $Collator->cmp($hiragana, $katakana), 1);
 151 ok( $Collator->ne($hiragana, $katakana) );
 152 ok( $Collator->gt($hiragana, $katakana) );
 153 ok( $Collator->ge($hiragana, $katakana) );
 154
 155 $Collator->{upper_before_lower} = 1;
 156
 157 ok( $Collator->cmp("abc", "ABC"), 1);
 158 ok( $Collator->ge("abc", "ABC"), 1);
 159 ok( $Collator->gt("abc", "ABC"), 1);
 160 ok( $Collator->cmp($hiragana, $katakana), 1);
 161 ok( $Collator->ge($hiragana, $katakana), 1);
 162 ok( $Collator->gt($hiragana, $katakana), 1);
 163
 164 $Collator->{katakana_before_hiragana} = 0;
 165
 166 ok( $Collator->cmp("abc", "ABC"), 1);
 167 ok( $Collator->cmp($hiragana, $katakana), -1);
 168
 169 $Collator->{upper_before_lower} = 0;
 170
 171 ok( $Collator->cmp("abc", "ABC"), -1);
 172 ok( $Collator->le("abc", "ABC") );
 173 ok( $Collator->cmp($hiragana, $katakana), -1);
 174 ok( $Collator->lt($hiragana, $katakana) );
 175
 176 ##############
 177
 178 my $ignoreAE = Unicode::Collate->new(
 179   table => 'keys.txt',
 180   normalization => undef,
 181   ignoreChar => qr/^[aAeE]$/,
 182 );
 183
 184 ok($ignoreAE->eq("element","lament"));
 185 ok($ignoreAE->eq("Perl","ePrl"));
 186
 187 ##############
 188
 189 my $onlyABC = Unicode::Collate->new(
 190     table => undef,
 191     normalization => undef,
 192     entry => << 'ENTRIES',
 193 0061 ; [.0101.0020.0002.0061] # LATIN SMALL LETTER A
 194 0041 ; [.0101.0020.0008.0041] # LATIN CAPITAL LETTER A
 195 0062 ; [.0102.0020.0002.0062] # LATIN SMALL LETTER B
 196 0042 ; [.0102.0020.0008.0042] # LATIN CAPITAL LETTER B
 197 0063 ; [.0103.0020.0002.0063] # LATIN SMALL LETTER C
 198 0043 ; [.0103.0020.0008.0043] # LATIN CAPITAL LETTER C
 199 ENTRIES
 200 );
 201
 202 ok(
 203   join(':', $onlyABC->sort( qw/ ABA BAC cc A Ab cAc aB / ) ),
 204   join(':',                 qw/ A aB Ab ABA BAC cAc cc / ),
 205 );
 206
 207 ##############
 208
 209 my $undefAE = Unicode::Collate->new(
 210   table => 'keys.txt',
 211   normalization => undef,
 212   undefChar => qr/^[aAeE]$/,
 213 );
 214
 215 ok($undefAE ->gt("edge","fog"));
 216 ok($Collator->lt("edge","fog"));
 217 ok($undefAE ->gt("lake","like"));
 218 ok($Collator->lt("lake","like"));
 219
 220 ##############
 221
 222 $Collator->{level} = 2;
 223
 224 my $str;
 225
 226 my $orig = "This is a Perl book.";
 227 my $sub = "PERL";
 228 my $rep = "camel";
 229 my $ret = "This is a camel book.";
 230
 231 $str = $orig;
 232 if (my($pos,$len) = $Collator->index($str, $sub)) {
 233   substr($str, $pos, $len, $rep);
 234 }
 235
 236 ok($str, $ret);
 237
 238 $Collator->{level} = $old_level;
 239
 240 $str = $orig;
 241 if (my($pos,$len) = $Collator->index($str, $sub)) {
 242   substr($str, $pos, $len, $rep);
 243 }
 244
 245 ok($str, $orig);
 246
 247 ##############
 248
 249 my $match;
 250
 251 $Collator->{level} = 1;
 252
 253 $str = "Pe\x{300}rl";
 254 $sub = "pe";
 255 $match = undef;
 256 if (my($pos, $len) = $Collator->index($str, $sub)) {
 257     $match = substr($str, $pos, $len);
 258 }
 259 ok($match, "Pe\x{300}");
 260
 261 $str = "P\x{300}e\x{300}\x{301}\x{303}rl";
 262 $sub = "pE";
 263 $match = undef;
 264 if (my($pos, $len) = $Collator->index($str, $sub)) {
 265     $match = substr($str, $pos, $len);
 266 }
 267 ok($match, "P\x{300}e\x{300}\x{301}\x{303}");
 268
 269 $Collator->{level} = $old_level;
 270
 271 ##############
 272
 273 $trad->{level} = 1;
 274
 275 $str = "Ich mu\x{00DF} studieren.";
 276 $sub = "m\x{00FC}ss";
 277 $match = undef;
 278 if (my($pos, $len) = $trad->index($str, $sub)) {
 279     $match = substr($str, $pos, $len);
 280 }
 281 ok($match, "mu\x{00DF}");
 282
 283 $trad->{level} = $old_level;
 284
 285 $str = "Ich mu\x{00DF} studieren.";
 286 $sub = "m\x{00FC}ss";
 287 $match = undef;
 288
 289 if (my($pos, $len) = $trad->index($str, $sub)) {
 290     $match = substr($str, $pos, $len);
 291 }
 292 ok($match, undef);
 293
 294 $match = undef;
 295 if (my($pos,$len) = $Collator->index("", "")) {
 296     $match = substr("", $pos, $len);
 297 }
 298 ok($match, "");
 299
 300 $match = undef;
 301 if (my($pos,$len) = $Collator->index("", "abc")) {
 302     $match = substr("", $pos, $len);
 303 }
 304 ok($match, undef);
 305
 306 ##############
 307
 308 # Table is undefined, then no entry is defined.
 309
 310 my $undef_table = Unicode::Collate->new(
 311   table => undef,
 312   normalization => undef,
 313   level => 1,
 314 );
 315
 316 # in the Unicode code point order
 317 ok($undef_table->lt('', 'A'));
 318 ok($undef_table->lt('ABC', 'B'));
 319
 320 # Hangul should be decomposed (even w/o Unicode::Normalize).
 321
 322 ok($undef_table->lt("Perl", "\x{AC00}"));
 323 ok($undef_table->eq("\x{AC00}", "\x{1100}\x{1161}"));
 324 ok($undef_table->eq("\x{AE00}", "\x{1100}\x{1173}\x{11AF}"));
 325 ok($undef_table->lt("\x{AE00}", "\x{3042}"));
 326   # U+AC00: Hangul GA
 327   # U+AE00: Hangul GEUL
 328   # U+3042: Hiragana A
 329
 330 # Weight for CJK Ideographs is defined, though.
 331
 332 ok($undef_table->lt("", "\x{4E00}"));
 333 ok($undef_table->lt("\x{4E8C}","ABC"));
 334 ok($undef_table->lt("\x{4E00}","\x{3042}"));
 335 ok($undef_table->lt("\x{4E00}","\x{4E8C}"));
 336   # U+4E00: Ideograph "ONE"
 337   # U+4E8C: Ideograph "TWO"
 338
 339
 340 ##############
 341
 342 my $few_entries = Unicode::Collate->new(
 343   entry => <<'ENTRIES',
 344 0050 ; [.0101.0020.0002.0050]  # P
 345 0045 ; [.0102.0020.0002.0045]  # E
 346 0052 ; [.0103.0020.0002.0052]  # R
 347 004C ; [.0104.0020.0002.004C]  # L
 348 1100 ; [.0105.0020.0002.1100]  # Hangul Jamo initial G
 349 1175 ; [.0106.0020.0002.1175]  # Hangul Jamo middle I
 350 5B57 ; [.0107.0020.0002.5B57]  # CJK Ideograph "Letter"
 351 ENTRIES
 352   table => undef,
 353   normalization => undef,
 354 );
 355
 356 # defined before undefined
 357
 358 my $sortABC = join '',
 359     $few_entries->sort(split //, "ABCDEFGHIJKLMNOPQRSTUVWXYZ ");
 360
 361 ok($sortABC eq "PERL ABCDFGHIJKMNOQSTUVWXYZ");
 362
 363 ok($few_entries->lt('E', 'D'));
 364 ok($few_entries->lt("\x{5B57}", "\x{4E00}"));
 365 ok($few_entries->lt("\x{AE30}", "\x{AC00}"));
 366
 367 # Hangul must be decomposed.
 368
 369 ok($few_entries->eq("\x{AC00}", "\x{1100}\x{1161}"));
 370
 371 ##############
 372
 373 my $all_undef = Unicode::Collate->new(
 374   table => undef,
 375   normalization => undef,
 376   overrideCJK => undef,
 377   overrideHangul => undef,
 378 );
 379
 380 # All in the Unicode code point order.
 381 # No hangul decomposition.
 382
 383 ok($all_undef->lt("\x{3042}", "\x{4E00}"));
 384 ok($all_undef->lt("\x{4DFF}", "\x{4E00}"));
 385 ok($all_undef->lt("\x{4E00}", "\x{AC00}"));
 386 ok($all_undef->gt("\x{AC00}", "\x{1100}\x{1161}"));
 387 ok($all_undef->gt("\x{AC00}", "\x{ABFF}"));
 388
 389 ##############
 390
 391 my $ignoreCJK = Unicode::Collate->new(
 392   table => undef,
 393   normalization => undef,
 394   overrideCJK => sub {()},
 395   entry => <<'ENTRIES',
 396 5B57 ; [.0107.0020.0002.5B57]  # CJK Ideograph "Letter"
 397 ENTRIES
 398 );
 399
 400 # All CJK Unified Ideographs except U+5B57 are ignored.
 401
 402 ok($ignoreCJK->eq("\x{4E00}", ""));
 403 ok($ignoreCJK->lt("\x{4E00}", "\0"));
 404 ok($ignoreCJK->eq("Pe\x{4E00}rl", "Perl")); # U+4E00 is a CJK.
 405 ok($ignoreCJK->gt("\x{4DFF}", "\x{4E00}")); # U+4DFF is not CJK.
 406 ok($ignoreCJK->lt("Pe\x{5B57}rl", "Perl")); # 'r' is unassigned.
 407
 408 ##############
 409
 410 my $ignoreHangul = Unicode::Collate->new(
 411   table => undef,
 412   normalization => undef,
 413   overrideHangul => sub {()},
 414   entry => <<'ENTRIES',
 415 AE00 ; [.0100.0020.0002.AE00]  # Hangul GEUL
 416 ENTRIES
 417 );
 418
 419 # All Hangul Syllables except U+AE00 are ignored.
 420
 421 ok($ignoreHangul->eq("\x{AC00}", ""));
 422 ok($ignoreHangul->lt("\x{AC00}", "\0"));
 423 ok($ignoreHangul->lt("\x{AC00}", "\x{AE00}"));
 424 ok($ignoreHangul->lt("\x{AC00}", "\x{1100}\x{1161}")); # Jamo are not ignored.
 425 ok($ignoreHangul->lt("Pe\x{AE00}rl", "Perl")); # 'r' is unassigned.
 426
 427 ##############
 428
 429 my $blanked = Unicode::Collate->new(
 430   table => 'keys.txt',
 431   normalization => undef,
 432   alternate => 'Blanked',
 433 );
 434
 435 ok($blanked->lt("death", "de luge"));
 436 ok($blanked->lt("de luge", "de-luge"));
 437 ok($blanked->lt("de-luge", "deluge"));
 438 ok($blanked->lt("deluge", "de\x{2010}luge"));
 439 ok($blanked->lt("deluge", "de Luge"));
 440
 441 ##############
 442
 443 my $nonIgn = Unicode::Collate->new(
 444   table => 'keys.txt',
 445   normalization => undef,
 446   alternate => 'Non-ignorable',
 447 );
 448
 449 ok($nonIgn->lt("de luge", "de Luge"));
 450 ok($nonIgn->lt("de Luge", "de-luge"));
 451 ok($nonIgn->lt("de-Luge", "de\x{2010}luge"));
 452 ok($nonIgn->lt("de-luge", "death"));
 453 ok($nonIgn->lt("death", "deluge"));
 454
 455 ##############
 456
 457 my $shifted = Unicode::Collate->new(
 458   table => 'keys.txt',
 459   normalization => undef,
 460   alternate => 'Shifted',
 461 );
 462
 463 ok($shifted->lt("death", "de luge"));
 464 ok($shifted->lt("de luge", "de-luge"));
 465 ok($shifted->lt("de-luge", "deluge"));
 466 ok($shifted->lt("deluge", "de Luge"));
 467 ok($shifted->lt("de Luge", "deLuge"));
 468
 469 ##############
 470
 471 my $shTrim = Unicode::Collate->new(
 472   table => 'keys.txt',
 473   normalization => undef,
 474   alternate => 'Shift-Trimmed',
 475 );
 476
 477 ok($shTrim->lt("death", "deluge"));
 478 ok($shTrim->lt("deluge", "de luge"));
 479 ok($shTrim->lt("de luge", "de-luge"));
 480 ok($shTrim->lt("de-luge", "deLuge"));
 481 ok($shTrim->lt("deLuge", "de Luge"));
 482
 483 ##############
 484
 485 my $overCJK = Unicode::Collate->new(
 486   table => undef,
 487   normalization => undef,
 488   entry => <<'ENTRIES',
 489 0061 ; [.0101.0020.0002.0061] # latin a
 490 0041 ; [.0101.0020.0008.0041] # LATIN A
 491 4E00 ; [.B1FC.0030.0004.4E00] # Ideograph; B1FC = FFFF - 4E03.
 492 ENTRIES
 493   overrideCJK => sub {
 494     my $u = 0xFFFF - $_[0]; # reversed
 495     [$u, 0x20, 0x2, $u];
 496   },
 497 );
 498
 499 ok($overCJK->lt("a", "A")); # diff. at level 3.
 500 ok($overCJK->lt( "\x{4E03}",  "\x{4E00}")); # diff. at level 2.
 501 ok($overCJK->lt("A\x{4E03}", "A\x{4E00}"));
 502 ok($overCJK->lt("A\x{4E03}", "a\x{4E00}"));
 503 ok($overCJK->lt("a\x{4E03}", "A\x{4E00}"));
 504
 505 ##############
 506
 507 # rearranged : 0x0E40..0x0E44, 0x0EC0..0x0EC4
 508
 509 ok($Collator->lt("A", "B"));
 510 ok($Collator->lt("\x{0E40}", "\x{0E41}"));
 511 ok($Collator->lt("\x{0E40}A", "\x{0E41}B"));
 512 ok($Collator->lt("\x{0E41}A", "\x{0E40}B"));
 513 ok($Collator->lt("A\x{0E41}A", "A\x{0E40}B"));
 514
 515 ok($all_undef->lt("A", "B"));
 516 ok($all_undef->lt("\x{0E40}", "\x{0E41}"));
 517 ok($all_undef->lt("\x{0E40}A", "\x{0E41}B"));
 518 ok($all_undef->lt("\x{0E41}A", "\x{0E40}B"));
 519 ok($all_undef->lt("A\x{0E41}A", "A\x{0E40}B"));
 520
 521 ##############
 522
 523 my $no_rearrange = Unicode::Collate->new(
 524   table => undef,
 525   normalization => undef,
 526   rearrange => [],
 527 );
 528
 529 ok($no_rearrange->lt("A", "B"));
 530 ok($no_rearrange->lt("\x{0E40}", "\x{0E41}"));
 531 ok($no_rearrange->lt("\x{0E40}A", "\x{0E41}B"));
 532 ok($no_rearrange->gt("\x{0E41}A", "\x{0E40}B"));
 533 ok($no_rearrange->gt("A\x{0E41}A", "A\x{0E40}B"));
 534
 535 ##############
 536
 537 # equivalent to $no_rearrange
 538
 539 my $undef_rearrange = Unicode::Collate->new(
 540   table => undef,
 541   normalization => undef,
 542   rearrange => undef,
 543 );
 544
 545 ok($undef_rearrange->lt("A", "B"));
 546 ok($undef_rearrange->lt("\x{0E40}", "\x{0E41}"));
 547 ok($undef_rearrange->lt("\x{0E40}A", "\x{0E41}B"));
 548 ok($undef_rearrange->gt("\x{0E41}A", "\x{0E40}B"));
 549 ok($undef_rearrange->gt("A\x{0E41}A", "A\x{0E40}B"));
 550
 551 ##############
 552
 553 my $dropArticles = Unicode::Collate->new(
 554   table => "keys.txt",
 555   normalization => undef,
 556   preprocess => sub {
 557     my $string = shift;
 558     $string =~ s/\b(?:an?|the)\s+//ig;
 559     $string;
 560   },
 561 );
 562
 563 ok($dropArticles->eq("camel", "a    camel"));
 564 ok($dropArticles->eq("Perl", "The Perl"));
 565 ok($dropArticles->lt("the pen", "a pencil"));
 566 ok($Collator->lt("Perl", "The Perl"));
 567 ok($Collator->gt("the pen", "a pencil"));
 568
 569 ##############
 570
 571 my $backLevel1 = Unicode::Collate->new(
 572   table => undef,
 573   normalization => undef,
 574   backwards => [ 1 ],
 575 );
 576
 577 # all strings are reversed at level 1.
 578
 579 ok($backLevel1->gt("AB", "BA"));
 580 ok($backLevel1->gt("\x{3042}\x{3044}", "\x{3044}\x{3042}"));
 581
 582 ##############
 583
 584 my $backLevel2 = Unicode::Collate->new(
 585   table => "keys.txt",
 586   normalization => undef,
 587   undefName => qr/HANGUL|HIRAGANA|KATAKANA|BOPOMOFO/,
 588   backwards => 2,
 589 );
 590
 591 ok($backLevel2->gt("Ca\x{300}ca\x{302}", "ca\x{302}ca\x{300}"));
 592 ok($backLevel2->gt("ca\x{300}ca\x{302}", "Ca\x{302}ca\x{300}"));
 593 ok($Collator  ->lt("Ca\x{300}ca\x{302}", "ca\x{302}ca\x{300}"));
 594 ok($Collator  ->lt("ca\x{300}ca\x{302}", "Ca\x{302}ca\x{300}"));
 595
 596
 597 # HIRAGANA and KATAKANA are made undefined via undefName.
 598 # So they are after CJK Unified Ideographs.
 599
 600 ok($backLevel2->lt("\x{4E00}", $hiragana));
 601 ok($backLevel2->lt("\x{4E03}", $katakana));
 602 ok($Collator  ->gt("\x{4E00}", $hiragana));
 603 ok($Collator  ->gt("\x{4E03}", $katakana));
 604
 605 ##############