1/*
2 *******************************************************************************
3 * Copyright (C) 2002-2014, International Business Machines Corporation and
4 * others. All Rights Reserved.
5 *******************************************************************************
6 */
7
8/**
9 * Port From:   ICU4C v2.1 : Collate/CollationKanaTest
10 * Source File: $ICU4CRoot/source/test/intltest/jacoll.cpp
11 **/
12
13package com.ibm.icu.dev.test.collator;
14
15import java.util.Locale;
16
17import com.ibm.icu.dev.test.TestFmwk;
18import com.ibm.icu.text.CollationKey;
19import com.ibm.icu.text.Collator;
20import com.ibm.icu.text.RuleBasedCollator;
21import com.ibm.icu.util.ULocale;
22
23public class CollationKanaTest extends TestFmwk{
24    public static void main(String[] args) throws Exception{
25        new CollationKanaTest().run(args);
26    }
27
28    private static char[][] testSourceCases = {
29        {0xff9E},
30        {0x3042},
31        {0x30A2},
32        {0x3042, 0x3042},
33        {0x30A2, 0x30FC},
34        {0x30A2, 0x30FC, 0x30C8}                               /*  6 */
35    };
36
37    private static char[][] testTargetCases = {
38        {0xFF9F},
39        {0x30A2},
40        {0x3042, 0x3042},
41        {0x30A2, 0x30FC},
42        {0x30A2, 0x30FC, 0x30C8},
43        {0x3042, 0x3042, 0x3068}                              /*  6 */
44    };
45
46    private static int[] results = {
47        -1,
48        0,   //Collator::LESS, /* Katakanas and Hiraganas are equal on tertiary level(ICU 2.0)*/
49        -1,
50        1, // Collator::LESS, /* Prolonged sound mark sorts BEFORE equivalent vowel (ICU 2.0)*/
51        -1,
52        -1,    //Collator::GREATER /* Prolonged sound mark sorts BEFORE equivalent vowel (ICU 2.0)*//*  6 */
53    };
54
55    private static char[][] testBaseCases = {
56        {0x30AB},
57        {0x30AB, 0x30AD},
58        {0x30AD},
59        {0x30AD, 0x30AD}
60    };
61
62    private static char[][] testPlainDakutenHandakutenCases = {
63        {0x30CF, 0x30AB},
64        {0x30D0, 0x30AB},
65        {0x30CF, 0x30AD},
66        {0x30D0, 0x30AD}
67    };
68
69    private static char[][] testSmallLargeCases = {
70        {0x30C3, 0x30CF},
71        {0x30C4, 0x30CF},
72        {0x30C3, 0x30D0},
73        {0x30C4, 0x30D0}
74    };
75
76    private static char[][] testKatakanaHiraganaCases = {
77        {0x3042, 0x30C3},
78        {0x30A2, 0x30C3},
79        {0x3042, 0x30C4},
80        {0x30A2, 0x30C4}
81    };
82
83    private static char[][] testChooonKigooCases = {
84        /*0*/ {0x30AB, 0x30FC, 0x3042},
85        /*1*/ {0x30AB, 0x30FC, 0x30A2},
86        /*2*/ {0x30AB, 0x30A4, 0x3042},
87        /*3*/ {0x30AB, 0x30A4, 0x30A2},
88        /*6*/ {0x30AD, 0x30FC, 0x3042}, /* Prolonged sound mark sorts BEFORE equivalent vowel (ICU 2.0)*/
89        /*7*/ {0x30AD, 0x30FC, 0x30A2}, /* Prolonged sound mark sorts BEFORE equivalent vowel (ICU 2.0)*/
90        /*4*/ {0x30AD, 0x30A4, 0x3042},
91        /*5*/ {0x30AD, 0x30A4, 0x30A2}
92    };
93
94    private Collator myCollation = null;
95
96    public CollationKanaTest() {
97    }
98    protected void init()throws Exception{
99        if(myCollation==null){
100            myCollation = Collator.getInstance(Locale.JAPANESE);
101        }
102    }
103    // performs test with strength TERIARY
104    public void TestTertiary() {
105        int i = 0;
106        myCollation.setStrength(Collator.TERTIARY);
107
108        for (i = 0; i < 6; i++) {
109            doTest(testSourceCases[i], testTargetCases[i], results[i]);
110        }
111    }
112
113    /* Testing base letters */
114    public void TestBase() {
115        int i;
116        myCollation.setStrength(Collator.PRIMARY);
117        for (i = 0; i < 3 ; i++) {
118            doTest(testBaseCases[i], testBaseCases[i + 1], -1);
119        }
120    }
121
122    /* Testing plain, Daku-ten, Handaku-ten letters */
123    public void TestPlainDakutenHandakuten() {
124        int i;
125        myCollation.setStrength(Collator.SECONDARY);
126        for (i = 0; i < 3 ; i++) {
127            doTest(testPlainDakutenHandakutenCases[i], testPlainDakutenHandakutenCases[i + 1], -1);
128        }
129    }
130
131    /*
132    * Test Small, Large letters
133    */
134    public void TestSmallLarge() {
135        int i;
136        myCollation.setStrength(Collator.TERTIARY);
137
138        for (i = 0; i < 3 ; i++) {
139            doTest(testSmallLargeCases[i], testSmallLargeCases[i + 1], -1);
140        }
141    }
142
143    /*
144    * Test Katakana, Hiragana letters
145    */
146    public void TestKatakanaHiragana() {
147        int i;
148        myCollation.setStrength(Collator.QUATERNARY);
149        for (i = 0; i < 3 ; i++) {
150            doTest(testKatakanaHiraganaCases[i], testKatakanaHiraganaCases[i + 1], -1);
151        }
152    }
153
154    /*
155    * Test Choo-on kigoo
156    */
157    public void TestChooonKigoo() {
158        int i;
159        myCollation.setStrength(Collator.QUATERNARY);
160        for (i = 0; i < 7 ; i++) {
161            doTest(testChooonKigooCases[i], testChooonKigooCases[i + 1], -1);
162        }
163    }
164
165    /*
166     * Test common Hiragana and Katakana characters (e.g. 0x3099) (ticket:6140)
167     */
168    public void TestCommonCharacters() {
169        char[] tmp1 = { 0x3058, 0x30B8 };
170        char[] tmp2 = { 0x3057, 0x3099, 0x30B7, 0x3099 };
171        CollationKey key1, key2;
172        int result;
173        String string1 = new String(tmp1);
174        String string2 = new String(tmp2);
175        RuleBasedCollator rb = (RuleBasedCollator)Collator.getInstance(ULocale.JAPANESE);
176        rb.setStrength(Collator.QUATERNARY);
177        rb.setAlternateHandlingShifted(false);
178
179        result = rb.compare(string1, string2);
180
181        key1 = rb.getCollationKey(string1);
182        key2 = rb.getCollationKey(string2);
183
184        if ( result != 0 || !key1.equals(key2)) {
185            errln("Failed Hiragana and Katakana common characters test. Expected results to be equal.");
186        }
187
188    }
189    // main test routine, tests rules specific to "Kana" locale
190    private void doTest(char[] source, char[] target, int result){
191
192        String s = new String(source);
193        String t = new String(target);
194        int compareResult = myCollation.compare(s, t);
195        CollationKey sortKey1, sortKey2;
196        sortKey1 = myCollation.getCollationKey(s);
197        sortKey2 = myCollation.getCollationKey(t);
198        int keyResult = sortKey1.compareTo(sortKey2);
199        reportCResult(s, t, sortKey1, sortKey2, compareResult, keyResult, compareResult, result);
200
201    }
202
203    private void reportCResult( String source, String target, CollationKey sourceKey, CollationKey targetKey,
204                                int compareResult, int keyResult, int incResult, int expectedResult ){
205        if (expectedResult < -1 || expectedResult > 1) {
206            errln("***** invalid call to reportCResult ****");
207            return;
208        }
209
210        boolean ok1 = (compareResult == expectedResult);
211        boolean ok2 = (keyResult == expectedResult);
212        boolean ok3 = (incResult == expectedResult);
213
214        if (ok1 && ok2 && ok3 && !isVerbose()){
215            return;
216        } else {
217            String msg1 = ok1? "Ok: compare(\"" : "FAIL: compare(\"";
218            String msg2 = "\", \"";
219            String msg3 = "\") returned ";
220            String msg4 = "; expected ";
221
222            String sExpect = new String("");
223            String sResult = new String("");
224            sResult = CollationTest.appendCompareResult(compareResult, sResult);
225            sExpect = CollationTest.appendCompareResult(expectedResult, sExpect);
226            if (ok1) {
227                logln(msg1 + source + msg2 + target + msg3 + sResult);
228            } else {
229                errln(msg1 + source + msg2 + target + msg3 + sResult + msg4 + sExpect);
230            }
231
232            msg1 = ok2 ? "Ok: key(\"" : "FAIL: key(\"";
233            msg2 = "\").compareTo(key(\"";
234            msg3 = "\")) returned ";
235            sResult = CollationTest.appendCompareResult(keyResult, sResult);
236            if (ok2) {
237                logln(msg1 + source + msg2 + target + msg3 + sResult);
238            } else {
239                errln(msg1 + source + msg2 + target + msg3 + sResult + msg4 + sExpect);
240                msg1 = "  ";
241                msg2 = " vs. ";
242                errln(msg1 + CollationTest.prettify(sourceKey) + msg2 + CollationTest.prettify(targetKey));
243            }
244
245            msg1 = ok3 ? "Ok: incCompare(\"" : "FAIL: incCompare(\"";
246            msg2 = "\", \"";
247            msg3 = "\") returned ";
248
249            sResult = CollationTest.appendCompareResult(incResult, sResult);
250
251            if (ok3) {
252                logln(msg1 + source + msg2 + target + msg3 + sResult);
253            } else {
254                errln(msg1 + source + msg2 + target + msg3 + sResult + msg4 + sExpect);
255            }
256        }
257    }
258}
259