cpan/Unicode-Collate/t/test.t

   1
   2 BEGIN {
   3     unless ("A" eq pack('U', 0x41)) {
   4         print "1..0 # Unicode::Collate " .
   5             "cannot stringify a Unicode code point\n";
   6         exit 0;
   7     }
   8     if ($ENV{PERL_CORE}) {
   9         chdir('t') if -d 't';
  10         @INC = $^O eq 'MacOS' ? qw(::lib) : qw(../lib);
  11     }
  12 }
  13
  14 use Test;
  15 BEGIN { plan tests => 107 };
  16
  17 use strict;
  18 use warnings;
  19 use Unicode::Collate;
  20
  21 ok(1);
  22
  23 #########################
  24
  25 sub _pack_U   { Unicode::Collate::pack_U(@_) }
  26 sub _unpack_U { Unicode::Collate::unpack_U(@_) }
  27
  28 my $A_acute = _pack_U(0xC1);
  29 my $a_acute = _pack_U(0xE1);
  30 my $acute   = _pack_U(0x0301);
  31
  32 my $hiragana = "\x{3042}\x{3044}";
  33 my $katakana = "\x{30A2}\x{30A4}";
  34
  35 ##### 2..7
  36
  37 my $Collator = Unicode::Collate->new(
  38   table => 'keys.txt',
  39   normalization => undef,
  40 );
  41
  42 ok(ref $Collator, "Unicode::Collate");
  43
  44 ok($Collator->cmp("", ""), 0);
  45 ok($Collator->eq("", ""));
  46 ok($Collator->cmp("", "perl"), -1);
  47
  48 ok(
  49   join(':', $Collator->sort( qw/ acha aca ada acia acka / ) ),
  50   join(':',                  qw/ aca acha acia acka ada / ),
  51 );
  52
  53 ok(
  54   join(':', $Collator->sort( qw/ ACHA ACA ADA ACIA ACKA / ) ),
  55   join(':',                  qw/ ACA ACHA ACIA ACKA ADA / ),
  56 );
  57
  58 ##### 8..18
  59
  60 ok($Collator->cmp("A$acute", $A_acute), 0); # @version 3.1.1 (prev: -1)
  61 ok($Collator->cmp($a_acute, $A_acute), -1);
  62 ok($Collator->eq("A\cA$acute", $A_acute)); # UCA v9. \cA is invariant.
  63
  64 my %old_level = $Collator->change(level => 1);
  65 ok($Collator->eq("A$acute", $A_acute));
  66 ok($Collator->eq("A", $A_acute));
  67
  68 ok($Collator->change(level => 2)->eq($a_acute, $A_acute));
  69 ok($Collator->lt("A", $A_acute));
  70
  71 ok($Collator->change(%old_level)->lt("A", $A_acute));
  72 ok($Collator->lt("A", $A_acute));
  73 ok($Collator->lt("A", $a_acute));
  74 ok($Collator->lt($a_acute, $A_acute));
  75
  76 ##### 19..25
  77
  78 $Collator->change(level => 2);
  79
  80 ok($Collator->{level}, 2);
  81
  82 ok( $Collator->cmp("ABC","abc"), 0);
  83 ok( $Collator->eq("ABC","abc") );
  84 ok( $Collator->le("ABC","abc") );
  85 ok( $Collator->cmp($hiragana, $katakana), 0);
  86 ok( $Collator->eq($hiragana, $katakana) );
  87 ok( $Collator->ge($hiragana, $katakana) );
  88
  89 ##### 26..31
  90
  91 # hangul
  92 ok( $Collator->eq("a\x{AC00}b", "a\x{1100}\x{1161}b") );
  93 ok( $Collator->eq("a\x{AE00}b", "a\x{1100}\x{1173}\x{11AF}b") );
  94 ok( $Collator->gt("a\x{AE00}b", "a\x{1100}\x{1173}b\x{11AF}") );
  95 ok( $Collator->lt("a\x{AC00}b", "a\x{AE00}b") );
  96 ok( $Collator->gt("a\x{D7A3}b", "a\x{C544}b") );
  97 ok( $Collator->lt("a\x{C544}b", "a\x{30A2}b") ); # hangul < hiragana
  98
  99 ##### 32..40
 100
 101 $Collator->change(%old_level, katakana_before_hiragana => 1);
 102
 103 ok($Collator->{level}, 4);
 104
 105 ok( $Collator->cmp("abc", "ABC"), -1);
 106 ok( $Collator->ne("abc", "ABC") );
 107 ok( $Collator->lt("abc", "ABC") );
 108 ok( $Collator->le("abc", "ABC") );
 109 ok( $Collator->cmp($hiragana, $katakana), 1);
 110 ok( $Collator->ne($hiragana, $katakana) );
 111 ok( $Collator->gt($hiragana, $katakana) );
 112 ok( $Collator->ge($hiragana, $katakana) );
 113
 114 ##### 41..46
 115
 116 $Collator->change(upper_before_lower => 1);
 117
 118 ok( $Collator->cmp("abc", "ABC"), 1);
 119 ok( $Collator->ge("abc", "ABC"), 1);
 120 ok( $Collator->gt("abc", "ABC"), 1);
 121 ok( $Collator->cmp($hiragana, $katakana), 1);
 122 ok( $Collator->ge($hiragana, $katakana), 1);
 123 ok( $Collator->gt($hiragana, $katakana), 1);
 124
 125 ##### 47..48
 126
 127 $Collator->change(katakana_before_hiragana => 0);
 128
 129 ok( $Collator->cmp("abc", "ABC"), 1);
 130 ok( $Collator->cmp($hiragana, $katakana), -1);
 131
 132 ##### 49..52
 133
 134 $Collator->change(upper_before_lower => 0);
 135
 136 ok( $Collator->cmp("abc", "ABC"), -1);
 137 ok( $Collator->le("abc", "ABC") );
 138 ok( $Collator->cmp($hiragana, $katakana), -1);
 139 ok( $Collator->lt($hiragana, $katakana) );
 140
 141 ##### 53..54
 142 {
 143     my $ignoreAE = Unicode::Collate->new(
 144         table => 'keys.txt',
 145         normalization => undef,
 146         ignoreChar => qr/^[aAeE]$/,
 147     );
 148     ok($ignoreAE->eq("element","lament"));
 149     ok($ignoreAE->eq("Perl","ePrl"));
 150 }
 151
 152 ##### 55
 153 {
 154     my $onlyABC = Unicode::Collate->new(
 155         table => undef,
 156         normalization => undef,
 157         entry => << 'ENTRIES',
 158 0061 ; [.0101.0020.0002.0061] # LATIN SMALL LETTER A
 159 0041 ; [.0101.0020.0008.0041] # LATIN CAPITAL LETTER A
 160 0062 ; [.0102.0020.0002.0062] # LATIN SMALL LETTER B
 161 0042 ; [.0102.0020.0008.0042] # LATIN CAPITAL LETTER B
 162 0063 ; [.0103.0020.0002.0063] # LATIN SMALL LETTER C
 163 0043 ; [.0103.0020.0008.0043] # LATIN CAPITAL LETTER C
 164 ENTRIES
 165     );
 166     ok(
 167         join(':', $onlyABC->sort( qw/ ABA BAC cc A Ab cAc aB / ) ),
 168         join(':',                 qw/ A aB Ab ABA BAC cAc cc / ),
 169     );
 170 }
 171
 172 ##### 56..59
 173 {
 174     my $undefAE = Unicode::Collate->new(
 175         table => 'keys.txt',
 176         normalization => undef,
 177         undefChar => qr/^[aAeE]$/,
 178     );
 179     ok($undefAE ->gt("edge","fog"));
 180     ok($Collator->lt("edge","fog"));
 181     ok($undefAE ->gt("lake","like"));
 182     ok($Collator->lt("lake","like"));
 183 }
 184
 185 ##### 60..69
 186 {
 187     # Table is undefined, then no entry is defined.
 188     my $undef_table = Unicode::Collate->new(
 189         table => undef,
 190         normalization => undef,
 191         level => 1,
 192     );
 193
 194     # in the Unicode code point order
 195     ok($undef_table->lt('', 'A'));
 196     ok($undef_table->lt('ABC', 'B'));
 197
 198     # Hangul should be decomposed (even w/o Unicode::Normalize).
 199     ok($undef_table->lt("Perl", "\x{AC00}"));
 200     ok($undef_table->eq("\x{AC00}", "\x{1100}\x{1161}"));
 201     ok($undef_table->eq("\x{AE00}", "\x{1100}\x{1173}\x{11AF}"));
 202     ok($undef_table->lt("\x{AE00}", "\x{3042}"));
 203
 204     # U+AC00: Hangul GA
 205     # U+AE00: Hangul GEUL
 206     # U+3042: Hiragana A
 207
 208     # Weight for CJK Ideographs is defined, though.
 209     ok($undef_table->lt("", "\x{4E00}"));
 210     ok($undef_table->lt("\x{4E8C}","ABC"));
 211     ok($undef_table->lt("\x{4E00}","\x{3042}"));
 212     ok($undef_table->lt("\x{4E00}","\x{4E8C}"));
 213
 214     # U+4E00: Ideograph "ONE"
 215     # U+4E8C: Ideograph "TWO"
 216 }
 217
 218 ##### 70..74
 219 {
 220     my $few_entries = Unicode::Collate->new(
 221         entry => <<'ENTRIES',
 222 0050 ; [.0101.0020.0002.0050]  # P
 223 0045 ; [.0102.0020.0002.0045]  # E
 224 0052 ; [.0103.0020.0002.0052]  # R
 225 004C ; [.0104.0020.0002.004C]  # L
 226 1100 ; [.0105.0020.0002.1100]  # Hangul Jamo initial G
 227 1175 ; [.0106.0020.0002.1175]  # Hangul Jamo middle I
 228 5B57 ; [.0107.0020.0002.5B57]  # CJK Ideograph "Letter"
 229 ENTRIES
 230         table => undef,
 231         normalization => undef,
 232     );
 233     # defined before undefined
 234     my $sortABC = join '',
 235         $few_entries->sort(split //, "ABCDEFGHIJKLMNOPQRSTUVWXYZ ");
 236
 237     ok($sortABC eq "PERL ABCDFGHIJKMNOQSTUVWXYZ");
 238
 239     ok($few_entries->lt('E', 'D'));
 240     ok($few_entries->lt("\x{5B57}", "\x{4E00}"));
 241     ok($few_entries->lt("\x{AE30}", "\x{AC00}"));
 242
 243     # Hangul must be decomposed.
 244     ok($few_entries->eq("\x{AC00}", "\x{1100}\x{1161}"));
 245 }
 246
 247 ##### 75..79
 248 {
 249     my $dropArticles = Unicode::Collate->new(
 250         table => "keys.txt",
 251         normalization => undef,
 252         preprocess => sub {
 253             my $string = shift;
 254             $string =~ s/\b(?:an?|the)\s+//ig;
 255             $string;
 256         },
 257     );
 258     ok($dropArticles->eq("camel", "a    camel"));
 259     ok($dropArticles->eq("Perl", "The Perl"));
 260     ok($dropArticles->lt("the pen", "a pencil"));
 261     ok($Collator->lt("Perl", "The Perl"));
 262     ok($Collator->gt("the pen", "a pencil"));
 263 }
 264
 265 ##### 80..83
 266 {
 267     my $undefName = Unicode::Collate->new(
 268         table => "keys.txt",
 269         normalization => undef,
 270         undefName => qr/HANGUL|HIRAGANA|KATAKANA|BOPOMOFO/,
 271     );
 272     # HIRAGANA and KATAKANA are made undefined via undefName.
 273     # So they are after CJK Unified Ideographs.
 274
 275     ok($undefName->lt("\x{4E00}", $hiragana));
 276     ok($undefName->lt("\x{4E03}", $katakana));
 277     ok($Collator ->gt("\x{4E00}", $hiragana));
 278     ok($Collator ->gt("\x{4E03}", $katakana));
 279 }
 280
 281 ##### 84..90
 282 {
 283     my $O_str = Unicode::Collate->new(
 284         table => "keys.txt",
 285         normalization => undef,
 286         entry => <<'ENTRIES',
 287 0008  ; [*0008.0000.0000.0000] # BACKSPACE (need to be non-ignorable)
 288 004F 0337 ; [.0B53.0020.0008.004F] # capital O WITH SHORT SOLIDUS OVERLAY
 289 006F 0008 002F ; [.0B53.0020.0002.006F] # LATIN SMALL LETTER O WITH STROKE
 290 004F 0008 002F ; [.0B53.0020.0008.004F] # LATIN CAPITAL LETTER O WITH STROKE
 291 006F 0337 ; [.0B53.0020.0002.004F] # small O WITH SHORT SOLIDUS OVERLAY
 292 200B  ; [.2000.0000.0000.0000] # ZERO WIDTH SPACE (may be non-sense but ...)
 293 #00F8 ; [.0B53.0020.0002.00F8] # LATIN SMALL LETTER O WITH STROKE
 294 #00D8 ; [.0B53.0020.0008.00D8] # LATIN CAPITAL LETTER O WITH STROKE
 295 ENTRIES
 296     );
 297
 298     my $o_BS_slash = _pack_U(0x006F, 0x0008, 0x002F);
 299     my $O_BS_slash = _pack_U(0x004F, 0x0008, 0x002F);
 300     my $o_sol    = _pack_U(0x006F, 0x0337);
 301     my $O_sol    = _pack_U(0x004F, 0x0337);
 302     my $o_stroke = _pack_U(0x00F8);
 303     my $O_stroke = _pack_U(0x00D8);
 304
 305     ok($O_str->eq($o_stroke, $o_BS_slash));
 306     ok($O_str->eq($O_stroke, $O_BS_slash));
 307
 308     ok($O_str->eq($o_stroke, $o_sol));
 309     ok($O_str->eq($O_stroke, $O_sol));
 310
 311     ok($Collator->eq("\x{200B}", "\0"));
 312     ok($O_str   ->gt("\x{200B}", "\0"));
 313     ok($O_str   ->gt("\x{200B}", "A"));
 314 }
 315
 316 ##### 91..101
 317
 318 my %origVer = $Collator->change(UCA_Version => 8);
 319
 320 $Collator->change(level => 3);
 321
 322 ok($Collator->gt("!\x{300}", ""));
 323 ok($Collator->gt("!\x{300}", "!"));
 324 ok($Collator->eq("!\x{300}", "\x{300}"));
 325
 326 $Collator->change(level => 2);
 327
 328 ok($Collator->eq("!\x{300}", "\x{300}"));
 329
 330 $Collator->change(level => 4);
 331
 332 ok($Collator->gt("!\x{300}", "!"));
 333 ok($Collator->lt("!\x{300}", "\x{300}"));
 334
 335 $Collator->change(%origVer, level => 3);
 336
 337 ok($Collator->eq("!\x{300}", ""));
 338 ok($Collator->eq("!\x{300}", "!"));
 339 ok($Collator->lt("!\x{300}", "\x{300}"));
 340
 341 $Collator->change(level => 4);
 342
 343 ok($Collator->gt("!\x{300}", ""));
 344 ok($Collator->eq("!\x{300}", "!"));
 345
 346 ##### 102..107
 347
 348 $_ = 'Foo';
 349
 350 my $c = Unicode::Collate->new(
 351   table => 'keys.txt',
 352   normalization => undef,
 353   upper_before_lower => 1,
 354 );
 355
 356 ok($_, 'Foo'); # fixed at v. 0.52; no longer clobber $_
 357
 358 my($temp, @temp); # Not the result but the side effect matters.
 359
 360 $_ = 'Foo';
 361 $temp = $c->getSortKey("abc");
 362 ok($_, 'Foo');
 363
 364 $_ = 'Foo';
 365 $temp = $c->viewSortKey("abc");
 366 ok($_, 'Foo');
 367
 368 $_ = 'Foo';
 369 @temp = $c->sort("abc", "xyz", "def");
 370 ok($_, 'Foo');
 371
 372 $_ = 'Foo';
 373 @temp = $c->index("perl5", "RL");
 374 ok($_, 'Foo');
 375
 376 $_ = 'Foo';
 377 @temp = $c->index("perl5", "LR");
 378 ok($_, 'Foo');
 379
 380 #####
 381