244 lines
9.8 KiB
Java
244 lines
9.8 KiB
Java
/*
|
|
* Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
/*
|
|
*
|
|
* A part of tests on the bug 4106263. CollationKey became non-final extendable class.
|
|
* The implementation of CollationKey is moved to the new private class,
|
|
* RuleBasedCollationKey. This test basically tests on the two features:
|
|
* 1. Existing code using CollationKey works (backward compatiblility)
|
|
* 2. CollationKey can be extended by its subclass.
|
|
*/
|
|
|
|
import java.util.Locale;
|
|
import java.text.Collator;
|
|
import java.text.CollationKey;
|
|
import java.io.*;
|
|
|
|
import java.text.*;
|
|
|
|
|
|
public class CollationKeyTestImpl extends CollationKey {
|
|
|
|
private static String[] sourceData_ja = {
|
|
"\u3042\u3044\u3046\u3048\u3048",
|
|
"\u3041\u3043\u3045\u3047\u3049",
|
|
"\u3052\u3054\u3056\u3058\u3058",
|
|
"\u3051\u3053\u3055\u3057\u3059",
|
|
"\u3062\u3064\u3066\u3068\u3068",
|
|
"\u3061\u3063\u3065\u3067\u3069",
|
|
"\u3072\u3074\u3075\u3078\u3078",
|
|
"\u3071\u3073\u3075\u3077\u3079",
|
|
"\u3082\u3084\u3085\u3088\u3088",
|
|
"\u3081\u3083\u3085\u3087\u3089",
|
|
"\u30a2\u30a4\u30a6\u30a8\u30aa",
|
|
"\u30a1\u30a3\u30a5\u30a7\u30a9",
|
|
"\u30c2\u30c4\u30c6\u30c8\u30ca",
|
|
"\u30c1\u30c3\u30c5\u30c7\u30c9",
|
|
"\u30b2\u30b4\u30b6\u30b8\u30ba",
|
|
"\u30b1\u30b3\u30b5\u30b7\u30b9",
|
|
"\u30d2\u30d4\u30d6\u30d8\u30da",
|
|
"\u30d1\u30d3\u30d5\u30d7\u30d9",
|
|
"\u30e2\u30e4\u30e6\u30e8\u30ea",
|
|
"\u30e1\u30e3\u30e5\u30e7\u30e9"
|
|
};
|
|
private static final String[] targetData_ja = {
|
|
"\u3042\u3044\u3046\u3048\u3048",
|
|
"\u3041\u3043\u3045\u3047\u3049",
|
|
"\u30a2\u30a4\u30a6\u30a8\u30aa",
|
|
"\u30a1\u30a3\u30a5\u30a7\u30a9",
|
|
"\u3052\u3054\u3056\u3058\u3058",
|
|
"\u3051\u3053\u3055\u3057\u3059",
|
|
"\u30b1\u30b3\u30b5\u30b7\u30b9",
|
|
"\u30b2\u30b4\u30b6\u30b8\u30ba",
|
|
"\u3061\u3063\u3065\u3067\u3069",
|
|
"\u30c1\u30c3\u30c5\u30c7\u30c9",
|
|
"\u3062\u3064\u3066\u3068\u3068",
|
|
"\u30c2\u30c4\u30c6\u30c8\u30ca",
|
|
"\u3071\u3073\u3075\u3077\u3079",
|
|
"\u30d1\u30d3\u30d5\u30d7\u30d9",
|
|
"\u3072\u3074\u3075\u3078\u3078",
|
|
"\u30d2\u30d4\u30d6\u30d8\u30da",
|
|
"\u3081\u3083\u3085\u3087\u3089",
|
|
"\u30e1\u30e3\u30e5\u30e7\u30e9",
|
|
"\u3082\u3084\u3085\u3088\u3088",
|
|
"\u30e2\u30e4\u30e6\u30e8\u30ea"
|
|
};
|
|
|
|
public void run() {
|
|
/** debug: printout the test data
|
|
for (int i=0; i<sourceData_ja.length; i++){
|
|
System.out.println(i+": "+sourceData_ja[i]);
|
|
}
|
|
**/
|
|
/*
|
|
* 1. Test the backward compatibility
|
|
* note: targetData_ja.length is equal to sourceData_ja.length
|
|
*/
|
|
Collator myCollator = Collator.getInstance(Locale.JAPAN);
|
|
CollationKey[] keys = new CollationKey[sourceData_ja.length];
|
|
CollationKey[] target_keys = new CollationKey[targetData_ja.length];
|
|
for (int i=0; i<sourceData_ja.length; i++){
|
|
keys[i] = myCollator.getCollationKey(sourceData_ja[i]);
|
|
target_keys[i] = myCollator.getCollationKey(targetData_ja[i]); //used later
|
|
}
|
|
/* Sort the string using CollationKey */
|
|
InsertionSort(keys);
|
|
/** debug: printout the result after sort
|
|
System.out.println("--- After Sorting ---");
|
|
for (int i=0; i<sourceData_ja.length; i++){
|
|
System.out.println(i+" :"+keys[i].getSourceString());
|
|
}
|
|
**/
|
|
/*
|
|
* Compare the result using equals method and getSourceString method.
|
|
*/
|
|
boolean pass = true;
|
|
for (int i=0; i<sourceData_ja.length; i++){
|
|
/* Comparing using String.equals: in order to use getStringSource() */
|
|
if (! targetData_ja[i].equals(keys[i].getSourceString())){
|
|
throw new RuntimeException("FAILED: CollationKeyTest backward compatibility "
|
|
+"while comparing" +targetData_ja[i]+" vs "
|
|
+keys[i].getSourceString());
|
|
}
|
|
/* Comparing using CollaionKey.equals: in order to use equals() */
|
|
if (! target_keys[i].equals(keys[i])){
|
|
throw new RuntimeException("FAILED: CollationKeyTest backward compatibility."
|
|
+" Using CollationKey.equals " +targetData_ja[i]
|
|
+" vs " +keys[i].getSourceString());
|
|
}
|
|
/* Comparing using CollaionKey.hashCode(): in order to use hashCode() */
|
|
if (target_keys[i].hashCode() != keys[i].hashCode()){
|
|
throw new RuntimeException("FAILED: CollationKeyTest backward compatibility."
|
|
+" Using CollationKey.hashCode " +targetData_ja[i]
|
|
+" vs " +keys[i].getSourceString());
|
|
}
|
|
/* Comparing using CollaionKey.toByteArray(): in order to use toByteArray() */
|
|
byte[] target_bytes = target_keys[i].toByteArray();
|
|
byte[] source_bytes = keys[i].toByteArray();
|
|
for (int j=0; j<target_bytes.length; j++){
|
|
Byte targetByte = new Byte(target_bytes[j]);
|
|
Byte sourceByte = new Byte(source_bytes[j]);
|
|
if (targetByte.compareTo(sourceByte)!=0){
|
|
throw new RuntimeException("FAILED: CollationKeyTest backward "
|
|
+"compatibility. Using Byte.compareTo from CollationKey.toByteArray "
|
|
+targetData_ja[i]
|
|
+" vs " +keys[i].getSourceString());
|
|
}
|
|
}
|
|
}
|
|
testSubclassMethods();
|
|
testConstructor();
|
|
}
|
|
|
|
/*
|
|
* Sort the array of CollationKey using compareTo method in insertion sort.
|
|
*/
|
|
private void InsertionSort(CollationKey[] keys){
|
|
int f, i;
|
|
CollationKey tmp;
|
|
|
|
for (f=1; f < keys.length; f++){
|
|
if(keys[f].compareTo( keys[f-1]) > 0){
|
|
continue;
|
|
}
|
|
tmp = keys[f];
|
|
i = f-1;
|
|
while ( (i>=0) && (keys[i].compareTo(tmp) > 0) ) {
|
|
keys[i+1] = keys[i];
|
|
i--;
|
|
}
|
|
keys[i+1]=tmp;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* From here is the bogus methods to test the subclass of
|
|
* the CollationKey class.
|
|
*/
|
|
public CollationKeyTestImpl(String str){
|
|
super (str);
|
|
// debug: System.out.println("CollationKeyTest extends CollationKey class: "+str);
|
|
}
|
|
/* abstract method: needs to be implemented */
|
|
public byte[] toByteArray(){
|
|
String foo= "Hello";
|
|
return foo.getBytes();
|
|
}
|
|
/* abstract method: needs to be implemented */
|
|
public int compareTo(CollationKey target){
|
|
return 0;
|
|
}
|
|
public boolean equals(Object target){
|
|
return true;
|
|
}
|
|
public String getSourceString(){
|
|
return "CollationKeyTestImpl";
|
|
}
|
|
/*
|
|
* This method tests the collection of bugus methods from the extended
|
|
* subclass of CollationKey class.
|
|
*/
|
|
private void testSubclassMethods() {
|
|
CollationKeyTestImpl clt1 = new CollationKeyTestImpl("testSubclassMethods-1");
|
|
CollationKeyTestImpl clt2 = new CollationKeyTestImpl("testSubclassMethods-2");
|
|
// extended method, equals always returns true
|
|
if (!clt1.equals(clt2)){
|
|
throw new RuntimeException("Failed: equals(CollationKeySubClass)");
|
|
}
|
|
// extended method, compareTo always returns 0
|
|
if (clt1.compareTo(clt2)!=0){
|
|
throw new RuntimeException("Failed: compareTo(CollationKeySubClass)");
|
|
}
|
|
// overriding extended method, getSourceString always returns "CollationKeyTestImpl"
|
|
if (! clt1.getSourceString().equals("CollationKeyTestImpl")){
|
|
throw new RuntimeException("Failed: CollationKey subclass overriding getSourceString()");
|
|
}
|
|
// extended method, toByteArray always returns bytes from "Hello"
|
|
String str2 = new String( clt2.toByteArray());
|
|
if (! clt2.equals("Hello")){
|
|
throw new RuntimeException("Failed: CollationKey subclass toByteArray()");
|
|
}
|
|
}
|
|
|
|
/*
|
|
* This method tests CollationKey constructor with null source string.
|
|
* It should throw NPE.
|
|
*/
|
|
private void testConstructor() {
|
|
boolean npe=false;
|
|
try{
|
|
CollationKeyTestImpl cltNull = new CollationKeyTestImpl(null);
|
|
} catch (NullPointerException npException){
|
|
npe=true;
|
|
// debug: System.out.println("--- NPE is thrown with NULL arguement: PASS ---");
|
|
}
|
|
if(!npe){
|
|
throw new RuntimeException("Failed: CollationKey Constructor with null source"+
|
|
" didn't throw NPE!");
|
|
}
|
|
}
|
|
|
|
}
|