Author: [EMAIL PROTECTED]
Date: Thu Sep 4 14:06:36 2008
New Revision: 3620
Added:
changes/jat/ucd/user/src/com/google/gwt/i18n/client/impl/ucd/CharTableImpl_UCD.java
(contents, props changed)
changes/jat/ucd/user/test/com/google/gwt/emultest/EmulSuiteUCD.gwt.xml
changes/jat/ucd/user/test/com/google/gwt/emultest/java/lang/CharacterUCDTest.java
(contents, props changed)
Modified:
changes/jat/ucd/user/src/com/google/gwt/compression/common/Huffman.java
changes/jat/ucd/user/src/com/google/gwt/i18n/I18N.gwt.xml
changes/jat/ucd/user/src/com/google/gwt/i18n/client/impl/CharTableImpl.java
changes/jat/ucd/user/super/com/google/gwt/emul/java/lang/Character.java
changes/jat/ucd/user/super/com/google/gwt/emul/java/lang/StringBuilder.java
Log:
UCD tables integrated and passing all tests.
Modified:
changes/jat/ucd/user/src/com/google/gwt/compression/common/Huffman.java
==============================================================================
--- changes/jat/ucd/user/src/com/google/gwt/compression/common/Huffman.java
(original)
+++ changes/jat/ucd/user/src/com/google/gwt/compression/common/Huffman.java
Thu Sep 4 14:06:36 2008
@@ -23,7 +23,7 @@
import java.util.PriorityQueue;
/**
- * TODO(jat): Class description here.
+ * Class for encoding/decoding huffman-compressed data.
*/
public class Huffman {
@@ -256,7 +256,10 @@
}
/**
- * TODO(jat): Class description here.
+ * Huffman encoding.
+ *
+ * Generates the canonical encoding of code lengths and codewords based
on
+ * the frequencies of the literal symbols.
*/
public static class Encode {
Modified: changes/jat/ucd/user/src/com/google/gwt/i18n/I18N.gwt.xml
==============================================================================
--- changes/jat/ucd/user/src/com/google/gwt/i18n/I18N.gwt.xml (original)
+++ changes/jat/ucd/user/src/com/google/gwt/i18n/I18N.gwt.xml Thu Sep 4
14:06:36 2008
@@ -73,4 +73,21 @@
<generate-with class="com.google.gwt.i18n.rebind.LocaleInfoGenerator">
<when-type-is
class="com.google.gwt.i18n.client.impl.LocaleInfoImpl" />
</generate-with>
+
+ <!-- This property defines how the various Character properties (such as
-->
+ <!-- isLetter(), toLowerCase(), etc) are handled. The default
-->
+ <!-- implementation only works with with US-ASCII characters in general,
-->
+ <!-- but does not pull in large tables. To get full Unicode support,
-->
+ <!-- add the following to your module.gwt.xml file:
-->
+ <!-- <extend-property name="charTables" values="ucd"/>
-->
+ <!-- <set-property name="charTables" value="ucd"/>
-->
+ <!-- Note that this will pull in the decompression code if any of the
-->
+ <!-- tables are used, and relatively small tables for each property that
-->
+ <!-- is
used. -->
+ <define-property name="charTables" values="ascii" />
+
+ <replace-with
class="com.google.gwt.i18n.client.impl.ucd.CharTableImpl_UCD">
+ <when-type-is class="com.google.gwt.i18n.client.impl.CharTableImpl"/>
+ <when-property-is name="charTables" value="ucd"/>
+ </replace-with>
</module>
Modified:
changes/jat/ucd/user/src/com/google/gwt/i18n/client/impl/CharTableImpl.java
==============================================================================
---
changes/jat/ucd/user/src/com/google/gwt/i18n/client/impl/CharTableImpl.java
(original)
+++
changes/jat/ucd/user/src/com/google/gwt/i18n/client/impl/CharTableImpl.java
Thu Sep 4 14:06:36 2008
@@ -37,7 +37,7 @@
return Instance.instance;
}
- public int getDirectionality(int cp) {
+ public byte getDirectionality(@SuppressWarnings("unused") int cp) {
return Character.DIRECTIONALITY_LEFT_TO_RIGHT;
}
@@ -63,6 +63,37 @@
}
public int getType(int cp) {
+ if (isLetter(cp)) {
+ if (isLowerCase(cp)) {
+ return Character.LOWERCASE_LETTER;
+ }
+ if (isUpperCase(cp)) {
+ return Character.UPPERCASE_LETTER;
+ }
+ if (Character.isTitleCase(cp)) {
+ return Character.TITLECASE_LETTER;
+ }
+ return Character.OTHER_LETTER;
+ }
+ if (isDigit(cp)
+ // US-ASCII digits taken care of in isDigit
+ // || (cp >= '0' && cp <= '9')
+ // Arabic-Indic digits
+ || (cp >= 0x660 && cp <= 0x669)
+ // Extended Arabic-Indic digits
+ || (cp >= 0x6F0 && cp <= 0x6F9)
+ // Devenagari digits
+ || (cp >= 0x966 && cp <= 0x96F)
+ // Full-width digits
+ || (cp >= 0xFF10 && cp <= 0xFF19)) {
+ return Character.DECIMAL_DIGIT_NUMBER;
+ }
+ if (cp < 32 || (cp >= 0x7F && cp <= 0x9F)) {
+ return Character.CONTROL;
+ }
+ if (cp == 32 || cp == 0xA0) {
+ return Character.SPACE_SEPARATOR;
+ }
return Character.UNASSIGNED;
}
@@ -70,7 +101,6 @@
return cp >= Character.MIN_CODE_POINT && cp <=
Character.MAX_CODE_POINT;
}
-
public native boolean isDigit(int cp) /*-{
if (cp < 0 || cp > 0xFFFF) {
return false;
@@ -132,6 +162,10 @@
public boolean isUpperCase(int cp) {
return toUpperCase(cp) == cp && isLetter(cp);
+ }
+
+ public boolean supportsFullUnicode() {
+ return false;
}
public native int toLowerCase(int cp) /*-{
Added:
changes/jat/ucd/user/src/com/google/gwt/i18n/client/impl/ucd/CharTableImpl_UCD.java
==============================================================================
--- (empty file)
+++
changes/jat/ucd/user/src/com/google/gwt/i18n/client/impl/ucd/CharTableImpl_UCD.java
Thu Sep 4 14:06:36 2008
@@ -0,0 +1,158 @@
+/*
+ * Copyright 2008 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may
not
+ * use this file except in compliance with the License. You may obtain a
copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
under
+ * the License.
+ */
+package com.google.gwt.i18n.client.impl.ucd;
+
+import com.google.gwt.i18n.client.impl.CharTableImpl;
+
+/**
+ * @author [EMAIL PROTECTED] (Your Name Here)
+ *
+ */
+public class CharTableImpl_UCD extends CharTableImpl {
+
+ @Override
+ public byte getDirectionality(int cp) {
+ return (byte) DirectionalityTable.getDirectionality(cp);
+ }
+
+ @Override
+ public int getNumericValue(int codePoint) {
+ return NumericValueTable.getNumericValue(codePoint);
+ }
+
+ @Override
+ public int getType(int codePoint) {
+ return TypeTable.getType(codePoint);
+ }
+
+ @Override
+ public boolean isDefined(int codePoint) {
+ return super.isDefined(codePoint);
+ }
+
+ @Override
+ public boolean isDigit(int codePoint) {
+ return DigitTable.isDigit(codePoint);
+ }
+
+ @Override
+ public boolean isIdentifierIgnorable(int codePoint) {
+ return IdentifierIgnorableTable.isIdentifierIgnorable(codePoint);
+ }
+
+ @Override
+ public boolean isJavaIdentifierPart(int codePoint) {
+ return JavaIdentifierPartTable.isJavaIdentifierPart(codePoint)
+ ^ isLetterOrDigit(codePoint);
+ }
+
+ @Override
+ public boolean isJavaIdentifierStart(int codePoint) {
+ return JavaIdentifierStartTable.isJavaIdentifierStart(codePoint)
+ ^ isLetter(codePoint);
+ }
+
+ @Override
+ public boolean isLetter(int codePoint) {
+ return LetterTable.isLetter(codePoint);
+ }
+
+ @Override
+ public boolean isLetterOrDigit(int codePoint) {
+ return isLetter(codePoint) | isDigit(codePoint);
+ }
+
+ @Override
+ public boolean isLowerCase(int codePoint) {
+ return LowerCaseTable.isLowerCase(codePoint);
+ }
+
+ @Override
+ public boolean isMirrored(int codePoint) {
+ return MirroredTable.isMirrored(codePoint);
+ }
+
+ @Override
+ public boolean isSpaceChar(int codePoint) {
+ return SpaceCharTable.isSpaceChar(codePoint);
+ }
+
+ @Override
+ public boolean isUnicodeIdentifierPart(int codePoint) {
+ return UnicodeIdentifierPartTable.isUnicodeIdentifierPart(codePoint)
+ ^ isLetterOrDigit(codePoint);
+ }
+
+ @Override
+ public boolean isUnicodeIdentifierStart(int codePoint) {
+ return UnicodeIdentifierStartTable.isUnicodeIdentifierStart(codePoint)
+ ^ isLetter(codePoint);
+ }
+
+ @Override
+ public boolean isUpperCase(int codePoint) {
+ return UpperCaseTable.isUpperCase(codePoint);
+ }
+
+ @Override
+ public boolean supportsFullUnicode() {
+ return true;
+ }
+
+ @Override
+ public int toLowerCase(int codePoint) {
+ return ToLowerCaseTable.toLowerCase(codePoint);
+ }
+
+ @Override
+ public String toLowerCase(String str) {
+ // TODO(jat): handle special cases, such as locale and context
+ StringBuilder buf = new StringBuilder();
+ int n = str.length();
+ int i = 0;
+ while (i < n) {
+ int cp = str.codePointAt(i);
+ i += Character.charCount(cp);
+ buf.appendCodePoint(toLowerCase(cp));
+ }
+ return buf.toString();
+ }
+
+ @Override
+ public int toTitleCase(int codePoint) {
+ return ToTitleCaseTable.toTitleCase(codePoint);
+ }
+
+ @Override
+ public int toUpperCase(int codePoint) {
+ return ToUpperCaseTable.toUpperCase(codePoint);
+ }
+
+ @Override
+ public String toUpperCase(String str) {
+ // TODO(jat): handle special cases, such as locale and context
+ StringBuilder buf = new StringBuilder();
+ int n = str.length();
+ int i = 0;
+ while (i < n) {
+ int cp = str.codePointAt(i);
+ i += Character.charCount(cp);
+ buf.appendCodePoint(toUpperCase(cp));
+ }
+ return buf.toString();
+ }
+
+}
Modified:
changes/jat/ucd/user/super/com/google/gwt/emul/java/lang/Character.java
==============================================================================
--- changes/jat/ucd/user/super/com/google/gwt/emul/java/lang/Character.java
(original)
+++ changes/jat/ucd/user/super/com/google/gwt/emul/java/lang/Character.java
Thu Sep 4 14:06:36 2008
@@ -119,7 +119,7 @@
public static final byte DIRECTIONALITY_UNDEFINED = -1;
public static final byte DIRECTIONALITY_LEFT_TO_RIGHT = 0;
- public static final byte DIRECTONALITY_RIGHT_TO_LEFT = 1;
+ public static final byte DIRECTIONALITY_RIGHT_TO_LEFT = 1;
public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC = 2;
public static final byte DIRECTIONALITY_EUROPEAN_NUMBER = 3;
public static final byte DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR = 4;
@@ -262,7 +262,7 @@
}
}
- public static int getDirectionality(int cp) {
+ public static byte getDirectionality(int cp) {
return CharTableImpl.instance().getDirectionality(cp);
}
@@ -364,7 +364,7 @@
return isHighSurrogate(highSurrogate) && isLowSurrogate(lowSurrogate);
}
- public static boolean isTitleCase(int cp) {
+ public static boolean isTitleCase(@SuppressWarnings("unused") int cp) {
return false;
}
@@ -541,7 +541,7 @@
/**
* Computes the high surrogate character of the UTF16 representation of a
- * non-BMP code point. See [EMAIL PROTECTED] getLowSurrogate}.
+ * non-BMP code point. See [EMAIL PROTECTED] #getLowSurrogate}.
*
* @param codePoint requested codePoint, required to be >=
* MIN_SUPPLEMENTARY_CODE_POINT
@@ -554,7 +554,7 @@
/**
* Computes the low surrogate character of the UTF16 representation of a
- * non-BMP code point. See [EMAIL PROTECTED] getHighSurrogate}.
+ * non-BMP code point. See [EMAIL PROTECTED] #getHighSurrogate}.
*
* @param codePoint requested codePoint, required to be >=
* MIN_SUPPLEMENTARY_CODE_POINT
Modified:
changes/jat/ucd/user/super/com/google/gwt/emul/java/lang/StringBuilder.java
==============================================================================
---
changes/jat/ucd/user/super/com/google/gwt/emul/java/lang/StringBuilder.java
(original)
+++
changes/jat/ucd/user/super/com/google/gwt/emul/java/lang/StringBuilder.java
Thu Sep 4 14:06:36 2008
@@ -121,12 +121,16 @@
}
}
return this;
- };
+ }
public StringBuilder append(StringBuffer x) {
return append(String.valueOf(x));
}
+ public StringBuilder appendCodePoint(int codePoint) {
+ return append(Character.toChars(codePoint));
+ }
+
/**
* This implementation does not track capacity; always returns
* [EMAIL PROTECTED] Integer#MAX_VALUE}.
@@ -139,6 +143,18 @@
return toString().charAt(index);
}
+ public int codePointAt(int index) {
+ return toString().codePointAt(index);
+ }
+
+ public int codePointBefore(int index) {
+ return toString().codePointBefore(index);
+ }
+
+ public int codePointCount(int beginIndex, int endIndex) {
+ return toString().codePointCount(beginIndex, endIndex);
+ }
+
public StringBuilder delete(int start, int end) {
return replace(start, end, "");
}
@@ -230,6 +246,10 @@
public int length() {
return stringLength;
+ }
+
+ public int offsetByCodePoints(int index, int codePointOffset) {
+ return toString().offsetByCodePoints(index, codePointOffset);
}
public StringBuilder replace(int start, int end, String toInsert) {
Added:
changes/jat/ucd/user/test/com/google/gwt/emultest/EmulSuiteUCD.gwt.xml
==============================================================================
--- (empty file)
+++ changes/jat/ucd/user/test/com/google/gwt/emultest/EmulSuiteUCD.gwt.xml
Thu Sep 4 14:06:36 2008
@@ -0,0 +1,19 @@
+<!--
-->
+<!-- Copyright 2008 Google
Inc. -->
+<!-- Licensed under the Apache License, Version 2.0 (the "License");
you -->
+<!-- may not use this file except in compliance with the License. You
may -->
+<!-- may obtain a copy of the License
at -->
+<!--
-->
+<!--
http://www.apache.org/licenses/LICENSE-2.0 -->
+<!--
-->
+<!-- Unless required by applicable law or agreed to in writing,
software -->
+<!-- distributed under the License is distributed on an "AS IS"
BASIS, -->
+<!-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
or -->
+<!-- implied. License for the specific language governing permissions
and -->
+<!-- limitations under the
License. -->
+
+<module>
+ <inherits name='com.google.gwt.emultest.EmulSuite'/>
+ <extend-property name="charTables" values="ucd"/>
+ <set-property name="charTables" value="ucd"/>
+</module>
Added:
changes/jat/ucd/user/test/com/google/gwt/emultest/java/lang/CharacterUCDTest.java
==============================================================================
--- (empty file)
+++
changes/jat/ucd/user/test/com/google/gwt/emultest/java/lang/CharacterUCDTest.java
Thu Sep 4 14:06:36 2008
@@ -0,0 +1,365 @@
+/*
+ * Copyright 2008 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may
not
+ * use this file except in compliance with the License. You may obtain a
copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
under
+ * the License.
+ */
+package com.google.gwt.emultest.java.lang;
+
+import com.google.gwt.junit.client.GWTTestCase;
+
+/**
+ * Tests for java.lang.Character.
+ */
+public class CharacterUCDTest extends GWTTestCase {
+
+ private static class CharSequenceAdapter implements CharSequence {
+ private char[] charArray;
+ private int start;
+ private int end;
+
+ public CharSequenceAdapter(char[] charArray) {
+ this(charArray, 0, charArray.length);
+ }
+
+ public CharSequenceAdapter(char[] charArray, int start, int end) {
+ this.charArray = charArray;
+ this.start = start;
+ this.end = end;
+ }
+
+ public char charAt(int index) {
+ return charArray[index + start];
+ }
+
+ public int length() {
+ return end - start;
+ }
+
+ public java.lang.CharSequence subSequence(int start, int end) {
+ return new CharSequenceAdapter(charArray, this.start + start,
+ this.start + end);
+ }
+ }
+
+
+ /**
+ * Helper class which applies some arbitrary char mutation function
+ * to a string and returns it.
+ */
+ public abstract class Changer {
+ String original;
+
+ public Changer(String o) {
+ original = o;
+ }
+
+ public abstract char change(char c);
+
+ public String changed() {
+ StringBuffer buf = new StringBuffer();
+ for (int i = 0; i < original.length(); i++) {
+ buf.append(change(original.charAt(i)));
+ }
+ return buf.toString();
+ }
+ }
+ /**
+ * Helper class which collects the set of characters which pass some
+ * arbitrary boolean function.
+ */
+ public abstract class Judge {
+ String original;
+
+ public Judge(String o) {
+ original = o;
+ }
+
+ public String allPass() {
+ StringBuffer buf = new StringBuffer();
+ for (int i = 0; i < original.length(); i++) {
+ if (pass(original.charAt(i))) {
+ buf.append(original.charAt(i));
+ }
+ }
+ return buf.toString();
+ }
+
+ public abstract boolean pass(char c);
+ }
+
+ class LowerCaseJudge extends Judge {
+ public LowerCaseJudge(String s) {
+ super(s);
+ }
+
+ public boolean pass(char c) {
+ return Character.isLowerCase(c);
+ }
+ }
+
+ class UpperCaseJudge extends Judge {
+ public UpperCaseJudge(String s) {
+ super(s);
+ }
+
+ public boolean pass(char c) {
+ return Character.isUpperCase(c);
+ }
+ }
+
+ public static String allChars;
+
+ public static final int NUM_CHARS_HANDLED = 127;
+
+ static {
+ StringBuffer b = new StringBuffer();
+ for (char c = 0; c < NUM_CHARS_HANDLED; c++) {
+ b.append(c);
+ }
+ allChars = b.toString();
+ }
+
+ Judge digitJudge = new Judge(allChars) {
+ public boolean pass(char c) {
+ return Character.isDigit(c);
+ }
+ };
+ Judge letterJudge = new Judge(allChars) {
+ public boolean pass(char c) {
+ return Character.isLetter(c);
+ }
+ };
+ Judge letterOrDigitJudge = new Judge(allChars) {
+ public boolean pass(char c) {
+ return Character.isLetterOrDigit(c);
+ }
+ };
+ Changer lowerCaseChanger = new Changer(allChars) {
+ public char change(char c) {
+ return Character.toLowerCase(c);
+ }
+ };
+ Judge lowerCaseJudge = new LowerCaseJudge(allChars);
+ Judge spaceJudge = new Judge(allChars) {
+ @SuppressWarnings("deprecation") // Character.isSpace()
+ public boolean pass(char c) {
+ return Character.isSpace(c); // suppress deprecation
+ }
+ };
+ Changer upperCaseChanger = new Changer(allChars) {
+ public char change(char c) {
+ return Character.toUpperCase(c);
+ }
+ };
+ Judge upperCaseJudge = new UpperCaseJudge(allChars);
+
+ @Override
+ public String getModuleName() {
+ return "com.google.gwt.emultest.EmulSuiteUCD";
+ }
+
+ public void testCharValue() {
+ assertEquals(new Character((char) 32).charValue(), (char) 32);
+ }
+
+ public void testCodePoint() {
+ assertEquals(1, Character.charCount(65));
+ assertEquals(2,
Character.charCount(Character.MIN_SUPPLEMENTARY_CODE_POINT));
+ char[] testPlain = new char[] { 'C', 'A', 'T' };
+ char[] testUnicode = new char[] { 'C', '\uD801', '\uDF00', 'T' };
+ CharSequence plainSequence = new CharSequenceAdapter(testPlain);
+ CharSequence unicodeSequence = new CharSequenceAdapter(testUnicode);
+ assertEquals(65, Character.codePointAt(testPlain, 1));
+ assertEquals(65, Character.codePointAt(plainSequence, 1));
+ assertEquals("codePointAt fails on surrogate pair", 67328,
+ Character.codePointAt(testUnicode, 1));
+ assertEquals("codePointAt fails on surrogate pair", 67328,
+ Character.codePointAt(unicodeSequence, 1));
+ assertEquals("codePointAt fails on first char of surrogate pair",
0xD801,
+ Character.codePointAt(testUnicode, 1, 2));
+ assertEquals(65, Character.codePointBefore(testPlain, 2));
+ assertEquals(65, Character.codePointBefore(plainSequence, 2));
+ assertEquals("codePointBefore fails on surrogate pair", 67328,
+ Character.codePointBefore(testUnicode, 3));
+ assertEquals("codePointBefore fails on surrogate pair", 67328,
+ Character.codePointBefore(unicodeSequence, 3));
+ assertEquals("codePointBefore fails on second char of surrogate pair",
+ 0xDF00, Character.codePointBefore(testUnicode, 3, 2));
+ assertEquals("codePointCount(plain): ", 3,
+ Character.codePointCount(testPlain, 0, 3));
+ assertEquals("codePointCount(plain): ", 3,
+ Character.codePointCount(plainSequence, 0, 3));
+ assertEquals("codePointCount(unicode): ", 3,
+ Character.codePointCount(testUnicode, 0, 4));
+ assertEquals("codePointCount(unicode): ", 3,
+ Character.codePointCount(unicodeSequence, 0, 4));
+ assertEquals(1, Character.codePointCount(testPlain, 1, 1));
+ assertEquals(1, Character.codePointCount(plainSequence, 1, 2));
+ assertEquals(1, Character.codePointCount(testUnicode, 1, 2));
+ assertEquals(1, Character.codePointCount(unicodeSequence, 1, 3));
+ assertEquals(2, Character.codePointCount(testUnicode, 2, 2));
+ assertEquals(2, Character.codePointCount(unicodeSequence, 2, 4));
+ assertEquals(1, Character.offsetByCodePoints(testUnicode, 0, 4, 0, 1));
+ assertEquals(1, Character.offsetByCodePoints(unicodeSequence, 0, 1));
+ assertEquals("offsetByCodePoints(1,1): ", 3,
+ Character.offsetByCodePoints(testUnicode, 0, 4, 1, 1));
+ assertEquals("offsetByCodePoints(1,1): ", 3,
+ Character.offsetByCodePoints(unicodeSequence, 1, 1));
+ assertEquals("offsetByCodePoints(2,1): ", 3,
+ Character.offsetByCodePoints(testUnicode, 0, 4, 2, 1));
+ assertEquals("offsetByCodePoints(2,1): ", 3,
+ Character.offsetByCodePoints(unicodeSequence, 2, 1));
+ assertEquals(4, Character.offsetByCodePoints(testUnicode, 0, 4, 3, 1));
+ assertEquals(4, Character.offsetByCodePoints(unicodeSequence, 3, 1));
+ assertEquals(1, Character.offsetByCodePoints(testUnicode, 0, 4, 2,
-1));
+ assertEquals(1, Character.offsetByCodePoints(unicodeSequence, 2, -1));
+ assertEquals(1, Character.offsetByCodePoints(testUnicode, 0, 4, 3,
-1));
+ assertEquals(1, Character.offsetByCodePoints(unicodeSequence, 3, -1));
+ assertEquals("offsetByCodePoints(4.-1): ", 3,
+ Character.offsetByCodePoints(testUnicode, 0, 4, 4, -1));
+ assertEquals("offsetByCodePoints(4.-1): ", 3,
+ Character.offsetByCodePoints(unicodeSequence, 4, -1));
+ assertEquals(0, Character.offsetByCodePoints(testUnicode, 0, 4, 3,
-2));
+ assertEquals(0, Character.offsetByCodePoints(unicodeSequence, 3, -2));
+ char[] nonBmpChar = new char[] { '\uD800', '\uDF46' };
+ assertEquals(0x10346, Character.codePointAt(nonBmpChar, 0));
+ assertEquals(1, Character.codePointCount(nonBmpChar, 0, 2));
+ }
+
+ public void testCompareTo() {
+ assertTrue(Character.valueOf('A').compareTo('B') < 0);
+ assertTrue(Character.valueOf('B').compareTo('A') > 0);
+ assertTrue(Character.valueOf('C').compareTo('C') == 0);
+ assertTrue(Character.valueOf('\uA001').compareTo('\uA000') > 0);
+ }
+
+ public void testConstructor() {
+ assertEquals(new Character((char) 32), new Character(' '));
+ }
+
+ public void testDigit() {
+ assertEquals("wrong number of digits", 10,
digitJudge.allPass().length());
+ }
+
+ public void testSurrogates() {
+ assertFalse(Character.isHighSurrogate('\uDF46'));
+ assertTrue(Character.isLowSurrogate('\uDF46'));
+ assertTrue(Character.isHighSurrogate('\uD800'));
+ assertFalse(Character.isLowSurrogate('\uD800'));
+ assertFalse(Character.isHighSurrogate('X'));
+ assertFalse(Character.isLowSurrogate('X'));
+ assertTrue(Character.isSurrogatePair('\uD800', '\uDF46'));
+ assertFalse(Character.isSurrogatePair('\uDF46', '\uD800'));
+ assertFalse(Character.isSurrogatePair('A', '\uDF46'));
+ assertFalse(Character.isSurrogatePair('\uD800', 'A'));
+ char[] chars = Character.toChars(0x10346);
+ assertEquals(0xD800, chars[0]);
+ assertEquals(0xDF46, chars[1]);
+ assertEquals(2, Character.toChars(67328, chars, 0));
+ assertEquals(0xD801, chars[0]);
+ assertEquals(0xDF00, chars[1]);
+ assertEquals(1, Character.toChars(65, chars, 0));
+ assertEquals('A', chars[0]);
+ assertTrue(Character.isSupplementaryCodePoint(0x10346));
+ assertFalse(Character.isSupplementaryCodePoint(65));
+ assertTrue(Character.isValidCodePoint(0x10346));
+ assertTrue(Character.isValidCodePoint(65));
+ assertFalse(Character.isValidCodePoint(0x1FFFFFFF));
+ assertEquals(0x10346, Character.toCodePoint('\uD800', '\uDF46'));
+ }
+
+ public void testLetter() {
+ assertEquals("wrong number of letters", 52,
letterJudge.allPass().length());
+ }
+
+ public void testLetterOrDigit() {
+ assertEquals("wrong number of letters", 62,
+ letterOrDigitJudge.allPass().length());
+ }
+
+ public void testLowerCase() {
+ assertEquals("wrong number of lowercase letters", 26,
+ lowerCaseJudge.allPass().length());
+ assertEquals("wrong number of lowercase letters after toLowerCase", 52,
+ new LowerCaseJudge(lowerCaseChanger.changed()).allPass().length());
+ }
+
+ public void testSpace() {
+ assertEquals("wrong number of spaces", 5,
spaceJudge.allPass().length());
+ }
+
+ public void testToFromDigit() {
+ for (int i = 0; i < 16; i++) {
+ assertEquals(i, Character.digit(Character.forDigit(i, 16), 16));
+ }
+ assertEquals(1, Character.digit('1', 10));
+ assertEquals('9', Character.forDigit(9, 10));
+ assertEquals(-1, Character.digit('7', 6));
+ assertEquals(-1, Character.digit('8', 8));
+ assertEquals(-1, Character.digit('A', 10));
+ }
+
+ public void testToString() {
+ assertEquals(" ", new Character((char) 32).toString());
+ }
+
+ public void testUCD() {
+ assertTrue(Character.isTitleCase(0x1C5));
+ assertFalse(Character.isTitleCase(0x1C4));
+ assertEquals(0x1C4, Character.toUpperCase(0x1C5));
+ assertEquals(0x1C4, Character.toUpperCase(0x1C6));
+ assertEquals(0x1C5, Character.toTitleCase(0x1C4));
+ assertEquals(0x1C5, Character.toTitleCase(0x1C5));
+ assertEquals(0x1C6, Character.toLowerCase(0x1C4));
+ assertEquals(0x1C6, Character.toLowerCase(0x1C5));
+ assertEquals(0x1C4, Character.toUpperCase(0x1C5));
+ assertTrue(Character.isLowerCase(0x3BF));
+ assertTrue(Character.isLowerCase(0xFF));
+ assertTrue(Character.isUpperCase(0xCE));
+ assertTrue(Character.isMirrored('('));
+ assertTrue(Character.isMirrored(']'));
+ assertTrue(Character.isMirrored('{'));
+ assertTrue(Character.isMirrored('>'));
+ assertTrue(Character.isMirrored(0xAB));
+ assertTrue(Character.isMirrored(0xBB));
+ assertFalse(Character.isMirrored('A'));
+ assertEquals(Character.DIRECTIONALITY_RIGHT_TO_LEFT,
+ Character.getDirectionality(0x5D8));
+ assertEquals(Character.UPPERCASE_LETTER, Character.getType('A'));
+ assertEquals(Character.UPPERCASE_LETTER, Character.getType(0x14C));
+ assertEquals(Character.UPPERCASE_LETTER, Character.getType(0x1F48));
+ assertEquals(Character.LOWERCASE_LETTER, Character.getType('z'));
+ assertEquals(Character.LOWERCASE_LETTER, Character.getType(0x14D));
+ assertEquals(Character.LOWERCASE_LETTER, Character.getType(0x1F50));
+ assertEquals(Character.TITLECASE_LETTER, Character.getType(0x1C5));
+ assertEquals(50, Character.getNumericValue(0x216C));
+ assertEquals(0, Character.getNumericValue('0'));
+ assertEquals(9, Character.getNumericValue('9'));
+ assertEquals(10, Character.getNumericValue('a'));
+ assertEquals(10, Character.getNumericValue('A'));
+ assertEquals(1, Character.getNumericValue(0x661));
+ assertEquals(9000, Character.getNumericValue(0x1012A));
+ assertEquals(-1, Character.getNumericValue('['));
+ }
+
+ public void testUpperCase() {
+ assertEquals("wrong number of uppercase letters", 26,
+ upperCaseJudge.allPass().length());
+ assertEquals("wrong number of uppercase letters after toUpperCase", 52,
+ new UpperCaseJudge(upperCaseChanger.changed()).allPass().length());
+ }
+
+ public void testValueOf() {
+ assertEquals('A', Character.valueOf('A').charValue());
+ }
+}
--~--~---------~--~----~------------~-------~--~----~
http://groups.google.com/group/Google-Web-Toolkit-Contributors
-~----------~----~----~----~------~----~------~--~---
