| /* 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.nio_char.tests.java.nio.charset; |
| |
| import dalvik.annotation.TestTargetClass; |
| import dalvik.annotation.TestTargets; |
| import dalvik.annotation.TestTargetNew; |
| import dalvik.annotation.TestLevel; |
| |
| import java.io.IOException; |
| import java.nio.BufferOverflowException; |
| 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.CoderMalfunctionError; |
| import java.nio.charset.CoderResult; |
| |
| import junit.framework.TestCase; |
| @TestTargetClass(CharsetEncoder.class) |
| public class CharsetEncoderTest extends TestCase { |
| |
| /** |
| * @tests java.nio.charset.CharsetEncoder.CharsetEncoder( |
| * java.nio.charset.Charset, float, float) |
| */ |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Checks IllegalArgumentException", |
| method = "CharsetEncoder", |
| args = {java.nio.charset.Charset.class, float.class, float.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Checks IllegalArgumentException", |
| method = "CharsetEncoder", |
| args = {java.nio.charset.Charset.class, float.class, float.class, byte[].class} |
| ) |
| }) |
| public void test_ConstructorLjava_nio_charset_CharsetFF() { |
| // Regression for HARMONY-141 |
| try { |
| Charset cs = Charset.forName("UTF-8"); |
| new MockCharsetEncoderForHarmony141(cs, 1.1f, 1); |
| fail("Assert 0: Should throw IllegalArgumentException."); |
| } catch (IllegalArgumentException e) { |
| // expected |
| } |
| |
| try { |
| Charset cs = Charset.forName("ISO8859-1"); |
| new MockCharsetEncoderForHarmony141(cs, 1.1f, 1, |
| new byte[] { 0x1a }); |
| fail("Assert 1: Should throw IllegalArgumentException."); |
| } catch (IllegalArgumentException e) { |
| // expected |
| } |
| } |
| |
| /** |
| * @tests java.nio.charset.CharsetEncoder.CharsetEncoder( |
| * java.nio.charset.Charset, float, float) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "CharsetEncoder", |
| args = {java.nio.charset.Charset.class, float.class, float.class} |
| ) |
| public void test_ConstructorLjava_nio_charset_CharsetNull() { |
| // Regression for HARMONY-491 |
| CharsetEncoder ech = new MockCharsetEncoderForHarmony491(null, 1, 1); |
| assertNull(ech.charset()); |
| } |
| |
| /** |
| * Helper for constructor tests |
| */ |
| |
| public static class MockCharsetEncoderForHarmony141 extends CharsetEncoder { |
| |
| protected MockCharsetEncoderForHarmony141(Charset cs, |
| float averageBytesPerChar, float maxBytesPerChar) { |
| super(cs, averageBytesPerChar, maxBytesPerChar); |
| } |
| |
| public MockCharsetEncoderForHarmony141(Charset cs, |
| float averageBytesPerChar, float maxBytesPerChar, |
| byte[] replacement) { |
| super(cs, averageBytesPerChar, maxBytesPerChar, replacement); |
| } |
| |
| protected CoderResult encodeLoop(CharBuffer in, ByteBuffer out) { |
| return null; |
| } |
| } |
| |
| public static class MockCharsetEncoderForHarmony491 extends CharsetEncoder { |
| |
| public MockCharsetEncoderForHarmony491(Charset arg0, float arg1, |
| float arg2) { |
| super(arg0, arg1, arg2); |
| } |
| |
| protected CoderResult encodeLoop(CharBuffer arg0, ByteBuffer arg1) { |
| return null; |
| } |
| |
| public boolean isLegalReplacement(byte[] arg0) { |
| return true; |
| } |
| } |
| |
| /* |
| * Test malfunction encode(CharBuffer) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL, |
| notes = "Regression test checks CoderMalfunctionError", |
| method = "encode", |
| args = {java.nio.CharBuffer.class} |
| ) |
| public void test_EncodeLjava_nio_CharBuffer() throws Exception { |
| MockMalfunctionCharset cs = new MockMalfunctionCharset("mock", null); |
| try { |
| cs.encode(CharBuffer.wrap("AB")); |
| fail("should throw CoderMalfunctionError"); |
| } catch (CoderMalfunctionError e) { |
| // expected |
| } |
| } |
| |
| /* |
| * Mock charset class with malfunction decode & encode. |
| */ |
| static final class MockMalfunctionCharset extends Charset { |
| |
| public MockMalfunctionCharset(String canonicalName, String[] aliases) { |
| super(canonicalName, aliases); |
| } |
| |
| public boolean contains(Charset cs) { |
| return false; |
| } |
| |
| public CharsetDecoder newDecoder() { |
| return Charset.forName("UTF-8").newDecoder(); |
| } |
| |
| public CharsetEncoder newEncoder() { |
| return new MockMalfunctionEncoder(this); |
| } |
| } |
| |
| /* |
| * Mock encoder. encodeLoop always throws unexpected exception. |
| */ |
| static class MockMalfunctionEncoder extends java.nio.charset.CharsetEncoder { |
| |
| public MockMalfunctionEncoder(Charset cs) { |
| super(cs, 1, 3, new byte[] { (byte) '?' }); |
| } |
| |
| protected CoderResult encodeLoop(CharBuffer in, ByteBuffer out) { |
| throw new BufferOverflowException(); |
| } |
| } |
| |
| /* |
| * Test reserve bytes encode(CharBuffer,ByteBuffer,boolean) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL, |
| notes = "Functional test.", |
| method = "encode", |
| args = {java.nio.CharBuffer.class, java.nio.ByteBuffer.class, boolean.class} |
| ) |
| public void test_EncodeLjava_nio_CharBufferLjava_nio_ByteBufferB() { |
| CharsetEncoder encoder = Charset.forName("utf-8").newEncoder(); |
| CharBuffer in1 = CharBuffer.wrap("\ud800"); |
| CharBuffer in2 = CharBuffer.wrap("\udc00"); |
| ByteBuffer out = ByteBuffer.allocate(4); |
| encoder.reset(); |
| CoderResult result = encoder.encode(in1, out, false); |
| assertEquals(4, out.remaining()); |
| assertTrue(result.isUnderflow()); |
| result = encoder.encode(in2, out, true); |
| assertEquals(4, out.remaining()); |
| assertTrue(result.isMalformed()); |
| } |
| |
| /** |
| * @tests {@link java.nio.charset.Charset#encode(java.nio.CharBuffer) |
| */ |
| public void testUtf8Encoding() throws IOException { |
| byte[] orig = new byte[] { (byte) 0xed, (byte) 0xa0, |
| (byte) 0x80 }; |
| String s = new String(orig, "UTF-8"); |
| assertEquals(1, s.length()); |
| assertEquals(55296, s.charAt(0)); |
| Charset.forName("UTF-8").encode(CharBuffer.wrap(s)); |
| // ByteBuffer buf = <result> |
| // for (byte o : orig) { |
| // byte b = 0; |
| // buf.get(b); |
| // assertEquals(o, b); |
| // } |
| } |
| } |