lib/Unicode/Collate/t/test.t

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