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


BEGIN {
    if (ord("A") == 193) {
	print "1..0 # Unicode::Collate not ported to EBCDIC\n";
	exit 0;
    }
}

BEGIN {
    if ($ENV{PERL_CORE}) {
        chdir('t') if -d 't';
        @INC = qw(../lib);
    }
}

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

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

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);

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

my $A_acute = pack('U', 0x00C1);
my $a_acute = pack('U', 0x00E1);
my $acute   = pack('U', 0x0301);

ok($Collator->cmp("A$acute", $A_acute), -1);
ok($Collator->cmp($a_acute, $A_acute), -1);

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 (!$@) {
  my $NFD = Unicode::Collate->new(
    table => 'keys.txt',
    entry => <<'ENTRIES',
0430 ; [.0B01.0020.0002.0430] # CYRILLIC SMALL LETTER A
0410 ; [.0B01.0020.0008.0410] # CYRILLIC CAPITAL LETTER A
04D3 ; [.0B09.0020.0002.04D3] # CYRILLIC SMALL LETTER A WITH DIAERESIS
0430 0308 ; [.0B09.0020.0002.04D3] # CYRILLIC SMALL LETTER A WITH DIAERESIS
04D3 ; [.0B09.0020.0002.04D3] # CYRILLIC SMALL LETTER A WITH DIAERESIS
0430 0308 ; [.0B09.0020.0002.04D3] # CYRILLIC SMALL LETTER A WITH DIAERESIS
04D2 ; [.0B09.0020.0008.04D2] # CYRILLIC CAPITAL LETTER A WITH DIAERESIS
0410 0308 ; [.0B09.0020.0008.04D2] # CYRILLIC CAPITAL LETTER A WITH DIAERESIS
0430 3099 ; [.0B10.0020.0002.04D3] # A WITH KATAKANA VOICED
0430 3099 0308 ; [.0B11.0020.0002.04D3] # A WITH KATAKANA VOICED, DIAERESIS
ENTRIES
  );
  ok($NFD->eq("A$acute", $A_acute));
  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}") );

  my %old_norm = $NFD->change(normalization => undef);
  ok($NFD->lt("A$acute", $A_acute));
  ok($NFD->cmp("A$acute", $A_acute), $Collator->cmp("A$acute", $A_acute));

  $NFD->change(%old_norm);
  ok($NFD->eq("A$acute", $A_acute));
  ok($NFD->change(normalization => undef)->lt("A$acute", $A_acute));
  ok($NFD->change(level => 1)->eq("A$acute", $A_acute));

}
else {
  ok(1);
  ok(1);
  ok(1);
  ok(1);
  ok(1);
  ok(1);
  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 ; [.0893.0020.0002.0063] % "ch" in traditional Spanish
 0043 0068 ; [.0893.0020.0008.0043] # "Ch" in traditional Spanish
 00DF ; [.09F3.0154.0004.00DF] [.09F3.0020.0004.00DF] # eszet in Germany
ENTRIES
);

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 / ),
);

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"));

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

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

my $str;

my $orig = "This is a Perl book.";
my $sub = "PERL";
my $rep = "camel";
my $ret = "This is a camel book.";

$str = $orig;
if (my($pos,$len) = $Collator->index($str, $sub)) {
  substr($str, $pos, $len, $rep);
}

ok($str, $ret);

$Collator->change(%old_level);

$str = $orig;
if (my($pos,$len) = $Collator->index($str, $sub)) {
  substr($str, $pos, $len, $rep);
}

ok($str, $orig);

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

my $match;

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

$str = "Pe\x{300}rl";
$sub = "pe";
$match = undef;
if (my($pos, $len) = $Collator->index($str, $sub)) {
    $match = substr($str, $pos, $len);
}
ok($match, "Pe\x{300}");

$str = "P\x{300}e\x{300}\x{301}\x{303}rl";
$sub = "pE";
$match = undef;
if (my($pos, $len) = $Collator->index($str, $sub)) {
    $match = substr($str, $pos, $len);
}
ok($match, "P\x{300}e\x{300}\x{301}\x{303}");

$Collator->change(%old_level);

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

%old_level = $trad->change(level => 1);

$str = "Ich mu\x{00DF} studieren.";
$sub = "m\x{00FC}ss";
$match = undef;
if (my($pos, $len) = $trad->index($str, $sub)) {
    $match = substr($str, $pos, $len);
}
ok($match, "mu\x{00DF}");

$trad->change(%old_level);

$str = "Ich mu\x{00DF} studieren.";
$sub = "m\x{00FC}ss";
$match = undef;

if (my($pos, $len) = $trad->index($str, $sub)) {
    $match = substr($str, $pos, $len);
}
ok($match, undef);

$match = undef;
if (my($pos,$len) = $Collator->index("", "")) {
    $match = substr("", $pos, $len);
}
ok($match, "");

$match = undef;
if (my($pos,$len) = $Collator->index("", "abc")) {
    $match = substr("", $pos, $len);
}
ok($match, undef);

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

# 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}"));

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

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 ]); # 'a'

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));

##############
Commit	Line	Data
45394607	1
4a2e806c	2	BEGIN {
	3	if (ord("A") == 193) {
	4	print "1..0 # Unicode::Collate not ported to EBCDIC\n";
	5	exit 0;
	6	}
	7	}
	8
ed423f7a	9	BEGIN {
	10	if ($ENV{PERL_CORE}) {
	11	chdir('t') if -d 't';
	12	@INC = qw(../lib);
	13	}
	14	}
	15
45394607	16	use Test;
ed423f7a	17	BEGIN { plan tests => 183};
45394607	18	use Unicode::Collate;
45394607	19
	20	#########################
	21
ed423f7a	22	ok(1); # If we made it this far, we're ok.
	23
	24	my $UCA_Version = "9";
3164dd77	25
	26	ok(Unicode::Collate::UCA_Version, $UCA_Version);
	27	ok(Unicode::Collate->UCA_Version, $UCA_Version);
	28
5398038e	29	my $Collator = Unicode::Collate->new(
45394607	30	table => 'keys.txt',
	31	normalization => undef,
	32	);
	33
5398038e	34	ok(ref $Collator, "Unicode::Collate");
45394607	35
3164dd77	36	ok($Collator->UCA_Version, $UCA_Version);
	37	ok($Collator->UCA_Version(), $UCA_Version);
	38
45394607	39	ok(
5398038e	40	join(':', $Collator->sort(
45394607	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
ed423f7a	48	ok($Collator->cmp("", ""), 0);
	49	ok($Collator->eq("", ""));
	50	ok($Collator->cmp("", "perl"), -1);
	51
	52	##############
	53
45394607	54	my $A_acute = pack('U', 0x00C1);
ed423f7a	55	my $a_acute = pack('U', 0x00E1);
45394607	56	my $acute = pack('U', 0x0301);
45394607	57
5398038e	58	ok($Collator->cmp("A$acute", $A_acute), -1);
ed423f7a	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));
45394607	72
809c7673	73	##############
	74
	75	eval { require Unicode::Normalize };
45394607	76
809c7673	77	if (!$@) {
45394607	78	my $NFD = Unicode::Collate->new(
45394607	79	table => 'keys.txt',
905aa9f0	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
45394607	92	);
905aa9f0	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}") );
ed423f7a	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
45394607	109	}
809c7673	110	else {
d16e9e3d	111	ok(1);
905aa9f0	112	ok(1);
	113	ok(1);
	114	ok(1);
	115	ok(1);
ed423f7a	116	ok(1);
	117	ok(1);
	118	ok(1);
	119	ok(1);
	120	ok(1);
45394607	121	}
45394607	122
809c7673	123	##############
	124
	125	my $trad = Unicode::Collate->new(
45394607	126	table => 'keys.txt',
45394607	127	normalization => undef,
809c7673	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
45394607	134	ENTRIES
	135	);
	136
	137	ok(
809c7673	138	join(':', $trad->sort( qw/ acha aca ada acia acka / ) ),
809c7673	139	join(':', qw/ aca acia acka acha ada / ),
45394607	140	);
	141
	142	ok(
809c7673	143	join(':', $Collator->sort( qw/ acha aca ada acia acka / ) ),
809c7673	144	join(':', qw/ aca acha acia acka ada / ),
45394607	145	);
45394607	146
45394607	147	my $hiragana = "\x{3042}\x{3044}";
	148	my $katakana = "\x{30A2}\x{30A4}";
	149
809c7673	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
ed423f7a	158	$Collator->change(level => 2);
809c7673	159
ed423f7a	160	ok($Collator->{level}, 2);
5398038e	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) );
45394607	168
5398038e	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
45394607	176
ed423f7a	177	$Collator->change(%old_level, katakana_before_hiragana => 1);
45394607	178
ed423f7a	179	ok($Collator->{level}, 4);
45394607	180
5398038e	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) );
45394607	189
ed423f7a	190	$Collator->change(upper_before_lower => 1);
45394607	191
5398038e	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);
45394607	198
ed423f7a	199	$Collator->change(katakana_before_hiragana => 0);
45394607	200
5398038e	201	ok( $Collator->cmp("abc", "ABC"), 1);
5398038e	202	ok( $Collator->cmp($hiragana, $katakana), -1);
45394607	203
ed423f7a	204	$Collator->change(upper_before_lower => 0);
45394607	205
5398038e	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) );
45394607	210
809c7673	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,
327745dc	226	normalization => undef,
809c7673	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(
45394607	245	table => 'keys.txt',
45394607	246	normalization => undef,
809c7673	247	undefChar => qr/^[aAeE]$/,
45394607	248	);
45394607	249
809c7673	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	##############
45394607	256
ed423f7a	257	$Collator->change(level => 2);
d16e9e3d	258
d16e9e3d	259	my $str;
5398038e	260
5398038e	261	my $orig = "This is a Perl book.";
d16e9e3d	262	my $sub = "PERL";
	263	my $rep = "camel";
	264	my $ret = "This is a camel book.";
	265
	266	$str = $orig;
809c7673	267	if (my($pos,$len) = $Collator->index($str, $sub)) {
5398038e	268	substr($str, $pos, $len, $rep);
d16e9e3d	269	}
	270
	271	ok($str, $ret);
	272
ed423f7a	273	$Collator->change(%old_level);
d16e9e3d	274
d16e9e3d	275	$str = $orig;
809c7673	276	if (my($pos,$len) = $Collator->index($str, $sub)) {
5398038e	277	substr($str, $pos, $len, $rep);
d16e9e3d	278	}
	279
	280	ok($str, $orig);
	281
809c7673	282	##############
	283
	284	my $match;
	285
ed423f7a	286	$Collator->change(level => 1);
809c7673	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
ed423f7a	304	$Collator->change(%old_level);
809c7673	305
	306	##############
	307
ed423f7a	308	%old_level = $trad->change(level => 1);
5398038e	309
	310	$str = "Ich mu\x{00DF} studieren.";
	311	$sub = "m\x{00FC}ss";
809c7673	312	$match = undef;
809c7673	313	if (my($pos, $len) = $trad->index($str, $sub)) {
5398038e	314	$match = substr($str, $pos, $len);
	315	}
	316	ok($match, "mu\x{00DF}");
	317
ed423f7a	318	$trad->change(%old_level);
5398038e	319
	320	$str = "Ich mu\x{00DF} studieren.";
	321	$sub = "m\x{00FC}ss";
	322	$match = undef;
809c7673	323
809c7673	324	if (my($pos, $len) = $trad->index($str, $sub)) {
5398038e	325	$match = substr($str, $pos, $len);
	326	}
	327	ok($match, undef);
	328
	329	$match = undef;
809c7673	330	if (my($pos,$len) = $Collator->index("", "")) {
5398038e	331	$match = substr("", $pos, $len);
	332	}
	333	ok($match, "");
	334
	335	$match = undef;
809c7673	336	if (my($pos,$len) = $Collator->index("", "abc")) {
5398038e	337	$match = substr("", $pos, $len);
	338	}
	339	ok($match, undef);
	340
809c7673	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
ed423f7a	408	my $all_undef_8 = Unicode::Collate->new(
809c7673	409	table => undef,
	410	normalization => undef,
	411	overrideCJK => undef,
	412	overrideHangul => undef,
ed423f7a	413	UCA_Version => 8,
809c7673	414	);
	415
	416	# All in the Unicode code point order.
	417	# No hangul decomposition.
	418
ed423f7a	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}"));
809c7673	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
ed423f7a	484	my %origAlter = $Collator->change(alternate => 'Blanked');
809c7673	485
ed423f7a	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"));
809c7673	491
ed423f7a	492	$Collator->change(alternate => 'Non-ignorable');
809c7673	493
ed423f7a	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"));
809c7673	499
ed423f7a	500	$Collator->change(alternate => 'Shifted');
809c7673	501
ed423f7a	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"));
809c7673	507
ed423f7a	508	$Collator->change(alternate => 'Shift-Trimmed');
809c7673	509
ed423f7a	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"));
809c7673	515
ed423f7a	516	$Collator->change(%origAlter);
809c7673	517
ed423f7a	518	ok($Collator->{alternate}, 'shifted');
809c7673	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
ed423f7a	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'
809c7673	552
ed423f7a	553	ok($Collator->gt("ab", "AB")); # as 'ba' > 'AB'
	554
	555	$Collator->change(%old_rearrange);
	556
	557	ok($Collator->lt("ab", "AB"));
809c7673	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
ed423f7a	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"));
809c7673	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
809c7673	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
3164dd77	642	# HIRAGANA and KATAKANA are made undefined via undefName.
3164dd77	643	# So they are after CJK Unified Ideographs.
809c7673	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	##############