[p5sagit/p5-mst-13.2.git] / lib / Unicode / Collate / t / test.t


BEGIN {
    unless ("A" eq pack('U', 0x41) || "A" eq pack('U', ord("A"))) {
	print "1..0 # Unicode::Collate " .
	    "cannot stringify a Unicode code point\n";
	exit 0;
    }
}

BEGIN {
    if ($ENV{PERL_CORE}) {
        chdir('t') if -d 't';
        @INC = $^O eq 'MacOS' ? qw(::lib) : qw(../lib);
    }
}

use Test;
BEGIN { plan tests => 194 };
use Unicode::Collate;

our $IsEBCDIC = ord("A") != 0x41;

#########################

ok(1); # If we made it this far, we're ok.

my $UCA_Version = "9";

ok(Unicode::Collate::UCA_Version, $UCA_Version);
ok(Unicode::Collate->UCA_Version, $UCA_Version);

my $Collator = Unicode::Collate->new(
  table => 'keys.txt',
  normalization => undef,
);

ok(ref $Collator, "Unicode::Collate");

ok($Collator->UCA_Version,   $UCA_Version);
ok($Collator->UCA_Version(), $UCA_Version);

ok(
  join(':', $Collator->sort( 
    qw/ lib strict Carp ExtUtils CGI Time warnings Math overload Pod CPAN /
  ) ),
  join(':',
    qw/ Carp CGI CPAN ExtUtils lib Math overload Pod strict Time warnings /
  ),
);

ok($Collator->cmp("", ""), 0);
ok($Collator->eq("", ""));
ok($Collator->cmp("", "perl"), -1);

##############

sub _pack_U   { Unicode::Collate::pack_U(@_) }
sub _unpack_U { Unicode::Collate::unpack_U(@_) }

my $A_acute = _pack_U(0xC1);
my $a_acute = _pack_U(0xE1);
my $acute   = _pack_U(0x0301);

ok($Collator->cmp("A$acute", $A_acute), 0); # @version 3.1.1 (prev: -1)
ok($Collator->cmp($a_acute, $A_acute), -1);
ok($Collator->eq("A\cA$acute", $A_acute)); # UCA v9. \cA is invariant.

my %old_level = $Collator->change(level => 1);
ok($Collator->eq("A$acute", $A_acute));
ok($Collator->eq("A", $A_acute));

ok($Collator->change(level => 2)->eq($a_acute, $A_acute));
ok($Collator->lt("A", $A_acute));

ok($Collator->change(%old_level)->lt("A", $A_acute));
ok($Collator->lt("A", $A_acute));
ok($Collator->lt("A", $a_acute));
ok($Collator->lt($a_acute, $A_acute));

##############

eval { require Unicode::Normalize };

if (!$@ && !$IsEBCDIC) {
  my $NFD = Unicode::Collate->new(
    table => undef,
    entry => <<'ENTRIES',
0430  ; [.0CB5.0020.0002.0430] # CYRILLIC SMALL LETTER A
0410  ; [.0CB5.0020.0008.0410] # CYRILLIC CAPITAL LETTER A
04D3  ; [.0CBD.0020.0002.04D3] # CYRILLIC SMALL LETTER A WITH DIAERESIS
0430 0308 ; [.0CBD.0020.0002.04D3] # CYRILLIC SMALL LETTER A WITH DIAERESIS
04D2  ; [.0CBD.0020.0008.04D2] # CYRILLIC CAPITAL LETTER A WITH DIAERESIS
0410 0308 ; [.0CBD.0020.0008.04D2] # CYRILLIC CAPITAL LETTER A WITH DIAERESIS
0430 3099 ; [.0CBE.0020.0002.04D3] # A WITH KATAKANA VOICED
0430 3099 0308 ; [.0CBF.0020.0002.04D3] # A WITH KATAKANA VOICED, DIAERESIS
ENTRIES
  );
  ok($NFD->eq("\x{4D3}\x{325}", "\x{430}\x{308}\x{325}"));
  ok($NFD->lt("\x{430}\x{308}A", "\x{430}\x{308}B"));
  ok($NFD->lt("\x{430}\x{3099}B", "\x{430}\x{308}\x{3099}A"));
  ok($NFD->eq("\x{0430}\x{3099}\x{309A}\x{0308}",
              "\x{0430}\x{309A}\x{3099}\x{0308}") );
}
else {
  ok(1);
  ok(1);
  ok(1);
  ok(1);
}

##############

my $trad = Unicode::Collate->new(
  table => 'keys.txt',
  normalization => undef,
  ignoreName => qr/HANGUL|HIRAGANA|KATAKANA|BOPOMOFO/,
  level => 4,
  entry => << 'ENTRIES',
 0063 0068 ; [.0A3F.0020.0002.0063] % "ch" in traditional Spanish
 0043 0068 ; [.0A3F.0020.0008.0043] # "Ch" in traditional Spanish
ENTRIES
);
# 0063  ; [.0A3D.0020.0002.0063] # LATIN SMALL LETTER C
# 0064  ; [.0A49.0020.0002.0064] # LATIN SMALL LETTER D
# Deutsch sz is included in 'keys.txt';

ok(
  join(':', $trad->sort( qw/ acha aca ada acia acka / ) ),
  join(':',              qw/ aca acia acka acha ada / ),
);

ok(
  join(':', $Collator->sort( qw/ acha aca ada acia acka / ) ),
  join(':',                  qw/ aca acha acia acka ada / ),
);
ok($trad->eq("ocho", "oc\cAho")); # UCA v9
ok($trad->eq("ocho", "oc\0\cA\0\cBho")); # UCA v9

my $hiragana = "\x{3042}\x{3044}";
my $katakana = "\x{30A2}\x{30A4}";

# HIRAGANA and KATAKANA are ignorable via ignoreName
ok($trad->eq($hiragana, ""));
ok($trad->eq("", $katakana));
ok($trad->eq($hiragana, $katakana));
ok($trad->eq($katakana, $hiragana));

##############

$Collator->change(level => 2);

ok($Collator->{level}, 2);

ok( $Collator->cmp("ABC","abc"), 0);
ok( $Collator->eq("ABC","abc") );
ok( $Collator->le("ABC","abc") );
ok( $Collator->cmp($hiragana, $katakana), 0);
ok( $Collator->eq($hiragana, $katakana) );
ok( $Collator->ge($hiragana, $katakana) );

# hangul
ok( $Collator->eq("a\x{AC00}b", "a\x{1100}\x{1161}b") );
ok( $Collator->eq("a\x{AE00}b", "a\x{1100}\x{1173}\x{11AF}b") );
ok( $Collator->gt("a\x{AE00}b", "a\x{1100}\x{1173}b\x{11AF}") );
ok( $Collator->lt("a\x{AC00}b", "a\x{AE00}b") );
ok( $Collator->gt("a\x{D7A3}b", "a\x{C544}b") );
ok( $Collator->lt("a\x{C544}b", "a\x{30A2}b") ); # hangul < hiragana

$Collator->change(%old_level, katakana_before_hiragana => 1);

ok($Collator->{level}, 4);

ok( $Collator->cmp("abc", "ABC"), -1);
ok( $Collator->ne("abc", "ABC") );
ok( $Collator->lt("abc", "ABC") );
ok( $Collator->le("abc", "ABC") );
ok( $Collator->cmp($hiragana, $katakana), 1);
ok( $Collator->ne($hiragana, $katakana) );
ok( $Collator->gt($hiragana, $katakana) );
ok( $Collator->ge($hiragana, $katakana) );

$Collator->change(upper_before_lower => 1);

ok( $Collator->cmp("abc", "ABC"), 1);
ok( $Collator->ge("abc", "ABC"), 1);
ok( $Collator->gt("abc", "ABC"), 1);
ok( $Collator->cmp($hiragana, $katakana), 1);
ok( $Collator->ge($hiragana, $katakana), 1);
ok( $Collator->gt($hiragana, $katakana), 1);

$Collator->change(katakana_before_hiragana => 0);

ok( $Collator->cmp("abc", "ABC"), 1);
ok( $Collator->cmp($hiragana, $katakana), -1);

$Collator->change(upper_before_lower => 0);

ok( $Collator->cmp("abc", "ABC"), -1);
ok( $Collator->le("abc", "ABC") );
ok( $Collator->cmp($hiragana, $katakana), -1);
ok( $Collator->lt($hiragana, $katakana) );

##############

my $ignoreAE = Unicode::Collate->new(
  table => 'keys.txt',
  normalization => undef,
  ignoreChar => qr/^[aAeE]$/,
);

ok($ignoreAE->eq("element","lament"));
ok($ignoreAE->eq("Perl","ePrl"));

##############

my $onlyABC = Unicode::Collate->new(
    table => undef,
    normalization => undef,
    entry => << 'ENTRIES',
0061 ; [.0101.0020.0002.0061] # LATIN SMALL LETTER A
0041 ; [.0101.0020.0008.0041] # LATIN CAPITAL LETTER A
0062 ; [.0102.0020.0002.0062] # LATIN SMALL LETTER B
0042 ; [.0102.0020.0008.0042] # LATIN CAPITAL LETTER B
0063 ; [.0103.0020.0002.0063] # LATIN SMALL LETTER C
0043 ; [.0103.0020.0008.0043] # LATIN CAPITAL LETTER C
ENTRIES
);

ok(
  join(':', $onlyABC->sort( qw/ ABA BAC cc A Ab cAc aB / ) ),
  join(':',                 qw/ A aB Ab ABA BAC cAc cc / ),
);

##############

my $undefAE = Unicode::Collate->new(
  table => 'keys.txt',
  normalization => undef,
  undefChar => qr/^[aAeE]$/,
);

ok($undefAE ->gt("edge","fog"));
ok($Collator->lt("edge","fog"));
ok($undefAE ->gt("lake","like"));
ok($Collator->lt("lake","like"));

##############

# Table is undefined, then no entry is defined.

my $undef_table = Unicode::Collate->new(
  table => undef,
  normalization => undef,
  level => 1,
);

# in the Unicode code point order
ok($undef_table->lt('', 'A'));
ok($undef_table->lt('ABC', 'B'));

# Hangul should be decomposed (even w/o Unicode::Normalize).

ok($undef_table->lt("Perl", "\x{AC00}"));
ok($undef_table->eq("\x{AC00}", "\x{1100}\x{1161}"));
ok($undef_table->eq("\x{AE00}", "\x{1100}\x{1173}\x{11AF}"));
ok($undef_table->lt("\x{AE00}", "\x{3042}"));
  # U+AC00: Hangul GA
  # U+AE00: Hangul GEUL
  # U+3042: Hiragana A

# Weight for CJK Ideographs is defined, though.

ok($undef_table->lt("", "\x{4E00}"));
ok($undef_table->lt("\x{4E8C}","ABC"));
ok($undef_table->lt("\x{4E00}","\x{3042}"));
ok($undef_table->lt("\x{4E00}","\x{4E8C}"));
  # U+4E00: Ideograph "ONE"
  # U+4E8C: Ideograph "TWO"


##############

my $few_entries = Unicode::Collate->new(
  entry => <<'ENTRIES',
0050 ; [.0101.0020.0002.0050]  # P
0045 ; [.0102.0020.0002.0045]  # E
0052 ; [.0103.0020.0002.0052]  # R
004C ; [.0104.0020.0002.004C]  # L
1100 ; [.0105.0020.0002.1100]  # Hangul Jamo initial G
1175 ; [.0106.0020.0002.1175]  # Hangul Jamo middle I
5B57 ; [.0107.0020.0002.5B57]  # CJK Ideograph "Letter"
ENTRIES
  table => undef,
  normalization => undef,
);

# defined before undefined

my $sortABC = join '',
    $few_entries->sort(split //, "ABCDEFGHIJKLMNOPQRSTUVWXYZ ");

ok($sortABC eq "PERL ABCDFGHIJKMNOQSTUVWXYZ");

ok($few_entries->lt('E', 'D'));
ok($few_entries->lt("\x{5B57}", "\x{4E00}"));
ok($few_entries->lt("\x{AE30}", "\x{AC00}"));

# Hangul must be decomposed.

ok($few_entries->eq("\x{AC00}", "\x{1100}\x{1161}"));

##############

my $all_undef_8 = Unicode::Collate->new(
  table => undef,
  normalization => undef,
  overrideCJK => undef,
  overrideHangul => undef,
  UCA_Version => 8,
);

# All in the Unicode code point order.
# No hangul decomposition.

ok($all_undef_8->lt("\x{3402}", "\x{4E00}"));
ok($all_undef_8->lt("\x{4DFF}", "\x{4E00}"));
ok($all_undef_8->lt("\x{4E00}", "\x{AC00}"));
ok($all_undef_8->gt("\x{AC00}", "\x{1100}\x{1161}"));
ok($all_undef_8->gt("\x{AC00}", "\x{ABFF}"));

##############

my $all_undef_9 = Unicode::Collate->new(
  table => undef,
  normalization => undef,
  overrideCJK => undef,
  overrideHangul => undef,
  UCA_Version => 9,
);

# CJK Ideo. < CJK ext A/B < Others.
# No hangul decomposition.

ok($all_undef_9->lt("\x{4E00}", "\x{3402}"));
ok($all_undef_9->lt("\x{3402}", "\x{20000}"));
ok($all_undef_9->lt("\x{20000}", "\x{AC00}"));
ok($all_undef_9->gt("\x{AC00}", "\x{1100}\x{1161}"));
ok($all_undef_9->gt("\x{AC00}", "\x{ABFF}")); # U+ABFF: not assigned

##############

my $ignoreCJK = Unicode::Collate->new(
  table => undef,
  normalization => undef,
  overrideCJK => sub {()},
  entry => <<'ENTRIES',
5B57 ; [.0107.0020.0002.5B57]  # CJK Ideograph "Letter"
ENTRIES
);

# All CJK Unified Ideographs except U+5B57 are ignored.

ok($ignoreCJK->eq("\x{4E00}", ""));
ok($ignoreCJK->lt("\x{4E00}", "\0"));
ok($ignoreCJK->eq("Pe\x{4E00}rl", "Perl")); # U+4E00 is a CJK.
ok($ignoreCJK->gt("\x{4DFF}", "\x{4E00}")); # U+4DFF is not CJK.
ok($ignoreCJK->lt("Pe\x{5B57}rl", "Perl")); # 'r' is unassigned.

##############

my $ignoreHangul = Unicode::Collate->new(
  table => undef,
  normalization => undef,
  overrideHangul => sub {()},
  entry => <<'ENTRIES',
AE00 ; [.0100.0020.0002.AE00]  # Hangul GEUL
ENTRIES
);

# All Hangul Syllables except U+AE00 are ignored.

ok($ignoreHangul->eq("\x{AC00}", ""));
ok($ignoreHangul->lt("\x{AC00}", "\0"));
ok($ignoreHangul->lt("\x{AC00}", "\x{AE00}"));
ok($ignoreHangul->lt("\x{AC00}", "\x{1100}\x{1161}")); # Jamo are not ignored.
ok($ignoreHangul->lt("Pe\x{AE00}rl", "Perl")); # 'r' is unassigned.

##############

my %origAlter = $Collator->change(alternate => 'Blanked');

ok($Collator->lt("death", "de luge"));
ok($Collator->lt("de luge", "de-luge"));
ok($Collator->lt("de-luge", "deluge"));
ok($Collator->lt("deluge", "de\x{2010}luge"));
ok($Collator->lt("deluge", "de Luge"));

$Collator->change(alternate => 'Non-ignorable');

ok($Collator->lt("de luge", "de Luge"));
ok($Collator->lt("de Luge", "de-luge"));
ok($Collator->lt("de-Luge", "de\x{2010}luge"));
ok($Collator->lt("de-luge", "death"));
ok($Collator->lt("death", "deluge"));

$Collator->change(alternate => 'Shifted');

ok($Collator->lt("death", "de luge"));
ok($Collator->lt("de luge", "de-luge"));
ok($Collator->lt("de-luge", "deluge"));
ok($Collator->lt("deluge", "de Luge"));
ok($Collator->lt("de Luge", "deLuge"));

$Collator->change(alternate => 'Shift-Trimmed');

ok($Collator->lt("death", "deluge"));
ok($Collator->lt("deluge", "de luge"));
ok($Collator->lt("de luge", "de-luge"));
ok($Collator->lt("de-luge", "deLuge"));
ok($Collator->lt("deLuge", "de Luge"));

$Collator->change(%origAlter);

ok($Collator->{alternate}, 'shifted');

##############

my $overCJK = Unicode::Collate->new(
  table => undef,
  normalization => undef,
  entry => <<'ENTRIES',
0061 ; [.0101.0020.0002.0061] # latin a
0041 ; [.0101.0020.0008.0041] # LATIN A
4E00 ; [.B1FC.0030.0004.4E00] # Ideograph; B1FC = FFFF - 4E03.
ENTRIES
  overrideCJK => sub {
    my $u = 0xFFFF - $_[0]; # reversed
    [$u, 0x20, 0x2, $u];
  },
);

ok($overCJK->lt("a", "A")); # diff. at level 3.
ok($overCJK->lt( "\x{4E03}",  "\x{4E00}")); # diff. at level 2.
ok($overCJK->lt("A\x{4E03}", "A\x{4E00}"));
ok($overCJK->lt("A\x{4E03}", "a\x{4E00}"));
ok($overCJK->lt("a\x{4E03}", "A\x{4E00}"));

##############

# rearrange : 0x0E40..0x0E44, 0x0EC0..0x0EC4 (default)

my %old_rearrange = $Collator->change(rearrange => undef);

ok($Collator->gt("\x{0E41}A", "\x{0E40}B"));
ok($Collator->gt("A\x{0E41}A", "A\x{0E40}B"));

$Collator->change(rearrange => [ 0x61 ]);
 # U+0061, 'a': This is a Unicode value, never a native value.

ok($Collator->gt("ab", "AB")); # as 'ba' > 'AB'

$Collator->change(%old_rearrange);

ok($Collator->lt("ab", "AB"));
ok($Collator->lt("\x{0E40}", "\x{0E41}"));
ok($Collator->lt("\x{0E40}A", "\x{0E41}B"));
ok($Collator->lt("\x{0E41}A", "\x{0E40}B"));
ok($Collator->lt("A\x{0E41}A", "A\x{0E40}B"));

ok($all_undef_8->lt("\x{0E40}", "\x{0E41}"));
ok($all_undef_8->lt("\x{0E40}A", "\x{0E41}B"));
ok($all_undef_8->lt("\x{0E41}A", "\x{0E40}B"));
ok($all_undef_8->lt("A\x{0E41}A", "A\x{0E40}B"));

##############

my $no_rearrange = Unicode::Collate->new(
  table => undef,
  normalization => undef,
  rearrange => [],
);

ok($no_rearrange->lt("A", "B"));
ok($no_rearrange->lt("\x{0E40}", "\x{0E41}"));
ok($no_rearrange->lt("\x{0E40}A", "\x{0E41}B"));
ok($no_rearrange->gt("\x{0E41}A", "\x{0E40}B"));
ok($no_rearrange->gt("A\x{0E41}A", "A\x{0E40}B"));

##############

my $undef_rearrange = Unicode::Collate->new(
  table => undef,
  normalization => undef,
  rearrange => undef,
);

ok($undef_rearrange->lt("A", "B"));
ok($undef_rearrange->lt("\x{0E40}", "\x{0E41}"));
ok($undef_rearrange->lt("\x{0E40}A", "\x{0E41}B"));
ok($undef_rearrange->gt("\x{0E41}A", "\x{0E40}B"));
ok($undef_rearrange->gt("A\x{0E41}A", "A\x{0E40}B"));

##############

my $dropArticles = Unicode::Collate->new(
  table => "keys.txt",
  normalization => undef,
  preprocess => sub {
    my $string = shift;
    $string =~ s/\b(?:an?|the)\s+//ig;
    $string;
  },
);

ok($dropArticles->eq("camel", "a    camel"));
ok($dropArticles->eq("Perl", "The Perl"));
ok($dropArticles->lt("the pen", "a pencil"));
ok($Collator->lt("Perl", "The Perl"));
ok($Collator->gt("the pen", "a pencil"));

##############

my $backLevel1 = Unicode::Collate->new(
  table => undef,
  normalization => undef,
  backwards => [ 1 ],
);

# all strings are reversed at level 1.

ok($backLevel1->gt("AB", "BA"));
ok($backLevel1->gt("\x{3042}\x{3044}", "\x{3044}\x{3042}"));

##############

my $backLevel2 = Unicode::Collate->new(
  table => "keys.txt",
  normalization => undef,
  undefName => qr/HANGUL|HIRAGANA|KATAKANA|BOPOMOFO/,
  backwards => 2,
);

ok($backLevel2->gt("Ca\x{300}ca\x{302}", "ca\x{302}ca\x{300}"));
ok($backLevel2->gt("ca\x{300}ca\x{302}", "Ca\x{302}ca\x{300}"));
ok($Collator  ->lt("Ca\x{300}ca\x{302}", "ca\x{302}ca\x{300}"));
ok($Collator  ->lt("ca\x{300}ca\x{302}", "Ca\x{302}ca\x{300}"));

# HIRAGANA and KATAKANA are made undefined via undefName.
# So they are after CJK Unified Ideographs.

ok($backLevel2->lt("\x{4E00}", $hiragana));
ok($backLevel2->lt("\x{4E03}", $katakana));
ok($Collator  ->gt("\x{4E00}", $hiragana));
ok($Collator  ->gt("\x{4E03}", $katakana));

##############

# ignorable after variable

# Shifted;
ok($Collator->eq("?\x{300}!\x{301}\x{315}", "?!"));
ok($Collator->eq("?\x{300}A\x{301}", "?$A_acute"));
ok($Collator->eq("?\x{300}", "?"));
ok($Collator->eq("?\x{344}", "?")); # U+0344 has two CEs.

$Collator->change(level => 3);
ok($Collator->eq("\cA", "?"));

$Collator->change(alternate => 'blanked', level => 4);
ok($Collator->eq("?\x{300}!\x{301}\x{315}", "?!"));
ok($Collator->eq("?\x{300}A\x{301}", "?$A_acute"));
ok($Collator->eq("?\x{300}", "?"));
ok($Collator->eq("?\x{344}", "?")); # U+0344 has two CEs.

$Collator->change(level => 3);
ok($Collator->eq("\cA", "?"));

$Collator->change(alternate => 'Non-ignorable', level => 4);

ok($Collator->lt("?\x{300}", "?!"));
ok($Collator->gt("?\x{300}A$acute", "?$A_acute"));
ok($Collator->gt("?\x{300}", "?"));
ok($Collator->gt("?\x{344}", "?"));

$Collator->change(level => 3);
ok($Collator->lt("\cA", "?"));

$Collator->change(alternate => 'Shifted', level => 4);

##############

# According to Conformance Test,
# a L3-ignorable is treated as a completely ignorable.

my $L3ignorable = Unicode::Collate->new(
  alternate => 'Non-ignorable',
  table => undef,
  normalization => undef,
  entry => <<'ENTRIES',
0000  ; [.0000.0000.0000.0000] # [0000] NULL (in 6429)
0001  ; [.0000.0000.0000.0000] # [0001] START OF HEADING (in 6429)
0591  ; [.0000.0000.0000.0591] # HEBREW ACCENT ETNAHTA
1D165 ; [.0000.0000.0000.1D165] # MUSICAL SYMBOL COMBINING STEM
0021  ; [*024B.0020.0002.0021] # EXCLAMATION MARK
09BE  ; [.114E.0020.0002.09BE] # BENGALI VOWEL SIGN AA
09C7  ; [.1157.0020.0002.09C7] # BENGALI VOWEL SIGN E
09CB  ; [.1159.0020.0002.09CB] # BENGALI VOWEL SIGN O
09C7 09BE ; [.1159.0020.0002.09CB] # BENGALI VOWEL SIGN O
ENTRIES
);

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