| /* |
| ******************************************************************************* |
| * Copyright (C) 2002-2010, International Business Machines Corporation and * |
| * others. All Rights Reserved. * |
| ******************************************************************************* |
| */ |
| |
| /** |
| * Port From: ICU4C v2.1 : Collate/CollationKanaTest |
| * Source File: $ICU4CRoot/source/test/intltest/jacoll.cpp |
| **/ |
| |
| package com.ibm.icu.dev.test.collator; |
| |
| import java.util.Locale; |
| |
| import com.ibm.icu.dev.test.TestFmwk; |
| import com.ibm.icu.text.CollationKey; |
| import com.ibm.icu.text.Collator; |
| import com.ibm.icu.text.RuleBasedCollator; |
| import com.ibm.icu.util.ULocale; |
| |
| public class CollationKanaTest extends TestFmwk{ |
| public static void main(String[] args) throws Exception{ |
| new CollationKanaTest().run(args); |
| } |
| |
| private static char[][] testSourceCases = { |
| {0xff9E}, |
| {0x3042}, |
| {0x30A2}, |
| {0x3042, 0x3042}, |
| {0x30A2, 0x30FC}, |
| {0x30A2, 0x30FC, 0x30C8} /* 6 */ |
| }; |
| |
| private static char[][] testTargetCases = { |
| {0xFF9F}, |
| {0x30A2}, |
| {0x3042, 0x3042}, |
| {0x30A2, 0x30FC}, |
| {0x30A2, 0x30FC, 0x30C8}, |
| {0x3042, 0x3042, 0x3068} /* 6 */ |
| }; |
| |
| private static int[] results = { |
| -1, |
| 0, //Collator::LESS, /* Katakanas and Hiraganas are equal on tertiary level(ICU 2.0)*/ |
| -1, |
| 1, // Collator::LESS, /* Prolonged sound mark sorts BEFORE equivalent vowel (ICU 2.0)*/ |
| -1, |
| -1, //Collator::GREATER /* Prolonged sound mark sorts BEFORE equivalent vowel (ICU 2.0)*//* 6 */ |
| }; |
| |
| private static char[][] testBaseCases = { |
| {0x30AB}, |
| {0x30AB, 0x30AD}, |
| {0x30AD}, |
| {0x30AD, 0x30AD} |
| }; |
| |
| private static char[][] testPlainDakutenHandakutenCases = { |
| {0x30CF, 0x30AB}, |
| {0x30D0, 0x30AB}, |
| {0x30CF, 0x30AD}, |
| {0x30D0, 0x30AD} |
| }; |
| |
| private static char[][] testSmallLargeCases = { |
| {0x30C3, 0x30CF}, |
| {0x30C4, 0x30CF}, |
| {0x30C3, 0x30D0}, |
| {0x30C4, 0x30D0} |
| }; |
| |
| private static char[][] testKatakanaHiraganaCases = { |
| {0x3042, 0x30C3}, |
| {0x30A2, 0x30C3}, |
| {0x3042, 0x30C4}, |
| {0x30A2, 0x30C4} |
| }; |
| |
| private static char[][] testChooonKigooCases = { |
| /*0*/ {0x30AB, 0x30FC, 0x3042}, |
| /*1*/ {0x30AB, 0x30FC, 0x30A2}, |
| /*2*/ {0x30AB, 0x30A4, 0x3042}, |
| /*3*/ {0x30AB, 0x30A4, 0x30A2}, |
| /*6*/ {0x30AD, 0x30FC, 0x3042}, /* Prolonged sound mark sorts BEFORE equivalent vowel (ICU 2.0)*/ |
| /*7*/ {0x30AD, 0x30FC, 0x30A2}, /* Prolonged sound mark sorts BEFORE equivalent vowel (ICU 2.0)*/ |
| /*4*/ {0x30AD, 0x30A4, 0x3042}, |
| /*5*/ {0x30AD, 0x30A4, 0x30A2} |
| }; |
| |
| private Collator myCollation = null; |
| |
| public CollationKanaTest() { |
| } |
| protected void init()throws Exception{ |
| if(myCollation==null){ |
| myCollation = Collator.getInstance(Locale.JAPANESE); |
| } |
| } |
| // performs test with strength TERIARY |
| public void TestTertiary() { |
| int i = 0; |
| myCollation.setStrength(Collator.TERTIARY); |
| |
| for (i = 0; i < 6; i++) { |
| doTest(testSourceCases[i], testTargetCases[i], results[i]); |
| } |
| } |
| |
| /* Testing base letters */ |
| public void TestBase() { |
| int i; |
| myCollation.setStrength(Collator.PRIMARY); |
| for (i = 0; i < 3 ; i++) { |
| doTest(testBaseCases[i], testBaseCases[i + 1], -1); |
| } |
| } |
| |
| /* Testing plain, Daku-ten, Handaku-ten letters */ |
| public void TestPlainDakutenHandakuten() { |
| int i; |
| myCollation.setStrength(Collator.SECONDARY); |
| for (i = 0; i < 3 ; i++) { |
| doTest(testPlainDakutenHandakutenCases[i], testPlainDakutenHandakutenCases[i + 1], -1); |
| } |
| } |
| |
| /* |
| * Test Small, Large letters |
| */ |
| public void TestSmallLarge() { |
| int i; |
| myCollation.setStrength(Collator.TERTIARY); |
| |
| for (i = 0; i < 3 ; i++) { |
| doTest(testSmallLargeCases[i], testSmallLargeCases[i + 1], -1); |
| } |
| } |
| |
| /* |
| * Test Katakana, Hiragana letters |
| */ |
| public void TestKatakanaHiragana() { |
| int i; |
| myCollation.setStrength(Collator.QUATERNARY); |
| for (i = 0; i < 3 ; i++) { |
| doTest(testKatakanaHiraganaCases[i], testKatakanaHiraganaCases[i + 1], -1); |
| } |
| } |
| |
| /* |
| * Test Choo-on kigoo |
| */ |
| public void TestChooonKigoo() { |
| int i; |
| myCollation.setStrength(Collator.QUATERNARY); |
| for (i = 0; i < 7 ; i++) { |
| doTest(testChooonKigooCases[i], testChooonKigooCases[i + 1], -1); |
| } |
| } |
| |
| /* |
| * Test common Hiragana and Katakana characters (e.g. 0x3099) (ticket:6140) |
| */ |
| public void TestCommonCharacters() { |
| char[] tmp1 = { 0x3058, 0x30B8 }; |
| char[] tmp2 = { 0x3057, 0x3099, 0x30B7, 0x3099 }; |
| CollationKey key1, key2; |
| int result; |
| String string1 = new String(tmp1); |
| String string2 = new String(tmp2); |
| RuleBasedCollator rb = (RuleBasedCollator)Collator.getInstance(ULocale.JAPAN); |
| rb.setHiraganaQuaternary(true); |
| rb.setStrength(Collator.QUATERNARY); |
| rb.setAlternateHandlingShifted(false); |
| |
| result = rb.compare(string1, string2); |
| |
| key1 = rb.getCollationKey(string1); |
| key2 = rb.getCollationKey(string2); |
| |
| if ( result != 0 || !key1.equals(key2)) { |
| errln("Failed Hiragana and Katakana common characters test. Expected results to be equal."); |
| } |
| |
| } |
| // main test routine, tests rules specific to "Kana" locale |
| private void doTest(char[] source, char[] target, int result){ |
| |
| String s = new String(source); |
| String t = new String(target); |
| int compareResult = myCollation.compare(s, t); |
| CollationKey sortKey1, sortKey2; |
| sortKey1 = myCollation.getCollationKey(s); |
| sortKey2 = myCollation.getCollationKey(t); |
| int keyResult = sortKey1.compareTo(sortKey2); |
| reportCResult(s, t, sortKey1, sortKey2, compareResult, keyResult, compareResult, result); |
| |
| } |
| |
| private void reportCResult( String source, String target, CollationKey sourceKey, CollationKey targetKey, |
| int compareResult, int keyResult, int incResult, int expectedResult ){ |
| if (expectedResult < -1 || expectedResult > 1) { |
| errln("***** invalid call to reportCResult ****"); |
| return; |
| } |
| |
| boolean ok1 = (compareResult == expectedResult); |
| boolean ok2 = (keyResult == expectedResult); |
| boolean ok3 = (incResult == expectedResult); |
| |
| if (ok1 && ok2 && ok3 && !isVerbose()){ |
| return; |
| } else { |
| String msg1 = ok1? "Ok: compare(\"" : "FAIL: compare(\""; |
| String msg2 = "\", \""; |
| String msg3 = "\") returned "; |
| String msg4 = "; expected "; |
| |
| String sExpect = new String(""); |
| String sResult = new String(""); |
| sResult = appendCompareResult(compareResult, sResult); |
| sExpect = appendCompareResult(expectedResult, sExpect); |
| if (ok1) { |
| logln(msg1 + source + msg2 + target + msg3 + sResult); |
| } else { |
| errln(msg1 + source + msg2 + target + msg3 + sResult + msg4 + sExpect); |
| } |
| |
| msg1 = ok2 ? "Ok: key(\"" : "FAIL: key(\""; |
| msg2 = "\").compareTo(key(\""; |
| msg3 = "\")) returned "; |
| sResult = appendCompareResult(keyResult, sResult); |
| if (ok2) { |
| logln(msg1 + source + msg2 + target + msg3 + sResult); |
| } else { |
| errln(msg1 + source + msg2 + target + msg3 + sResult + msg4 + sExpect); |
| msg1 = " "; |
| msg2 = " vs. "; |
| errln(msg1 + prettify(sourceKey) + msg2 + prettify(targetKey)); |
| } |
| |
| msg1 = ok3 ? "Ok: incCompare(\"" : "FAIL: incCompare(\""; |
| msg2 = "\", \""; |
| msg3 = "\") returned "; |
| |
| sResult = appendCompareResult(incResult, sResult); |
| |
| if (ok3) { |
| logln(msg1 + source + msg2 + target + msg3 + sResult); |
| } else { |
| errln(msg1 + source + msg2 + target + msg3 + sResult + msg4 + sExpect); |
| } |
| } |
| } |
| |
| private String appendCompareResult(int result, String target){ |
| if (result == -1) { |
| target += "LESS"; |
| } else if (result == 0) { |
| target += "EQUAL"; |
| } else if (result == 1) { |
| target += "GREATER"; |
| } else { |
| String huh = "?"; |
| target += huh + result; |
| } |
| return target; |
| } |
| |
| String prettify(CollationKey sourceKey) { |
| int i; |
| byte[] bytes= sourceKey.toByteArray(); |
| String target = "["; |
| |
| for (i = 0; i < bytes.length; i++) { |
| target += Integer.toHexString(bytes[i]); |
| target += " "; |
| } |
| target += "]"; |
| return target; |
| } |
| } |