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