/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 tests.api.java.nio.charset;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;
import java.nio.charset.CoderResult;
import java.nio.charset.IllegalCharsetNameException;
import java.nio.charset.UnsupportedCharsetException;
import java.nio.charset.spi.CharsetProvider;
import java.security.Permission;
import java.util.Iterator;
import java.util.Locale;
import java.util.SortedMap;
import java.util.Vector;
import junit.framework.TestCase;
/**
* Test class java.nio.Charset.
*/
public class CharsetTest extends TestCase {
static MockCharset charset1 = new MockCharset("mockCharset00",
new String[] { "mockCharset01", "mockCharset02" });
static MockCharset charset2 = new MockCharset("mockCharset10",
new String[] { "mockCharset11", "mockCharset12" });
/*
* @see TestCase#setUp()
*/
protected void setUp() throws Exception {
super.setUp();
}
/*
* @see TestCase#tearDown()
*/
protected void tearDown() throws Exception {
super.tearDown();
}
/*
* Test the required 6 charsets are supported.
*/
public void testRequiredCharsetSupported() {
assertTrue(Charset.isSupported("US-ASCII"));
assertTrue(Charset.isSupported("ASCII"));
assertTrue(Charset.isSupported("ISO-8859-1"));
assertTrue(Charset.isSupported("ISO8859_1"));
assertTrue(Charset.isSupported("UTF-8"));
assertTrue(Charset.isSupported("UTF8"));
assertTrue(Charset.isSupported("UTF-16"));
assertTrue(Charset.isSupported("UTF-16BE"));
assertTrue(Charset.isSupported("UTF-16LE"));
Charset c1 = Charset.forName("US-ASCII");
assertEquals("US-ASCII", Charset.forName("US-ASCII").name());
assertEquals("US-ASCII", Charset.forName("ASCII").name());
assertEquals("ISO-8859-1", Charset.forName("ISO-8859-1").name());
assertEquals("ISO-8859-1", Charset.forName("ISO8859_1").name());
assertEquals("UTF-8", Charset.forName("UTF-8").name());
assertEquals("UTF-8", Charset.forName("UTF8").name());
assertEquals("UTF-16", Charset.forName("UTF-16").name());
assertEquals("UTF-16BE", Charset.forName("UTF-16BE").name());
assertEquals("UTF-16LE", Charset.forName("UTF-16LE").name());
assertNotSame(Charset.availableCharsets(), Charset.availableCharsets());
// assertSame(Charset.forName("US-ASCII"), Charset.availableCharsets()
// .get("US-ASCII"));
// assertSame(Charset.forName("US-ASCII"), c1);
assertTrue(Charset.availableCharsets().containsKey("US-ASCII"));
assertTrue(Charset.availableCharsets().containsKey("ISO-8859-1"));
assertTrue(Charset.availableCharsets().containsKey("UTF-8"));
assertTrue(Charset.availableCharsets().containsKey("UTF-16"));
assertTrue(Charset.availableCharsets().containsKey("UTF-16BE"));
assertTrue(Charset.availableCharsets().containsKey("UTF-16LE"));
}
/*
* Test the method isSupported(String) with null.
*/
public void testIsSupported_Null() {
try {
Charset.isSupported(null);
fail("Should throw IllegalArgumentException!");
} catch (IllegalArgumentException e) {
// expected
}
}
/*
* Test the method isSupported(String) with empty string.
*
*/
public void testIsSupported_EmptyString() {
try {
Charset.isSupported("");
} catch (IllegalArgumentException e) {
// FIXME: Commented out since RI does throw IAE
// fail("Should not throw IllegalArgumentException!");
}
}
/*
* Test the method isSupported(String) with a string starting with ".".
*
*/
public void testIsSupported_InvalidInitialCharacter() {
try {
Charset.isSupported(".char");
} catch (IllegalArgumentException e) {
fail("Should not throw IllegalArgumentException!");
}
}
/*
* Test the method isSupported(String) with illegal charset name.
*/
public void testIsSupported_IllegalName() {
try {
Charset.isSupported(" ///#$$");
fail("Should throw IllegalCharsetNameException!");
} catch (IllegalCharsetNameException e) {
// expected
}
}
/*
* Test the method isSupported(String) with not supported charset name.
*/
public void testIsSupported_NotSupported() {
assertFalse(Charset.isSupported("impossible"));
}
/*
* Test the method forName(String) with null.
*/
public void testForName_Null() {
try {
Charset.forName(null);
fail("Should throw IllegalArgumentException!");
} catch (IllegalArgumentException e) {
// expected
}
}
/*
* Test the method forName(String) with empty string.
*/
public void testForName_EmptyString() {
try {
Charset.forName("");
fail("Should throw IllegalArgumentException!");
} catch (IllegalArgumentException e) {
// expected
}
}
/*
* Test the method forName(String) with a string starting with ".".
*/
public void testForName_InvalidInitialCharacter() {
try {
Charset.forName(".char");
fail("Should throw IllegalArgumentException!");
} catch (IllegalArgumentException e) {
// expected
}
}
/*
* Test the method forName(String) with illegal charset name.
*/
public void testForName_IllegalName() {
try {
Charset.forName(" ///#$$");
fail("Should throw IllegalCharsetNameException!");
} catch (IllegalCharsetNameException e) {
// expected
}
}
/*
* Test the method forName(String) with not supported charset name.
*/
public void testForName_NotSupported() {
try {
Charset.forName("impossible");
fail("Should throw UnsupportedCharsetException!");
} catch (UnsupportedCharsetException e) {
// expected
}
}
/*
* Test the constructor with normal parameter values.
*/
public void testConstructor_Normal() {
final String mockName = "mockChar1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.:-_";
MockCharset c = new MockCharset(mockName, new String[] { "mock" });
assertEquals(mockName, c.name());
assertEquals(mockName, c.displayName());
assertEquals(mockName, c.displayName(Locale.getDefault()));
assertEquals("mock", c.aliases().toArray()[0]);
assertEquals(1, c.aliases().toArray().length);
}
/*
* Test the constructor with empty canonical name.
*
*/
public void testConstructor_EmptyCanonicalName() {
try {
new MockCharset("", new String[0]);
} catch (IllegalCharsetNameException e) {
// FIXME: Commented out since RI does throw IAE
// fail("Should not throw IllegalArgumentException!");
}
}
/*
* Test the constructor with illegal canonical name: starting with neither a
* digit nor a letter.
*
*/
public void testConstructor_IllegalCanonicalName_Initial() {
try {
new MockCharset("-123", new String[] { "mock" });
} catch (IllegalCharsetNameException e) {
fail("Should not throw IllegalArgumentException!");
}
}
/*
* Test the constructor with illegal canonical name, illegal character in
* the middle.
*/
public void testConstructor_IllegalCanonicalName_Middle() {
try {
new MockCharset("1%%23", new String[] { "mock" });
fail("Should throw IllegalCharsetNameException!");
} catch (IllegalCharsetNameException e) {
// expected
}
try {
new MockCharset("1//23", new String[] { "mock" });
fail("Should throw IllegalCharsetNameException!");
} catch (IllegalCharsetNameException e) {
// expected
}
}
/*
* Test the constructor with null canonical name.
*/
public void testConstructor_NullCanonicalName() {
try {
MockCharset c = new MockCharset(null, new String[] { "mock" });
fail("Should throw NullPointerException!");
} catch (NullPointerException e) {
// expected
}
}
/*
* Test the constructor with null aliases.
*/
public void testConstructor_NullAliases() {
MockCharset c = new MockCharset("mockChar", null);
assertEquals("mockChar", c.name());
assertEquals("mockChar", c.displayName());
assertEquals("mockChar", c.displayName(Locale.getDefault()));
assertEquals(0, c.aliases().toArray().length);
}
/*
* Test the constructor with a null aliases.
*/
public void testConstructor_NullAliase() {
try {
new MockCharset("mockChar", new String[] { "mock", null });
fail("Should throw NullPointerException!");
} catch (NullPointerException e) {
// expected
}
}
/*
* Test the constructor with no aliases.
*/
public void testConstructor_NoAliases() {
MockCharset c = new MockCharset("mockChar", new String[0]);
assertEquals("mockChar", c.name());
assertEquals("mockChar", c.displayName());
assertEquals("mockChar", c.displayName(Locale.getDefault()));
assertEquals(0, c.aliases().toArray().length);
}
/*
* Test the constructor with empty aliases.
*
*/
public void testConstructor_EmptyAliases() {
try {
new MockCharset("mockChar", new String[] { "" });
} catch (IllegalCharsetNameException e) {
// FIXME: Commented out since RI does throw IAE
// fail("Should not throw IllegalArgumentException!");
}
}
/*
* Test the constructor with illegal aliases: starting with neither a digit
* nor a letter.
*
*/
public void testConstructor_IllegalAliases_Initial() {
try {
new MockCharset("mockChar", new String[] { "mock", "-123" });
} catch (IllegalCharsetNameException e) {
fail("Should not throw IllegalArgumentException!");
}
}
/*
* Test the constructor with illegal aliase, illegal character in the
* middle.
*/
public void testConstructor_IllegalAliases_Middle() {
try {
new MockCharset("mockChar", new String[] { "mock", "22##ab" });
fail("Should throw IllegalCharsetNameException!");
} catch (IllegalCharsetNameException e) {
// expected
}
try {
new MockCharset("mockChar", new String[] { "mock", "22%%ab" });
fail("Should throw IllegalCharsetNameException!");
} catch (IllegalCharsetNameException e) {
// expected
}
}
/*
* Test the method aliases() with multiple aliases. Most conditions have
* been tested in the testcases for the constructors.
*/
public void testAliases_Multiple() {
final String mockName = "mockChar1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.:-_";
MockCharset c = new MockCharset("mockChar", new String[] { "mock",
mockName, "mock2" });
assertEquals("mockChar", c.name());
assertEquals(3, c.aliases().size());
assertTrue(c.aliases().contains("mock"));
assertTrue(c.aliases().contains(mockName));
assertTrue(c.aliases().contains("mock2"));
try {
c.aliases().clear();
fail("Should throw UnsupportedOperationException!");
} catch (UnsupportedOperationException e) {
// expected
}
}
/*
* Test the method aliases() with duplicate aliases, one same with its
* canonical name.
*/
public void testAliases_Duplicate() {
final String mockName = "mockChar1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.:-_";
MockCharset c = new MockCharset("mockChar", new String[] { "mockChar",
"mock", mockName, "mock", "mockChar", "mock", "mock2" });
assertEquals("mockChar", c.name());
assertEquals(4, c.aliases().size());
assertTrue(c.aliases().contains("mockChar"));
assertTrue(c.aliases().contains("mock"));
assertTrue(c.aliases().contains(mockName));
assertTrue(c.aliases().contains("mock2"));
}
/*
* Test the method canEncode(). Test the default return value.
*/
public void testCanEncode() {
MockCharset c = new MockCharset("mock", null);
assertTrue(c.canEncode());
}
/*
* Test the method isRegistered(). Test the default return value.
*/
public void testIsRegistered() {
MockCharset c = new MockCharset("mock", null);
assertTrue(c.isRegistered());
}
/*
* The name() method has been tested by the testcases for the constructor.
*/
public void testName() {
// already covered by testConstructor_XXX series
}
/*
* The displayName() method have been tested by the testcases for the
* constructor.
*/
public void testDisplayName() {
// already covered by testConstructor_XXX series
}
/*
* Test displayName(Locale) with null.
*/
public void testDisplayName_Locale_Null() {
MockCharset c = new MockCharset("mock", null);
assertEquals("mock", c.displayName(null));
}
/*
* Test the method compareTo(Object) with normal conditions.
*/
public void testCompareTo_Normal() {
MockCharset c1 = new MockCharset("mock", null);
assertEquals(0, c1.compareTo(c1));
MockCharset c2 = new MockCharset("Mock", null);
assertEquals(0, c1.compareTo(c2));
c2 = new MockCharset("mock2", null);
assertTrue(c1.compareTo(c2) < 0);
assertTrue(c2.compareTo(c1) > 0);
c2 = new MockCharset("mack", null);
assertTrue(c1.compareTo(c2) > 0);
assertTrue(c2.compareTo(c1) < 0);
c2 = new MockCharset("m.", null);
assertTrue(c1.compareTo(c2) > 0);
assertTrue(c2.compareTo(c1) < 0);
c2 = new MockCharset("m:", null);
assertEquals("mock".compareToIgnoreCase("m:"), c1.compareTo(c2));
assertEquals("m:".compareToIgnoreCase("mock"), c2.compareTo(c1));
c2 = new MockCharset("m-", null);
assertTrue(c1.compareTo(c2) > 0);
assertTrue(c2.compareTo(c1) < 0);
c2 = new MockCharset("m_", null);
assertTrue(c1.compareTo(c2) > 0);
assertTrue(c2.compareTo(c1) < 0);
}
/*
* Test the method compareTo(Object) with null param.
*/
public void testCompareTo_Null() {
MockCharset c1 = new MockCharset("mock", null);
try {
c1.compareTo(null);
fail("Should throw NullPointerException!");
} catch (NullPointerException e) {
// expected
}
}
/*
* Test the method compareTo(Object) with another kind of charset object.
*/
public void testCompareTo_DiffCharsetClass() {
MockCharset c1 = new MockCharset("mock", null);
MockCharset2 c2 = new MockCharset2("Mock", new String[] { "myname" });
assertEquals(0, c1.compareTo(c2));
assertEquals(0, c2.compareTo(c1));
}
/*
* Test the method equals(Object) with null param.
*/
public void testEquals_Normal() {
MockCharset c1 = new MockCharset("mock", null);
MockCharset2 c2 = new MockCharset2("mock", null);
assertTrue(c1.equals(c2));
assertTrue(c2.equals(c1));
c2 = new MockCharset2("Mock", null);
assertFalse(c1.equals(c2));
assertFalse(c2.equals(c1));
}
/*
* Test the method equals(Object) with normal conditions.
*/
public void testEquals_Null() {
MockCharset c1 = new MockCharset("mock", null);
assertFalse(c1.equals(null));
}
/*
* Test the method equals(Object) with another kind of charset object.
*/
public void testEquals_NonCharsetObject() {
MockCharset c1 = new MockCharset("mock", null);
assertFalse(c1.equals("test"));
}
/*
* Test the method equals(Object) with another kind of charset object.
*/
public void testEquals_DiffCharsetClass() {
MockCharset c1 = new MockCharset("mock", null);
MockCharset2 c2 = new MockCharset2("mock", null);
assertTrue(c1.equals(c2));
assertTrue(c2.equals(c1));
}
/*
* Test the method hashCode().
*/
public void testHashCode_DiffCharsetClass() {
MockCharset c1 = new MockCharset("mock", null);
assertEquals(c1.hashCode(), "mock".hashCode());
final String mockName = "mockChar1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.:-_";
c1 = new MockCharset(mockName, new String[] { "mockChar", "mock",
mockName, "mock", "mockChar", "mock", "mock2" });
assertEquals(mockName.hashCode(), c1.hashCode());
}
/*
* Test the method encode(CharBuffer) under normal condition.
*/
public void testEncode_CharBuffer_Normal() throws Exception {
MockCharset c1 = new MockCharset("testEncode_CharBuffer_Normal_mock", null);
ByteBuffer bb = c1.encode(CharBuffer.wrap("abcdefg"));
assertEquals("abcdefg", new String(bb.array(), "iso8859-1"));
bb = c1.encode(CharBuffer.wrap(""));
assertEquals("", new String(bb.array(), "iso8859-1"));
}
/*
* Test the method encode(CharBuffer) with an unmappable char.
*/
public void testEncode_CharBuffer_Unmappable() throws Exception {
Charset c1 = Charset.forName("iso8859-1");
ByteBuffer bb = c1.encode(CharBuffer.wrap("abcd\u5D14efg"));
assertEquals(new String(bb.array(), "iso8859-1"), "abcd"
+ new String(c1.newEncoder().replacement(), "iso8859-1")
+ "efg");
}
/*
* Test the method encode(CharBuffer) with null CharBuffer.
*/
public void testEncode_CharBuffer_NullCharBuffer() {
MockCharset c = new MockCharset("mock", null);
try {
c.encode((CharBuffer) null);
fail("Should throw NullPointerException!");
} catch (NullPointerException e) {
// expected
}
}
/*
* Test the method encode(CharBuffer) with null encoder.
*/
public void testEncode_CharBuffer_NullEncoder() {
MockCharset2 c = new MockCharset2("mock2", null);
try {
c.encode(CharBuffer.wrap("hehe"));
fail("Should throw NullPointerException!");
} catch (NullPointerException e) {
// expected
}
}
/*
* Test the method encode(String) under normal condition.
*/
public void testEncode_String_Normal() throws Exception {
MockCharset c1 = new MockCharset("testEncode_String_Normal_mock", null);
ByteBuffer bb = c1.encode("abcdefg");
assertEquals("abcdefg", new String(bb.array(), "iso8859-1"));
bb = c1.encode("");
assertEquals("", new String(bb.array(), "iso8859-1"));
}
/*
* Test the method encode(String) with an unmappable char.
*/
public void testEncode_String_Unmappable() throws Exception {
Charset c1 = Charset.forName("iso8859-1");
ByteBuffer bb = c1.encode("abcd\u5D14efg");
assertEquals(new String(bb.array(), "iso8859-1"), "abcd"
+ new String(c1.newEncoder().replacement(), "iso8859-1")
+ "efg");
}
/*
* Test the method encode(String) with null CharBuffer.
*/
public void testEncode_String_NullString() {
MockCharset c = new MockCharset("mock", null);
try {
c.encode((String) null);
fail("Should throw NullPointerException!");
} catch (NullPointerException e) {
// expected
}
}
/*
* Test the method encode(String) with null encoder.
*/
public void testEncode_String_NullEncoder() {
MockCharset2 c = new MockCharset2("mock2", null);
try {
c.encode("hehe");
fail("Should throw NullPointerException!");
} catch (NullPointerException e) {
// expected
}
}
/*
* Test the method decode(ByteBuffer) under normal condition.
*/
public void testDecode_Normal() throws Exception {
MockCharset c1 = new MockCharset("mock", null);
CharBuffer cb = c1.decode(ByteBuffer.wrap("abcdefg"
.getBytes("iso8859-1")));
assertEquals("abcdefg", new String(cb.array()));
cb = c1.decode(ByteBuffer.wrap("".getBytes("iso8859-1")));
assertEquals("", new String(cb.array()));
}
/*
* Test the method decode(ByteBuffer) with a malformed input.
*/
public void testDecode_Malformed() throws Exception {
Charset c1 = Charset.forName("iso8859-1");
CharBuffer cb = c1.decode(ByteBuffer.wrap("abcd\u5D14efg"
.getBytes("iso8859-1")));
byte[] replacement = c1.newEncoder().replacement();
assertEquals(new String(cb.array()).trim(), "abcd" + new String(replacement, "iso8859-1")
+ "efg");
}
/*
* Test the method decode(ByteBuffer) with null CharBuffer.
*/
public void testDecode_NullByteBuffer() {
MockCharset c = new MockCharset("mock", null);
try {
c.decode(null);
fail("Should throw NullPointerException!");
} catch (NullPointerException e) {
// expected
}
}
/*
* Test the method decode(ByteBuffer) with null encoder.
*/
public void testDecode_NullDecoder() {
MockCharset2 c = new MockCharset2("mock2", null);
try {
c.decode(ByteBuffer.wrap("hehe".getBytes()));
fail("Should throw NullPointerException!");
} catch (NullPointerException e) {
// expected
}
}
/*
* Test the method toString().
*/
public void testToString() {
MockCharset c1 = new MockCharset("mock", null);
assertTrue(-1 != c1.toString().indexOf("mock"));
}
/**
* @tests java.nio.charset.Charset#availableCharsets()
*/
public void test_availableCharsets() throws Exception {
// regression test for Harmony-1051
ClassLoader originalClassLoader = Thread.currentThread()
.getContextClassLoader();
try {
Thread.currentThread().setContextClassLoader(null);
SortedMap<String, Charset> charsets = Charset.availableCharsets();
// make sure "mockCharset00" is loaded by MockCharsetProvider
assertTrue(charsets.containsKey("mockCharset00"));
} finally {
Thread.currentThread().setContextClassLoader(originalClassLoader);
}
}
/**
* @tests java.nio.charset.Charset#availableCharsets()
*/
public void test_forNameLString() throws Exception {
// regression test for Harmony-1051
ClassLoader originalClassLoader = Thread.currentThread()
.getContextClassLoader();
try {
Thread.currentThread().setContextClassLoader(null);
// make sure "mockCharset00" is loaded by MockCharsetProvider
assertNotNull(Charset.forName("mockCharset00"));
} finally {
Thread.currentThread().setContextClassLoader(originalClassLoader);
}
}
/*
* Mock charset class.
*/
static final class MockCharset extends Charset {
public MockCharset(String canonicalName, String[] aliases) {
super(canonicalName, aliases);
}
public boolean contains(Charset cs) {
return false;
}
public CharsetDecoder newDecoder() {
return new MockDecoder(this);
}
public CharsetEncoder newEncoder() {
return new MockEncoder(this);
}
}
/*
* Another mock charset class.
*/
static class MockCharset2 extends Charset {
public MockCharset2(String canonicalName, String[] aliases) {
super(canonicalName, aliases);
}
public boolean contains(Charset cs) {
return false;
}
public CharsetDecoder newDecoder() {
return null;
}
public CharsetEncoder newEncoder() {
return null;
}
}
/*
* Mock encoder.
*/
static class MockEncoder extends java.nio.charset.CharsetEncoder {
public MockEncoder(Charset cs) {
super(cs, 1, 3, new byte[] { (byte) '?' });
}
protected CoderResult encodeLoop(CharBuffer in, ByteBuffer out) {
while (in.remaining() > 0) {
out.put((byte) in.get());
// out.put((byte) '!');
}
return CoderResult.UNDERFLOW;
}
}
/*
* Mock decoder.
*/
static class MockDecoder extends java.nio.charset.CharsetDecoder {
public MockDecoder(Charset cs) {
super(cs, 1, 10);
}
protected CoderResult decodeLoop(ByteBuffer in, CharBuffer out) {
while (in.remaining() > 0) {
out.put((char) in.get());
}
return CoderResult.UNDERFLOW;
}
}
/*
* Mock charset provider.
*/
public static class MockCharsetProvider extends CharsetProvider {
public Charset charsetForName(String charsetName) {
if ("MockCharset00".equalsIgnoreCase(charsetName)
|| "MockCharset01".equalsIgnoreCase(charsetName)
|| "MockCharset02".equalsIgnoreCase(charsetName)) {
return new MockCharset("mockCharset00", new String[] {
"mockCharset01", "mockCharset02" });
}
return null;
}
public Iterator charsets() {
Vector v = new Vector();
v.add(new MockCharset("mockCharset00", new String[] {
"mockCharset01", "mockCharset02" }));
return v.iterator();
}
}
}