| /* 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 dalvik.annotation.TestTargetClass; |
| import dalvik.annotation.TestTargets; |
| import dalvik.annotation.TestTargetNew; |
| import dalvik.annotation.TestLevel; |
| |
| 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.CharsetEncoder; |
| import java.nio.charset.CoderResult; |
| import java.nio.charset.CodingErrorAction; |
| import java.nio.charset.MalformedInputException; |
| import java.nio.charset.UnmappableCharacterException; |
| import java.nio.charset.UnsupportedCharsetException; |
| import java.util.Arrays; |
| |
| import junit.framework.TestCase; |
| |
| @TestTargetClass(CharsetEncoder.class) |
| |
| /** |
| * Super class for concrete charset test suites. |
| */ |
| public class AbstractCharsetEncoderTestCase extends TestCase { |
| |
| Charset cs; |
| |
| // Target encoder (tobj): |
| CharsetEncoder encoder; |
| |
| static final String unistr = " buffer";// \u8000\u8001\u00a5\u3000\r\n"; |
| |
| byte[] unibytes = new byte[] { 32, 98, 117, 102, 102, 101, 114 }; |
| |
| |
| // default for Charset abstract class |
| byte[] defaultReplacement = new byte[] { 63 }; |
| |
| // specific for Charset implementation subclass |
| byte[] specifiedReplacement = new byte[] { 26 }; |
| |
| byte[] unibytesWithRep = null; |
| |
| byte[] surrogate = new byte[0]; |
| |
| |
| protected void setUp() throws Exception { |
| super.setUp(); |
| encoder = cs.newEncoder(); |
| if (null == unibytesWithRep) { |
| byte[] replacement = encoder.replacement(); |
| unibytesWithRep = new byte[replacement.length + unibytes.length]; |
| System.arraycopy(replacement, 0, unibytesWithRep, 0, |
| replacement.length); |
| System.arraycopy(unibytes, 0, unibytesWithRep, replacement.length, |
| unibytes.length); |
| } |
| } |
| |
| protected void tearDown() throws Exception { |
| super.tearDown(); |
| } |
| |
| |
| /* |
| * Class under test for boolean canEncode(char) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "canEncode", |
| args = {char.class} |
| ) |
| public void testCanEncodechar() throws CharacterCodingException { |
| // for non-mapped char |
| assertTrue(encoder.canEncode('\uc2c0')); |
| // surrogate char for unicode |
| // 1st byte: d800-dbff |
| // 2nd byte: dc00-dfff |
| assertTrue(encoder.canEncode('\ud800')); |
| // valid surrogate pair |
| assertTrue(encoder.canEncode('\udc00')); |
| } |
| |
| /*----------------------------------------- |
| * Class under test for illegal state case |
| * methods which can change internal states are two encode, flush, two canEncode, reset |
| * ----------------------------------------- |
| */ |
| |
| // Normal case: just after reset, and it also means reset can be done |
| // anywhere |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "canEncode", |
| args = {char.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "canEncode", |
| args = {java.lang.CharSequence.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "encode", |
| args = {java.nio.CharBuffer.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "encode", |
| args = {java.nio.CharBuffer.class, java.nio.ByteBuffer.class, boolean.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "reset", |
| args = {} |
| ) |
| }) |
| public void testResetIllegalState() throws CharacterCodingException { |
| assertSame(encoder, encoder.reset()); |
| encoder.canEncode('\ud901'); |
| assertSame(encoder, encoder.reset()); |
| encoder.canEncode("\ud901\udc00"); |
| assertSame(encoder, encoder.reset()); |
| encoder.encode(CharBuffer.wrap("aaa")); |
| assertSame(encoder, encoder.reset()); |
| encoder.encode(CharBuffer.wrap("aaa"), ByteBuffer.allocate(3), false); |
| assertSame(encoder, encoder.reset()); |
| encoder.encode(CharBuffer.wrap("aaa"), ByteBuffer.allocate(3), true); |
| assertSame(encoder, encoder.reset()); |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "reset", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "flush", |
| args = {java.nio.ByteBuffer.class} |
| ) |
| }) |
| public void testFlushIllegalState() throws CharacterCodingException { |
| CharBuffer in = CharBuffer.wrap("aaa"); |
| ByteBuffer out = ByteBuffer.allocate(5); |
| |
| // Normal case: after encode with endOfInput is true |
| assertSame(encoder, encoder.reset()); |
| encoder.encode(in, out, true); |
| out.rewind(); |
| CoderResult result = encoder.flush(out); |
| |
| // Illegal state: flush twice |
| try { |
| encoder.flush(out); |
| fail("should throw IllegalStateException"); |
| } catch (IllegalStateException e) { |
| } |
| |
| // Illegal state: flush after encode with endOfInput is false |
| assertSame(encoder, encoder.reset()); |
| encoder.encode(in, out, false); |
| try { |
| encoder.flush(out); |
| fail("should throw IllegalStateException"); |
| } catch (IllegalStateException e) { |
| } |
| } |
| |
| // test illegal states for encode facade |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "encode", |
| args = {java.nio.CharBuffer.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "canEncode", |
| args = {char.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "canEncode", |
| args = {java.lang.CharSequence.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "encode", |
| args = {java.nio.CharBuffer.class, java.nio.ByteBuffer.class, boolean.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "flush", |
| args = {java.nio.ByteBuffer.class} |
| ) |
| }) |
| public void testEncodeFacadeIllegalState() throws CharacterCodingException { |
| // encode facade can be execute in anywhere |
| CharBuffer in = CharBuffer.wrap("aaa"); |
| // Normal case: just created |
| encoder.encode(in); |
| in.rewind(); |
| |
| // Normal case: just after encode facade |
| encoder.encode(in); |
| in.rewind(); |
| |
| // Normal case: just after canEncode |
| assertSame(encoder, encoder.reset()); |
| encoder.canEncode("\ud902\udc00"); |
| encoder.encode(in); |
| in.rewind(); |
| assertSame(encoder, encoder.reset()); |
| encoder.canEncode('\ud902'); |
| encoder.encode(in); |
| in.rewind(); |
| |
| // Normal case: just after encode with that endOfInput is true |
| assertSame(encoder, encoder.reset()); |
| encoder.encode(CharBuffer.wrap("testCanEncodeIllegalState2"), |
| ByteBuffer.allocate(30), true); |
| encoder.encode(in); |
| in.rewind(); |
| |
| // Normal case:just after encode with that endOfInput is false |
| assertSame(encoder, encoder.reset()); |
| encoder.encode(CharBuffer.wrap("testCanEncodeIllegalState3"), |
| ByteBuffer.allocate(30), false); |
| encoder.encode(in); |
| in.rewind(); |
| |
| // Normal case: just after flush |
| assertSame(encoder, encoder.reset()); |
| encoder.encode(CharBuffer.wrap("testCanEncodeIllegalState4"), |
| ByteBuffer.allocate(30), true); |
| encoder.flush(ByteBuffer.allocate(10)); |
| encoder.encode(in); |
| in.rewind(); |
| } |
| |
| // test illegal states for two encode method with endOfInput is true |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "encode", |
| args = {java.nio.CharBuffer.class, java.nio.ByteBuffer.class, boolean.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "canEncode", |
| args = {char.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "canEncode", |
| args = {java.lang.CharSequence.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "reset", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "flush", |
| args = {java.nio.ByteBuffer.class} |
| ) |
| }) |
| public void testEncodeTrueIllegalState() throws CharacterCodingException { |
| CharBuffer in = CharBuffer.wrap("aaa"); |
| ByteBuffer out = ByteBuffer.allocate(5); |
| // Normal case: just created |
| encoder.encode(in, out, true); |
| in.rewind(); |
| out.rewind(); |
| |
| in.rewind(); |
| out.rewind(); |
| |
| // Normal case: just after encode with that endOfInput is true |
| assertSame(encoder, encoder.reset()); |
| encoder.encode(CharBuffer.wrap("testCanEncodeIllegalState2"), |
| ByteBuffer.allocate(30), true); |
| encoder.encode(in, out, true); |
| in.rewind(); |
| out.rewind(); |
| |
| // Normal case:just after encode with that endOfInput is false |
| assertSame(encoder, encoder.reset()); |
| encoder.encode(CharBuffer.wrap("testCanEncodeIllegalState3"), |
| ByteBuffer.allocate(30), false); |
| encoder.encode(in, out, true); |
| in.rewind(); |
| out.rewind(); |
| |
| // Illegal state: just after flush |
| assertSame(encoder, encoder.reset()); |
| encoder.encode(CharBuffer.wrap("testCanEncodeIllegalState4"), |
| ByteBuffer.allocate(30), true); |
| encoder.flush(ByteBuffer.allocate(10)); |
| try { |
| encoder.encode(in, out, true); |
| fail("should illegal state"); |
| } catch (IllegalStateException e) { |
| } |
| |
| // Normal case: after canEncode |
| assertSame(encoder, encoder.reset()); |
| encoder.canEncode("\ud906\udc00"); |
| encoder.encode(in, out, true); |
| in.rewind(); |
| out.rewind(); |
| assertSame(encoder, encoder.reset()); |
| encoder.canEncode('\ud905'); |
| encoder.encode(in, out, true); |
| } |
| |
| // test illegal states for two encode method with endOfInput is false |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "encode", |
| args = {java.nio.CharBuffer.class, java.nio.ByteBuffer.class, boolean.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "encode", |
| args = {java.nio.CharBuffer.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "canEncode", |
| args = {char.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "canEncode", |
| args = {java.lang.CharSequence.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "reset", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "flush", |
| args = {java.nio.ByteBuffer.class} |
| ) |
| }) |
| public void testEncodeFalseIllegalState() throws CharacterCodingException { |
| CharBuffer in = CharBuffer.wrap("aaa"); |
| ByteBuffer out = ByteBuffer.allocate(5); |
| // Normal case: just created |
| encoder.encode(in, out, false); |
| in.rewind(); |
| out.rewind(); |
| |
| // Illegal state: just after encode facade |
| assertSame(encoder, encoder.reset()); |
| encoder.encode(CharBuffer.wrap("testCanEncodeIllegalState1")); |
| try { |
| encoder.encode(in, out, false); |
| fail("should illegal state"); |
| } catch (IllegalStateException e) { |
| } |
| |
| // Illegal state: just after encode with that endOfInput is true |
| assertSame(encoder, encoder.reset()); |
| encoder.encode(CharBuffer.wrap("testCanEncodeIllegalState2"), |
| ByteBuffer.allocate(30), true); |
| try { |
| encoder.encode(in, out, false); |
| fail("should illegal state"); |
| } catch (IllegalStateException e) { |
| } |
| |
| // Normal case:just after encode with that endOfInput is false |
| assertSame(encoder, encoder.reset()); |
| encoder.encode(CharBuffer.wrap("testCanEncodeIllegalState3"), |
| ByteBuffer.allocate(30), false); |
| encoder.encode(in, out, false); |
| in.rewind(); |
| out.rewind(); |
| |
| // Illegal state: just after flush |
| assertSame(encoder, encoder.reset()); |
| encoder.encode(CharBuffer.wrap("testCanEncodeIllegalState4"), |
| ByteBuffer.allocate(30), true); |
| encoder.flush(ByteBuffer.allocate(10)); |
| try { |
| encoder.encode(in, out, false); |
| fail("should illegal state"); |
| } catch (IllegalStateException e) { |
| } |
| |
| // Normal case: after canEncode |
| assertSame(encoder, encoder.reset()); |
| encoder.canEncode("\ud906\udc00"); |
| encoder.encode(in, out, false); |
| in.rewind(); |
| out.rewind(); |
| assertSame(encoder, encoder.reset()); |
| encoder.canEncode('\ud905'); |
| encoder.encode(in, out, false); |
| } |
| |
| // test illegal states for two canEncode methods |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "canEncode", |
| args = {char.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "canEncode", |
| args = {java.lang.CharSequence.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "reset", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "flush", |
| args = {java.nio.ByteBuffer.class} |
| ) |
| }) |
| public void testCanEncodeIllegalState() throws CharacterCodingException { |
| // Normal case: just created |
| encoder.canEncode("\ud900\udc00"); |
| encoder.canEncode('\ud900'); |
| |
| // Illegal state: just after encode with that endOfInput is true |
| assertSame(encoder, encoder.reset()); |
| encoder.encode(CharBuffer.wrap("testCanEncodeIllegalState2"), |
| ByteBuffer.allocate(30), true); |
| try { |
| encoder.canEncode("\ud903\udc00"); |
| fail("should throw illegal state exception"); |
| } catch (IllegalStateException e) { |
| } |
| |
| // Illegal state:just after encode with that endOfInput is false |
| assertSame(encoder, encoder.reset()); |
| encoder.encode(CharBuffer.wrap("testCanEncodeIllegalState3"), |
| ByteBuffer.allocate(30), false); |
| try { |
| encoder.canEncode("\ud904\udc00"); |
| fail("should throw illegal state exception"); |
| } catch (IllegalStateException e) { |
| } |
| |
| // Normal case: just after flush |
| encoder.encode(CharBuffer.wrap("testCanEncodeIllegalState4"), |
| ByteBuffer.allocate(30), true); |
| encoder.flush(ByteBuffer.allocate(10)); |
| encoder.canEncode("\ud905\udc00"); |
| encoder.canEncode('\ud906'); |
| |
| // Normal case: after reset again |
| assertSame(encoder, encoder.reset()); |
| encoder.canEncode("\ud906\udc00"); |
| encoder.canEncode('\ud905'); |
| } |
| |
| /* |
| * --------------------------------- illegal state test end |
| * --------------------------------- |
| */ |
| |
| /* |
| * Class under test for boolean canEncode(CharSequence) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "canEncode", |
| args = {java.lang.CharSequence.class} |
| ) |
| public void testCanEncodeCharSequence() { |
| // for non-mapped char |
| assertTrue(encoder.canEncode("\uc2c0")); |
| // surrogate char for unicode |
| // 1st byte: d800-dbff |
| // 2nd byte: dc00-dfff |
| assertTrue(encoder.canEncode("\ud800")); |
| // valid surrogate pair |
| assertTrue(encoder.canEncode("\ud800\udc00")); |
| // invalid surrogate pair |
| assertTrue(encoder.canEncode("\ud800\udb00")); |
| } |
| |
| |
| |
| /* |
| * Class under test for ByteBuffer encode(CharBuffer) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "encode", |
| args = {java.nio.CharBuffer.class} |
| ) |
| public void testEncodeCharBuffer() throws CharacterCodingException { |
| // Null pointer |
| try { |
| encoder.encode(null); |
| fail("should throw null pointer exception"); |
| } catch (NullPointerException e) { |
| } |
| |
| // empty input buffer |
| ByteBuffer out = encoder.encode(CharBuffer.wrap("")); |
| assertEquals(out.position(), 0); |
| assertByteArray(out, new byte[0]); |
| // assertByteArray(out, surrogate); |
| |
| // normal case |
| out = encoder.encode(CharBuffer.wrap(unistr)); |
| assertEquals(out.position(), 0); |
| assertByteArray(out, addSurrogate(unibytes)); |
| |
| // Regression test for harmony-3378 |
| Charset cs = Charset.forName("UTF-8"); |
| CharsetEncoder encoder = cs.newEncoder(); |
| encoder.onMalformedInput(CodingErrorAction.REPLACE); |
| encoder = encoder.replaceWith(new byte[] { (byte) 0xef, (byte) 0xbf, |
| (byte) 0xbd, }); |
| CharBuffer in = CharBuffer.wrap("\ud800"); |
| out = encoder.encode(in); |
| assertNotNull(out); |
| } |
| |
| private byte[] addSurrogate(byte[] expected) { |
| if (surrogate.length > 0) { |
| byte[] temp = new byte[surrogate.length + expected.length]; |
| System.arraycopy(surrogate, 0, temp, 0, surrogate.length); |
| System.arraycopy(expected, 0, temp, surrogate.length, |
| expected.length); |
| expected = temp; |
| } |
| return expected; |
| } |
| |
| /** |
| * @return |
| */ |
| protected byte[] getEmptyByteArray() { |
| return new byte[0]; |
| } |
| |
| CharBuffer getMalformedCharBuffer() { |
| return CharBuffer.wrap("malform buffer"); |
| } |
| |
| CharBuffer getUnmapCharBuffer() { |
| return CharBuffer.wrap("unmap buffer"); |
| } |
| |
| CharBuffer getExceptionCharBuffer() { |
| return CharBuffer.wrap("runtime buffer"); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "encode", |
| args = {java.nio.CharBuffer.class} |
| ) |
| public void testEncodeCharBufferException() throws CharacterCodingException { |
| ByteBuffer out; |
| CharBuffer in; |
| // MalformedException: |
| in = getMalformedCharBuffer(); |
| encoder.onMalformedInput(CodingErrorAction.REPORT); |
| encoder.onUnmappableCharacter(CodingErrorAction.REPORT); |
| if (in != null) { |
| try { |
| // regression test for Harmony-1379 |
| encoder.encode(in); |
| fail("should throw MalformedInputException"); |
| } catch (MalformedInputException e) { |
| } |
| |
| encoder.reset(); |
| in.rewind(); |
| encoder.onMalformedInput(CodingErrorAction.IGNORE); |
| out = encoder.encode(in); |
| assertByteArray(out, addSurrogate(unibytes)); |
| |
| encoder.reset(); |
| in.rewind(); |
| encoder.onMalformedInput(CodingErrorAction.REPLACE); |
| out = encoder.encode(in); |
| assertByteArray(out, addSurrogate(unibytesWithRep)); |
| } |
| |
| // Unmapped Exception: |
| in = getUnmapCharBuffer(); |
| encoder.onMalformedInput(CodingErrorAction.REPORT); |
| encoder.onUnmappableCharacter(CodingErrorAction.REPORT); |
| if (in != null) { |
| encoder.reset(); |
| try { |
| encoder.encode(in); |
| fail("should throw UnmappableCharacterException"); |
| } catch (UnmappableCharacterException e) { |
| } |
| |
| encoder.reset(); |
| in.rewind(); |
| encoder.onUnmappableCharacter(CodingErrorAction.IGNORE); |
| out = encoder.encode(in); |
| assertByteArray(out, unibytes); |
| |
| encoder.reset(); |
| in.rewind(); |
| encoder.onUnmappableCharacter(CodingErrorAction.REPLACE); |
| out = encoder.encode(in); |
| assertByteArray(out, unibytesWithRep); |
| } |
| |
| // RuntimeException |
| try { |
| encoder.encode(getExceptionCharBuffer()); |
| fail("should throw runtime exception"); |
| } catch (RuntimeException e) { |
| } |
| } |
| |
| /* |
| * utility method, extract given bytebuffer to a string and compare with |
| * give string |
| */ |
| void assertByteArray(ByteBuffer out, byte[] expected) { |
| out = out.duplicate(); |
| if (out.position() != 0) { |
| out.flip(); |
| } |
| byte[] ba = new byte[out.limit() - out.position()]; |
| out.get(ba); |
| // byte[] ba = out.array(); |
| assertTrue(Arrays.equals(ba, expected)); |
| } |
| |
| /* |
| * Class under test for CoderResult encode(CharBuffer, ByteBuffer, boolean) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "encode", |
| args = {java.nio.CharBuffer.class, java.nio.ByteBuffer.class, boolean.class} |
| ) |
| public void testEncodeCharBufferByteBufferboolean() |
| throws CharacterCodingException { |
| ByteBuffer out = ByteBuffer.allocate(200); |
| CharBuffer in = CharBuffer.wrap(unistr); |
| // Null pointer |
| try { |
| encoder.encode(null, out, true); |
| fail("should throw null pointer exception"); |
| } catch (NullPointerException e) { |
| } |
| try { |
| encoder.encode(in, null, true); |
| fail("should throw null pointer exception"); |
| } catch (NullPointerException e) { |
| } |
| |
| // normal case, one complete operation |
| assertSame(encoder, encoder.reset()); |
| in.rewind(); |
| out.rewind(); |
| assertSame(CoderResult.UNDERFLOW, encoder.encode(in, out, true)); |
| assertEquals(out.limit(), 200); |
| assertTrue(out.position() > 0); |
| assertTrue(out.remaining() > 0); |
| assertEquals(out.capacity(), 200); |
| assertByteArray(out, addSurrogate(unibytes)); |
| in.rewind(); |
| |
| encoder.flush(out); |
| |
| // normal case, one complete operation, but call twice, first time set |
| // endOfInput to false |
| assertSame(encoder, encoder.reset()); |
| in.rewind(); |
| out = ByteBuffer.allocate(200); |
| assertSame(CoderResult.UNDERFLOW, encoder.encode(in, out, false)); |
| assertEquals(out.limit(), 200); |
| assertTrue(out.position() > 0); |
| assertTrue(out.remaining() > 0); |
| assertEquals(out.capacity(), 200); |
| assertByteArray(out, addSurrogate(unibytes)); |
| |
| in.rewind(); |
| assertSame(CoderResult.UNDERFLOW, encoder.encode(in, out, false)); |
| in.rewind(); |
| assertSame(CoderResult.UNDERFLOW, encoder.encode(in, out, true)); |
| assertEquals(out.limit(), 200); |
| assertTrue(out.position() > 0); |
| assertTrue(out.remaining() > 0); |
| assertEquals(out.capacity(), 200); |
| |
| assertByteArray(out, addSurrogate(duplicateByteArray(unibytes, 3))); |
| |
| // overflow |
| out = ByteBuffer.allocate(4); |
| assertSame(encoder, encoder.reset()); |
| in.rewind(); |
| out.rewind(); |
| assertSame(CoderResult.OVERFLOW, encoder.encode(in, out, true)); |
| assertEquals(out.limit(), 4); |
| assertEquals(out.position(), 4); |
| assertEquals(out.remaining(), 0); |
| assertEquals(out.capacity(), 4); |
| ByteBuffer temp = ByteBuffer.allocate(200); |
| out.flip(); |
| temp.put(out); |
| out = temp; |
| assertSame(CoderResult.UNDERFLOW, encoder.encode(in, out, true)); |
| assertEquals(out.limit(), 200); |
| assertTrue(out.position() > 0); |
| assertTrue(out.remaining() > 0); |
| assertEquals(out.capacity(), 200); |
| assertByteArray(out, addSurrogate(unibytes)); |
| |
| assertSame(encoder, encoder.reset()); |
| in.rewind(); |
| out = ByteBuffer.allocate(4); |
| assertSame(CoderResult.OVERFLOW, encoder.encode(in, out, false)); |
| assertEquals(out.limit(), 4); |
| assertEquals(out.position(), 4); |
| assertEquals(out.remaining(), 0); |
| assertEquals(out.capacity(), 4); |
| temp = ByteBuffer.allocate(200); |
| out.flip(); |
| temp.put(out); |
| out = temp; |
| assertSame(CoderResult.UNDERFLOW, encoder.encode(in, out, false)); |
| assertEquals(out.limit(), 200); |
| assertTrue(out.position() > 0); |
| assertTrue(out.remaining() > 0); |
| assertEquals(out.capacity(), 200); |
| assertByteArray(out, addSurrogate(unibytes)); |
| } |
| |
| void printByteBuffer(ByteBuffer buffer) { |
| System.out.println("print buffer"); |
| if (buffer.position() != 0) { |
| buffer.flip(); |
| } |
| byte[] ba = buffer.array(); |
| for (int i = 0; i < ba.length; i++) { |
| System.out.println(Integer.toHexString(ba[i])); |
| } |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "encode", |
| args = {java.nio.CharBuffer.class, java.nio.ByteBuffer.class, boolean.class} |
| ) |
| public void testEncodeCharBufferByteBufferbooleanExceptionFalse() |
| throws CharacterCodingException { |
| implTestEncodeCharBufferByteBufferbooleanException(false); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "encode", |
| args = {java.nio.CharBuffer.class, java.nio.ByteBuffer.class, boolean.class} |
| ) |
| public void testEncodeCharBufferByteBufferbooleanExceptionTrue() |
| throws CharacterCodingException { |
| implTestEncodeCharBufferByteBufferbooleanException(true); |
| } |
| |
| private byte[] duplicateByteArray(byte[] ba, int times) { |
| byte[] result = new byte[ba.length * times]; |
| for (int i = 0; i < times; i++) { |
| System.arraycopy(ba, 0, result, i * ba.length, ba.length); |
| } |
| return result; |
| } |
| |
| protected void implTestEncodeCharBufferByteBufferbooleanException( |
| boolean endOfInput) throws CharacterCodingException { |
| ByteBuffer out = ByteBuffer.allocate(100); |
| |
| // MalformedException: |
| CharBuffer in = getMalformedCharBuffer(); |
| encoder.onMalformedInput(CodingErrorAction.REPORT); |
| encoder.onUnmappableCharacter(CodingErrorAction.REPORT); |
| if (in != null) { |
| encoder.reset(); |
| CoderResult r = encoder.encode(in, out, endOfInput); |
| assertTrue(r.isMalformed()); |
| |
| encoder.reset(); |
| out.clear(); |
| in.rewind(); |
| encoder.onMalformedInput(CodingErrorAction.IGNORE); |
| assertSame(CoderResult.UNDERFLOW, encoder.encode(in, out, |
| endOfInput)); |
| assertCodingErrorAction(endOfInput, out, in, unibytes); |
| |
| encoder.reset(); |
| out.clear(); |
| in.rewind(); |
| encoder.onMalformedInput(CodingErrorAction.REPLACE); |
| assertSame(CoderResult.UNDERFLOW, encoder.encode(in, out, |
| endOfInput)); |
| assertCodingErrorAction(endOfInput, out, in, unibytesWithRep); |
| } else { |
| // System.out.println("Cannot find malformed char buffer for " |
| // + cs.name()); |
| } |
| |
| // Unmapped Exception: |
| in = getUnmapCharBuffer(); |
| encoder.onMalformedInput(CodingErrorAction.REPORT); |
| encoder.onUnmappableCharacter(CodingErrorAction.REPORT); |
| if (in != null) { |
| encoder.reset(); |
| out.clear(); |
| assertTrue(encoder.encode(in, out, endOfInput).isUnmappable()); |
| |
| encoder.reset(); |
| out.clear(); |
| in.rewind(); |
| encoder.onUnmappableCharacter(CodingErrorAction.IGNORE); |
| assertSame(CoderResult.UNDERFLOW, encoder.encode(in, out, |
| endOfInput)); |
| assertCodingErrorAction(endOfInput, out, in, unibytes); |
| |
| encoder.reset(); |
| out.clear(); |
| in.rewind(); |
| encoder.onUnmappableCharacter(CodingErrorAction.REPLACE); |
| assertSame(CoderResult.UNDERFLOW, encoder.encode(in, out, |
| endOfInput)); |
| assertCodingErrorAction(endOfInput, out, in, unibytesWithRep); |
| } else { |
| // System.out.println("Cannot find unmapped char buffer for " |
| // + cs.name()); |
| } |
| |
| // RuntimeException |
| try { |
| encoder.encode(getExceptionCharBuffer()); |
| fail("should throw runtime exception"); |
| } catch (RuntimeException e) { |
| } |
| } |
| |
| private void assertCodingErrorAction(boolean endOfInput, ByteBuffer out, |
| CharBuffer in, byte[] expect) { |
| if (endOfInput) { |
| assertByteArray(out, addSurrogate(expect)); |
| } else { |
| in.rewind(); |
| assertSame(CoderResult.UNDERFLOW, encoder.encode(in, out, |
| endOfInput)); |
| in.rewind(); |
| assertSame(CoderResult.UNDERFLOW, encoder.encode(in, out, true)); |
| assertByteArray(out, addSurrogate(duplicateByteArray(expect, 3))); |
| } |
| } |
| |
| /* |
| * Class under test for CoderResult flush(ByteBuffer) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "encode", |
| args = {java.nio.CharBuffer.class, java.nio.ByteBuffer.class, boolean.class} |
| ) |
| public void testFlush() throws CharacterCodingException { |
| ByteBuffer out = ByteBuffer.allocate(6); |
| CharBuffer in = CharBuffer.wrap("aaa"); |
| assertEquals(in.remaining(), 3); |
| |
| // by encode facade, so that internal state will be wrong |
| encoder.encode(CharBuffer.wrap("testFlush"), ByteBuffer.allocate(20), |
| true); |
| assertSame(CoderResult.UNDERFLOW, encoder |
| .flush(ByteBuffer.allocate(50))); |
| } |
| |
| /* |
| * test isLegalReplacement(byte[]) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "isLegalReplacement", |
| args = {byte[].class} |
| ) |
| public void testIsLegalReplacement() { |
| try { |
| encoder.isLegalReplacement(null); |
| fail("should throw null pointer exception"); |
| } catch (NullPointerException e) { |
| } |
| assertTrue(encoder.isLegalReplacement(specifiedReplacement)); |
| |
| assertTrue(encoder.isLegalReplacement(new byte[200])); |
| byte[] ba = getIllegalByteArray(); |
| if (ba != null) { |
| assertFalse(encoder.isLegalReplacement(ba)); |
| } |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "isLegalReplacement", |
| args = {byte[].class} |
| ) |
| public void testIsLegalReplacementEmptyArray() { |
| // ISO, ASC, GB, UTF8 encoder will throw exception in RI |
| // others will pass |
| // try { |
| assertTrue(encoder.isLegalReplacement(new byte[0])); |
| // fail("should throw ArrayIndexOutOfBoundsException"); |
| // } catch (ArrayIndexOutOfBoundsException e) { |
| // } |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "onMalformedInput", |
| args = {java.nio.charset.CodingErrorAction.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "malformedInputAction", |
| args = {} |
| ) |
| }) |
| public void testOnMalformedInput() { |
| assertSame(CodingErrorAction.REPORT, encoder.malformedInputAction()); |
| try { |
| encoder.onMalformedInput(null); |
| fail("should throw null pointer exception"); |
| } catch (IllegalArgumentException e) { |
| } |
| encoder.onMalformedInput(CodingErrorAction.IGNORE); |
| assertSame(CodingErrorAction.IGNORE, encoder.malformedInputAction()); |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "onUnmappableCharacter", |
| args = {java.nio.charset.CodingErrorAction.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "unmappableCharacterAction", |
| args = {} |
| ) |
| }) |
| public void testOnUnmappableCharacter() { |
| assertSame(CodingErrorAction.REPORT, encoder |
| .unmappableCharacterAction()); |
| try { |
| encoder.onUnmappableCharacter(null); |
| fail("should throw null pointer exception"); |
| } catch (IllegalArgumentException e) { |
| } |
| encoder.onUnmappableCharacter(CodingErrorAction.IGNORE); |
| assertSame(CodingErrorAction.IGNORE, encoder |
| .unmappableCharacterAction()); |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "replaceWith", |
| args = {byte[].class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "replacement", |
| args = {} |
| ) |
| }) |
| public void testReplacement() { |
| try { |
| encoder.replaceWith(null); |
| fail("should throw null pointer exception"); |
| } catch (IllegalArgumentException e) { |
| } |
| try { |
| encoder.replaceWith(new byte[0]); |
| fail("should throw null pointer exception"); |
| } catch (IllegalArgumentException e) { |
| } |
| try { |
| encoder.replaceWith(new byte[100]); |
| fail("should throw null pointer exception"); |
| } catch (IllegalArgumentException e) { |
| } |
| |
| byte[] nr = getLegalByteArray(); |
| assertSame(encoder, encoder.replaceWith(nr)); |
| assertSame(nr, encoder.replacement()); |
| |
| nr = getIllegalByteArray(); |
| try { |
| encoder.replaceWith(new byte[100]); |
| fail("should throw null pointer exception"); |
| } catch (IllegalArgumentException e) { |
| } |
| } |
| |
| protected byte[] getLegalByteArray() { |
| return new byte[] { 'a' }; |
| } |
| |
| protected byte[] getIllegalByteArray() { |
| return new byte[155]; |
| } |
| |
| } |
