/*
* 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
* @bug 4048446 4051866 4053636 4054238 4054734 4054736 4058613 4059820 4060154
* 4062418 4065540 4066189 4066696 4076676 4078588 4079231 4081866 4087241
* 4087243 4092260 4095316 4101940 4103436 4114076 4114077 4124632 4132736
* 4133509 4139572 4141640 4179126 4179686 4244884 4663220
* @library /java/text/testlib
* @summary Regression tests for Collation and associated classes
* @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.text.*;
import java.util.Locale;
import java.util.Vector;
public class Regression extends CollatorTest {
public static void main(String[] args) throws Exception {
new Regression().run(args);
}
// CollationElementIterator.reset() doesn't work
//
public void Test4048446() {
CollationElementIterator i1 = en_us.getCollationElementIterator(test1);
CollationElementIterator i2 = en_us.getCollationElementIterator(test1);
while ( i1.next() != CollationElementIterator.NULLORDER ) {
}
i1.reset();
assertEqual(i1, i2);
}
// Collator -> rules -> Collator round-trip broken for expanding characters
//
public void Test4051866() throws ParseException {
// Build a collator containing expanding characters
RuleBasedCollator c1 = new RuleBasedCollator("< o "
+"& oe ,o\u3080"
+"& oe ,\u1530 ,O"
+"& OE ,O\u3080"
+"& OE ,\u1520"
+"< p ,P");
// Build another using the rules from the first
RuleBasedCollator c2 = new RuleBasedCollator(c1.getRules());
// Make sure they're the same
if (!c1.getRules().equals(c2.getRules())) {
errln("Rules are not equal");
}
}
// Collator thinks "black-bird" == "black"
//
public void Test4053636() {
if (en_us.equals("black-bird","black")) {
errln("black-bird == black");
}
}
// CollationElementIterator will not work correctly if the associated
// Collator object's mode is changed
//
public void Test4054238() {
RuleBasedCollator c = (RuleBasedCollator) en_us.clone();
c.setDecomposition(Collator.CANONICAL_DECOMPOSITION);
CollationElementIterator i1 = en_us.getCollationElementIterator(test3);
c.setDecomposition(Collator.NO_DECOMPOSITION);
CollationElementIterator i2 = en_us.getCollationElementIterator(test3);
// At this point, BOTH iterators should use NO_DECOMPOSITION, since the
// collator itself is in that mode
assertEqual(i1, i2);
}
// Collator.IDENTICAL documented but not implemented
//
public void Test4054734() {
RuleBasedCollator c = (RuleBasedCollator) en_us.clone();
try {
c.setStrength(Collator.IDENTICAL);
}
catch (Exception e) {
errln("Caught " + e.toString() + " setting Collator.IDENTICAL");
}
String[] decomp = {
"\u0001", "<", "\u0002",
"\u0001", "=", "\u0001",
"A\u0001", ">", "~\u0002", // Ensure A and ~ are not compared bitwise
"\u00C0", "=", "A\u0300" // Decomp should make these equal
};
c.setDecomposition(Collator.CANONICAL_DECOMPOSITION);
compareArray(c, decomp);
String[] nodecomp = {
"\u00C0", ">", "A\u0300" // A-grave vs. A combining-grave
};
c.setDecomposition(Collator.NO_DECOMPOSITION);
compareArray(c, nodecomp);
}
// Full Decomposition mode not implemented
//
public void Test4054736() {
RuleBasedCollator c = (RuleBasedCollator) en_us.clone();
c.setDecomposition(Collator.FULL_DECOMPOSITION);
String[] tests = {
"\uFB4f", "=", "\u05D0\u05DC", // Alef-Lamed vs. Alef, Lamed
};
compareArray(c, tests);
}
// Collator.getInstance() causes an ArrayIndexOutofBoundsException for Korean
//
public void Test4058613() {
// Creating a default collator doesn't work when Korean is the default
// locale
Locale oldDefault = Locale.getDefault();
Locale.setDefault( Locale.KOREAN );
try {
Collator c = Collator.getInstance();
// Since the fix to this bug was to turn of decomposition for Korean collators,
// ensure that's what we got
if (c.getDecomposition() != Collator.NO_DECOMPOSITION) {
errln("Decomposition is not set to NO_DECOMPOSITION");
}
}
finally {
Locale.setDefault(oldDefault);
}
}
// RuleBasedCollator.getRules does not return the exact pattern as input
// for expanding character sequences
//
public void Test4059820() {
RuleBasedCollator c = null;
try {
c = new RuleBasedCollator("< a < b , c/a < d < z");
} catch (ParseException e) {
errln("Exception building collator: " + e.toString());
return;
}
if ( c.getRules().indexOf("c/a") == -1) {
errln("returned rules do not contain 'c/a'");
}
}
// MergeCollation::fixEntry broken for "& H < \u0131, \u0130, i, I"
//
public void Test4060154() {
RuleBasedCollator c = null;
try {
c = new RuleBasedCollator("< g, G < h, H < i, I < j, J"
+ " & H < \u0131, \u0130, i, I" );
} catch (ParseException e) {
errln("Exception building collator: " + e.toString());
return;
}
c.setDecomposition(Collator.CANONICAL_DECOMPOSITION);
String[] tertiary = {
"A", "<", "B",
"H", "<", "\u0131",
"H", "<", "I",
"\u0131", "<", "\u0130",
"\u0130", "<", "i",
"\u0130", ">", "H",
};
c.setStrength(Collator.TERTIARY);
compareArray(c, tertiary);
String[] secondary = {
"H", "<", "I",
"\u0131", "=", "\u0130",
};
c.setStrength(Collator.PRIMARY);
compareArray(c, secondary);
};
// Secondary/Tertiary comparison incorrect in French Secondary
//
public void Test4062418() throws ParseException {
RuleBasedCollator c = (RuleBasedCollator) Collator.getInstance(Locale.FRANCE);
c.setStrength(Collator.SECONDARY);
String[] tests = {
"p\u00eache", "<", "p\u00e9ch\u00e9", // Comparing accents from end, p\u00e9ch\u00e9 is greater
};
compareArray(c, tests);
}
// Collator.compare() method broken if either string contains spaces
//
public void Test4065540() {
if (en_us.compare("abcd e", "abcd f") == 0) {
errln("'abcd e' == 'abcd f'");
}
}
// Unicode characters need to be recursively decomposed to get the
// correct result. For example,
// u1EB1 -> \u0103 + \u0300 -> a + \u0306 + \u0300.
//
public void Test4066189() {
String test1 = "\u1EB1";
String test2 = "a\u0306\u0300";
RuleBasedCollator c1 = (RuleBasedCollator) en_us.clone();
c1.setDecomposition(Collator.FULL_DECOMPOSITION);
CollationElementIterator i1 = en_us.getCollationElementIterator(test1);
RuleBasedCollator c2 = (RuleBasedCollator) en_us.clone();
c2.setDecomposition(Collator.NO_DECOMPOSITION);
CollationElementIterator i2 = en_us.getCollationElementIterator(test2);
assertEqual(i1, i2);
}
// French secondary collation checking at the end of compare iteration fails
//
public void Test4066696() {
RuleBasedCollator c = (RuleBasedCollator) Collator.getInstance(Locale.FRANCE);
c.setStrength(Collator.SECONDARY);
String[] tests = {
"\u00e0", "<", "\u01fa", // a-grave < A-ring-acute
};
compareArray(c, tests);
}
// Bad canonicalization of same-class combining characters
//
public void Test4076676() {
// These combining characters are all in the same class, so they should not
// be reordered, and they should compare as unequal.
String s1 = "A\u0301\u0302\u0300";
String s2 = "A\u0302\u0300\u0301";
RuleBasedCollator c = (RuleBasedCollator) en_us.clone();
c.setStrength(Collator.TERTIARY);
if (c.compare(s1,s2) == 0) {
errln("Same-class combining chars were reordered");
}
}
// RuleBasedCollator.equals(null) throws NullPointerException
//
public void Test4079231() {
try {
if (en_us.equals(null)) {
errln("en_us.equals(null) returned true");
}
}
catch (Exception e) {
errln("en_us.equals(null) threw " + e.toString());
}
}
// RuleBasedCollator breaks on "< a < bb" rule
//
public void Test4078588() throws ParseException {
RuleBasedCollator rbc=new RuleBasedCollator("< a < bb");
int result = rbc.compare("a","bb");
if (result != -1) {
errln("Compare(a,bb) returned " + result + "; expected -1");
}
}
// Combining characters in different classes not reordered properly.
//
public void Test4081866() throws ParseException {
// These combining characters are all in different classes,
// so they should be reordered and the strings should compare as equal.
String s1 = "A\u0300\u0316\u0327\u0315";
String s2 = "A\u0327\u0316\u0315\u0300";
RuleBasedCollator c = (RuleBasedCollator) en_us.clone();
c.setStrength(Collator.TERTIARY);
// Now that the default collators are set to NO_DECOMPOSITION
// (as a result of fixing bug 4114077), we must set it explicitly
// when we're testing reordering behavior. -- lwerner, 5/5/98
c.setDecomposition(Collator.CANONICAL_DECOMPOSITION);
if (c.compare(s1,s2) != 0) {
errln("Combining chars were not reordered");
}
}
// string comparison errors in Scandinavian collators
//
public void Test4087241() {
RuleBasedCollator c = (RuleBasedCollator) Collator.getInstance(
new Locale("da", "DK"));
c.setStrength(Collator.SECONDARY);
String[] tests = {
"\u007a", "<", "\u00e6", // z < ae
"a\u0308", "<", "a\u030a", // a-unlaut < a-ring
"Y", "<", "u\u0308", // Y < u-umlaut
};
compareArray(c, tests);
}
// CollationKey takes ignorable strings into account when it shouldn't
//
public void Test4087243() {
RuleBasedCollator c = (RuleBasedCollator) en_us.clone();
c.setStrength(Collator.TERTIARY);
String[] tests = {
"123", "=", "123\u0001", // 1 2 3 = 1 2 3 ctrl-A
};
compareArray(c, tests);
}
// Mu/micro conflict
// Micro symbol and greek lowercase letter Mu should sort identically
//
public void Test4092260() {
Collator c = Collator.getInstance(new Locale("el", ""));
// will only be equal when FULL_DECOMPOSITION is used
c.setDecomposition(Collator.FULL_DECOMPOSITION);
String[] tests = {
"\u00B5", "=", "\u03BC",
};
compareArray(c, tests);
}
void Test4095316() {
Collator c = Collator.getInstance(new Locale("el", "GR"));
c.setStrength(Collator.TERTIARY);
// javadocs for RuleBasedCollator clearly specify that characters containing compatability
// chars MUST use FULL_DECOMPOSITION to get accurate comparisons.
c.setDecomposition(Collator.FULL_DECOMPOSITION);
String[] tests = {
"\u03D4", "=", "\u03AB",
};
compareArray(c, tests);
}
public void Test4101940() {
try {
RuleBasedCollator c = new RuleBasedCollator("< a < b");
CollationElementIterator i = c.getCollationElementIterator("");
i.reset();
if (i.next() != i.NULLORDER) {
errln("next did not return NULLORDER");
}
}
catch (Exception e) {
errln("Caught " + e );
}
}
// Collator.compare not handling spaces properly
//
public void Test4103436() {
RuleBasedCollator c = (RuleBasedCollator) en_us.clone();
c.setStrength(Collator.TERTIARY);
String[] tests = {
"file", "<", "file access",
"file", "<", "fileaccess",
};
compareArray(c, tests);
}
// Collation not Unicode conformant with Hangul syllables
//
public void Test4114076() {
RuleBasedCollator c = (RuleBasedCollator) en_us.clone();
c.setStrength(Collator.TERTIARY);
//
// With Canonical decomposition, Hangul syllables should get decomposed
// into Jamo, but Jamo characters should not be decomposed into
// conjoining Jamo
//
c.setDecomposition(Collator.CANONICAL_DECOMPOSITION);
String[] test1 = {
"\ud4db", "=", "\u1111\u1171\u11b6",
};
compareArray(c, test1);
// Full decomposition result should be the same as canonical decomposition
// for all hangul.
c.setDecomposition(Collator.FULL_DECOMPOSITION);
compareArray(c, test1);
}
// Collator.getCollationKey was hanging on certain character sequences
//
public void Test4124632() throws Exception {
Collator coll = Collator.getInstance(Locale.JAPAN);
try {
coll.getCollationKey("A\u0308bc");
} catch (OutOfMemoryError e) {
errln("Ran out of memory -- probably an infinite loop");
}
}
// sort order of french words with multiple accents has errors
//
public void Test4132736() {
Collator c = Collator.getInstance(Locale.FRANCE);
String[] test1 = {
"e\u0300e\u0301", "<", "e\u0301e\u0300",
"e\u0300\u0301", ">", "e\u0301\u0300",
};
compareArray(c, test1);
}
// The sorting using java.text.CollationKey is not in the exact order
//
public void Test4133509() {
String[] test1 = {
"Exception", "<", "ExceptionInInitializerError",
"Graphics", "<", "GraphicsEnvironment",
"String", "<", "StringBuffer",
};
compareArray(en_us, test1);
}
// Collation with decomposition off doesn't work for Europe
//
public void Test4114077() {
// Ensure that we get the same results with decomposition off
// as we do with it on....
RuleBasedCollator c = (RuleBasedCollator) en_us.clone();
c.setStrength(Collator.TERTIARY);
String[] test1 = {
"\u00C0", "=", "A\u0300", // Should be equivalent
"p\u00eache", ">", "p\u00e9ch\u00e9",
"\u0204", "=", "E\u030F",
"\u01fa", "=", "A\u030a\u0301", // a-ring-acute -> a-ring, acute
// -> a, ring, acute
"A\u0300\u0316", "<", "A\u0316\u0300", // No reordering --> unequal
};
c.setDecomposition(Collator.NO_DECOMPOSITION);
compareArray(c, test1);
String[] test2 = {
"A\u0300\u0316", "=", "A\u0316\u0300", // Reordering --> equal
};
c.setDecomposition(Collator.CANONICAL_DECOMPOSITION);
compareArray(c, test2);
}
// Support for Swedish gone in 1.1.6 (Can't create Swedish collator)
//
public void Test4141640() {
//
// Rather than just creating a Swedish collator, we might as well
// try to instantiate one for every locale available on the system
// in order to prevent this sort of bug from cropping up in the future
//
Locale[] locales = Collator.getAvailableLocales();
for (int i = 0; i < locales.length; i++) {
try {
Collator c = Collator.getInstance(locales[i]);
} catch (Exception e) {
errln("Caught " + e + " creating collator for " + locales[i]);
}
}
}
// getCollationKey throws exception for spanish text
// Cannot reproduce this bug on 1.2, however it DOES fail on 1.1.6
//
public void Test4139572() {
//
// Code pasted straight from the bug report
//
// create spanish locale and collator
Locale l = new Locale("es", "es");
Collator col = Collator.getInstance(l);
// this spanish phrase kills it!
col.getCollationKey("Nombre De Objeto");
}
// RuleBasedCollator doesn't use getCollationElementIterator internally
//
public void Test4146160() throws ParseException {
//
// Use a custom collator class whose getCollationElementIterator
// methods increment a count....
//
My4146160Collator.count = 0;
new My4146160Collator().getCollationKey("1");
if (My4146160Collator.count < 1) {
errln("getCollationElementIterator not called");
}
My4146160Collator.count = 0;
new My4146160Collator().compare("1", "2");
if (My4146160Collator.count < 1) {
errln("getCollationElementIterator not called");
}
}
static class My4146160Collator extends RuleBasedCollator {
public My4146160Collator() throws ParseException {
super(Regression.en_us.getRules());
}
public CollationElementIterator getCollationElementIterator(
String text) {
count++;
return super.getCollationElementIterator(text);
}
public CollationElementIterator getCollationElementIterator(
CharacterIterator text) {
count++;
return super.getCollationElementIterator(text);
}
public static int count = 0;
};
// CollationElementIterator.previous broken for expanding char sequences
//
public void Test4179686() throws ParseException {
// Create a collator with a few expanding character sequences in it....
RuleBasedCollator coll = new RuleBasedCollator(en_us.getRules()
+ " & ae ; \u00e4 & AE ; \u00c4"
+ " & oe ; \u00f6 & OE ; \u00d6"
+ " & ue ; \u00fc & UE ; \u00dc");
String text = "T\u00f6ne"; // o-umlaut
CollationElementIterator iter = coll.getCollationElementIterator(text);
Vector elements = new Vector();
int elem;
// Iterate forward and collect all of the elements into a Vector
while ((elem = iter.next()) != iter.NULLORDER) {
elements.addElement(new Integer(elem));
}
// Now iterate backward and make sure they're the same
int index = elements.size() - 1;
while ((elem = iter.previous()) != iter.NULLORDER) {
int expect = ((Integer)elements.elementAt(index)).intValue();
if (elem != expect) {
errln("Mismatch at index " + index
+ ": got " + Integer.toString(elem,16)
+ ", expected " + Integer.toString(expect,16));
}
index--;
}
}
public void Test4244884() throws ParseException {
RuleBasedCollator coll = (RuleBasedCollator)Collator.getInstance(Locale.US);
coll = new RuleBasedCollator(coll.getRules()
+ " & C < ch , cH , Ch , CH < cat < crunchy");
String[] testStrings = new String[] {
"car",
"cave",
"clamp",
"cramp",
"czar",
"church",
"catalogue",
"crunchy",
"dog"
};
for (int i = 1; i < testStrings.length; i++) {
if (coll.compare(testStrings[i - 1], testStrings[i]) >= 0) {
errln("error: \"" + testStrings[i - 1]
+ "\" is greater than or equal to \"" + testStrings[i]
+ "\".");
}
}
}
public void Test4179216() throws ParseException {
// you can position a CollationElementIterator in the middle of
// a contracting character sequence, yielding a bogus collation
// element
RuleBasedCollator coll = (RuleBasedCollator)Collator.getInstance(Locale.US);
coll = new RuleBasedCollator(coll.getRules()
+ " & C < ch , cH , Ch , CH < cat < crunchy");
String testText = "church church catcatcher runcrunchynchy";
CollationElementIterator iter = coll.getCollationElementIterator(
testText);
// test that the "ch" combination works properly
iter.setOffset(4);
int elt4 = CollationElementIterator.primaryOrder(iter.next());
iter.reset();
int elt0 = CollationElementIterator.primaryOrder(iter.next());
iter.setOffset(5);
int elt5 = CollationElementIterator.primaryOrder(iter.next());
if (elt4 != elt0 || elt5 != elt0)
errln("The collation elements at positions 0 (" + elt0 + "), 4 ("
+ elt4 + "), and 5 (" + elt5 + ") don't match.");
// test that the "cat" combination works properly
iter.setOffset(14);
int elt14 = CollationElementIterator.primaryOrder(iter.next());
iter.setOffset(15);
int elt15 = CollationElementIterator.primaryOrder(iter.next());
iter.setOffset(16);
int elt16 = CollationElementIterator.primaryOrder(iter.next());
iter.setOffset(17);
int elt17 = CollationElementIterator.primaryOrder(iter.next());
iter.setOffset(18);
int elt18 = CollationElementIterator.primaryOrder(iter.next());
iter.setOffset(19);
int elt19 = CollationElementIterator.primaryOrder(iter.next());
if (elt14 != elt15 || elt14 != elt16 || elt14 != elt17
|| elt14 != elt18 || elt14 != elt19)
errln("\"cat\" elements don't match: elt14 = " + elt14 + ", elt15 = "
+ elt15 + ", elt16 = " + elt16 + ", elt17 = " + elt17
+ ", elt18 = " + elt18 + ", elt19 = " + elt19);
// now generate a complete list of the collation elements,
// first using next() and then using setOffset(), and
// make sure both interfaces return the same set of elements
iter.reset();
int elt = iter.next();
int count = 0;
while (elt != CollationElementIterator.NULLORDER) {
++count;
elt = iter.next();
}
String[] nextElements = new String[count];
String[] setOffsetElements = new String[count];
int lastPos = 0;
iter.reset();
elt = iter.next();
count = 0;
while (elt != CollationElementIterator.NULLORDER) {
nextElements[count++] = testText.substring(lastPos, iter.getOffset());
lastPos = iter.getOffset();
elt = iter.next();
}
count = 0;
for (int i = 0; i < testText.length(); ) {
iter.setOffset(i);
lastPos = iter.getOffset();
elt = iter.next();
setOffsetElements[count++] = testText.substring(lastPos, iter.getOffset());
i = iter.getOffset();
}
for (int i = 0; i < nextElements.length; i++) {
if (nextElements[i].equals(setOffsetElements[i])) {
logln(nextElements[i]);
} else {
errln("Error: next() yielded " + nextElements[i] + ", but setOffset() yielded "
+ setOffsetElements[i]);
}
}
}
public void Test4216006() throws Exception {
// rule parser barfs on "<\u00e0=a\u0300", and on other cases
// where the same token (after normalization) appears twice in a row
boolean caughtException = false;
try {
RuleBasedCollator dummy = new RuleBasedCollator("\u00e0<a\u0300");
}
catch (ParseException e) {
caughtException = true;
}
if (!caughtException) {
throw new Exception("\"a<a\" collation sequence didn't cause parse error!");
}
RuleBasedCollator collator = new RuleBasedCollator("<\u00e0=a\u0300");
collator.setDecomposition(Collator.FULL_DECOMPOSITION);
collator.setStrength(Collator.IDENTICAL);
String[] tests = {
"a\u0300", "=", "\u00e0",
"\u00e0", "=", "a\u0300"
};
compareArray(collator, tests);
}
public void Test4171974() {
// test French accent ordering more thoroughly
String[] frenchList = {
"\u0075\u0075", // u u
"\u00fc\u0075", // u-umlaut u
"\u01d6\u0075", // u-umlaut-macron u
"\u016b\u0075", // u-macron u
"\u1e7b\u0075", // u-macron-umlaut u
"\u0075\u00fc", // u u-umlaut
"\u00fc\u00fc", // u-umlaut u-umlaut
"\u01d6\u00fc", // u-umlaut-macron u-umlaut
"\u016b\u00fc", // u-macron u-umlaut
"\u1e7b\u00fc", // u-macron-umlaut u-umlaut
"\u0075\u01d6", // u u-umlaut-macron
"\u00fc\u01d6", // u-umlaut u-umlaut-macron
"\u01d6\u01d6", // u-umlaut-macron u-umlaut-macron
"\u016b\u01d6", // u-macron u-umlaut-macron
"\u1e7b\u01d6", // u-macron-umlaut u-umlaut-macron
"\u0075\u016b", // u u-macron
"\u00fc\u016b", // u-umlaut u-macron
"\u01d6\u016b", // u-umlaut-macron u-macron
"\u016b\u016b", // u-macron u-macron
"\u1e7b\u016b", // u-macron-umlaut u-macron
"\u0075\u1e7b", // u u-macron-umlaut
"\u00fc\u1e7b", // u-umlaut u-macron-umlaut
"\u01d6\u1e7b", // u-umlaut-macron u-macron-umlaut
"\u016b\u1e7b", // u-macron u-macron-umlaut
"\u1e7b\u1e7b" // u-macron-umlaut u-macron-umlaut
};
Collator french = Collator.getInstance(Locale.FRENCH);
logln("Testing French order...");
checkListOrder(frenchList, french);
logln("Testing French order without decomposition...");
french.setDecomposition(Collator.NO_DECOMPOSITION);
checkListOrder(frenchList, french);
String[] englishList = {
"\u0075\u0075", // u u
"\u0075\u00fc", // u u-umlaut
"\u0075\u01d6", // u u-umlaut-macron
"\u0075\u016b", // u u-macron
"\u0075\u1e7b", // u u-macron-umlaut
"\u00fc\u0075", // u-umlaut u
"\u00fc\u00fc", // u-umlaut u-umlaut
"\u00fc\u01d6", // u-umlaut u-umlaut-macron
"\u00fc\u016b", // u-umlaut u-macron
"\u00fc\u1e7b", // u-umlaut u-macron-umlaut
"\u01d6\u0075", // u-umlaut-macron u
"\u01d6\u00fc", // u-umlaut-macron u-umlaut
"\u01d6\u01d6", // u-umlaut-macron u-umlaut-macron
"\u01d6\u016b", // u-umlaut-macron u-macron
"\u01d6\u1e7b", // u-umlaut-macron u-macron-umlaut
"\u016b\u0075", // u-macron u
"\u016b\u00fc", // u-macron u-umlaut
"\u016b\u01d6", // u-macron u-umlaut-macron
"\u016b\u016b", // u-macron u-macron
"\u016b\u1e7b", // u-macron u-macron-umlaut
"\u1e7b\u0075", // u-macron-umlaut u
"\u1e7b\u00fc", // u-macron-umlaut u-umlaut
"\u1e7b\u01d6", // u-macron-umlaut u-umlaut-macron
"\u1e7b\u016b", // u-macron-umlaut u-macron
"\u1e7b\u1e7b" // u-macron-umlaut u-macron-umlaut
};
Collator english = Collator.getInstance(Locale.ENGLISH);
logln("Testing English order...");
checkListOrder(englishList, english);
logln("Testing English order without decomposition...");
english.setDecomposition(Collator.NO_DECOMPOSITION);
checkListOrder(englishList, english);
}
private void checkListOrder(String[] sortedList, Collator c) {
// this function uses the specified Collator to make sure the
// passed-in list is already sorted into ascending order
for (int i = 0; i < sortedList.length - 1; i++) {
if (c.compare(sortedList[i], sortedList[i + 1]) >= 0) {
errln("List out of order at element #" + i + ": "
+ prettify(sortedList[i]) + " >= "
+ prettify(sortedList[i + 1]));
}
}
}
// CollationElementIterator set doesn't work propertly with next/prev
public void Test4663220() {
RuleBasedCollator collator = (RuleBasedCollator)Collator.getInstance(Locale.US);
CharacterIterator stringIter = new StringCharacterIterator("fox");
CollationElementIterator iter = collator.getCollationElementIterator(stringIter);
int[] elements_next = new int[3];
logln("calling next:");
for (int i = 0; i < 3; ++i) {
logln("[" + i + "] " + (elements_next[i] = iter.next()));
}
int[] elements_fwd = new int[3];
logln("calling set/next:");
for (int i = 0; i < 3; ++i) {
iter.setOffset(i);
logln("[" + i + "] " + (elements_fwd[i] = iter.next()));
}
for (int i = 0; i < 3; ++i) {
if (elements_next[i] != elements_fwd[i]) {
errln("mismatch at position " + i +
": " + elements_next[i] +
" != " + elements_fwd[i]);
}
}
}
//------------------------------------------------------------------------
// Internal utilities
//
private void compareArray(Collator c, String[] tests) {
for (int i = 0; i < tests.length; i += 3) {
int expect = 0;
if (tests[i+1].equals("<")) {
expect = -1;
} else if (tests[i+1].equals(">")) {
expect = 1;
} else if (tests[i+1].equals("=")) {
expect = 0;
} else {
expect = Integer.decode(tests[i+1]).intValue();
}
int result = c.compare(tests[i], tests[i+2]);
if (sign(result) != sign(expect))
{
errln( i/3 + ": compare(" + prettify(tests[i])
+ " , " + prettify(tests[i+2])
+ ") got " + result + "; expected " + expect);
}
else
{
// Collator.compare worked OK; now try the collation keys
CollationKey k1 = c.getCollationKey(tests[i]);
CollationKey k2 = c.getCollationKey(tests[i+2]);
result = k1.compareTo(k2);
if (sign(result) != sign(expect)) {
errln( i/3 + ": key(" + prettify(tests[i])
+ ").compareTo(key(" + prettify(tests[i+2])
+ ")) got " + result + "; expected " + expect);
errln(" " + prettify(k1) + " vs. " + prettify(k2));
}
}
}
}
private static final int sign(int i) {
if (i < 0) return -1;
if (i > 0) return 1;
return 0;
}
static RuleBasedCollator en_us = (RuleBasedCollator)Collator.getInstance(Locale.US);
String test1 = "XFILE What subset of all possible test cases has the highest probability of detecting the most errors?";
String test2 = "Xf ile What subset of all possible test cases has the lowest probability of detecting the least errors?";
String test3 = "a\u00FCbeck Gr\u00F6\u00DFe L\u00FCbeck";
}