android-4.2.2_r1/s

/* 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();
		}
	}
}