xref: /libcore/harmony-tests/src/test/java/org/apache/harmony/tests/java/nio/charset/CharsetDecoderTest.java

/* 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 org.apache.harmony.tests.java.nio.charset;

import java.io.UnsupportedEncodingException;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CoderResult;
import java.nio.charset.CodingErrorAction;
import java.nio.charset.MalformedInputException;
import java.nio.charset.UnmappableCharacterException;

import junit.framework.TestCase;

/**
 * API unit test for java.nio.CharsetDecoder
 */
public class CharsetDecoderTest extends TestCase {

    protected static final int MAX_BYTES = 3;

    protected static final double AVER_BYTES = 0.5;

    // default charset
    private static final Charset MOCKCS = new CharsetEncoderTest.MockCharset(
            "mock", new String[0]);

    Charset cs = MOCKCS;

    // default decoder
    protected static CharsetDecoder decoder;

    String bom = "";

    protected void setUp() throws Exception {
        super.setUp();
        decoder = cs.newDecoder();
    }

    protected void tearDown() throws Exception {
        super.tearDown();
    }

    // FIXME: give up this tests
    // /*
    // * test default value
    // */
    // public void testDefaultCharsPerByte() {
    // assertTrue(decoder.averageCharsPerByte() == AVER_BYTES);
    // assertTrue(decoder.maxCharsPerByte() == MAX_BYTES);
    // }

    public void testDefaultValues() {
        assertSame(cs, decoder.charset());
        try {
            decoder.detectedCharset();
            fail("should unsupported");
        } catch (UnsupportedOperationException e) {
        }
        try {
            assertTrue(decoder.isCharsetDetected());
            fail("should unsupported");
        } catch (UnsupportedOperationException e) {
        }
        assertFalse(decoder.isAutoDetecting());
        assertSame(CodingErrorAction.REPORT, decoder.malformedInputAction());
        assertSame(CodingErrorAction.REPORT, decoder
                .unmappableCharacterAction());
        assertEquals(decoder.replacement(), "\ufffd");
    }

    /*
     * test constructor
     */
    public void testCharsetDecoder() {
        // default value
        decoder = new MockCharsetDecoder(cs, (float) AVER_BYTES, MAX_BYTES);

        // normal case
        CharsetDecoder ec = new MockCharsetDecoder(cs, 1, MAX_BYTES);
        assertSame(ec.charset(), cs);
        assertEquals(1.0, ec.averageCharsPerByte(), 0.0);
        assertTrue(ec.maxCharsPerByte() == MAX_BYTES);

        /*
         * ------------------------ Exceptional cases -------------------------
         */
        // Normal case: null charset
        ec = new MockCharsetDecoder(null, 1, MAX_BYTES);
        assertNull(ec.charset());
        assertEquals(1.0, ec.averageCharsPerByte(), 0.0);
        assertTrue(ec.maxCharsPerByte() == MAX_BYTES);

        ec = new MockCharsetDecoder(new CharsetEncoderTest.MockCharset("mock",
                new String[0]), 1, MAX_BYTES);

        // Commented out since the comment is wrong since MAX_BYTES > 1
        // // OK: average length less than max length
        // ec = new MockCharsetDecoder(cs, MAX_BYTES, 1);
        // assertTrue(ec.averageCharsPerByte() == MAX_BYTES);
        // assertTrue(ec.maxCharsPerByte() == 1);

        // Illegal Argument: zero length
        try {
            ec = new MockCharsetDecoder(cs, 0, MAX_BYTES);
            fail("should throw IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        }
        try {
            ec = new MockCharsetDecoder(cs, 1, 0);
            fail("should throw IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        }

        // Illegal Argument: negative length
        try {
            ec = new MockCharsetDecoder(cs, -1, MAX_BYTES);
            fail("should throw IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        }
        try {
            ec = new MockCharsetDecoder(cs, 1, -1);
            fail("should throw IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        }
    }

    /*
     * test onMalformedInput
     */
    public void testOnMalformedInput() {
        assertSame(CodingErrorAction.REPORT, decoder.malformedInputAction());
        try {
            decoder.onMalformedInput(null);
            fail("should throw null pointer exception");
        } catch (IllegalArgumentException e) {
        }
        decoder.onMalformedInput(CodingErrorAction.IGNORE);
        assertSame(CodingErrorAction.IGNORE, decoder.malformedInputAction());
    }

    /*
     * test unmappableCharacter
     */
    public void testOnUnmappableCharacter() {
        assertSame(CodingErrorAction.REPORT, decoder
                .unmappableCharacterAction());
        try {
            decoder.onUnmappableCharacter(null);
            fail("should throw null pointer exception");
        } catch (IllegalArgumentException e) {
        }
        decoder.onUnmappableCharacter(CodingErrorAction.IGNORE);
        assertSame(CodingErrorAction.IGNORE, decoder
                .unmappableCharacterAction());
    }

    /*
     * test replaceWith
     */
    public void testReplaceWith() {
        try {
            decoder.replaceWith(null);
            fail("should throw null pointer exception");
        } catch (IllegalArgumentException e) {
        }
        try {
            decoder.replaceWith("");
            fail("should throw null pointer exception");
        } catch (IllegalArgumentException e) {
        }
        try {
            decoder.replaceWith("testReplaceWith");
            fail("should throw illegal argument exception");
        } catch (IllegalArgumentException e) {
        }

        decoder.replaceWith("a");
        assertSame("a", decoder.replacement());
    }

    /*
     * Class under test for CharBuffer decode(ByteBuffer)
     */
    public void testDecodeByteBuffer() throws CharacterCodingException {
        implTestDecodeByteBuffer();
    }

    void implTestDecodeByteBuffer() throws CharacterCodingException {
        // Null pointer
        try {
            decoder.decode(null);
            fail("should throw null pointer exception");
        } catch (NullPointerException e) {
        }

        // empty input buffer
        CharBuffer out = decoder.decode(ByteBuffer.allocate(0));
        assertCharBufferValue("", out);

        // normal case
        ByteBuffer in = getByteBuffer();
        out = decoder.decode(in);
        assertEquals(0, out.position());
        assertEquals(getString().length(), out.limit());
        assertEquals(getString().length(), out.remaining());
        assertCharBufferValue(getString(), out);

        // normal read only case
        in = getByteBuffer().asReadOnlyBuffer();
        out = decoder.decode(in);
        assertEquals(out.position(), 0);
        assertEquals(out.limit(), getString().length());
        assertEquals(out.remaining(), getString().length());
        assertCharBufferValue(getString(), out);
    }

    public void testDecodeByteBufferException()
            throws CharacterCodingException, UnsupportedEncodingException {
        CharBuffer out;
        ByteBuffer in;
        String replaceStr = decoder.replacement() + getString();

        // MalformedException:
        decoder.onMalformedInput(CodingErrorAction.REPORT);
        decoder.onUnmappableCharacter(CodingErrorAction.REPORT);
        in = getMalformedByteBuffer();
        if (in != null) {
            try {
                CharBuffer buffer = decoder.decode(in);
                assertTrue(buffer.remaining() > 0);
                fail("should throw MalformedInputException");
            } catch (MalformedInputException e) {
            }

            decoder.reset();
            in.rewind();
            decoder.onMalformedInput(CodingErrorAction.IGNORE);
            out = decoder.decode(in);
            assertCharBufferValue(getString(), out);

            decoder.reset();
            in.rewind();
            decoder.onMalformedInput(CodingErrorAction.REPLACE);
            out = decoder.decode(in);
            assertCharBufferValue(replaceStr, out);
        }

        // Unmapped Exception:
        decoder.onMalformedInput(CodingErrorAction.REPORT);
        decoder.onUnmappableCharacter(CodingErrorAction.REPORT);
        in = getUnmappedByteBuffer();
        if (in != null) {
            try {
                decoder.decode(in);
                fail("should throw UnmappableCharacterException");
            } catch (UnmappableCharacterException e) {
            }

            decoder.reset();
            in.rewind();
            decoder.onUnmappableCharacter(CodingErrorAction.IGNORE);
            out = decoder.decode(in);
            assertCharBufferValue(getString(), out);

            decoder.reset();
            in.rewind();
            decoder.onUnmappableCharacter(CodingErrorAction.REPLACE);
            out = decoder.decode(in);
            assertCharBufferValue(replaceStr, out);
        }

        // RuntimeException
        try {
            decoder.decode(getExceptionByteArray());
            fail("should throw runtime exception");
        } catch (RuntimeException e) {
        }
    }

    /*
     * Class under test for CoderResult decode(ByteBuffer, CharBuffer, boolean)
     */
    public void testDecodeByteBufferCharBuffer() {
        implTestDecodeByteBufferCharBuffer(getByteBuffer());
    }

    public void testDecodeByteBufferCharBufferReadOnly() {
        implTestDecodeByteBufferCharBuffer(getByteBuffer());
    }

    void implTestDecodeByteBufferCharBuffer(ByteBuffer in) {
        CharBuffer out = CharBuffer.allocate(100);

        // Null pointer
        decoder.reset();
        try {
            decoder.decode(null, out, true);
            fail("NullPointerException expected");
        } catch (NullPointerException e) {
        }
        try {
            decoder.decode(in, null, true);
            fail("NullPointerException expected");
        } catch (NullPointerException e) {
        }

        // normal case, one complete operation
        decoder.reset();
        in.rewind();
        out.rewind();
        assertSame(CoderResult.UNDERFLOW, decoder.decode(in, out, true));
        assertEquals(out.limit(), 100);
        assertEquals(out.position(), getString().length());
        assertEquals(out.remaining(), 100 - getString().length());
        assertEquals(out.capacity(), 100);
        assertCharBufferValue(getString(), out);
        decoder.flush(out);

        // normal case, one complete operation, but call twice, first time set
        // endOfInput to false
        decoder.reset();
        in.rewind();
        out.clear();
        assertSame(CoderResult.UNDERFLOW, decoder.decode(in, out, false));
        assertEquals(out.limit(), 100);
        assertEquals(out.position(), getString().length());
        assertEquals(out.remaining(), 100 - getString().length());
        assertEquals(out.capacity(), 100);
        assertCharBufferValue(getString(), out);

        decoder.reset();
        in.rewind();
        out.clear();
        assertSame(CoderResult.UNDERFLOW, decoder.decode(in, out, false));
        in = getHeadlessByteBuffer();
        assertSame(CoderResult.UNDERFLOW, decoder.decode(in, out, false));
        in.rewind();
        assertSame(CoderResult.UNDERFLOW, decoder.decode(in, out, true));
        assertEquals(out.limit(), 100);
        assertTrue(out.position() > 0);
        assertEquals(out.remaining(), out.capacity() - out.position());
        assertEquals(out.capacity(), 100);
        assertCharBufferValue(getString() + getString() + getString(), out);

        // overflow
        out = CharBuffer.allocate(4);
        decoder.reset();
        in = getByteBuffer();
        out.rewind();
        assertSame(CoderResult.OVERFLOW, decoder.decode(in, out, false));

        assertCharBufferValue(getString().substring(0, 4), out);
        out = CharBuffer.allocate(100);
        assertSame(CoderResult.UNDERFLOW, decoder.decode(in, out, false));
        assertCharBufferValue(getString().substring(4), out);
        in.rewind();
        out = CharBuffer.allocate(100);
        assertSame(CoderResult.UNDERFLOW, decoder.decode(in, out, true));
        assertCharBufferValue(bom + getString(), out);
    }

    public void testDecodeCharBufferByteBufferUnmappedException()
            throws CharacterCodingException, UnsupportedEncodingException {
        implTestDecodeCharBufferByteBufferUnmappedException(
                getUnmappedByteBuffer(), true);
    }

    public void testDecodeCharBufferByteIncompleteBufferUnmappedException()
            throws CharacterCodingException, UnsupportedEncodingException {
        implTestDecodeCharBufferByteBufferUnmappedException(
                getUnmappedByteBuffer(), false);
    }

    public void testDecodeCharBufferByteReadOnlyBufferUnmappedException()
            throws CharacterCodingException, UnsupportedEncodingException {
        implTestDecodeCharBufferByteBufferUnmappedException(
                readOnly(getUnmappedByteBuffer()), true);
    }

    public void testDecodeCharBufferByteReadOnlyIncompleteBufferUnmappedException()
            throws CharacterCodingException, UnsupportedEncodingException {
        implTestDecodeCharBufferByteBufferUnmappedException(
                readOnly(getUnmappedByteBuffer()), false);
    }

    void implTestDecodeCharBufferByteBufferUnmappedException(ByteBuffer in,
            boolean endOfInput) throws CharacterCodingException,
            UnsupportedEncodingException {
        if (null == in) {
            return;
        }
        CharBuffer out = CharBuffer.allocate(50);

        decoder.onMalformedInput(CodingErrorAction.REPORT);
        decoder.reset();
        decoder.onUnmappableCharacter(CodingErrorAction.REPORT);
        CoderResult result = decoder.decode(in, out, endOfInput);
        assertTrue(result.isUnmappable());

        decoder.reset();
        out.clear();
        in.rewind();
        decoder.onUnmappableCharacter(CodingErrorAction.IGNORE);
        assertSame(CoderResult.UNDERFLOW, decoder.decode(in, out, endOfInput));
        assertCharBufferValue(getString(), out);

        decoder.reset();
        out.clear();
        in.rewind();
        decoder.onUnmappableCharacter(CodingErrorAction.REPLACE);
        assertSame(CoderResult.UNDERFLOW, decoder.decode(in, out, endOfInput));
        assertCharBufferValue(decoder.replacement() + getString(), out);
    }

    public void testDecodeCharBufferByteBufferMalformedException()
            throws CharacterCodingException, UnsupportedEncodingException {
        implTestDecodeCharBufferByteBufferMalformedException(
                getMalformedByteBuffer(), true);
    }

    public void testDecodeCharBufferByteIncompleteBufferMalformedException()
            throws CharacterCodingException, UnsupportedEncodingException {

        implTestDecodeCharBufferByteBufferMalformedException(
                getMalformedByteBuffer(), false);
    }

    public void testDecodeCharBufferByteReadOnlyBufferMalformedException()
            throws CharacterCodingException, UnsupportedEncodingException {
        implTestDecodeCharBufferByteBufferMalformedException(
                readOnly(getMalformedByteBuffer()), true);
    }

    public void testDecodeCharBufferByteReadOnlyIncompleteBufferMalformedException()
            throws CharacterCodingException, UnsupportedEncodingException {
        implTestDecodeCharBufferByteBufferMalformedException(
                readOnly(getMalformedByteBuffer()), false);
    }

    void implTestDecodeCharBufferByteBufferMalformedException(ByteBuffer in,
            boolean endOfInput) throws CharacterCodingException,
            UnsupportedEncodingException {
        if (null == in) {
            return;
        }
        CharBuffer out = CharBuffer.allocate(getString().length() * 3);
        decoder.onUnmappableCharacter(CodingErrorAction.REPORT);
        decoder.reset();
        decoder.onMalformedInput(CodingErrorAction.REPORT);
        CoderResult result = decoder.decode(in, out, endOfInput);
        assertTrue(result.isMalformed());

        decoder.reset();
        out.clear();
        in.rewind();
        decoder.onMalformedInput(CodingErrorAction.IGNORE);
        assertSame(CoderResult.UNDERFLOW, decoder.decode(in, out, endOfInput));
        assertCharBufferValue(getString(), out);

        decoder.reset();
        out.clear();
        in.rewind();
        decoder.onMalformedInput(CodingErrorAction.REPLACE);
        assertSame(CoderResult.UNDERFLOW, decoder.decode(in, out, endOfInput));
        assertCharBufferValue(decoder.replacement() + getString(), out);
    }

    public void testDecodeCharBufferByteBufferException()
            throws CharacterCodingException, UnsupportedEncodingException {
        implTestDecodeCharBufferByteBufferException(getExceptionByteArray(),
                true);
    }

    public void testDecodeCharBufferByteIncompleteBufferException()
            throws CharacterCodingException, UnsupportedEncodingException {
        implTestDecodeCharBufferByteBufferException(getExceptionByteArray(),
                false);
    }

    public void testDecodeCharBufferByteReadOnlyBufferException()
            throws CharacterCodingException, UnsupportedEncodingException {
        implTestDecodeCharBufferByteBufferException(
                readOnly(getExceptionByteArray()), true);
    }

    public void testDecodeCharBufferByteReadOnlyIncompleteBufferException()
            throws CharacterCodingException, UnsupportedEncodingException {
        implTestDecodeCharBufferByteBufferException(
                readOnly(getExceptionByteArray()), false);
    }

    void implTestDecodeCharBufferByteBufferException(ByteBuffer in,
            boolean endOfInput) throws CharacterCodingException,
            UnsupportedEncodingException {
        CharBuffer out = CharBuffer.allocate(50);
        decoder.reset();
        try {
            decoder.decode(in, out, endOfInput);
            fail("should throw runtime exception");
        } catch (RuntimeException e) {
        }
    }

    private ByteBuffer readOnly(ByteBuffer b) {
        if (null == b) {
            return null;
        }
        return b.asReadOnlyBuffer();
    }

    protected String getString() {
        return " buffer";
    }

    protected ByteBuffer getByteBuffer() {
        return ByteBuffer.wrap(new byte[] { 32, 98, 117, 102, 102, 101, 114 });
    }

    protected ByteBuffer getHeadlessByteBuffer() {
        return getByteBuffer();
    }

    ByteBuffer getExceptionByteArray() throws UnsupportedEncodingException {
        // "runtime"
        return ByteBuffer
                .wrap(new byte[] { 114, 117, 110, 116, 105, 109, 101 });
    }

    ByteBuffer getUnmappedByteBuffer() throws UnsupportedEncodingException {
        // "unmap buffer"
        byte[] ba = new byte[] { 117, 110, 109, 97, 112, 32, 98, 117, 102, 102,
                101, 114 };
        return ByteBuffer.wrap(ba);
    }

    ByteBuffer getMalformedByteBuffer() throws UnsupportedEncodingException {
        // "malform buffer"
        byte[] ba = new byte[] { 109, 97, 108, 102, 111, 114, 109, 32, 98, 117,
                102, 102, 101, 114 };
        return ByteBuffer.wrap(ba);
    }

    private void assertCharBufferValue(String expected, CharBuffer out) {
        if (out.position() != 0) {
            out.flip();
        }
        assertEquals(expected, new String(out.array(), out.arrayOffset(), out
                .arrayOffset() + out.limit()));
    }

    /*
     * test flush
     */
    public void testFlush() throws CharacterCodingException {
        CharBuffer out = CharBuffer.allocate(10);
        ByteBuffer in = ByteBuffer.wrap(new byte[] { 12, 12 });
        decoder.decode(in, out, true);
        assertSame(CoderResult.UNDERFLOW, decoder.flush(out));

        decoder.reset();
        decoder.decode((ByteBuffer) in.rewind(), (CharBuffer) out.rewind(),
                true);
        assertSame(CoderResult.UNDERFLOW, decoder
                .flush(CharBuffer.allocate(10)));
    }

    /*
     * ---------------------------------- methods to test illegal state
     * -----------------------------------
     */
    // Normal case: just after reset, and it also means reset can be done
    // anywhere
    public void testResetIllegalState() throws CharacterCodingException {
        decoder.reset();
        decoder.decode(getByteBuffer());
        decoder.reset();
        decoder.decode(getByteBuffer(), CharBuffer.allocate(3), false);
        decoder.reset();
        decoder.decode(getByteBuffer(), CharBuffer.allocate(3), true);
        decoder.reset();
    }

    public void testFlushIllegalState() throws CharacterCodingException {
        ByteBuffer in = ByteBuffer.wrap(new byte[] { 98, 98 });
        CharBuffer out = CharBuffer.allocate(5);

        // Illegal state: after reset.
        decoder.reset();
        try {
            decoder.flush(out);
            fail();
        } catch (IllegalStateException expected) {
        }

        // Normal case: after decode with endOfInput is true
        decoder.reset();
        decoder.decode(in, out, true);
        out.rewind();
        CoderResult result = decoder.flush(out);
        assertSame(result, CoderResult.UNDERFLOW);

        // Good state: flush twice
        decoder.flush(out);

        // Illegal state: flush after decode with endOfInput is false
        decoder.reset();
        decoder.decode(in, out, false);
        try {
            decoder.flush(out);
            fail();
        } catch (IllegalStateException expected) {
        }
    }

    // test illegal states for decode facade
    public void testDecodeFacadeIllegalState() throws CharacterCodingException {
        // decode facade can be execute in anywhere
        ByteBuffer in = getByteBuffer();

        // Normal case: just created
        decoder.decode(in);
        in.rewind();

        // Normal case: just after decode facade
        decoder.decode(in);
        in.rewind();

        // Normal case: just after decode with that endOfInput is true
        decoder.reset();
        decoder.decode(getByteBuffer(), CharBuffer.allocate(30), true);
        decoder.decode(in);
        in.rewind();

        // Normal case:just after decode with that endOfInput is false
        decoder.reset();
        decoder.decode(getByteBuffer(), CharBuffer.allocate(30), false);
        decoder.decode(in);
        in.rewind();

        // Normal case: just after flush
        decoder.reset();
        decoder.decode(getByteBuffer(), CharBuffer.allocate(30), true);
        decoder.flush(CharBuffer.allocate(10));
        decoder.decode(in);
        in.rewind();
    }

    // test illegal states for two decode method with endOfInput is true
    public void testDecodeTrueIllegalState() throws CharacterCodingException {
        ByteBuffer in = ByteBuffer.wrap(new byte[] { 98, 98 });
        CharBuffer out = CharBuffer.allocate(100);
        // Normal case: just created
        decoder.decode(in, out, true);
        in.rewind();
        out.rewind();

        // Normal case: just after decode with that endOfInput is true
        decoder.reset();
        decoder.decode(in, CharBuffer.allocate(30), true);
        in.rewind();
        decoder.decode(in, out, true);
        in.rewind();
        out.rewind();

        // Normal case:just after decode with that endOfInput is false
        decoder.reset();
        decoder.decode(in, CharBuffer.allocate(30), false);
        in.rewind();
        decoder.decode(in, out, true);
        in.rewind();
        out.rewind();

        // Illegal state: just after flush
        decoder.reset();
        decoder.decode(in, CharBuffer.allocate(30), true);
        decoder.flush(CharBuffer.allocate(10));
        in.rewind();
        try {
            decoder.decode(in, out, true);
            fail("should illegal state");
        } catch (IllegalStateException e) {
        }
        in.rewind();
        out.rewind();

    }

    // test illegal states for two decode method with endOfInput is false
    public void testDecodeFalseIllegalState() throws CharacterCodingException {
        ByteBuffer in = ByteBuffer.wrap(new byte[] { 98, 98 });
        CharBuffer out = CharBuffer.allocate(5);
        // Normal case: just created
        decoder.decode(in, out, false);
        in.rewind();
        out.rewind();

        // Illegal state: just after decode facade
        decoder.reset();
        decoder.decode(in);
        in.rewind();
        try {
            decoder.decode(in, out, false);
            fail("should illegal state");
        } catch (IllegalStateException e) {
        }
        in.rewind();
        out.rewind();

        // Illegal state: just after decode with that endOfInput is true
        decoder.reset();
        decoder.decode(in, CharBuffer.allocate(30), true);
        in.rewind();
        try {
            decoder.decode(in, out, false);
            fail("should illegal state");
        } catch (IllegalStateException e) {
        }
        in.rewind();
        out.rewind();

        // Normal case:just after decode with that endOfInput is false
        decoder.reset();
        decoder.decode(in, CharBuffer.allocate(30), false);
        in.rewind();
        decoder.decode(in, out, false);
        in.rewind();
        out.rewind();

        // Illegal state: just after flush
        decoder.reset();
        decoder.decode(in, CharBuffer.allocate(30), true);
        in.rewind();
        decoder.flush(CharBuffer.allocate(10));
        try {
            decoder.decode(in, out, false);
            fail("should illegal state");
        } catch (IllegalStateException e) {
        }
    }

    /*
     * --------------------------------- illegal state test end
     * ---------------------------------
     */

    public void testImplFlush() {
        decoder = new MockCharsetDecoder(cs, 1, 3);
        assertEquals(CoderResult.UNDERFLOW, ((MockCharsetDecoder) decoder)
                .pubImplFlush(null));
    }

    public void testImplOnMalformedInput() {
        decoder = new MockCharsetDecoder(cs, 1, 3);
        assertEquals(CoderResult.UNDERFLOW, ((MockCharsetDecoder) decoder)
                .pubImplFlush(null));

    }

    public void testImplOnUnmappableCharacter() {
        decoder = new MockCharsetDecoder(cs, 1, 3);
        ((MockCharsetDecoder) decoder).pubImplOnUnmappableCharacter(null);
    }

    public void testImplReplaceWith() {
        decoder = new MockCharsetDecoder(cs, 1, 3);
        ((MockCharsetDecoder) decoder).pubImplReplaceWith(null);
    }

    public void testImplReset() {
        decoder = new MockCharsetDecoder(cs, 1, 3);
        ((MockCharsetDecoder) decoder).pubImplReset();
    }

    /*
     * mock decoder
     */
    public static class MockCharsetDecoder extends CharsetDecoder {
        public MockCharsetDecoder(Charset cs, float ave, float max) {
            super(cs, ave, max);
        }

        protected CoderResult decodeLoop(ByteBuffer in, CharBuffer out) {
            int inPosition = in.position();
            byte[] input = new byte[in.remaining()];
            in.get(input);
            String result;
            try {
                result = new String(input, "UTF-8");
            } catch (UnsupportedEncodingException e) {
                throw new AssertionError(e);
            }
            if (result.startsWith("malform")) {
                // reset the cursor to the error position
                in.position(inPosition);
                // set the error length
                return CoderResult.malformedForLength("malform".length());
            } else if (result.startsWith("unmap")) {
                // reset the cursor to the error position
                in.position(inPosition);
                // set the error length
                return CoderResult.unmappableForLength("unmap".length());
            } else if (result.startsWith("runtime")) {
                // reset the cursor to the error position
                in.position(0);
                // set the error length
                throw new RuntimeException("runtime");
            }
            int inLeft = input.length;
            int outLeft = out.remaining();
            CoderResult r = CoderResult.UNDERFLOW;
            int length = inLeft;
            if (outLeft < inLeft) {
                r = CoderResult.OVERFLOW;
                length = outLeft;
                in.position(inPosition + outLeft);
            }
            for (int i = 0; i < length; i++) {
                out.put((char) input[i]);
            }
            return r;
        }

        protected CoderResult implFlush(CharBuffer out) {
            CoderResult result = super.implFlush(out);
            if (out.remaining() >= 5) {
                // TODO
                // out.put("flush");
                result = CoderResult.UNDERFLOW;
            } else {
                // out.put("flush", 0, out.remaining());
                result = CoderResult.OVERFLOW;
            }
            return result;
        }

        public CoderResult pubImplFlush(CharBuffer out) {
            return super.implFlush(out);
        }

        public void pubImplOnMalformedInput(CodingErrorAction newAction) {
            super.implOnMalformedInput(newAction);
        }

        public void pubImplOnUnmappableCharacter(CodingErrorAction newAction) {
            super.implOnUnmappableCharacter(newAction);
        }

        public void pubImplReplaceWith(String newReplacement) {
            super.implReplaceWith(newReplacement);
        }

        public void pubImplReset() {
            super.implReset();
        }

    }

}