| /* |
| * 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. |
| */ |
| |
| /* |
| * @test |
| * @library /java/text/testlib |
| * @summary test Collation API |
| * @modules jdk.localedata |
| */ |
| /* |
| (C) Copyright Taligent, Inc. 1996 - All Rights Reserved |
| (C) Copyright IBM Corp. 1996 - All Rights Reserved |
| |
| The original version of this source code and documentation is copyrighted and |
| owned by Taligent, Inc., a wholly-owned subsidiary of IBM. These materials are |
| provided under terms of a License Agreement between Taligent and Sun. This |
| technology is protected by multiple US and International patents. This notice and |
| attribution to Taligent may not be removed. |
| Taligent is a registered trademark of Taligent, Inc. |
| */ |
| |
| import java.util.Locale; |
| import java.text.Collator; |
| import java.text.RuleBasedCollator; |
| import java.text.CollationKey; |
| import java.text.CollationElementIterator; |
| |
| public class APITest extends CollatorTest { |
| |
| public static void main(String[] args) throws Exception { |
| new APITest().run(args); |
| } |
| |
| final void doAssert(boolean condition, String message) |
| { |
| if (!condition) { |
| err("ERROR: "); |
| errln(message); |
| } |
| } |
| |
| public final void TestProperty( ) |
| { |
| Collator col = null; |
| try { |
| col = Collator.getInstance(Locale.ROOT); |
| logln("The property tests begin : "); |
| logln("Test ctors : "); |
| doAssert(col.compare("ab", "abc") < 0, "ab < abc comparison failed"); |
| doAssert(col.compare("ab", "AB") < 0, "ab < AB comparison failed"); |
| doAssert(col.compare("black-bird", "blackbird") > 0, "black-bird > blackbird comparison failed"); |
| doAssert(col.compare("black bird", "black-bird") < 0, "black bird < black-bird comparison failed"); |
| doAssert(col.compare("Hello", "hello") > 0, "Hello > hello comparison failed"); |
| |
| logln("Test ctors ends."); |
| logln("testing Collator.getStrength() method ..."); |
| doAssert(col.getStrength() == Collator.TERTIARY, "collation object has the wrong strength"); |
| doAssert(col.getStrength() != Collator.PRIMARY, "collation object's strength is primary difference"); |
| |
| logln("testing Collator.setStrength() method ..."); |
| col.setStrength(Collator.SECONDARY); |
| doAssert(col.getStrength() != Collator.TERTIARY, "collation object's strength is secondary difference"); |
| doAssert(col.getStrength() != Collator.PRIMARY, "collation object's strength is primary difference"); |
| doAssert(col.getStrength() == Collator.SECONDARY, "collation object has the wrong strength"); |
| |
| logln("testing Collator.setDecomposition() method ..."); |
| col.setDecomposition(Collator.NO_DECOMPOSITION); |
| doAssert(col.getDecomposition() != Collator.FULL_DECOMPOSITION, "collation object's strength is secondary difference"); |
| doAssert(col.getDecomposition() != Collator.CANONICAL_DECOMPOSITION, "collation object's strength is primary difference"); |
| doAssert(col.getDecomposition() == Collator.NO_DECOMPOSITION, "collation object has the wrong strength"); |
| } catch (Exception foo) { |
| errln("Error : " + foo.getMessage()); |
| errln("Default Collator creation failed."); |
| } |
| logln("Default collation property test ended."); |
| logln("Collator.getRules() testing ..."); |
| doAssert(((RuleBasedCollator)col).getRules().length() != 0, "getRules() result incorrect" ); |
| logln("getRules tests end."); |
| try { |
| col = Collator.getInstance(Locale.FRENCH); |
| col.setStrength(Collator.PRIMARY); |
| logln("testing Collator.getStrength() method again ..."); |
| doAssert(col.getStrength() != Collator.TERTIARY, "collation object has the wrong strength"); |
| doAssert(col.getStrength() == Collator.PRIMARY, "collation object's strength is not primary difference"); |
| |
| logln("testing French Collator.setStrength() method ..."); |
| col.setStrength(Collator.TERTIARY); |
| doAssert(col.getStrength() == Collator.TERTIARY, "collation object's strength is not tertiary difference"); |
| doAssert(col.getStrength() != Collator.PRIMARY, "collation object's strength is primary difference"); |
| doAssert(col.getStrength() != Collator.SECONDARY, "collation object's strength is secondary difference"); |
| |
| } catch (Exception bar) { |
| errln("Error : " + bar.getMessage()); |
| errln("Creating French collation failed."); |
| } |
| |
| logln("Create junk collation: "); |
| Locale abcd = new Locale("ab", "CD", ""); |
| Collator junk = null; |
| try { |
| junk = Collator.getInstance(abcd); |
| } catch (Exception err) { |
| errln("Error : " + err.getMessage()); |
| errln("Junk collation creation failed, should at least return the collator for the base bundle."); |
| } |
| try { |
| col = Collator.getInstance(Locale.ROOT); |
| doAssert(col.equals(junk), "The base bundle's collation should be returned."); |
| } catch (Exception exc) { |
| errln("Error : " + exc.getMessage()); |
| errln("Default collation comparison, caching not working."); |
| } |
| |
| logln("Collator property test ended."); |
| } |
| |
| public final void TestHashCode( ) |
| { |
| logln("hashCode tests begin."); |
| Collator col1 = null; |
| try { |
| col1 = Collator.getInstance(Locale.ROOT); |
| } catch (Exception foo) { |
| errln("Error : " + foo.getMessage()); |
| errln("Default collation creation failed."); |
| } |
| Collator col2 = null; |
| Locale dk = new Locale("da", "DK", ""); |
| try { |
| col2 = Collator.getInstance(dk); |
| } catch (Exception bar) { |
| errln("Error : " + bar.getMessage()); |
| errln("Danish collation creation failed."); |
| return; |
| } |
| Collator col3 = null; |
| try { |
| col3 = Collator.getInstance(Locale.ROOT); |
| } catch (Exception err) { |
| errln("Error : " + err.getMessage()); |
| errln("2nd default collation creation failed."); |
| } |
| logln("Collator.hashCode() testing ..."); |
| |
| if (col1 != null) { |
| doAssert(col1.hashCode() != col2.hashCode(), "Hash test1 result incorrect"); |
| if (col3 != null) { |
| doAssert(col1.hashCode() == col3.hashCode(), "Hash result not equal"); |
| } |
| } |
| |
| logln("hashCode tests end."); |
| } |
| |
| //---------------------------------------------------------------------------- |
| // ctor -- Tests the constructor methods |
| // |
| public final void TestCollationKey( ) |
| { |
| logln("testing CollationKey begins..."); |
| Collator col = null; |
| try { |
| col = Collator.getInstance(Locale.ROOT); |
| } catch (Exception foo) { |
| errln("Error : " + foo.getMessage()); |
| errln("Default collation creation failed."); |
| } |
| if (col == null) { |
| return; |
| } |
| |
| String test1 = "Abcda", test2 = "abcda"; |
| logln("Use tertiary comparison level testing ...."); |
| CollationKey sortk1 = col.getCollationKey(test1); |
| CollationKey sortk2 = col.getCollationKey(test2); |
| doAssert(sortk1.compareTo(sortk2) > 0, |
| "Result should be \"Abcda\" >>> \"abcda\""); |
| CollationKey sortk3 = sortk2; |
| CollationKey sortkNew = sortk1; |
| doAssert(sortk1 != sortk2, "The sort keys should be different"); |
| doAssert(sortk1.hashCode() != sortk2.hashCode(), "sort key hashCode() failed"); |
| doAssert(sortk2.compareTo(sortk3) == 0, "The sort keys should be the same"); |
| doAssert(sortk1 == sortkNew, "The sort keys assignment failed"); |
| doAssert(sortk1.hashCode() == sortkNew.hashCode(), "sort key hashCode() failed"); |
| doAssert(sortkNew != sortk3, "The sort keys should be different"); |
| doAssert(sortk1.compareTo(sortk3) > 0, "Result should be \"Abcda\" >>> \"abcda\""); |
| doAssert(sortk2.compareTo(sortk3) == 0, "Result should be \"abcda\" == \"abcda\""); |
| long cnt1, cnt2; |
| byte byteArray1[] = sortk1.toByteArray(); |
| byte byteArray2[] = sortk2.toByteArray(); |
| doAssert(byteArray1 != null && byteArray2 != null, "CollationKey.toByteArray failed."); |
| logln("testing sortkey ends..."); |
| } |
| //---------------------------------------------------------------------------- |
| // ctor -- Tests the constructor methods |
| // |
| public final void TestElemIter( ) |
| { |
| logln("testing sortkey begins..."); |
| Collator col = null; |
| try { |
| col = Collator.getInstance(); |
| } catch (Exception foo) { |
| errln("Error : " + foo.getMessage()); |
| errln("Default collation creation failed."); |
| } |
| RuleBasedCollator rbCol; |
| if (col instanceof RuleBasedCollator) { |
| rbCol = (RuleBasedCollator) col; |
| } else { |
| return; |
| } |
| String testString1 = "XFILE What subset of all possible test cases has the highest probability of detecting the most errors?"; |
| String testString2 = "Xf ile What subset of all possible test cases has the lowest probability of detecting the least errors?"; |
| logln("Constructors and comparison testing...."); |
| CollationElementIterator iterator1 = rbCol.getCollationElementIterator(testString1); |
| CollationElementIterator iterator2 = rbCol.getCollationElementIterator(testString1); |
| CollationElementIterator iterator3 = rbCol.getCollationElementIterator(testString2); |
| int order1, order2, order3; |
| order1 = iterator1.next(); |
| order2 = iterator2.next(); |
| doAssert(order1 == order2, "The order result should be the same"); |
| |
| order3 = iterator3.next(); |
| doAssert(CollationElementIterator.primaryOrder(order1) |
| == CollationElementIterator.primaryOrder(order3), |
| "The primary orders should be the same"); |
| doAssert(CollationElementIterator.secondaryOrder(order1) |
| == CollationElementIterator.secondaryOrder(order3), |
| "The secondary orders should be the same"); |
| doAssert(CollationElementIterator.tertiaryOrder(order1) |
| == CollationElementIterator.tertiaryOrder(order3), |
| "The tertiary orders should be the same"); |
| |
| order1 = iterator1.next(); |
| order3 = iterator3.next(); |
| doAssert(CollationElementIterator.primaryOrder(order1) |
| == CollationElementIterator.primaryOrder(order3), |
| "The primary orders should be identical"); |
| doAssert(CollationElementIterator.tertiaryOrder(order1) |
| != CollationElementIterator.tertiaryOrder(order3), |
| "The tertiary orders should be different"); |
| |
| order1 = iterator1.next(); |
| order3 = iterator3.next(); |
| doAssert(CollationElementIterator.secondaryOrder(order1) |
| != CollationElementIterator.secondaryOrder(order3), |
| "The secondary orders should be different"); |
| doAssert(order1 != CollationElementIterator.NULLORDER, |
| "Unexpected end of iterator reached"); |
| |
| iterator1.reset(); |
| iterator2.reset(); |
| iterator3.reset(); |
| order1 = iterator1.next(); |
| order2 = iterator2.next(); |
| doAssert(order1 == order2, "The order result should be the same"); |
| |
| order3 = iterator3.next(); |
| doAssert(CollationElementIterator.primaryOrder(order1) |
| == CollationElementIterator.primaryOrder(order3), |
| "The orders should be the same"); |
| doAssert(CollationElementIterator.secondaryOrder(order1) |
| == CollationElementIterator.secondaryOrder(order3), |
| "The orders should be the same"); |
| doAssert(CollationElementIterator.tertiaryOrder(order1) |
| == CollationElementIterator.tertiaryOrder(order3), |
| "The orders should be the same"); |
| |
| order1 = iterator1.next(); |
| order2 = iterator2.next(); |
| order3 = iterator3.next(); |
| doAssert(CollationElementIterator.primaryOrder(order1) |
| == CollationElementIterator.primaryOrder(order3), |
| "The primary orders should be identical"); |
| doAssert(CollationElementIterator.tertiaryOrder(order1) |
| != CollationElementIterator.tertiaryOrder(order3), |
| "The tertiary orders should be different"); |
| |
| order1 = iterator1.next(); |
| order3 = iterator3.next(); |
| doAssert(CollationElementIterator.secondaryOrder(order1) |
| != CollationElementIterator.secondaryOrder(order3), |
| "The secondary orders should be different"); |
| doAssert(order1 != CollationElementIterator.NULLORDER, "Unexpected end of iterator reached"); |
| logln("testing CollationElementIterator ends..."); |
| } |
| |
| public final void TestGetAll() |
| { |
| Locale[] list = Collator.getAvailableLocales(); |
| for (int i = 0; i < list.length; ++i) { |
| log("Locale name: "); |
| log(list[i].toString()); |
| log(" , the display name is : "); |
| logln(list[i].getDisplayName()); |
| } |
| } |
| } |