1 /*************************************************************************
2  *
3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4  *
5  * Copyright 2000, 2010 Oracle and/or its affiliates.
6  *
7  * OpenOffice.org - a multi-platform office productivity suite
8  *
9  * This file is part of OpenOffice.org.
10  *
11  * OpenOffice.org is free software: you can redistribute it and/or modify
12  * it under the terms of the GNU Lesser General Public License version 3
13  * only, as published by the Free Software Foundation.
14  *
15  * OpenOffice.org is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU Lesser General Public License version 3 for more details
19  * (a copy is included in the LICENSE file that accompanied this code).
20  *
21  * You should have received a copy of the GNU Lesser General Public License
22  * version 3 along with OpenOffice.org.  If not, see
23  * <http://www.openoffice.org/license.html>
24  * for a copy of the LGPLv3 License.
25  *
26  ************************************************************************/
27 
28 package ifc.i18n;
29 
30 import java.text.Collator;
31 
32 import lib.MultiMethodTest;
33 
34 import com.sun.star.i18n.CollatorOptions;
35 import com.sun.star.i18n.XCollator;
36 import com.sun.star.lang.Locale;
37 
38 /**
39 * Testing <code>com.sun.star.i18n.XCollator</code>
40 * interface methods :
41 * <ul>
42 *  <li><code> compareSubstring()</code></li>
43 *  <li><code> compareString()</code></li>
44 *  <li><code> loadDefaultCollator()</code></li>
45 *  <li><code> loadCollatorAlgorithm()</code></li>
46 *  <li><code> listCollatorAlgorithms()</code></li>
47 *  <li><code> loadCollatorAlgorithmWithEndUserOption()</code></li>
48 *  <li><code> listCollatorOptions()</code></li>
49 * </ul> <p>
50 * Test is <b> NOT </b> multithread compilant. <p>
51 * @see com.sun.star.i18n.XCollator
52 */
53 public class _XCollator extends MultiMethodTest {
54     public XCollator oObj = null;
55     private String[] alg = null ;
56     private int[] opt = null ;
57     Locale loc = new Locale("en", "EN", "");
58 
59     /**
60     * Just retrieves a list of algorithms. <p>
61     * Has <b>OK</b> status if non-zero length array returned.
62     */
63     public void _listCollatorAlgorithms() {
64         alg = oObj.listCollatorAlgorithms(loc) ;
65         log.println("Collator algorithms :");
66         if (alg != null) {
67             for (int i = 0; i < alg.length; i++) {
68                 log.println("  '" + alg[i] + "'") ;
69             }
70             tRes.tested("listCollatorAlgorithms()", alg.length > 0) ;
71         } else {
72             tRes.tested("listCollatorAlgorithms()", false) ;
73         }
74     }
75 
76     /**
77     * Just gets a list of options for some collator. <p>
78     * Has <b>OK</b> status if not null value returned.<p>
79     * The following method tests are to be completed successfully before :
80     * <ul>
81     *  <li> <code> listCollatorAlgorithms </code> : to have some
82     *    algorithm name. </li>
83     * </ul>
84     */
85     public void _listCollatorOptions() {
86         requiredMethod("listCollatorAlgorithms()") ;
87         opt = oObj.listCollatorOptions(alg[0]) ;
88         log.println("Collator '" + alg[0] + "' options :");
89         if (opt != null) {
90             for (int i = 0; i < opt.length; i++) {
91                 log.println("  " + opt[i]) ;
92             }
93             tRes.tested("listCollatorOptions()", true) ;
94         } else {
95             tRes.tested("listCollatorOptions()", false) ;
96         }
97     }
98 
99     /**
100     * Calls the method with no options and with options(IGNORE_CASE),
101     * compares strings.<p>
102     * Has <b>OK</b> status if compareString() returned correct values.
103     */
104     public void _loadDefaultCollator() {
105         oObj.loadDefaultCollator(loc, 0);
106         boolean res = oObj.compareString("A", "a") != 0;
107         oObj.loadDefaultCollator(loc,
108             CollatorOptions.CollatorOptions_IGNORE_CASE);
109         res &= oObj.compareString("a", "A") == 0;
110         tRes.tested("loadDefaultCollator()", res) ;
111     }
112 
113     /**
114     * Calls the method with no options and with options(IGNORE_CASE),
115     * compares strings.<p>
116     * Has <b>OK</b> status if compareString() returned correct values.
117     * The following method tests are to be completed successfully before :
118     * <ul>
119     *  <li> <code> listCollatorAlgorithms </code> : to have some
120     *    algorithm name. </li>
121     * </ul>
122     */
123     public void _loadCollatorAlgorithm() {
124         requiredMethod("listCollatorAlgorithms()");
125         oObj.loadCollatorAlgorithm(alg[0], loc,
126             CollatorOptions.CollatorOptions_IGNORE_CASE);
127         boolean res = oObj.compareString("A", "a") == 0;
128         oObj.loadCollatorAlgorithm(alg[0], loc, 0);
129         res &= oObj.compareString("a", "A") != 0;
130         tRes.tested("loadCollatorAlgorithm()", res);
131     }
132 
133     /**
134     * Calls the method with no options and with options(IGNORE_CASE),
135     * compares strings.<p>
136     * Has <b>OK</b> status if compareString() returned correct values.
137     * The following method tests are to be completed successfully before :
138     * <ul>
139     *  <li> <code> listCollatorAlgorithms </code> : to have some
140     *    algorithm name. </li>
141     * </ul>
142     */
143     public void _loadCollatorAlgorithmWithEndUserOption() {
144         requiredMethod("listCollatorAlgorithms()");
145         oObj.loadCollatorAlgorithmWithEndUserOption(alg[0], loc,
146             new int[] {0});
147         boolean res = oObj.compareString("A", "a") != 0;
148         oObj.loadCollatorAlgorithmWithEndUserOption(alg[0], loc,
149             new int[] {CollatorOptions.CollatorOptions_IGNORE_CASE});
150         res = oObj.compareString("A", "a") == 0;
151         tRes.tested("loadCollatorAlgorithmWithEndUserOption()", res);
152     }
153 
154     /**
155     * Test is performed for locales : en, ru, ja, zh, ko.
156     * Default collator is loaded for each locale. Then collation
157     * is performed for different combination of symbols from range of
158     * this locale.<p>
159     * Has <b>OK</b> status if comparing of different strings
160     * returns not 0 value, then comparing in the opposite
161     * order returns value with opposite sign, and comparing
162     * of two equal strings returns 0. The such comparing is performed
163     * for one character strings.
164     */
165     public void _compareSubstring() {
166         boolean result = true ;
167         char[] chars = new char[2] ;
168         Collator col = null ;
169 
170         log.println(" #### Testing English locale ####") ;
171         oObj.loadDefaultCollator(loc, 0) ;
172         col = Collator.getInstance(new java.util.Locale("en", "EN")) ;
173         for (char ch = 0x0020; ch < 0x007F; ch ++) {
174             chars[0] = ch ; chars[1] = (char) (ch + 1) ;
175             result &= testCompareSubstring(chars, col) ;
176         }
177 
178         log.println(" #### Testing Russian locale ####") ;
179         oObj.loadDefaultCollator(
180             new com.sun.star.lang.Locale("ru", "RU", ""), 0) ;
181         col = Collator.getInstance(new java.util.Locale("ru", "RU")) ;
182         for (char ch = 0x0410; ch < 0x0450; ch ++) {
183             chars[0] = ch ; chars[1] = (char) (ch + 1) ;
184             result &= testCompareSubstring(chars, col) ;
185         }
186 
187         log.println(" #### Testing Japan locale ####") ;
188         oObj.loadDefaultCollator(
189             new com.sun.star.lang.Locale("ja", "JP", ""), 0) ;
190         col = Collator.getInstance(new java.util.Locale("ja", "JP")) ;
191         for (char ch = 0x4E00; ch < 0x4EFD; ch ++) {
192             chars[0] = ch ; chars[1] = (char) (ch + 1) ;
193             result &= testCompareSubstring(chars, col) ;
194         }
195 
196         log.println(" #### Testing China locale ####") ;
197         oObj.loadDefaultCollator(new Locale("zh", "CN", ""), 0) ;
198         col = Collator.getInstance(new java.util.Locale("zh", "CN")) ;
199         for (char ch = 0x4E00; ch < 0x4EFD; ch ++) {
200             chars[0] = ch ; chars[1] = (char) (ch + 1) ;
201             result &= testCompareSubstring(chars, col) ;
202         }
203 
204         log.println(" #### Testing Korean locale ####") ;
205         oObj.loadDefaultCollator(new Locale("ko", "KR", ""), 0) ;
206         col = Collator.getInstance(new java.util.Locale("ko", "KR")) ;
207         for (char ch = 0x4E00; ch < 0x4EFD; ch ++) {
208             chars[0] = ch ; chars[1] = (char) (ch + 1) ;
209             result &= testCompareSubstring(chars, col) ;
210         }
211 
212         tRes.tested("compareSubstring()", result) ;
213     }
214 
215     /**
216     * Test is performed for locales : en, ru, ja, zh, ko.
217     * Default collator is loaded for each locale. Then collation
218     * is performed for different combination of symbols from range of
219     * this locale.<p>
220     * Has <b>OK</b> status if comparing of different strings
221     * returns not 0 value, then comparing in the opposite
222     * order returns value with opposite sign, and comparing
223     * of two equal strings returns 0. The such comparing is performed
224     * for one character strings.
225     */
226     public void _compareString() {
227         boolean result = true ;
228         char[] chars = new char[2] ;
229         Collator col = null ;
230         log.println(" #### Testing English locale ####") ;
231         oObj.loadDefaultCollator(
232             new com.sun.star.lang.Locale("en", "EN", ""), 0) ;
233         col = Collator.getInstance(new java.util.Locale("en", "EN")) ;
234         for (char ch = 0x0020; ch < 0x007F; ch ++) {
235             chars[0] = ch ; chars[1] = (char) (ch + 1) ;
236             result &= testCompareString(chars, col) ;
237         }
238 
239         log.println(" #### Testing Russian locale ####") ;
240         oObj.loadDefaultCollator(
241             new com.sun.star.lang.Locale("ru", "RU", ""), 0) ;
242         col = Collator.getInstance(new java.util.Locale("ru", "RU")) ;
243         for (char ch = 0x0410; ch < 0x0450; ch ++) {
244             chars[0] = ch ; chars[1] = (char) (ch + 1) ;
245             result &= testCompareString(chars, col) ;
246         }
247 
248         log.println(" #### Testing Japan locale ####") ;
249         oObj.loadDefaultCollator(
250             new com.sun.star.lang.Locale("ja", "JP", ""), 0) ;
251         col = Collator.getInstance(new java.util.Locale("ja", "JP")) ;
252         for (char ch = 0x4E00; ch < 0x4EFD; ch ++) {
253             chars[0] = ch ; chars[1] = (char) (ch + 1) ;
254             result &= testCompareString(chars, col) ;
255         }
256 
257         log.println(" #### Testing China locale ####") ;
258         oObj.loadDefaultCollator(new Locale("zh", "CN", ""), 0) ;
259         col = Collator.getInstance(new java.util.Locale("zh", "CN")) ;
260         for (char ch = 0x4E00; ch < 0x4EFD; ch ++) {
261             chars[0] = ch ; chars[1] = (char) (ch + 1) ;
262             result &= testCompareString(chars, col) ;
263         }
264 
265         log.println(" #### Testing Korean locale ####") ;
266         oObj.loadDefaultCollator(new Locale("ko", "KR", ""), 0) ;
267         col = Collator.getInstance(new java.util.Locale("ko", "KR")) ;
268         for (char ch = 0x4E00; ch < 0x4EFD; ch ++) {
269             chars[0] = ch ; chars[1] = (char) (ch + 1) ;
270             result &= testCompareString(chars, col) ;
271         }
272 
273         tRes.tested("compareString()", result) ;
274     }
275 
276 
277     /**
278     * Testing compareString() method. At first method is testing single chars
279     * comparing, then strings comparing.
280     * @param locChar sequence of at list two characters of a given locale
281     * to be used in comparing.
282     * @param col Collator for a given locale
283     * @return true if:
284     * <ol>
285     *  <li> if comparing of two identical characters returns zero</li>
286     *  <li> if comparing of two different characters returns non zero</li>
287     *  <li> if comparing of two identical strings, composed of given chars
288     *  returns zero</li>
289     *  <li> if comparing of two different strings, composed of given chars
290     *  returns non zero</li>
291     * </ol>
292     */
293     public boolean testCompareString(char[] locChar, Collator col) {
294         boolean result = true;
295         int res;
296         String msg = "";
297 
298         String char0 = "_"+new String(new char[] {locChar[0]});
299         String char1 = "_"+new String(new char[] {locChar[1]});
300         res = oObj.compareString(char0 , char0) ;
301         if (res != 0) {
302             msg += "  Testing collation of single equal characters ("
303                 + toUnicode(char0) + ") ... FAILED\n" ;
304         }
305         result &= res == 0 ;
306         res = oObj.compareString(char0, char1) ;
307         if (res == 0) {
308             msg += "  Testing collation of single different" +
309                 " characters (" + toUnicode(char0+char1) +
310                 ") ... FAILED (0 returned)\n" ;
311             msg += "  Java collator returned " +
312                 col.compare(char0, char1) + "\n" ;
313             result = false ;
314         } else { // opposite order - sum of results must be 0
315             res += oObj.compareString(char1, char0) ;
316             if (res != 0) {
317                 msg += "  Testing collation of single different" +
318                     " characters (" + toUnicode(char0+char1) +
319                     ") ... FAILED\n" ;
320             }
321             result &= res == 0 ;
322         }
323 
324         String str1 = new String(new char[] {locChar[0], locChar[0],
325             locChar[1], locChar[1], locChar[1]}) ;
326         String str2 = new String(new char[] {locChar[0], locChar[0],
327             locChar[0], locChar[1], locChar[1]}) ;
328 
329         res = oObj.compareString(str1 , str1) ;
330         if (res != 0) {
331             msg += "  Testing collation of equal strings (" +
332                 toUnicode(str1) + ") ... FAILED\n" ;
333         }
334         result &= res == 0 ;
335         res = oObj.compareString(str1, str2) ;
336         if (res == 0) {
337             msg += "  Testing collation of different strings ((" +
338                 toUnicode(str1) + "),(" + toUnicode(str2) +
339                 ")) ... FAILED (0 returned)\n" ;
340             msg += "  Java collator returned " +
341                 col.compare(str1, str2) + "\n" ;
342             result = false ;
343         } else { // opposite order - sum of results must be
344             res += oObj.compareString(str2, str1) ;
345             if (res != 0) {
346                 msg += "  Testing collation of different strings ((" +
347                     toUnicode(str1) + "),(" + toUnicode(str2) +
348                     ")) ... FAILED\n" ;
349             }
350             result &= res == 0 ;
351         }
352 
353         if (!result) {
354             log.println(msg) ;
355         }
356         return result ;
357     }
358 
359 
360     /**
361     * Testing compareSubstring() method. Method is testing substrings comparing.
362     * @param locChar sequence of at list two characters of a given locale
363     * to be used in comparing.
364     * @param col Collator for a given locale
365     * @return true if:
366     * <ol>
367     *  <li> if comparing of two identical substrings of strings, composed
368     *  of given chars returns zero</li>
369     *  <li> if comparing of two different substrings of strings, composed
370     *  of given chars returns non zero</li>
371     * </ol>
372     */
373     public boolean testCompareSubstring(char[] locChar, Collator col) {
374         boolean result = true ;
375         int res ;
376         String msg = "" ;
377 
378         String str1 = new String(new char[] {locChar[0], locChar[0],
379             locChar[1], locChar[1], locChar[1]}) ;
380         String str2 = new String(new char[] {locChar[0], locChar[0],
381             locChar[0], locChar[1], locChar[1]}) ;
382 
383         res = oObj.compareSubstring(str1, 1, 2 , str2, 2, 2) ;
384         if (res != 0) {
385             msg += "  Testing collation of equal substrings (" +
386                 toUnicode(str1) + ") ... FAILED\n" ;
387         }
388         result &= res == 0 ;
389         res = oObj.compareSubstring(str1, 1, 2, str2, 1, 2) ;
390         if (res == 0) {
391             msg += "  Testing collation of different strings ((" +
392                 toUnicode(str1.substring(1, 3)) + "),(" +
393                 toUnicode(str2.substring(1, 3))
394                 + ")) ... FAILED (0 returned)\n" ;
395             msg += "  Java collator returned " + col.compare
396                 (str1.substring(1, 3), str2.substring(1, 3)) + "\n" ;
397             result = false ;
398         } else { // opposite order - sum of results must be
399             res += oObj.compareSubstring(str2, 1, 2, str1, 1, 2) ;
400             if (res != 0) {
401                 msg += "  Testing collation of different strings ((" +
402                     toUnicode(str1) + "),(" + toUnicode(str2) +
403                     ")) ... FAILED\n" ;
404             }
405             result &= res == 0 ;
406         }
407 
408         if (!result) {
409             log.println(msg) ;
410         }
411         return result ;
412     }
413 
414 
415     /**
416     * Transforms string to unicode hex codes.
417     * @param str String to be transformed
418     */
419     public String toUnicode(String str) {
420         char[] chars = str.toCharArray() ;
421         String res = "" ;
422         for (int i = 0; i < chars.length; i++) {
423             if (i != 0) res += "," ;
424             res += Integer.toHexString(chars[i]) ;
425         }
426         return res ;
427     }
428 
429 }
430 
431