svn checkout svn://somepath@1234 working-directoryorsvn checkout url://repository/path@1234
or
svn checkout -r 1234 url://repository/pathWednesday, December 21, 2011
Checkout a specific revision from subversion from command line
Friday, December 9, 2011
UTF8 encode decode
/* 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);
// }
}
}
source :
Subscribe to:
Posts (Atom)