| /** |
| ******************************************************************************* |
| * Copyright (C) 2006-2010, International Business Machines Corporation and * |
| * others. All Rights Reserved. * |
| ******************************************************************************* |
| * |
| ******************************************************************************* |
| */ |
| |
| package com.ibm.icu.dev.test.charset; |
| |
| import java.nio.BufferOverflowException; |
| 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.UnsupportedCharsetException; |
| import java.nio.charset.spi.CharsetProvider; |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.MissingResourceException; |
| import java.util.Set; |
| import java.util.SortedMap; |
| |
| import com.ibm.icu.charset.CharsetCallback; |
| import com.ibm.icu.charset.CharsetDecoderICU; |
| import com.ibm.icu.charset.CharsetEncoderICU; |
| import com.ibm.icu.charset.CharsetICU; |
| import com.ibm.icu.charset.CharsetProviderICU; |
| import com.ibm.icu.dev.test.TestFmwk; |
| import com.ibm.icu.text.UTF16; |
| |
| public class TestCharset extends TestFmwk { |
| private String m_encoding = "UTF-16"; |
| CharsetDecoder m_decoder = null; |
| CharsetEncoder m_encoder = null; |
| Charset m_charset =null; |
| static final String unistr = "abcd\ud800\udc00\u1234\u00a5\u3000\r\n"; |
| static final byte[] byteStr ={ |
| (byte) 0x00,(byte) 'a', |
| (byte) 0x00,(byte) 'b', |
| (byte) 0x00,(byte) 'c', |
| (byte) 0x00,(byte) 'd', |
| (byte) 0xd8,(byte) 0x00, |
| (byte) 0xdc,(byte) 0x00, |
| (byte) 0x12,(byte) 0x34, |
| (byte) 0x00,(byte) 0xa5, |
| (byte) 0x30,(byte) 0x00, |
| (byte) 0x00,(byte) 0x0d, |
| (byte) 0x00,(byte) 0x0a }; |
| static final byte[] expectedByteStr ={ |
| (byte) 0xfe,(byte) 0xff, |
| (byte) 0x00,(byte) 'a', |
| (byte) 0x00,(byte) 'b', |
| (byte) 0x00,(byte) 'c', |
| (byte) 0x00,(byte) 'd', |
| (byte) 0xd8,(byte) 0x00, |
| (byte) 0xdc,(byte) 0x00, |
| (byte) 0x12,(byte) 0x34, |
| (byte) 0x00,(byte) 0xa5, |
| (byte) 0x30,(byte) 0x00, |
| (byte) 0x00,(byte) 0x0d, |
| (byte) 0x00,(byte) 0x0a }; |
| |
| protected void init(){ |
| try{ |
| if ("UTF-16".equals(m_encoding)) { |
| int x = 2; |
| x++; |
| } |
| CharsetProviderICU provider = new CharsetProviderICU(); |
| //Charset charset = CharsetICU.forName(encoding); |
| m_charset = provider.charsetForName(m_encoding); |
| m_decoder = (CharsetDecoder) m_charset.newDecoder(); |
| m_encoder = (CharsetEncoder) m_charset.newEncoder(); |
| }catch(MissingResourceException ex){ |
| warnln("Could not load charset data"); |
| } |
| } |
| |
| public static void main(String[] args) throws Exception { |
| new TestCharset().run(args); |
| } |
| public void TestUTF16Converter(){ |
| CharsetProvider icu = new CharsetProviderICU(); |
| Charset cs1 = icu.charsetForName("UTF-16BE"); |
| CharsetEncoder e1 = cs1.newEncoder(); |
| CharsetDecoder d1 = cs1.newDecoder(); |
| |
| Charset cs2 = icu.charsetForName("UTF-16LE"); |
| CharsetEncoder e2 = cs2.newEncoder(); |
| CharsetDecoder d2 = cs2.newDecoder(); |
| |
| for(int i=0x0000; i<0x10FFFF; i+=0xFF){ |
| CharBuffer us = CharBuffer.allocate(0xFF*2); |
| ByteBuffer bs1 = ByteBuffer.allocate(0xFF*8); |
| ByteBuffer bs2 = ByteBuffer.allocate(0xFF*8); |
| for(int j=0;j<0xFF; j++){ |
| int c = i+j; |
| |
| if((c>=0xd800&&c<=0xdFFF)||c>0x10FFFF){ |
| continue; |
| } |
| |
| if(c>0xFFFF){ |
| char lead = UTF16.getLeadSurrogate(c); |
| char trail = UTF16.getTrailSurrogate(c); |
| if(!UTF16.isLeadSurrogate(lead)){ |
| errln("lead is not lead!"+lead+" for cp: \\U"+Integer.toHexString(c)); |
| continue; |
| } |
| if(!UTF16.isTrailSurrogate(trail)){ |
| errln("trail is not trail!"+trail); |
| continue; |
| } |
| us.put(lead); |
| us.put(trail); |
| bs1.put((byte)(lead>>8)); |
| bs1.put((byte)(lead&0xFF)); |
| bs1.put((byte)(trail>>8)); |
| bs1.put((byte)(trail&0xFF)); |
| |
| bs2.put((byte)(lead&0xFF)); |
| bs2.put((byte)(lead>>8)); |
| bs2.put((byte)(trail&0xFF)); |
| bs2.put((byte)(trail>>8)); |
| }else{ |
| |
| if(c<0xFF){ |
| bs1.put((byte)0x00); |
| bs1.put((byte)(c)); |
| bs2.put((byte)(c)); |
| bs2.put((byte)0x00); |
| }else{ |
| bs1.put((byte)(c>>8)); |
| bs1.put((byte)(c&0xFF)); |
| |
| bs2.put((byte)(c&0xFF)); |
| bs2.put((byte)(c>>8)); |
| } |
| us.put((char)c); |
| } |
| } |
| |
| |
| us.limit(us.position()); |
| us.position(0); |
| if(us.length()==0){ |
| continue; |
| } |
| |
| |
| bs1.limit(bs1.position()); |
| bs1.position(0); |
| ByteBuffer newBS = ByteBuffer.allocate(bs1.capacity()); |
| //newBS.put((byte)0xFE); |
| //newBS.put((byte)0xFF); |
| newBS.put(bs1); |
| bs1.position(0); |
| smBufDecode(d1, "UTF-16", bs1, us); |
| smBufEncode(e1, "UTF-16", us, newBS); |
| |
| bs2.limit(bs2.position()); |
| bs2.position(0); |
| newBS.clear(); |
| //newBS.put((byte)0xFF); |
| //newBS.put((byte)0xFE); |
| newBS.put(bs2); |
| bs2.position(0); |
| smBufDecode(d2, "UTF16-LE", bs2, us); |
| smBufEncode(e2, "UTF-16LE", us, newBS); |
| |
| } |
| } |
| public void TestUTF32Converter(){ |
| CharsetProvider icu = new CharsetProviderICU(); |
| Charset cs1 = icu.charsetForName("UTF-32BE"); |
| CharsetEncoder e1 = cs1.newEncoder(); |
| CharsetDecoder d1 = cs1.newDecoder(); |
| |
| Charset cs2 = icu.charsetForName("UTF-32LE"); |
| CharsetEncoder e2 = cs2.newEncoder(); |
| CharsetDecoder d2 = cs2.newDecoder(); |
| |
| for(int i=0x000; i<0x10FFFF; i+=0xFF){ |
| CharBuffer us = CharBuffer.allocate(0xFF*2); |
| ByteBuffer bs1 = ByteBuffer.allocate(0xFF*8); |
| ByteBuffer bs2 = ByteBuffer.allocate(0xFF*8); |
| for(int j=0;j<0xFF; j++){ |
| int c = i+j; |
| |
| if((c>=0xd800&&c<=0xdFFF)||c>0x10FFFF){ |
| continue; |
| } |
| |
| if(c>0xFFFF){ |
| char lead = UTF16.getLeadSurrogate(c); |
| char trail = UTF16.getTrailSurrogate(c); |
| |
| us.put(lead); |
| us.put(trail); |
| }else{ |
| us.put((char)c); |
| } |
| bs1.put((byte) (c >>> 24)); |
| bs1.put((byte) (c >>> 16)); |
| bs1.put((byte) (c >>> 8)); |
| bs1.put((byte) (c & 0xFF)); |
| |
| bs2.put((byte) (c & 0xFF)); |
| bs2.put((byte) (c >>> 8)); |
| bs2.put((byte) (c >>> 16)); |
| bs2.put((byte) (c >>> 24)); |
| } |
| bs1.limit(bs1.position()); |
| bs1.position(0); |
| bs2.limit(bs2.position()); |
| bs2.position(0); |
| us.limit(us.position()); |
| us.position(0); |
| if(us.length()==0){ |
| continue; |
| } |
| |
| |
| ByteBuffer newBS = ByteBuffer.allocate(bs1.capacity()); |
| |
| newBS.put((byte)0x00); |
| newBS.put((byte)0x00); |
| newBS.put((byte)0xFE); |
| newBS.put((byte)0xFF); |
| |
| newBS.put(bs1); |
| bs1.position(0); |
| smBufDecode(d1, "UTF-32", bs1, us); |
| smBufEncode(e1, "UTF-32", us, newBS); |
| |
| |
| newBS.clear(); |
| |
| newBS.put((byte)0xFF); |
| newBS.put((byte)0xFE); |
| newBS.put((byte)0x00); |
| newBS.put((byte)0x00); |
| |
| newBS.put(bs2); |
| bs2.position(0); |
| smBufDecode(d2, "UTF-32LE", bs2, us); |
| smBufEncode(e2, "UTF-32LE", us, newBS); |
| |
| } |
| } |
| public void TestASCIIConverter() { |
| runTestASCIIBasedConverter("ASCII", 0x80); |
| } |
| public void Test88591Converter() { |
| runTestASCIIBasedConverter("iso-8859-1", 0x100); |
| } |
| public void runTestASCIIBasedConverter(String converter, int limit){ |
| CharsetProvider icu = new CharsetProviderICU(); |
| Charset icuChar = icu.charsetForName(converter); |
| CharsetEncoder encoder = icuChar.newEncoder(); |
| CharsetDecoder decoder = icuChar.newDecoder(); |
| CoderResult cr; |
| |
| /* test with and without array-backed buffers */ |
| |
| byte[] bytes = new byte[0x10000]; |
| char[] chars = new char[0x10000]; |
| for (int j = 0; j <= 0xffff; j++) { |
| bytes[j] = (byte) j; |
| chars[j] = (char) j; |
| } |
| |
| boolean fail = false; |
| boolean arrays = false; |
| boolean decoding = false; |
| int i; |
| |
| // 0 thru limit - 1 |
| ByteBuffer bs = ByteBuffer.wrap(bytes, 0, limit); |
| CharBuffer us = CharBuffer.wrap(chars, 0, limit); |
| smBufDecode(decoder, converter, bs, us, true); |
| smBufDecode(decoder, converter, bs, us, false); |
| smBufEncode(encoder, converter, us, bs, true); |
| smBufEncode(encoder, converter, us, bs, false); |
| for (i = 0; i < limit; i++) { |
| bs = ByteBuffer.wrap(bytes, i, 1).slice(); |
| us = CharBuffer.wrap(chars, i, 1).slice(); |
| try { |
| decoding = true; |
| arrays = true; |
| smBufDecode(decoder, converter, bs, us, true, false, true); |
| |
| decoding = true; |
| arrays = false; |
| smBufDecode(decoder, converter, bs, us, true, false, false); |
| |
| decoding = false; |
| arrays = true; |
| smBufEncode(encoder, converter, us, bs, true, false, true); |
| |
| decoding = false; |
| arrays = false; |
| smBufEncode(encoder, converter, us, bs, true, false, false); |
| |
| } catch (Exception ex) { |
| errln("Failed to fail to " + (decoding ? "decode" : "encode") + " 0x" |
| + Integer.toHexString(i) + (arrays ? " with arrays" : " without arrays") + " in " + converter); |
| return; |
| } |
| } |
| |
| // decode limit thru 255 |
| for (i = limit; i <= 0xff; i++) { |
| bs = ByteBuffer.wrap(bytes, i, 1).slice(); |
| us = CharBuffer.wrap(chars, i, 1).slice(); |
| try { |
| smBufDecode(decoder, converter, bs, us, true, false, true); |
| fail = true; |
| arrays = true; |
| break; |
| } catch (Exception ex) { |
| } |
| try { |
| smBufDecode(decoder, converter, bs, us, true, false, false); |
| fail = true; |
| arrays = false; |
| break; |
| } catch (Exception ex) { |
| } |
| } |
| if (fail) { |
| errln("Failed to fail to decode 0x" + Integer.toHexString(i) |
| + (arrays ? " with arrays" : " without arrays") + " in " + converter); |
| return; |
| } |
| |
| // encode limit thru 0xffff, skipping through much of the 1ff to feff range to save |
| // time (it would take too much time to test every possible case) |
| for (i = limit; i <= 0xffff; i = ((i>=0x1ff && i<0xfeff) ? i+0xfd : i+1)) { |
| bs = ByteBuffer.wrap(bytes, i, 1).slice(); |
| us = CharBuffer.wrap(chars, i, 1).slice(); |
| try { |
| smBufEncode(encoder, converter, us, bs, true, false, true); |
| fail = true; |
| arrays = true; |
| break; |
| } catch (Exception ex) { |
| } |
| try { |
| smBufEncode(encoder, converter, us, bs, true, false, false); |
| fail = true; |
| arrays = false; |
| break; |
| } catch (Exception ex) { |
| } |
| } |
| if (fail) { |
| errln("Failed to fail to encode 0x" + Integer.toHexString(i) |
| + (arrays ? " with arrays" : " without arrays") + " in " + converter); |
| return; |
| } |
| |
| // test overflow / underflow edge cases |
| outer: for (int n = 1; n <= 3; n++) { |
| for (int m = 0; m < n; m++) { |
| // expecting underflow |
| try { |
| bs = ByteBuffer.wrap(bytes, 'a', m).slice(); |
| us = CharBuffer.wrap(chars, 'a', m).slice(); |
| smBufDecode(decoder, converter, bs, us, true, false, true); |
| smBufDecode(decoder, converter, bs, us, true, false, false); |
| smBufEncode(encoder, converter, us, bs, true, false, true); |
| smBufEncode(encoder, converter, us, bs, true, false, false); |
| bs = ByteBuffer.wrap(bytes, 'a', m).slice(); |
| us = CharBuffer.wrap(chars, 'a', n).slice(); |
| smBufDecode(decoder, converter, bs, us, true, false, true, m); |
| smBufDecode(decoder, converter, bs, us, true, false, false, m); |
| bs = ByteBuffer.wrap(bytes, 'a', n).slice(); |
| us = CharBuffer.wrap(chars, 'a', m).slice(); |
| smBufEncode(encoder, converter, us, bs, true, false, true, m); |
| smBufEncode(encoder, converter, us, bs, true, false, false, m); |
| bs = ByteBuffer.wrap(bytes, 'a', n).slice(); |
| us = CharBuffer.wrap(chars, 'a', n).slice(); |
| smBufDecode(decoder, converter, bs, us, true, false, true); |
| smBufDecode(decoder, converter, bs, us, true, false, false); |
| smBufEncode(encoder, converter, us, bs, true, false, true); |
| smBufEncode(encoder, converter, us, bs, true, false, false); |
| } catch (Exception ex) { |
| fail = true; |
| break outer; |
| } |
| |
| // expecting overflow |
| try { |
| bs = ByteBuffer.wrap(bytes, 'a', n).slice(); |
| us = CharBuffer.wrap(chars, 'a', m).slice(); |
| smBufDecode(decoder, converter, bs, us, true, false, true); |
| fail = true; |
| break; |
| } catch (Exception ex) { |
| if (!(ex instanceof BufferOverflowException)) { |
| fail = true; |
| break outer; |
| } |
| } |
| try { |
| bs = ByteBuffer.wrap(bytes, 'a', n).slice(); |
| us = CharBuffer.wrap(chars, 'a', m).slice(); |
| smBufDecode(decoder, converter, bs, us, true, false, false); |
| fail = true; |
| } catch (Exception ex) { |
| if (!(ex instanceof BufferOverflowException)) { |
| fail = true; |
| break outer; |
| } |
| } |
| try { |
| bs = ByteBuffer.wrap(bytes, 'a', m).slice(); |
| us = CharBuffer.wrap(chars, 'a', n).slice(); |
| smBufEncode(encoder, converter, us, bs, true, false, true); |
| fail = true; |
| } catch (Exception ex) { |
| if (!(ex instanceof BufferOverflowException)) { |
| fail = true; |
| break outer; |
| } |
| } |
| try { |
| bs = ByteBuffer.wrap(bytes, 'a', m).slice(); |
| us = CharBuffer.wrap(chars, 'a', n).slice(); |
| smBufEncode(encoder, converter, us, bs, true, false, false); |
| fail = true; |
| } catch (Exception ex) { |
| if (!(ex instanceof BufferOverflowException)) { |
| fail = true; |
| break outer; |
| } |
| } |
| } |
| } |
| if (fail) { |
| errln("Incorrect result in " + converter + " for underflow / overflow edge cases"); |
| return; |
| } |
| |
| // test surrogate combinations in encoding |
| String lead = "\ud888"; |
| String trail = "\udc88"; |
| String norm = "a"; |
| String ext = "\u0275"; // theta |
| String end = ""; |
| bs = ByteBuffer.wrap(new byte[] { 0 }); |
| String[] input = new String[] { // |
| lead + lead, // malf(1) |
| lead + trail, // unmap(2) |
| lead + norm, // malf(1) |
| lead + ext, // malf(1) |
| lead + end, // malf(1) |
| trail + norm, // malf(1) |
| trail + end, // malf(1) |
| ext + norm, // unmap(1) |
| ext + end, // unmap(1) |
| }; |
| CoderResult[] result = new CoderResult[] { |
| CoderResult.malformedForLength(1), |
| CoderResult.unmappableForLength(2), |
| CoderResult.malformedForLength(1), |
| CoderResult.malformedForLength(1), |
| CoderResult.malformedForLength(1), |
| CoderResult.malformedForLength(1), |
| CoderResult.malformedForLength(1), |
| CoderResult.unmappableForLength(1), |
| CoderResult.unmappableForLength(1), |
| }; |
| |
| for (int index = 0; index < input.length; index++) { |
| CharBuffer source = CharBuffer.wrap(input[index]); |
| cr = encoder.encode(source, bs, true); |
| bs.rewind(); |
| encoder.reset(); |
| |
| // if cr != results[x] |
| if (!((cr.isUnderflow() && result[index].isUnderflow()) |
| || (cr.isOverflow() && result[index].isOverflow()) |
| || (cr.isMalformed() && result[index].isMalformed()) |
| || (cr.isUnmappable() && result[index].isUnmappable())) |
| || (cr.isError() && cr.length() != result[index].length())) { |
| errln("Incorrect result in " + converter + " for \"" + input[index] + "\"" + ", expected: " + result[index] + ", received: " + cr); |
| break; |
| } |
| |
| source = CharBuffer.wrap(input[index].toCharArray()); |
| cr = encoder.encode(source, bs, true); |
| bs.rewind(); |
| encoder.reset(); |
| |
| // if cr != results[x] |
| if (!((cr.isUnderflow() && result[index].isUnderflow()) |
| || (cr.isOverflow() && result[index].isOverflow()) |
| || (cr.isMalformed() && result[index].isMalformed()) |
| || (cr.isUnmappable() && result[index].isUnmappable())) |
| || (cr.isError() && cr.length() != result[index].length())) { |
| errln("Incorrect result in " + converter + " for \"" + input[index] + "\"" + ", expected: " + result[index] + ", received: " + cr); |
| break; |
| } |
| } |
| } |
| public void TestUTF8Converter() { |
| String converter = "UTF-8"; |
| CharsetProvider icu = new CharsetProviderICU(); |
| Charset icuChar = icu.charsetForName(converter); |
| CharsetEncoder encoder = icuChar.newEncoder(); |
| CharsetDecoder decoder = icuChar.newDecoder(); |
| ByteBuffer bs; |
| CharBuffer us; |
| CoderResult cr; |
| |
| |
| int[] size = new int[] { 1<<7, 1<<11, 1<<16 }; // # of 1,2,3 byte combinations |
| byte[] bytes = new byte[size[0] + size[1]*2 + size[2]*3]; |
| char[] chars = new char[size[0] + size[1] + size[2]]; |
| int i = 0; |
| int x, y; |
| |
| // 0 to 1 << 7 (1 byters) |
| for (; i < size[0]; i++) { |
| bytes[i] = (byte) i; |
| chars[i] = (char) i; |
| bs = ByteBuffer.wrap(bytes, i, 1).slice(); |
| us = CharBuffer.wrap(chars, i, 1).slice(); |
| try { |
| smBufDecode(decoder, converter, bs, us, true, false, true); |
| smBufDecode(decoder, converter, bs, us, true, false, false); |
| smBufEncode(encoder, converter, us, bs, true, false, true); |
| smBufEncode(encoder, converter, us, bs, true, false, false); |
| } catch (Exception ex) { |
| errln("Incorrect result in " + converter + " for 0x" |
| + Integer.toHexString(i)); |
| break; |
| } |
| } |
| |
| // 1 << 7 to 1 << 11 (2 byters) |
| for (; i < size[1]; i++) { |
| x = size[0] + i*2; |
| y = size[0] + i; |
| bytes[x + 0] = (byte) (0xc0 | ((i >> 6) & 0x1f)); |
| bytes[x + 1] = (byte) (0x80 | ((i >> 0) & 0x3f)); |
| chars[y] = (char) i; |
| bs = ByteBuffer.wrap(bytes, x, 2).slice(); |
| us = CharBuffer.wrap(chars, y, 1).slice(); |
| try { |
| smBufDecode(decoder, converter, bs, us, true, false, true); |
| smBufDecode(decoder, converter, bs, us, true, false, false); |
| smBufEncode(encoder, converter, us, bs, true, false, true); |
| smBufEncode(encoder, converter, us, bs, true, false, false); |
| } catch (Exception ex) { |
| errln("Incorrect result in " + converter + " for 0x" |
| + Integer.toHexString(i)); |
| break; |
| } |
| } |
| |
| // 1 << 11 to 1 << 16 (3 byters and surrogates) |
| for (; i < size[2]; i++) { |
| x = size[0] + size[1] * 2 + i * 3; |
| y = size[0] + size[1] + i; |
| bytes[x + 0] = (byte) (0xe0 | ((i >> 12) & 0x0f)); |
| bytes[x + 1] = (byte) (0x80 | ((i >> 6) & 0x3f)); |
| bytes[x + 2] = (byte) (0x80 | ((i >> 0) & 0x3f)); |
| chars[y] = (char) i; |
| if (!UTF16.isSurrogate((char)i)) { |
| bs = ByteBuffer.wrap(bytes, x, 3).slice(); |
| us = CharBuffer.wrap(chars, y, 1).slice(); |
| try { |
| smBufDecode(decoder, converter, bs, us, true, false, true); |
| smBufDecode(decoder, converter, bs, us, true, false, false); |
| smBufEncode(encoder, converter, us, bs, true, false, true); |
| smBufEncode(encoder, converter, us, bs, true, false, false); |
| } catch (Exception ex) { |
| errln("Incorrect result in " + converter + " for 0x" |
| + Integer.toHexString(i)); |
| break; |
| } |
| } else { |
| bs = ByteBuffer.wrap(bytes, x, 3).slice(); |
| us = CharBuffer.wrap(chars, y, 1).slice(); |
| |
| decoder.reset(); |
| cr = decoder.decode(bs, us, true); |
| bs.rewind(); |
| us.rewind(); |
| if (!cr.isMalformed() || cr.length() != 3) { |
| errln("Incorrect result in " + converter + " decoder for 0x" |
| + Integer.toHexString(i) + " received " + cr); |
| break; |
| } |
| encoder.reset(); |
| cr = encoder.encode(us, bs, true); |
| bs.rewind(); |
| us.rewind(); |
| if (!cr.isMalformed() || cr.length() != 1) { |
| errln("Incorrect result in " + converter + " encoder for 0x" |
| + Integer.toHexString(i) + " received " + cr); |
| break; |
| } |
| |
| bs = ByteBuffer.wrap(bytes, x, 3).slice(); |
| us = CharBuffer.wrap(new String(chars, y, 1)); |
| |
| decoder.reset(); |
| cr = decoder.decode(bs, us, true); |
| bs.rewind(); |
| us.rewind(); |
| if (!cr.isMalformed() || cr.length() != 3) { |
| errln("Incorrect result in " + converter + " decoder for 0x" |
| + Integer.toHexString(i) + " received " + cr); |
| break; |
| } |
| encoder.reset(); |
| cr = encoder.encode(us, bs, true); |
| bs.rewind(); |
| us.rewind(); |
| if (!cr.isMalformed() || cr.length() != 1) { |
| errln("Incorrect result in " + converter + " encoder for 0x" |
| + Integer.toHexString(i) + " received " + cr); |
| break; |
| } |
| |
| |
| } |
| } |
| if (true) |
| return; |
| } |
| |
| public void TestHZ() { |
| /* test input */ |
| char[] in = new char[] { |
| 0x3000, 0x3001, 0x3002, 0x00B7, 0x02C9, 0x02C7, 0x00A8, 0x3003, 0x3005, 0x2014, |
| 0xFF5E, 0x2016, 0x2026, 0x007E, 0x997C, 0x70B3, 0x75C5, 0x5E76, 0x73BB, 0x83E0, |
| 0x64AD, 0x62E8, 0x94B5, 0x000A, 0x6CE2, 0x535A, 0x52C3, 0x640F, 0x94C2, 0x7B94, |
| 0x4F2F, 0x5E1B, 0x8236, 0x000A, 0x8116, 0x818A, 0x6E24, 0x6CCA, 0x9A73, 0x6355, |
| 0x535C, 0x54FA, 0x8865, 0x000A, 0x57E0, 0x4E0D, 0x5E03, 0x6B65, 0x7C3F, 0x90E8, |
| 0x6016, 0x248F, 0x2490, 0x000A, 0x2491, 0x2492, 0x2493, 0x2494, 0x2495, 0x2496, |
| 0x2497, 0x2498, 0x2499, 0x000A, 0x249A, 0x249B, 0x2474, 0x2475, 0x2476, 0x2477, |
| 0x2478, 0x2479, 0x247A, 0x000A, 0x247B, 0x247C, 0x247D, 0x247E, 0x247F, 0x2480, |
| 0x2481, 0x2482, 0x2483, 0x000A, 0x0041, 0x0043, 0x0044, 0x0045, 0x0046, 0x007E, |
| 0x0048, 0x0049, 0x004A, 0x000A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F, 0x0050, |
| 0x0051, 0x0052, 0x0053, 0x000A, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, |
| 0x005A, 0x005B, 0x005C, 0x000A |
| }; |
| |
| String converter = "HZ"; |
| CharsetProvider icu = new CharsetProviderICU(); |
| Charset icuChar = icu.charsetForName(converter); |
| CharsetEncoder encoder = icuChar.newEncoder(); |
| CharsetDecoder decoder = icuChar.newDecoder(); |
| try { |
| CharBuffer start = CharBuffer.wrap(in); |
| ByteBuffer bytes = encoder.encode(start); |
| CharBuffer finish = decoder.decode(bytes); |
| |
| if (!equals(start, finish)) { |
| errln(converter + " roundtrip test failed: start does not match finish"); |
| |
| char[] finishArray = new char[finish.limit()]; |
| for (int i=0; i<finishArray.length; i++) |
| finishArray[i] = finish.get(i); |
| |
| logln("start: " + hex(in)); |
| logln("finish: " + hex(finishArray)); |
| } |
| } catch (CharacterCodingException ex) { |
| errln(converter + " roundtrip test failed: " + ex.getMessage()); |
| ex.printStackTrace(System.err); |
| } |
| |
| /* For better code coverage */ |
| CoderResult result = CoderResult.UNDERFLOW; |
| byte byteout[] = { |
| (byte)0x7e, (byte)0x7d, (byte)0x41, |
| (byte)0x7e, (byte)0x7b, (byte)0x21, |
| }; |
| char charin[] = { |
| (char)0x0041, (char)0x0042, (char)0x3000 |
| }; |
| ByteBuffer bb = ByteBuffer.wrap(byteout); |
| CharBuffer cb = CharBuffer.wrap(charin); |
| int testLoopSize = 5; |
| int bbLimits[] = { 0, 1, 3, 4, 6}; |
| int bbPositions[] = { 0, 0, 0, 3, 3 }; |
| int ccPositions[] = { 0, 0, 0, 2, 2 }; |
| for (int i = 0; i < testLoopSize; i++) { |
| encoder.reset(); |
| bb.limit(bbLimits[i]); |
| bb.position(bbPositions[i]); |
| cb.position(ccPositions[i]); |
| result = encoder.encode(cb, bb, true); |
| |
| if (i < 3) { |
| if (!result.isOverflow()) { |
| errln("Overflow buffer error should have occurred while encoding HZ (" + i + ")"); |
| } |
| } else { |
| if (result.isError()) { |
| errln("Error should not have occurred while encoding HZ.(" + i + ")"); |
| } |
| } |
| } |
| } |
| |
| public void TestUTF8Surrogates() { |
| byte[][] in = new byte[][] { |
| { (byte)0x61, }, |
| { (byte)0xc2, (byte)0x80, }, |
| { (byte)0xe0, (byte)0xa0, (byte)0x80, }, |
| { (byte)0xf0, (byte)0x90, (byte)0x80, (byte)0x80, }, |
| { (byte)0xf4, (byte)0x84, (byte)0x8c, (byte)0xa1, }, |
| { (byte)0xf0, (byte)0x90, (byte)0x90, (byte)0x81, }, |
| }; |
| |
| /* expected test results */ |
| char[][] results = new char[][] { |
| /* number of bytes read, code point */ |
| { '\u0061', }, |
| { '\u0080', }, |
| { '\u0800', }, |
| { '\ud800', '\udc00', }, // 10000 |
| { '\udbd0', '\udf21', }, // 104321 |
| { '\ud801', '\udc01', }, // 10401 |
| }; |
| |
| /* error test input */ |
| byte[][] in2 = new byte[][] { |
| { (byte)0x61, }, |
| { (byte)0xc0, (byte)0x80, /* illegal non-shortest form */ |
| (byte)0xe0, (byte)0x80, (byte)0x80, /* illegal non-shortest form */ |
| (byte)0xf0, (byte)0x80, (byte)0x80, (byte)0x80, /* illegal non-shortest form */ |
| (byte)0xc0, (byte)0xc0, /* illegal trail byte */ |
| (byte)0xf4, (byte)0x90, (byte)0x80, (byte)0x80, /* 0x110000 out of range */ |
| (byte)0xf8, (byte)0x80, (byte)0x80, (byte)0x80, (byte)0x80, /* too long */ |
| (byte)0xfe, /* illegal byte altogether */ |
| (byte)0x62, }, |
| }; |
| |
| /* expected error test results */ |
| char[][] results2 = new char[][] { |
| /* number of bytes read, code point */ |
| { '\u0062', }, |
| { '\u0062', }, |
| }; |
| |
| String converter = "UTF-8"; |
| CharsetProvider icu = new CharsetProviderICU(); |
| Charset icuChar = icu.charsetForName(converter); |
| CharsetDecoder decoder = icuChar.newDecoder(); |
| |
| int i; |
| try { |
| for (i = 0; i < in.length; i++) { |
| ByteBuffer source = ByteBuffer.wrap(in[i]); |
| CharBuffer expected = CharBuffer.wrap(results[i]); |
| smBufDecode(decoder, converter, source, expected, true, false, |
| true); |
| smBufDecode(decoder, converter, source, expected, true, false, |
| false); |
| } |
| } catch (Exception ex) { |
| errln("Incorrect result in " + converter); |
| } |
| try { |
| for (i = 0; i < in2.length; i++) { |
| ByteBuffer source = ByteBuffer.wrap(in2[i]); |
| CharBuffer expected = CharBuffer.wrap(results2[i]); |
| decoder.onMalformedInput(CodingErrorAction.IGNORE); |
| smBufDecode(decoder, converter, source, expected, true, false, |
| true); |
| smBufDecode(decoder, converter, source, expected, true, false, |
| false); |
| } |
| } catch (Exception ex) { |
| errln("Incorrect result in " + converter); |
| } |
| } |
| |
| public void TestSurrogateBehavior() { |
| CharsetProviderICU icu = new CharsetProviderICU(); |
| |
| // get all the converters into an array |
| Object[] converters = CharsetProviderICU.getAvailableNames(); |
| |
| String norm = "a"; |
| String ext = "\u0275"; // theta |
| String lead = "\ud835"; |
| String trail = "\udd04"; |
| // lead + trail = \U1d504 (fraktur capital A) |
| |
| String input = |
| // error position |
| ext // unmap(1) 1 |
| + lead // under 1 |
| + lead // malf(1) 2 |
| + trail // unmap(2) 4 |
| + trail // malf(1) 5 |
| + ext // unmap(1) 6 |
| + norm // unmap(1) 7 |
| ; |
| CoderResult[] results = new CoderResult[] { |
| CoderResult.unmappableForLength(1), // or underflow |
| CoderResult.UNDERFLOW, |
| CoderResult.malformedForLength(1), |
| CoderResult.unmappableForLength(2), // or underflow |
| CoderResult.malformedForLength(1), |
| CoderResult.unmappableForLength(1), // or underflow |
| CoderResult.unmappableForLength(1), // or underflow |
| }; |
| int[] positions = new int[] { 1,1,2,4,5,6,7 }; |
| int n = positions.length; |
| |
| int badcount = 0; |
| int goodcount = 0; |
| int[] uhohindices = new int[n]; |
| int[] badposindices = new int[n]; |
| int[] malfindices = new int[n]; |
| int[] unmapindices = new int[n]; |
| ArrayList pass = new ArrayList(); |
| ArrayList exempt = new ArrayList(); |
| |
| outer: for (int conv=0; conv<converters.length; conv++) { |
| String converter = (String)converters[conv]; |
| if (converter.equals("x-IMAP-mailbox-name") || converter.equals("UTF-7") || converter.equals("CESU-8") || converter.equals("BOCU-1") || |
| converter.equals("x-LMBCS-1")) { |
| exempt.add(converter); |
| continue; |
| } |
| |
| boolean currentlybad = false; |
| Charset icuChar = icu.charsetForName(converter); |
| CharsetEncoder encoder = icuChar.newEncoder(); |
| CoderResult cr; |
| |
| CharBuffer source = CharBuffer.wrap(input); |
| ByteBuffer target = ByteBuffer.allocate(30); |
| ByteBuffer expected = null; |
| try { |
| encoder.onUnmappableCharacter(CodingErrorAction.IGNORE); |
| encoder.onMalformedInput(CodingErrorAction.IGNORE); |
| expected = encoder.encode(CharBuffer.wrap(ext + lead + trail + ext + norm)); |
| encoder.reset(); |
| } catch (CharacterCodingException ex) { |
| errln("Unexpected CharacterCodingException: " + ex.getMessage()); |
| return; |
| } catch (RuntimeException ex) { |
| if (!currentlybad) {currentlybad = true; badcount++; logln(""); } |
| errln(converter + " " + ex.getClass().getName() + ": " + ex.getMessage()); |
| continue outer; |
| } |
| |
| encoder.onUnmappableCharacter(CodingErrorAction.REPORT); |
| encoder.onMalformedInput(CodingErrorAction.REPORT); |
| for (int i=0; i<n; i++) { |
| source.limit(i+1); |
| cr = encoder.encode(source, target, i == n - 1); |
| if (!(equals(cr, results[i]) |
| || (results[i].isUnmappable() && cr.isUnderflow()) // mappability depends on the converter |
| )) { |
| if (!currentlybad) {currentlybad = true; badcount++; logln(""); } |
| if (results[i].isMalformed() && cr.isMalformed()) { |
| malfindices[i]++; |
| } else if (results[i].isUnmappable() && cr.isUnmappable()) { |
| unmapindices[i]++; |
| } else { |
| uhohindices[i]++; |
| } |
| errln("(index=" + i + ") " + converter + " Received: " + cr + " Expected: " + results[i]); |
| } |
| if (source.position() != positions[i]) { |
| if (!currentlybad) {currentlybad = true; badcount++; logln(""); } |
| badposindices[i]++; |
| errln("(index=" + i + ") " + converter + " Received: " + source.position() + " Expected: " + positions[i]); |
| } |
| |
| } |
| encoder.reset(); |
| |
| //System.out.println("\n" + hex(target.array())); |
| //System.out.println(hex(expected.array()) + "\n" + expected.limit()); |
| if (!(equals(target, expected, expected.limit()) && target.position() == expected.limit())) { |
| if (!currentlybad) {currentlybad = true; badcount++; logln(""); } |
| errln(converter + " Received: \"" + hex(target.array()) + "\" Expected: \"" + hex(expected.array()) + "\""); |
| } |
| |
| if (!currentlybad) { |
| goodcount++; |
| pass.add(converter); |
| } |
| } |
| |
| logln("\n" + badcount + " / " + (converters.length - exempt.size()) + " (" + goodcount + " good, " + badcount + " bad)"); |
| log("index\t"); for (int i=0; i<n; i++) log(i + "\t"); logln(""); |
| log("unmap\t"); for (int i=0; i<n; i++) log(unmapindices[i] + "\t"); logln(""); |
| log("malf \t"); for (int i=0; i<n; i++) log(malfindices[i] + "\t"); logln(""); |
| log("pos \t"); for (int i=0; i<n; i++) log(badposindices[i] + "\t"); logln(""); |
| log("uhoh \t"); for (int i=0; i<n; i++) log(uhohindices[i] + "\t"); logln(""); |
| logln(""); |
| log("The few that passed: "); for (int i=0; i<pass.size(); i++) log(pass.get(i) + ", "); logln(""); |
| log("The few that are exempt: "); for (int i=0; i<exempt.size(); i++) log(exempt.get(i) + ", "); logln(""); |
| } |
| |
| // public void TestCharsetCallback() { |
| // String currentTest = "initialization"; |
| // try { |
| // Class[] params; |
| // |
| // // get the classes |
| // Class CharsetCallback = Class.forName("com.ibm.icu.charset.CharsetCallback"); |
| // Class Decoder = Class.forName("com.ibm.icu.charset.CharsetCallback$Decoder"); |
| // Class Encoder = Class.forName("com.ibm.icu.charset.CharsetCallback$Encoder"); |
| // |
| // // set up encoderCall |
| // params = new Class[] {CharsetEncoderICU.class, Object.class, |
| // CharBuffer.class, ByteBuffer.class, IntBuffer.class, |
| // char[].class, int.class, int.class, CoderResult.class }; |
| // Method encoderCall = Encoder.getDeclaredMethod("call", params); |
| // |
| // // set up decoderCall |
| // params = new Class[] {CharsetDecoderICU.class, Object.class, |
| // ByteBuffer.class, CharBuffer.class, IntBuffer.class, |
| // char[].class, int.class, CoderResult.class}; |
| // Method decoderCall = Decoder.getDeclaredMethod("call", params); |
| // |
| // // get relevant fields |
| // Object SUB_STOP_ON_ILLEGAL = getFieldValue(CharsetCallback, "SUB_STOP_ON_ILLEGAL", null); |
| // |
| // // set up a few arguments |
| // CharsetProvider provider = new CharsetProviderICU(); |
| // Charset charset = provider.charsetForName("UTF-8"); |
| // CharsetEncoderICU encoder = (CharsetEncoderICU)charset.newEncoder(); |
| // CharsetDecoderICU decoder = (CharsetDecoderICU)charset.newDecoder(); |
| // CharBuffer chars = CharBuffer.allocate(10); |
| // chars.put('o'); |
| // chars.put('k'); |
| // ByteBuffer bytes = ByteBuffer.allocate(10); |
| // bytes.put((byte)'o'); |
| // bytes.put((byte)'k'); |
| // IntBuffer offsets = IntBuffer.allocate(10); |
| // offsets.put(0); |
| // offsets.put(1); |
| // char[] buffer = null; |
| // Integer length = new Integer(2); |
| // Integer cp = new Integer(0); |
| // CoderResult unmap = CoderResult.unmappableForLength(2); |
| // CoderResult malf = CoderResult.malformedForLength(2); |
| // CoderResult under = CoderResult.UNDERFLOW; |
| // |
| // // set up error arrays |
| // Integer invalidCharLength = new Integer(1); |
| // Byte subChar1 = new Byte((byte)0); |
| // Byte subChar1_alternate = new Byte((byte)1); // for TO_U_CALLBACK_SUBSTITUTE |
| // |
| // // set up chars and bytes backups and expected values for certain cases |
| // CharBuffer charsBackup = bufferCopy(chars); |
| // ByteBuffer bytesBackup = bufferCopy(bytes); |
| // IntBuffer offsetsBackup = bufferCopy(offsets); |
| // CharBuffer encoderCharsExpected = bufferCopy(chars); |
| // ByteBuffer encoderBytesExpected = bufferCopy(bytes); |
| // IntBuffer encoderOffsetsExpected = bufferCopy(offsets); |
| // CharBuffer decoderCharsExpected1 = bufferCopy(chars); |
| // CharBuffer decoderCharsExpected2 = bufferCopy(chars); |
| // IntBuffer decoderOffsetsExpected1 = bufferCopy(offsets); |
| // IntBuffer decoderOffsetsExpected2 = bufferCopy(offsets); |
| // |
| // // initialize fields to obtain expected data |
| // setFieldValue(CharsetDecoderICU.class, "invalidCharLength", decoder, invalidCharLength); |
| // setFieldValue(CharsetICU.class, "subChar1", ((CharsetICU) decoder.charset()), subChar1); |
| // |
| // // run cbFromUWriteSub |
| // Method cbFromUWriteSub = CharsetEncoderICU.class.getDeclaredMethod("cbFromUWriteSub", new Class[] { CharsetEncoderICU.class, CharBuffer.class, ByteBuffer.class, IntBuffer.class}); |
| // cbFromUWriteSub.setAccessible(true); |
| // CoderResult encoderResultExpected = (CoderResult)cbFromUWriteSub.invoke(encoder, new Object[] {encoder, encoderCharsExpected, encoderBytesExpected, encoderOffsetsExpected}); |
| // |
| // // run toUWriteUChars with normal data |
| // Method toUWriteUChars = CharsetDecoderICU.class.getDeclaredMethod("toUWriteUChars", new Class[] { CharsetDecoderICU.class, char[].class, int.class, int.class, CharBuffer.class, IntBuffer.class, int.class}); |
| // toUWriteUChars.setAccessible(true); |
| // CoderResult decoderResultExpected1 = (CoderResult)toUWriteUChars.invoke(decoder, new Object[] {decoder, new char[] {0xFFFD}, new Integer(0), new Integer(1), decoderCharsExpected1, decoderOffsetsExpected1, new Integer(bytes.position())}); |
| // |
| // // reset certain fields |
| // setFieldValue(CharsetDecoderICU.class, "invalidCharLength", decoder, invalidCharLength); |
| // setFieldValue(CharsetICU.class, "subChar1", ((CharsetICU) decoder.charset()), subChar1_alternate); |
| // |
| // // run toUWriteUChars again |
| // CoderResult decoderResultExpected2 = (CoderResult)toUWriteUChars.invoke(decoder, new Object[] {decoder, new char[] {0x1A}, new Integer(0), new Integer(1), decoderCharsExpected2, decoderOffsetsExpected2, new Integer(bytes.position())}); |
| // |
| // // begin creating the tests array |
| // ArrayList tests = new ArrayList(); |
| // |
| // // create tests for FROM_U_CALLBACK_SKIP 0 |
| // tests.add(new Object[] {encoderCall, "FROM_U_CALLBACK_SKIP", new Object[] { encoder, null, chars, bytes, offsets, buffer, length, cp, null }, under, charsBackup, bytesBackup, offsetsBackup, new Object[] { }}); |
| // tests.add(new Object[] {encoderCall, "FROM_U_CALLBACK_SKIP", new Object[] { encoder, SUB_STOP_ON_ILLEGAL, chars, bytes, offsets, buffer, length, cp, malf }, malf, charsBackup, bytesBackup, offsetsBackup, new Object[] { }}); |
| // tests.add(new Object[] {encoderCall, "FROM_U_CALLBACK_SKIP", new Object[] { encoder, SUB_STOP_ON_ILLEGAL, chars, bytes, offsets, buffer, length, cp, unmap }, under, charsBackup, bytesBackup, offsetsBackup, new Object[] { }}); |
| // tests.add(new Object[] {encoderCall, "FROM_U_CALLBACK_SKIP", new Object[] { encoder, SUB_STOP_ON_ILLEGAL + "xx", chars, bytes, offsets, buffer, length, cp, null }, null, charsBackup, bytesBackup, offsetsBackup, new Object[] { }}); |
| // |
| // // create tests for TO_U_CALLBACK_SKIP 4 |
| // tests.add(new Object[] {decoderCall, "TO_U_CALLBACK_SKIP", new Object[] { decoder, null, bytes, chars, offsets, buffer, length, null }, under, charsBackup, bytesBackup, offsetsBackup, new Object[] { invalidCharLength, subChar1 }}); |
| // tests.add(new Object[] {decoderCall, "TO_U_CALLBACK_SKIP", new Object[] { decoder, SUB_STOP_ON_ILLEGAL, bytes, chars, offsets, buffer, length, malf }, malf, charsBackup, bytesBackup, offsetsBackup, new Object[] { invalidCharLength, subChar1 }}); |
| // tests.add(new Object[] {decoderCall, "TO_U_CALLBACK_SKIP", new Object[] { decoder, SUB_STOP_ON_ILLEGAL, bytes, chars, offsets, buffer, length, unmap }, under, charsBackup, bytesBackup, offsetsBackup, new Object[] { invalidCharLength, subChar1 }}); |
| // tests.add(new Object[] {decoderCall, "TO_U_CALLBACK_SKIP", new Object[] { decoder, SUB_STOP_ON_ILLEGAL + "xx", bytes, chars, offsets, buffer, length, null }, null, charsBackup, bytesBackup, offsetsBackup, new Object[] { invalidCharLength, subChar1 }}); |
| // |
| // // create tests for FROM_U_CALLBACK_STOP 8 |
| // tests.add(new Object[] {encoderCall, "FROM_U_CALLBACK_STOP", new Object[] { encoder, null, chars, bytes, offsets, buffer, length, cp, null }, null, charsBackup, bytesBackup, offsetsBackup, new Object[] { }}); |
| // tests.add(new Object[] {encoderCall, "FROM_U_CALLBACK_STOP", new Object[] { encoder, SUB_STOP_ON_ILLEGAL, chars, bytes, offsets, buffer, length, cp, malf }, malf, charsBackup, bytesBackup, offsetsBackup, new Object[] { }}); |
| // tests.add(new Object[] {encoderCall, "FROM_U_CALLBACK_STOP", new Object[] { encoder, SUB_STOP_ON_ILLEGAL, chars, bytes, offsets, buffer, length, cp, unmap }, unmap, charsBackup, bytesBackup, offsetsBackup, new Object[] { }}); |
| // tests.add(new Object[] {encoderCall, "FROM_U_CALLBACK_STOP", new Object[] { encoder, SUB_STOP_ON_ILLEGAL + "xx", chars, bytes, offsets, buffer, length, cp, null }, null, charsBackup, bytesBackup, offsetsBackup, new Object[] { }}); |
| // |
| // // create tests for TO_U_CALLBACK_STOP 12 |
| // tests.add(new Object[] {decoderCall, "TO_U_CALLBACK_STOP", new Object[] { decoder, null, bytes, chars, offsets, buffer, length, null }, null, charsBackup, bytesBackup, offsetsBackup, new Object[] { invalidCharLength, subChar1 }}); |
| // tests.add(new Object[] {decoderCall, "TO_U_CALLBACK_STOP", new Object[] { decoder, SUB_STOP_ON_ILLEGAL, bytes, chars, offsets, buffer, length, malf }, malf, charsBackup, bytesBackup, offsetsBackup, new Object[] { invalidCharLength, subChar1 }}); |
| // tests.add(new Object[] {decoderCall, "TO_U_CALLBACK_STOP", new Object[] { decoder, SUB_STOP_ON_ILLEGAL, bytes, chars, offsets, buffer, length, unmap }, unmap, charsBackup, bytesBackup, offsetsBackup, new Object[] { invalidCharLength, subChar1 }}); |
| // tests.add(new Object[] {decoderCall, "TO_U_CALLBACK_STOP", new Object[] { decoder, SUB_STOP_ON_ILLEGAL + "xx", bytes, chars, offsets, buffer, length, null }, null, charsBackup, bytesBackup, offsetsBackup, new Object[] { invalidCharLength, subChar1 }}); |
| // |
| // // create tests for FROM_U_CALLBACK_SUBSTITUTE 16 |
| // tests.add(new Object[] {encoderCall, "FROM_U_CALLBACK_SUBSTITUTE", new Object[] { encoder, null, chars, bytes, offsets, buffer, length, cp, null }, encoderResultExpected, encoderCharsExpected, encoderBytesExpected, encoderOffsetsExpected, new Object[] { }}); |
| // tests.add(new Object[] {encoderCall, "FROM_U_CALLBACK_SUBSTITUTE", new Object[] { encoder, SUB_STOP_ON_ILLEGAL, chars, bytes, offsets, buffer, length, cp, malf }, malf, charsBackup, bytesBackup, offsetsBackup, new Object[] { }}); |
| // tests.add(new Object[] {encoderCall, "FROM_U_CALLBACK_SUBSTITUTE", new Object[] { encoder, SUB_STOP_ON_ILLEGAL, chars, bytes, offsets, buffer, length, cp, unmap }, encoderResultExpected, encoderCharsExpected, encoderBytesExpected, encoderOffsetsExpected, new Object[] { }}); |
| // tests.add(new Object[] {encoderCall, "FROM_U_CALLBACK_SUBSTITUTE", new Object[] { encoder, SUB_STOP_ON_ILLEGAL + "xx", chars, bytes, offsets, buffer, length, cp, null }, null, charsBackup, bytesBackup, offsetsBackup, new Object[] { }}); |
| // |
| // // create tests for TO_U_CALLBACK_SUBSTITUTE 20 |
| // tests.add(new Object[] {decoderCall, "TO_U_CALLBACK_SUBSTITUTE", new Object[] { decoder, null, bytes, chars, offsets, buffer, length, null }, decoderResultExpected1, decoderCharsExpected1, bytesBackup, decoderOffsetsExpected1, new Object[] { invalidCharLength, subChar1 }}); |
| // tests.add(new Object[] {decoderCall, "TO_U_CALLBACK_SUBSTITUTE", new Object[] { decoder, null, bytes, chars, offsets, buffer, length, null }, decoderResultExpected2, decoderCharsExpected2, bytesBackup, decoderOffsetsExpected2, new Object[] { invalidCharLength, subChar1_alternate }}); |
| // |
| // Iterator iter = tests.iterator(); |
| // for (int i=0; iter.hasNext(); i++) { |
| // // get the data out of the map |
| // Object[] next = (Object[])iter.next(); |
| // |
| // Method method = (Method)next[0]; |
| // String fieldName = (String)next[1]; |
| // Object field = getFieldValue(CharsetCallback, fieldName, null); |
| // Object[] args = (Object[])next[2]; |
| // CoderResult expected = (CoderResult)next[3]; |
| // CharBuffer charsExpected = (CharBuffer)next[4]; |
| // ByteBuffer bytesExpected = (ByteBuffer)next[5]; |
| // IntBuffer offsetsExpected = (IntBuffer)next[6]; |
| // |
| // // set up error arrays and certain fields |
| // Object[] values = (Object[])next[7]; |
| // if (method == decoderCall) { |
| // decoder.reset(); |
| // setFieldValue(CharsetDecoderICU.class, "invalidCharLength", decoder, values[0]); |
| // setFieldValue(CharsetICU.class, "subChar1", ((CharsetICU) decoder.charset()), values[1]); |
| // } else if (method == encoderCall) { |
| // encoder.reset(); |
| // } |
| // |
| // try { |
| // // invoke the method |
| // CoderResult actual = (CoderResult)method.invoke(field, args); |
| // |
| // // if expected != actual |
| // if (!coderResultsEqual(expected, actual)) { |
| // // case #i refers to the index in the arraylist tests |
| // errln(fieldName + " failed to return the correct result for case #" + i + "."); |
| // } |
| // // if the expected buffers != actual buffers |
| // else if (!(buffersEqual(chars, charsExpected) && |
| // buffersEqual(bytes, bytesExpected) && |
| // buffersEqual(offsets, offsetsExpected))) { |
| // // case #i refers to the index in the arraylist tests |
| // errln(fieldName + " did not perform the correct operation on the buffers for case #" + i + "."); |
| // } |
| // } catch (InvocationTargetException ex) { |
| // // case #i refers to the index in the arraylist tests |
| // errln(fieldName + " threw an exception for case #" + i + ": " + ex.getCause()); |
| // //ex.getCause().printStackTrace(); |
| // } |
| // |
| // // reset the buffers |
| // System.arraycopy(bytesBackup.array(), 0, bytes.array(), 0, 10); |
| // System.arraycopy(charsBackup.array(), 0, chars.array(), 0, 10); |
| // System.arraycopy(offsetsBackup.array(), 0, offsets.array(), 0, 10); |
| // bytes.position(bytesBackup.position()); |
| // chars.position(charsBackup.position()); |
| // offsets.position(offsetsBackup.position()); |
| // } |
| // |
| // } catch (Exception ex) { |
| // errln("TestCharsetCallback skipped due to " + ex.toString()); |
| // ex.printStackTrace(); |
| // } |
| // } |
| // |
| // private Object getFieldValue(Class c, String name, Object instance) throws Exception { |
| // Field field = c.getDeclaredField(name); |
| // field.setAccessible(true); |
| // return field.get(instance); |
| // } |
| // private void setFieldValue(Class c, String name, Object instance, Object value) throws Exception { |
| // Field field = c.getDeclaredField(name); |
| // field.setAccessible(true); |
| // if (value instanceof Boolean) |
| // field.setBoolean(instance, ((Boolean)value).booleanValue()); |
| // else if (value instanceof Byte) |
| // field.setByte(instance, ((Byte)value).byteValue()); |
| // else if (value instanceof Character) |
| // field.setChar(instance, ((Character)value).charValue()); |
| // else if (value instanceof Double) |
| // field.setDouble(instance, ((Double)value).doubleValue()); |
| // else if (value instanceof Float) |
| // field.setFloat(instance, ((Float)value).floatValue()); |
| // else if (value instanceof Integer) |
| // field.setInt(instance, ((Integer)value).intValue()); |
| // else if (value instanceof Long) |
| // field.setLong(instance, ((Long)value).longValue()); |
| // else if (value instanceof Short) |
| // field.setShort(instance, ((Short)value).shortValue()); |
| // else |
| // field.set(instance, value); |
| // } |
| // private boolean coderResultsEqual(CoderResult a, CoderResult b) { |
| // if (a == null && b == null) |
| // return true; |
| // if (a == null || b == null) |
| // return false; |
| // if ((a.isUnderflow() && b.isUnderflow()) || (a.isOverflow() && b.isOverflow())) |
| // return true; |
| // if (a.length() != b.length()) |
| // return false; |
| // if ((a.isMalformed() && b.isMalformed()) || (a.isUnmappable() && b.isUnmappable())) |
| // return true; |
| // return false; |
| // } |
| // private boolean buffersEqual(ByteBuffer a, ByteBuffer b) { |
| // if (a.position() != b.position()) |
| // return false; |
| // int limit = a.position(); |
| // for (int i=0; i<limit; i++) |
| // if (a.get(i) != b.get(i)) |
| // return false; |
| // return true; |
| // } |
| // private boolean buffersEqual(CharBuffer a, CharBuffer b) { |
| // if (a.position() != b.position()) |
| // return false; |
| // int limit = a.position(); |
| // for (int i=0; i<limit; i++) |
| // if (a.get(i) != b.get(i)) |
| // return false; |
| // return true; |
| // } |
| // private boolean buffersEqual(IntBuffer a, IntBuffer b) { |
| // if (a.position() != b.position()) |
| // return false; |
| // int limit = a.position(); |
| // for (int i=0; i<limit; i++) |
| // if (a.get(i) != b.get(i)) |
| // return false; |
| // return true; |
| // } |
| // private ByteBuffer bufferCopy(ByteBuffer src) { |
| // ByteBuffer dest = ByteBuffer.allocate(src.limit()); |
| // System.arraycopy(src.array(), 0, dest.array(), 0, src.limit()); |
| // dest.position(src.position()); |
| // return dest; |
| // } |
| // private CharBuffer bufferCopy(CharBuffer src) { |
| // CharBuffer dest = CharBuffer.allocate(src.limit()); |
| // System.arraycopy(src.array(), 0, dest.array(), 0, src.limit()); |
| // dest.position(src.position()); |
| // return dest; |
| // } |
| // private IntBuffer bufferCopy(IntBuffer src) { |
| // IntBuffer dest = IntBuffer.allocate(src.limit()); |
| // System.arraycopy(src.array(), 0, dest.array(), 0, src.limit()); |
| // dest.position(src.position()); |
| // return dest; |
| // } |
| |
| |
| public void TestAPISemantics(/*String encoding*/) |
| throws Exception { |
| int rc; |
| ByteBuffer byes = ByteBuffer.wrap(byteStr); |
| CharBuffer uniVal = CharBuffer.wrap(unistr); |
| ByteBuffer expected = ByteBuffer.wrap(expectedByteStr); |
| |
| rc = 0; |
| if(m_decoder==null){ |
| warnln("Could not load decoder."); |
| return; |
| } |
| m_decoder.reset(); |
| /* Convert the whole buffer to Unicode */ |
| try { |
| CharBuffer chars = CharBuffer.allocate(unistr.length()); |
| CoderResult result = m_decoder.decode(byes, chars, false); |
| |
| if (result.isError()) { |
| errln("ToChars encountered Error"); |
| rc = 1; |
| } |
| if (result.isOverflow()) { |
| errln("ToChars encountered overflow exception"); |
| rc = 1; |
| } |
| if (!equals(chars, unistr)) { |
| errln("ToChars does not match"); |
| printchars(chars); |
| errln("Expected : "); |
| printchars(unistr); |
| rc = 2; |
| } |
| |
| } catch (Exception e) { |
| errln("ToChars - exception in buffer"); |
| rc = 5; |
| } |
| |
| /* Convert single bytes to Unicode */ |
| try { |
| CharBuffer chars = CharBuffer.allocate(unistr.length()); |
| ByteBuffer b = ByteBuffer.wrap(byteStr); |
| m_decoder.reset(); |
| CoderResult result=null; |
| for (int i = 1; i <= byteStr.length; i++) { |
| b.limit(i); |
| result = m_decoder.decode(b, chars, false); |
| if(result.isOverflow()){ |
| errln("ToChars single threw an overflow exception"); |
| } |
| if (result.isError()) { |
| errln("ToChars single the result is an error "+result.toString()); |
| } |
| } |
| if (unistr.length() != (chars.limit())) { |
| errln("ToChars single len does not match"); |
| rc = 3; |
| } |
| if (!equals(chars, unistr)) { |
| errln("ToChars single does not match"); |
| printchars(chars); |
| rc = 4; |
| } |
| } catch (Exception e) { |
| errln("ToChars - exception in single"); |
| //e.printStackTrace(); |
| rc = 6; |
| } |
| |
| /* Convert the buffer one at a time to Unicode */ |
| try { |
| CharBuffer chars = CharBuffer.allocate(unistr.length()); |
| m_decoder.reset(); |
| byes.rewind(); |
| for (int i = 1; i <= byteStr.length; i++) { |
| byes.limit(i); |
| CoderResult result = m_decoder.decode(byes, chars, false); |
| if (result.isError()) { |
| errln("Error while decoding: "+result.toString()); |
| } |
| if(result.isOverflow()){ |
| errln("ToChars Simple threw an overflow exception"); |
| } |
| } |
| if (chars.limit() != unistr.length()) { |
| errln("ToChars Simple buffer len does not match"); |
| rc = 7; |
| } |
| if (!equals(chars, unistr)) { |
| errln("ToChars Simple buffer does not match"); |
| printchars(chars); |
| err(" Expected : "); |
| printchars(unistr); |
| rc = 8; |
| } |
| } catch (Exception e) { |
| errln("ToChars - exception in single buffer"); |
| //e.printStackTrace(System.err); |
| rc = 9; |
| } |
| if (rc != 0) { |
| errln("Test Simple ToChars for encoding : FAILED"); |
| } |
| |
| rc = 0; |
| /* Convert the whole buffer from unicode */ |
| try { |
| ByteBuffer bytes = ByteBuffer.allocate(expectedByteStr.length); |
| m_encoder.reset(); |
| CoderResult result = m_encoder.encode(uniVal, bytes, false); |
| if (result.isError()) { |
| errln("FromChars reported error: " + result.toString()); |
| rc = 1; |
| } |
| if(result.isOverflow()){ |
| errln("FromChars threw an overflow exception"); |
| } |
| bytes.position(0); |
| if (!bytes.equals(expected)) { |
| errln("FromChars does not match"); |
| printbytes(bytes); |
| printbytes(expected); |
| rc = 2; |
| } |
| } catch (Exception e) { |
| errln("FromChars - exception in buffer"); |
| //e.printStackTrace(System.err); |
| rc = 5; |
| } |
| |
| /* Convert the buffer one char at a time to unicode */ |
| try { |
| ByteBuffer bytes = ByteBuffer.allocate(expectedByteStr.length); |
| CharBuffer c = CharBuffer.wrap(unistr); |
| m_encoder.reset(); |
| CoderResult result= null; |
| for (int i = 1; i <= unistr.length(); i++) { |
| c.limit(i); |
| result = m_encoder.encode(c, bytes, false); |
| if(result.isOverflow()){ |
| errln("FromChars single threw an overflow exception"); |
| } |
| if(result.isError()){ |
| errln("FromChars single threw an error: "+ result.toString()); |
| } |
| } |
| if (expectedByteStr.length != bytes.limit()) { |
| errln("FromChars single len does not match"); |
| rc = 3; |
| } |
| |
| bytes.position(0); |
| if (!bytes.equals(expected)) { |
| errln("FromChars single does not match"); |
| printbytes(bytes); |
| printbytes(expected); |
| rc = 4; |
| } |
| |
| } catch (Exception e) { |
| errln("FromChars - exception in single"); |
| //e.printStackTrace(System.err); |
| rc = 6; |
| } |
| |
| /* Convert one char at a time to unicode */ |
| try { |
| ByteBuffer bytes = ByteBuffer.allocate(expectedByteStr.length); |
| m_encoder.reset(); |
| char[] temp = unistr.toCharArray(); |
| CoderResult result=null; |
| for (int i = 0; i <= temp.length; i++) { |
| uniVal.limit(i); |
| result = m_encoder.encode(uniVal, bytes, false); |
| if(result.isOverflow()){ |
| errln("FromChars simple threw an overflow exception"); |
| } |
| if(result.isError()){ |
| errln("FromChars simple threw an error: "+ result.toString()); |
| } |
| } |
| if (bytes.limit() != expectedByteStr.length) { |
| errln("FromChars Simple len does not match"); |
| rc = 7; |
| } |
| if (!bytes.equals(byes)) { |
| errln("FromChars Simple does not match"); |
| printbytes(bytes); |
| printbytes(byes); |
| rc = 8; |
| } |
| } catch (Exception e) { |
| errln("FromChars - exception in single buffer"); |
| //e.printStackTrace(System.err); |
| rc = 9; |
| } |
| if (rc != 0) { |
| errln("Test Simple FromChars " + m_encoding + " --FAILED"); |
| } |
| } |
| |
| void printchars(CharBuffer buf) { |
| int i; |
| char[] chars = new char[buf.limit()]; |
| //save the current position |
| int pos = buf.position(); |
| buf.position(0); |
| buf.get(chars); |
| //reset to old position |
| buf.position(pos); |
| for (i = 0; i < chars.length; i++) { |
| err(hex(chars[i]) + " "); |
| } |
| errln(""); |
| } |
| void printchars(String str) { |
| char[] chars = str.toCharArray(); |
| for (int i = 0; i < chars.length; i++) { |
| err(hex(chars[i]) + " "); |
| } |
| errln(""); |
| } |
| void printbytes(ByteBuffer buf) { |
| int i; |
| byte[] bytes = new byte[buf.limit()]; |
| //save the current position |
| int pos = buf.position(); |
| buf.position(0); |
| buf.get(bytes); |
| //reset to old position |
| buf.position(pos); |
| for (i = 0; i < bytes.length; i++) { |
| System.out.print(hex(bytes[i]) + " "); |
| } |
| errln(""); |
| } |
| |
| public boolean equals(CoderResult a, CoderResult b) { |
| return (a.isUnderflow() && b.isUnderflow()) |
| || (a.isOverflow() && b.isOverflow()) |
| || (a.isMalformed() && b.isMalformed() && a.length() == b.length()) |
| || (a.isUnmappable() && b.isUnmappable() && a.length() == b.length()); |
| } |
| public boolean equals(CharBuffer buf, String str) { |
| return equals(buf, str.toCharArray()); |
| } |
| public boolean equals(CharBuffer buf, CharBuffer str) { |
| if (buf.limit() != str.limit()) |
| return false; |
| int limit = buf.limit(); |
| for (int i = 0; i < limit; i++) |
| if (buf.get(i) != str.get(i)) |
| return false; |
| return true; |
| } |
| public boolean equals(CharBuffer buf, CharBuffer str, int limit) { |
| if (limit > buf.limit() || limit > str.limit()) |
| return false; |
| for (int i = 0; i < limit; i++) |
| if (buf.get(i) != str.get(i)) |
| return false; |
| return true; |
| } |
| public boolean equals(CharBuffer buf, char[] compareTo) { |
| char[] chars = new char[buf.limit()]; |
| //save the current position |
| int pos = buf.position(); |
| buf.position(0); |
| buf.get(chars); |
| //reset to old position |
| buf.position(pos); |
| return equals(chars, compareTo); |
| } |
| |
| public boolean equals(char[] chars, char[] compareTo) { |
| if (chars.length != compareTo.length) { |
| errln( |
| "Length does not match chars: " |
| + chars.length |
| + " compareTo: " |
| + compareTo.length); |
| return false; |
| } else { |
| boolean result = true; |
| for (int i = 0; i < chars.length; i++) { |
| if (chars[i] != compareTo[i]) { |
| logln( |
| "Got: " |
| + hex(chars[i]) |
| + " Expected: " |
| + hex(compareTo[i]) |
| + " At: " |
| + i); |
| result = false; |
| } |
| } |
| return result; |
| } |
| } |
| |
| public boolean equals(ByteBuffer buf, byte[] compareTo) { |
| byte[] chars = new byte[buf.limit()]; |
| //save the current position |
| int pos = buf.position(); |
| buf.position(0); |
| buf.get(chars); |
| //reset to old position |
| buf.position(pos); |
| return equals(chars, compareTo); |
| } |
| public boolean equals(ByteBuffer buf, ByteBuffer compareTo) { |
| if (buf.limit() != compareTo.limit()) |
| return false; |
| int limit = buf.limit(); |
| for (int i = 0; i < limit; i++) |
| if (buf.get(i) != compareTo.get(i)) |
| return false; |
| return true; |
| } |
| public boolean equals(ByteBuffer buf, ByteBuffer compareTo, int limit) { |
| if (limit > buf.limit() || limit > compareTo.limit()) |
| return false; |
| for (int i = 0; i < limit; i++) |
| if (buf.get(i) != compareTo.get(i)) |
| return false; |
| return true; |
| } |
| public boolean equals(byte[] chars, byte[] compareTo) { |
| if (false/*chars.length != compareTo.length*/) { |
| errln( |
| "Length does not match chars: " |
| + chars.length |
| + " compareTo: " |
| + compareTo.length); |
| return false; |
| } else { |
| boolean result = true; |
| for (int i = 0; i < chars.length; i++) { |
| if (chars[i] != compareTo[i]) { |
| logln( |
| "Got: " |
| + hex(chars[i]) |
| + " Expected: " |
| + hex(compareTo[i]) |
| + " At: " |
| + i); |
| result = false; |
| } |
| } |
| return result; |
| } |
| } |
| |
| // TODO |
| /* |
| public void TestCallback(String encoding) throws Exception { |
| |
| byte[] gbSource = |
| { |
| (byte) 0x81, |
| (byte) 0x36, |
| (byte) 0xDE, |
| (byte) 0x36, |
| (byte) 0x81, |
| (byte) 0x36, |
| (byte) 0xDE, |
| (byte) 0x37, |
| (byte) 0x81, |
| (byte) 0x36, |
| (byte) 0xDE, |
| (byte) 0x38, |
| (byte) 0xe3, |
| (byte) 0x32, |
| (byte) 0x9a, |
| (byte) 0x36 }; |
| |
| char[] subChars = { 'P', 'I' }; |
| |
| decoder.reset(); |
| |
| decoder.replaceWith(new String(subChars)); |
| ByteBuffer mySource = ByteBuffer.wrap(gbSource); |
| CharBuffer myTarget = CharBuffer.allocate(5); |
| |
| decoder.decode(mySource, myTarget, true); |
| char[] expectedResult = |
| { '\u22A6', '\u22A7', '\u22A8', '\u0050', '\u0049', }; |
| |
| if (!equals(myTarget, new String(expectedResult))) { |
| errln("Test callback GB18030 to Unicode : FAILED"); |
| } |
| |
| } |
| */ |
| public void TestCanConvert(/*String encoding*/)throws Exception { |
| char[] mySource = { |
| '\ud800', '\udc00',/*surrogate pair */ |
| '\u22A6','\u22A7','\u22A8','\u22A9','\u22AA', |
| '\u22AB','\u22AC','\u22AD','\u22AE','\u22AF', |
| '\u22B0','\u22B1','\u22B2','\u22B3','\u22B4', |
| '\ud800','\udc00',/*surrogate pair */ |
| '\u22B5','\u22B6','\u22B7','\u22B8','\u22B9', |
| '\u22BA','\u22BB','\u22BC','\u22BD','\u22BE' |
| }; |
| if(m_encoder==null){ |
| warnln("Could not load encoder."); |
| return; |
| } |
| m_encoder.reset(); |
| if (!m_encoder.canEncode(new String(mySource))) { |
| errln("Test canConvert() " + m_encoding + " failed. "+m_encoder); |
| } |
| |
| } |
| public void TestAvailableCharsets() { |
| SortedMap map = Charset.availableCharsets(); |
| Set keySet = map.keySet(); |
| Iterator iter = keySet.iterator(); |
| while(iter.hasNext()){ |
| logln("Charset name: "+iter.next().toString()); |
| } |
| Object[] charsets = CharsetProviderICU.getAvailableNames(); |
| int mapSize = map.size(); |
| if(mapSize < charsets.length){ |
| errln("Charset.availableCharsets() returned a number less than the number returned by icu. ICU: " + charsets.length |
| + " JDK: " + mapSize); |
| } |
| logln("Total Number of chasets = " + map.size()); |
| } |
| /* ticket 5580 */ |
| public void TestJavaCanonicalNameOnAvailableCharsets() { |
| CharsetProviderICU provider = new CharsetProviderICU(); |
| Iterator allCharsets = provider.charsets(); |
| String errorMessage = null; |
| |
| while (allCharsets.hasNext()) { |
| Charset _chset = (Charset)allCharsets.next(); |
| Charset chset = Charset.forName(_chset.name()); |
| |
| if (!chset.name().equals(_chset.name())) { |
| if (errorMessage == null) { |
| errorMessage = new String("Error: Charset.forName( " + _chset.name() + " ) returned " + chset + " instead of " + _chset); |
| } else { |
| errorMessage = errorMessage + "\nError: Charset.forName( " + _chset.name() + " ) returned " + chset + " instead of " + _chset; |
| } |
| } |
| } |
| |
| if (errorMessage != null) { |
| errln(errorMessage); |
| } |
| } |
| |
| public void TestWindows936(){ |
| CharsetProviderICU icu = new CharsetProviderICU(); |
| Charset cs = icu.charsetForName("windows-936-2000"); |
| String canonicalName = cs.name(); |
| if(!canonicalName.equals("GBK")){ |
| errln("Did not get the expected canonical name. Got: "+canonicalName); //get the canonical name |
| } |
| } |
| |
| public void TestICUAvailableCharsets() { |
| CharsetProviderICU icu = new CharsetProviderICU(); |
| Object[] charsets = CharsetProviderICU.getAvailableNames(); |
| for(int i=0;i<charsets.length;i++){ |
| Charset cs = icu.charsetForName((String)charsets[i]); |
| try{ |
| CharsetEncoder encoder = cs.newEncoder(); |
| if(encoder!=null){ |
| logln("Creation of encoder succeeded. "+cs.toString()); |
| } |
| }catch(Exception ex){ |
| errln("Could not instantiate encoder for "+charsets[i]+". Error: "+ex.toString()); |
| } |
| try{ |
| CharsetDecoder decoder = cs.newDecoder(); |
| if(decoder!=null){ |
| logln("Creation of decoder succeeded. "+cs.toString()); |
| } |
| }catch(Exception ex){ |
| errln("Could not instantiate decoder for "+charsets[i]+". Error: "+ex.toString()); |
| } |
| } |
| } |
| /* jitterbug 4312 */ |
| public void TestUnsupportedCharset(){ |
| CharsetProvider icu = new CharsetProviderICU(); |
| Charset icuChar = icu.charsetForName("impossible"); |
| if(icuChar != null){ |
| errln("ICU does not conform to the spec"); |
| } |
| } |
| |
| |
| public void TestEncoderCreation(){ |
| try{ |
| Charset cs = Charset.forName("GB_2312-80"); |
| CharsetEncoder enc = cs.newEncoder(); |
| if(enc!=null && (enc instanceof CharsetEncoderICU) ){ |
| logln("Successfully created the encoder: "+ enc); |
| }else{ |
| errln("Error creating charset encoder."); |
| } |
| }catch(Exception e){ |
| warnln("Error creating charset encoder."+ e.toString()); |
| // e.printStackTrace(); |
| } |
| try{ |
| Charset cs = Charset.forName("x-ibm-971_P100-1995"); |
| CharsetEncoder enc = cs.newEncoder(); |
| if(enc!=null && (enc instanceof CharsetEncoderICU) ){ |
| logln("Successfully created the encoder: "+ enc); |
| }else{ |
| errln("Error creating charset encoder."); |
| } |
| }catch(Exception e){ |
| warnln("Error creating charset encoder."+ e.toString()); |
| } |
| } |
| public void TestSubBytes(){ |
| try{ |
| //create utf-8 decoder |
| CharsetDecoder decoder = new CharsetProviderICU().charsetForName("utf-8").newDecoder(); |
| |
| //create a valid byte array, which can be decoded to " buffer" |
| byte[] unibytes = new byte[] { 0x0020, 0x0062, 0x0075, 0x0066, 0x0066, 0x0065, 0x0072 }; |
| |
| ByteBuffer buffer = ByteBuffer.allocate(20); |
| |
| //add a evil byte to make the byte buffer be malformed input |
| buffer.put((byte)0xd8); |
| |
| //put the valid byte array |
| buffer.put(unibytes); |
| |
| //reset postion |
| buffer.flip(); |
| |
| decoder.onMalformedInput(CodingErrorAction.REPLACE); |
| CharBuffer out = decoder.decode(buffer); |
| String expected = "\ufffd buffer"; |
| if(!expected.equals(new String(out.array()))){ |
| errln("Did not get the expected result for substitution chars. Got: "+ |
| new String(out.array()) + "("+ hex(out.array())+")"); |
| } |
| logln("Output: "+ new String(out.array()) + "("+ hex(out.array())+")"); |
| }catch (CharacterCodingException ex){ |
| errln("Unexpected exception: "+ex.toString()); |
| } |
| } |
| /* |
| public void TestImplFlushFailure(){ |
| |
| try{ |
| CharBuffer in = CharBuffer.wrap("\u3005\u3006\u3007\u30FC\u2015\u2010\uFF0F"); |
| CharsetEncoder encoder = new CharsetProviderICU().charsetForName("iso-2022-jp").newEncoder(); |
| ByteBuffer out = ByteBuffer.allocate(30); |
| encoder.encode(in, out, true); |
| encoder.flush(out); |
| if(out.position()!= 20){ |
| errln("Did not get the expected position from flush"); |
| } |
| |
| }catch (Exception ex){ |
| errln("Could not create encoder for iso-2022-jp exception: "+ex.toString()); |
| } |
| } |
| */ |
| public void TestISO88591() { |
| |
| Charset cs = new CharsetProviderICU().charsetForName("iso-8859-1"); |
| if(cs!=null){ |
| CharsetEncoder encoder = cs.newEncoder(); |
| if(encoder!=null){ |
| encoder.canEncode("\uc2a3"); |
| }else{ |
| errln("Could not create encoder for iso-8859-1"); |
| } |
| }else{ |
| errln("Could not create Charset for iso-8859-1"); |
| } |
| |
| } |
| public void TestUTF8Encode() { |
| CharsetEncoder encoderICU = new CharsetProviderICU().charsetForName("utf-8").newEncoder(); |
| ByteBuffer out = ByteBuffer.allocate(30); |
| CoderResult result = encoderICU.encode(CharBuffer.wrap("\ud800"), out, true); |
| |
| if (result.isMalformed()) { |
| logln("\\ud800 is malformed for ICU4JNI utf-8 encoder"); |
| } else if (result.isUnderflow()) { |
| errln("\\ud800 is OK for ICU4JNI utf-8 encoder"); |
| } |
| |
| CharsetEncoder encoderJDK = Charset.forName("utf-8").newEncoder(); |
| result = encoderJDK.encode(CharBuffer.wrap("\ud800"), ByteBuffer |
| .allocate(10), true); |
| if (result.isUnderflow()) { |
| errln("\\ud800 is OK for JDK utf-8 encoder"); |
| } else if (result.isMalformed()) { |
| logln("\\ud800 is malformed for JDK utf-8 encoder"); |
| } |
| } |
| |
| /* private void printCB(CharBuffer buf){ |
| buf.rewind(); |
| while(buf.hasRemaining()){ |
| System.out.println(hex(buf.get())); |
| } |
| buf.rewind(); |
| } |
| */ |
| public void TestUTF8() throws CharacterCodingException{ |
| try{ |
| CharsetEncoder encoderICU = new CharsetProviderICU().charsetForName("utf-8").newEncoder(); |
| encoderICU.encode(CharBuffer.wrap("\ud800")); |
| errln("\\ud800 is OK for ICU4JNI utf-8 encoder"); |
| }catch (Exception e) { |
| logln("\\ud800 is malformed for JDK utf-8 encoder"); |
| //e.printStackTrace(); |
| } |
| |
| CharsetEncoder encoderJDK = Charset.forName("utf-8").newEncoder(); |
| try { |
| encoderJDK.encode(CharBuffer.wrap("\ud800")); |
| errln("\\ud800 is OK for JDK utf-8 encoder"); |
| } catch (Exception e) { |
| logln("\\ud800 is malformed for JDK utf-8 encoder"); |
| //e.printStackTrace(); |
| } |
| } |
| |
| public void TestUTF16Bom(){ |
| |
| Charset cs = (new CharsetProviderICU()).charsetForName("UTF-16"); |
| char[] in = new char[] { 0x1122, 0x2211, 0x3344, 0x4433, |
| 0x5566, 0x6655, 0x7788, 0x8877, 0x9900 }; |
| CharBuffer inBuf = CharBuffer.allocate(in.length); |
| inBuf.put(in); |
| CharsetEncoder encoder = cs.newEncoder(); |
| ByteBuffer outBuf = ByteBuffer.allocate(in.length*2+2); |
| inBuf.rewind(); |
| encoder.encode(inBuf, outBuf, true); |
| outBuf.rewind(); |
| if(outBuf.get(0)!= (byte)0xFE && outBuf.get(1)!= (byte)0xFF){ |
| errln("The UTF16 encoder did not appended bom. Length returned: " + outBuf.remaining()); |
| } |
| while(outBuf.hasRemaining()){ |
| logln("0x"+hex(outBuf.get())); |
| } |
| CharsetDecoder decoder = cs.newDecoder(); |
| outBuf.rewind(); |
| CharBuffer rt = CharBuffer.allocate(in.length); |
| CoderResult cr = decoder.decode(outBuf, rt, true); |
| if(cr.isError()){ |
| errln("Decoding with BOM failed. Error: "+ cr.toString()); |
| } |
| equals(rt, in); |
| { |
| rt.clear(); |
| outBuf.rewind(); |
| Charset utf16 = Charset.forName("UTF-16"); |
| CharsetDecoder dc = utf16.newDecoder(); |
| cr = dc.decode(outBuf, rt, true); |
| equals(rt, in); |
| } |
| } |
| |
| private void smBufDecode(CharsetDecoder decoder, String encoding, ByteBuffer source, CharBuffer target, |
| boolean throwException, boolean flush) throws BufferOverflowException, Exception { |
| smBufDecode(decoder, encoding, source, target, throwException, flush, true); |
| } |
| |
| private void smBufDecode(CharsetDecoder decoder, String encoding, ByteBuffer source, CharBuffer target, |
| boolean throwException, boolean flush, boolean backedByArray) throws BufferOverflowException, Exception { |
| smBufDecode(decoder, encoding, source, target, throwException, flush, backedByArray, -1); |
| } |
| |
| private void smBufDecode(CharsetDecoder decoder, String encoding, ByteBuffer source, CharBuffer target, |
| boolean throwException, boolean flush, boolean backedByArray, int targetLimit) |
| throws BufferOverflowException, Exception { |
| ByteBuffer mySource; |
| CharBuffer myTarget; |
| if (backedByArray) { |
| mySource = ByteBuffer.allocate(source.capacity()); |
| myTarget = CharBuffer.allocate(target.capacity()); |
| } else { |
| // this does not guarantee by any means that mySource and myTarget |
| // are not backed by arrays |
| mySource = ByteBuffer.allocateDirect(source.capacity()); |
| myTarget = ByteBuffer.allocateDirect(target.capacity() * 2).asCharBuffer(); |
| } |
| mySource.position(source.position()); |
| for (int i = source.position(); i < source.limit(); i++) |
| mySource.put(i, source.get(i)); |
| |
| { |
| decoder.reset(); |
| myTarget.limit(target.limit()); |
| mySource.limit(source.limit()); |
| mySource.position(source.position()); |
| CoderResult result = CoderResult.UNDERFLOW; |
| result = decoder.decode(mySource, myTarget, true); |
| if (flush) { |
| result = decoder.flush(myTarget); |
| } |
| if (result.isError()) { |
| if (throwException) { |
| throw new Exception(); |
| } |
| errln("Test complete buffers while decoding failed. " + result.toString()); |
| return; |
| } |
| if (result.isOverflow()) { |
| if (throwException) { |
| throw new BufferOverflowException(); |
| } |
| errln("Test complete buffers while decoding threw overflow exception"); |
| return; |
| } |
| myTarget.limit(myTarget.position()); |
| myTarget.position(0); |
| target.position(0); |
| if (result.isUnderflow() && !equals(myTarget, target, targetLimit)) { |
| errln(" Test complete buffers while decoding " + encoding + " TO Unicode--failed"); |
| } |
| } |
| if (isQuick()) { |
| return; |
| } |
| { |
| decoder.reset(); |
| myTarget.limit(target.position()); |
| mySource.limit(source.position()); |
| mySource.position(source.position()); |
| myTarget.clear(); |
| myTarget.position(0); |
| |
| int inputLen = mySource.remaining(); |
| |
| CoderResult result = CoderResult.UNDERFLOW; |
| for (int i = 1; i <= inputLen; i++) { |
| mySource.limit(i); |
| if (i == inputLen) { |
| result = decoder.decode(mySource, myTarget, true); |
| } else { |
| result = decoder.decode(mySource, myTarget, false); |
| } |
| if (result.isError()) { |
| errln("Test small input buffers while decoding failed. " + result.toString()); |
| break; |
| } |
| if (result.isOverflow()) { |
| if (throwException) { |
| throw new BufferOverflowException(); |
| } |
| errln("Test small input buffers while decoding threw overflow exception"); |
| break; |
| } |
| |
| } |
| if (result.isUnderflow() && !equals(myTarget, target, targetLimit)) { |
| errln("Test small input buffers while decoding " + encoding + " TO Unicode--failed"); |
| } |
| } |
| { |
| decoder.reset(); |
| myTarget.limit(0); |
| mySource.limit(0); |
| mySource.position(source.position()); |
| myTarget.clear(); |
| while (true) { |
| CoderResult result = decoder.decode(mySource, myTarget, false); |
| if (result.isUnderflow()) { |
| if (mySource.limit() < source.limit()) |
| mySource.limit(mySource.limit() + 1); |
| } else if (result.isOverflow()) { |
| if (myTarget.limit() < target.limit()) |
| myTarget.limit(myTarget.limit() + 1); |
| else |
| break; |
| } else /*if (result.isError())*/ { |
| errln("Test small output buffers while decoding " + result.toString()); |
| } |
| if (mySource.position() == mySource.limit()) { |
| result = decoder.decode(mySource, myTarget, true); |
| if (result.isError()) { |
| errln("Test small output buffers while decoding " + result.toString()); |
| } |
| result = decoder.flush(myTarget); |
| if (result.isError()) { |
| errln("Test small output buffers while decoding " + result.toString()); |
| } |
| break; |
| } |
| } |
| |
| if (!equals(myTarget, target, targetLimit)) { |
| errln("Test small output buffers " + encoding + " TO Unicode failed"); |
| } |
| } |
| } |
| |
| private void smBufEncode(CharsetEncoder encoder, String encoding, CharBuffer source, ByteBuffer target, |
| boolean throwException, boolean flush) throws Exception, BufferOverflowException { |
| smBufEncode(encoder, encoding, source, target, throwException, flush, true); |
| } |
| |
| private void smBufEncode(CharsetEncoder encoder, String encoding, CharBuffer source, ByteBuffer target, |
| boolean throwException, boolean flush, boolean backedByArray) throws Exception, BufferOverflowException { |
| smBufEncode(encoder, encoding, source, target, throwException, flush, true, -1); |
| } |
| |
| private void smBufEncode(CharsetEncoder encoder, String encoding, CharBuffer source, ByteBuffer target, |
| boolean throwException, boolean flush, boolean backedByArray, int targetLimit) throws Exception, |
| BufferOverflowException { |
| logln("Running smBufEncode for " + encoding + " with class " + encoder); |
| |
| CharBuffer mySource; |
| ByteBuffer myTarget; |
| if (backedByArray) { |
| mySource = CharBuffer.allocate(source.capacity()); |
| myTarget = ByteBuffer.allocate(target.capacity()); |
| } else { |
| mySource = ByteBuffer.allocateDirect(source.capacity() * 2).asCharBuffer(); |
| myTarget = ByteBuffer.allocateDirect(target.capacity()); |
| } |
| mySource.position(source.position()); |
| for (int i = source.position(); i < source.limit(); i++) |
| mySource.put(i, source.get(i)); |
| |
| myTarget.clear(); |
| { |
| logln("Running tests on small input buffers for " + encoding); |
| encoder.reset(); |
| myTarget.limit(target.limit()); |
| mySource.limit(source.limit()); |
| mySource.position(source.position()); |
| CoderResult result = null; |
| |
| result = encoder.encode(mySource, myTarget, true); |
| if (flush) { |
| result = encoder.flush(myTarget); |
| } |
| |
| if (result.isError()) { |
| if (throwException) { |
| throw new Exception(); |
| } |
| errln("Test complete while encoding failed. " + result.toString()); |
| } |
| if (result.isOverflow()) { |
| if (throwException) { |
| throw new BufferOverflowException(); |
| } |
| errln("Test complete while encoding threw overflow exception"); |
| } |
| if (!equals(myTarget, target, targetLimit)) { |
| errln("Test complete buffers while encoding for " + encoding + " failed"); |
| |
| } else { |
| logln("Tests complete buffers for " + encoding + " passed"); |
| } |
| } |
| if (isQuick()) { |
| return; |
| } |
| { |
| logln("Running tests on small input buffers for " + encoding); |
| encoder.reset(); |
| myTarget.clear(); |
| myTarget.limit(target.limit()); |
| mySource.limit(source.limit()); |
| mySource.position(source.position()); |
| int inputLen = mySource.limit(); |
| CoderResult result = null; |
| for (int i = 1; i <= inputLen; i++) { |
| mySource.limit(i); |
| result = encoder.encode(mySource, myTarget, false); |
| if (result.isError()) { |
| errln("Test small input buffers while encoding failed. " + result.toString()); |
| } |
| if (result.isOverflow()) { |
| if (throwException) { |
| throw new BufferOverflowException(); |
| } |
| errln("Test small input buffers while encoding threw overflow exception"); |
| } |
| } |
| if (!equals(myTarget, target, targetLimit)) { |
| errln("Test small input buffers " + encoding + " From Unicode failed"); |
| } else { |
| logln("Tests on small input buffers for " + encoding + " passed"); |
| } |
| } |
| { |
| logln("Running tests on small output buffers for " + encoding); |
| encoder.reset(); |
| myTarget.clear(); |
| myTarget.limit(target.limit()); |
| mySource.limit(source.limit()); |
| mySource.position(source.position()); |
| mySource.position(0); |
| myTarget.position(0); |
| |
| logln("myTarget.limit: " + myTarget.limit() + " myTarget.capcity: " + myTarget.capacity()); |
| |
| while (true) { |
| int pos = myTarget.position(); |
| |
| CoderResult result = encoder.encode(mySource, myTarget, false); |
| logln("myTarget.Position: " + pos + " myTarget.limit: " + myTarget.limit()); |
| logln("mySource.position: " + mySource.position() + " mySource.limit: " + mySource.limit()); |
| |
| if (result.isError()) { |
| errln("Test small output buffers while encoding " + result.toString()); |
| } |
| if (mySource.position() == mySource.limit()) { |
| result = encoder.encode(mySource, myTarget, true); |
| if (result.isError()) { |
| errln("Test small output buffers while encoding " + result.toString()); |
| } |
| |
| myTarget.limit(myTarget.capacity()); |
| result = encoder.flush(myTarget); |
| if (result.isError()) { |
| errln("Test small output buffers while encoding " + result.toString()); |
| } |
| break; |
| } |
| } |
| if (!equals(myTarget, target, targetLimit)) { |
| errln("Test small output buffers " + encoding + " From Unicode failed."); |
| } |
| logln("Tests on small output buffers for " + encoding + " passed"); |
| } |
| } |
| |
| public void convertAllTest(ByteBuffer bSource, CharBuffer uSource) throws Exception { |
| { |
| try { |
| m_decoder.reset(); |
| ByteBuffer mySource = bSource.duplicate(); |
| CharBuffer myTarget = m_decoder.decode(mySource); |
| if (!equals(myTarget, uSource)) { |
| errln( |
| "--Test convertAll() " |
| + m_encoding |
| + " to Unicode --FAILED"); |
| } |
| } catch (Exception e) { |
| //e.printStackTrace(); |
| errln(e.getMessage()); |
| } |
| } |
| { |
| try { |
| m_encoder.reset(); |
| CharBuffer mySource = CharBuffer.wrap(uSource); |
| ByteBuffer myTarget = m_encoder.encode(mySource); |
| if (!equals(myTarget, bSource)) { |
| errln( |
| "--Test convertAll() " |
| + m_encoding |
| + " to Unicode --FAILED"); |
| } |
| } catch (Exception e) { |
| //e.printStackTrace(); |
| errln("encoder.encode() failed "+ e.getMessage()+" "+e.toString()); |
| } |
| } |
| |
| } |
| //TODO |
| /* |
| public void TestString(ByteBuffer bSource, CharBuffer uSource) throws Exception { |
| try { |
| { |
| String source = uSource.toString(); |
| byte[] target = source.getBytes(m_encoding); |
| if (!equals(target, bSource.array())) { |
| errln("encode using string API failed"); |
| } |
| } |
| { |
| |
| String target = new String(bSource.array(), m_encoding); |
| if (!equals(uSource, target.toCharArray())) { |
| errln("decode using string API failed"); |
| } |
| } |
| } catch (Exception e) { |
| //e.printStackTrace(); |
| errln(e.getMessage()); |
| } |
| } |
| |
| /*private void fromUnicodeTest() throws Exception { |
| |
| logln("Loaded Charset: " + charset.getClass().toString()); |
| logln("Loaded CharsetEncoder: " + encoder.getClass().toString()); |
| logln("Loaded CharsetDecoder: " + decoder.getClass().toString()); |
| |
| ByteBuffer myTarget = ByteBuffer.allocate(gbSource.length); |
| logln("Created ByteBuffer of length: " + uSource.length); |
| CharBuffer mySource = CharBuffer.wrap(uSource); |
| logln("Wrapped ByteBuffer with CharBuffer "); |
| encoder.reset(); |
| logln("Test Unicode to " + encoding ); |
| encoder.encode(mySource, myTarget, true); |
| if (!equals(myTarget, gbSource)) { |
| errln("--Test Unicode to " + encoding + ": FAILED"); |
| } |
| logln("Test Unicode to " + encoding +" passed"); |
| } |
| |
| public void TestToUnicode( ) throws Exception { |
| |
| logln("Loaded Charset: " + charset.getClass().toString()); |
| logln("Loaded CharsetEncoder: " + encoder.getClass().toString()); |
| logln("Loaded CharsetDecoder: " + decoder.getClass().toString()); |
| |
| CharBuffer myTarget = CharBuffer.allocate(uSource.length); |
| ByteBuffer mySource = ByteBuffer.wrap(getByteArray(gbSource)); |
| decoder.reset(); |
| CoderResult result = decoder.decode(mySource, myTarget, true); |
| if (result.isError()) { |
| errln("Test ToUnicode -- FAILED"); |
| } |
| if (!equals(myTarget, uSource)) { |
| errln("--Test " + encoding + " to Unicode :FAILED"); |
| } |
| } |
| |
| public static byte[] getByteArray(char[] source) { |
| byte[] target = new byte[source.length]; |
| int i = source.length; |
| for (; --i >= 0;) { |
| target[i] = (byte) source[i]; |
| } |
| return target; |
| } |
| /* |
| private void smBufCharset(Charset charset) { |
| try { |
| ByteBuffer bTarget = charset.encode(CharBuffer.wrap(uSource)); |
| CharBuffer uTarget = |
| charset.decode(ByteBuffer.wrap(getByteArray(gbSource))); |
| |
| if (!equals(uTarget, uSource)) { |
| errln("Test " + charset.toString() + " to Unicode :FAILED"); |
| } |
| if (!equals(bTarget, gbSource)) { |
| errln("Test " + charset.toString() + " from Unicode :FAILED"); |
| } |
| } catch (Exception ex) { |
| errln("Encountered exception in smBufCharset"); |
| } |
| } |
| |
| public void TestMultithreaded() throws Exception { |
| final Charset cs = Charset.forName(encoding); |
| if (cs == charset) { |
| errln("The objects are equal"); |
| } |
| smBufCharset(cs); |
| try { |
| final Thread t1 = new Thread() { |
| public void run() { |
| // commented out since the mehtods on |
| // Charset API are supposed to be thread |
| // safe ... to test it we dont sync |
| |
| // synchronized(charset){ |
| while (!interrupted()) { |
| try { |
| smBufCharset(cs); |
| } catch (UnsupportedCharsetException ueEx) { |
| errln(ueEx.toString()); |
| } |
| } |
| |
| // } |
| } |
| }; |
| final Thread t2 = new Thread() { |
| public void run() { |
| // synchronized(charset){ |
| while (!interrupted()) { |
| try { |
| smBufCharset(cs); |
| } catch (UnsupportedCharsetException ueEx) { |
| errln(ueEx.toString()); |
| } |
| } |
| |
| //} |
| } |
| }; |
| t1.start(); |
| t2.start(); |
| int i = 0; |
| for (;;) { |
| if (i > 1000000000) { |
| try { |
| t1.interrupt(); |
| } catch (Exception e) { |
| } |
| try { |
| t2.interrupt(); |
| } catch (Exception e) { |
| } |
| break; |
| } |
| i++; |
| } |
| } catch (Exception e) { |
| throw e; |
| } |
| } |
| |
| public void TestSynchronizedMultithreaded() throws Exception { |
| // Methods on CharsetDecoder and CharsetEncoder classes |
| // are inherently unsafe if accessed by multiple concurrent |
| // thread so we synchronize them |
| final Charset charset = Charset.forName(encoding); |
| final CharsetDecoder decoder = charset.newDecoder(); |
| final CharsetEncoder encoder = charset.newEncoder(); |
| try { |
| final Thread t1 = new Thread() { |
| public void run() { |
| while (!interrupted()) { |
| try { |
| synchronized (encoder) { |
| smBufEncode(encoder, encoding); |
| } |
| synchronized (decoder) { |
| smBufDecode(decoder, encoding); |
| } |
| } catch (UnsupportedCharsetException ueEx) { |
| errln(ueEx.toString()); |
| } |
| } |
| |
| } |
| }; |
| final Thread t2 = new Thread() { |
| public void run() { |
| while (!interrupted()) { |
| try { |
| synchronized (encoder) { |
| smBufEncode(encoder, encoding); |
| } |
| synchronized (decoder) { |
| smBufDecode(decoder, encoding); |
| } |
| } catch (UnsupportedCharsetException ueEx) { |
| errln(ueEx.toString()); |
| } |
| } |
| } |
| }; |
| t1.start(); |
| t2.start(); |
| int i = 0; |
| for (;;) { |
| if (i > 1000000000) { |
| try { |
| t1.interrupt(); |
| } catch (Exception e) { |
| } |
| try { |
| t2.interrupt(); |
| } catch (Exception e) { |
| } |
| break; |
| } |
| i++; |
| } |
| } catch (Exception e) { |
| throw e; |
| } |
| } |
| */ |
| |
| public void TestMBCS(){ |
| { |
| // Encoder: from Unicode conversion |
| CharsetEncoder encoderICU = new CharsetProviderICU().charsetForName("ibm-971").newEncoder(); |
| ByteBuffer out = ByteBuffer.allocate(6); |
| encoderICU.onUnmappableCharacter(CodingErrorAction.REPLACE); |
| CoderResult result = encoderICU.encode(CharBuffer.wrap("\u0131\u0061\u00a1"), out, true); |
| if(!result.isError()){ |
| byte[] expected = {(byte)0xA9, (byte)0xA5, (byte)0xAF, (byte)0xFE, (byte)0xA2, (byte)0xAE}; |
| if(!equals(expected, out.array())){ |
| errln("Did not get the expected result for substitution bytes. Got: "+ |
| hex(out.array())); |
| } |
| logln("Output: "+ hex(out.array())); |
| }else{ |
| errln("Encode operation failed for encoder: "+encoderICU.toString()); |
| } |
| } |
| { |
| // Decoder: to Unicode conversion |
| CharsetDecoder decoderICU = new CharsetProviderICU().charsetForName("ibm-971").newDecoder(); |
| CharBuffer out = CharBuffer.allocate(3); |
| decoderICU.onMalformedInput(CodingErrorAction.REPLACE); |
| CoderResult result = decoderICU.decode(ByteBuffer.wrap(new byte[] { (byte)0xA2, (byte)0xAE, (byte)0x12, (byte)0x34, (byte)0xEF, (byte)0xDC }), out, true); |
| if(!result.isError()){ |
| char[] expected = {'\u00a1', '\ufffd', '\u6676'}; |
| if(!equals(expected, out.array())){ |
| errln("Did not get the expected result for substitution chars. Got: "+ |
| hex(out.array())); |
| } |
| logln("Output: "+ hex(out.array())); |
| }else{ |
| errln("Decode operation failed for encoder: "+decoderICU.toString()); |
| } |
| } |
| } |
| |
| public void TestJB4897(){ |
| CharsetProviderICU provider = new CharsetProviderICU(); |
| Charset charset = provider.charsetForName("x-abracadabra"); |
| if(charset!=null && charset.canEncode()== true){ |
| errln("provider.charsetForName() does not validate the charset names" ); |
| } |
| } |
| |
| public void TestJB5027() { |
| CharsetProviderICU provider= new CharsetProviderICU(); |
| |
| Charset fake = provider.charsetForName("doesNotExist"); |
| if(fake != null){ |
| errln("\"doesNotExist\" returned " + fake); |
| } |
| Charset xfake = provider.charsetForName("x-doesNotExist"); |
| if(xfake!=null){ |
| errln("\"x-doesNotExist\" returned " + xfake); |
| } |
| } |
| //test to make sure that number of aliases and canonical names are in the charsets that are in |
| public void TestAllNames() { |
| |
| CharsetProviderICU provider= new CharsetProviderICU(); |
| Object[] available = CharsetProviderICU.getAvailableNames(); |
| for(int i=0; i<available.length;i++){ |
| try{ |
| String canon = CharsetProviderICU.getICUCanonicalName((String)available[i]); |
| |
| // ',' is not allowed by Java's charset name checker |
| if(canon.indexOf(',')>=0){ |
| continue; |
| } |
| Charset cs = provider.charsetForName((String)available[i]); |
| |
| Object[] javaAliases = cs.aliases().toArray(); |
| //seach for ICU canonical name in javaAliases |
| boolean inAliasList = false; |
| for(int j=0; j<javaAliases.length; j++){ |
| String java = (String) javaAliases[j]; |
| if(java.equals(canon)){ |
| logln("javaAlias: " + java + " canon: " + canon); |
| inAliasList = true; |
| } |
| } |
| if(inAliasList == false){ |
| errln("Could not find ICU canonical name: "+canon+ " for java canonical name: "+ available[i]+ " "+ i); |
| } |
| }catch(UnsupportedCharsetException ex){ |
| errln("could no load charset "+ available[i]+" "+ex.getMessage()); |
| continue; |
| } |
| } |
| } |
| public void TestDecoderImplFlush() { |
| CharsetProviderICU provider = new CharsetProviderICU(); |
| Charset ics = provider.charsetForName("UTF-16"); |
| Charset jcs = Charset.forName("UTF-16"); // Java's UTF-16 charset |
| execDecoder(jcs); |
| execDecoder(ics); |
| } |
| public void TestEncoderImplFlush() { |
| CharsetProviderICU provider = new CharsetProviderICU(); |
| Charset ics = provider.charsetForName("UTF-16"); |
| Charset jcs = Charset.forName("UTF-16"); // Java's UTF-16 charset |
| execEncoder(jcs); |
| execEncoder(ics); |
| } |
| private void execDecoder(Charset cs){ |
| CharsetDecoder decoder = cs.newDecoder(); |
| decoder.onMalformedInput(CodingErrorAction.REPORT); |
| decoder.onUnmappableCharacter(CodingErrorAction.REPORT); |
| CharBuffer out = CharBuffer.allocate(10); |
| CoderResult result = decoder.decode(ByteBuffer.wrap(new byte[] { -1, |
| -2, 32, 0, 98 }), out, false); |
| result = decoder.decode(ByteBuffer.wrap(new byte[] { 98 }), out, true); |
| |
| logln(cs.getClass().toString()+ ":" +result.toString()); |
| try { |
| result = decoder.flush(out); |
| logln(cs.getClass().toString()+ ":" +result.toString()); |
| } catch (Exception e) { |
| errln(e.getMessage()+" "+cs.getClass().toString()); |
| } |
| } |
| private void execEncoder(Charset cs){ |
| CharsetEncoder encoder = cs.newEncoder(); |
| encoder.onMalformedInput(CodingErrorAction.REPORT); |
| encoder.onUnmappableCharacter(CodingErrorAction.REPORT); |
| ByteBuffer out = ByteBuffer.allocate(10); |
| CoderResult result = encoder.encode(CharBuffer.wrap(new char[] { '\uFFFF', |
| '\u2345', 32, 98 }), out, false); |
| logln(cs.getClass().toString()+ ":" +result.toString()); |
| result = encoder.encode(CharBuffer.wrap(new char[] { 98 }), out, true); |
| |
| logln(cs.getClass().toString()+ ":" +result.toString()); |
| try { |
| result = encoder.flush(out); |
| logln(cs.getClass().toString()+ ":" +result.toString()); |
| } catch (Exception e) { |
| errln(e.getMessage()+" "+cs.getClass().toString()); |
| } |
| } |
| public void TestDecodeMalformed() { |
| CharsetProviderICU provider = new CharsetProviderICU(); |
| Charset ics = provider.charsetForName("UTF-16BE"); |
| //Use SUN's charset |
| Charset jcs = Charset.forName("UTF-16"); |
| CoderResult ir = execMalformed(ics); |
| CoderResult jr = execMalformed(jcs); |
| if(ir!=jr){ |
| errln("ICU's decoder did not return the same result as Sun. ICU: "+ir.toString()+" Sun: "+jr.toString()); |
| } |
| } |
| private CoderResult execMalformed(Charset cs){ |
| CharsetDecoder decoder = cs.newDecoder(); |
| decoder.onMalformedInput(CodingErrorAction.IGNORE); |
| decoder.onUnmappableCharacter(CodingErrorAction.REPORT); |
| ByteBuffer in = ByteBuffer.wrap(new byte[] { 0x00, 0x41, 0x00, 0x42, 0x01 }); |
| CharBuffer out = CharBuffer.allocate(3); |
| return decoder.decode(in, out, true); |
| } |
| |
| public void TestJavaUTF16Decoder(){ |
| CharsetProviderICU provider = new CharsetProviderICU(); |
| Charset ics = provider.charsetForName("UTF-16BE"); |
| //Use SUN's charset |
| Charset jcs = Charset.forName("UTF-16"); |
| Exception ie = execConvertAll(ics); |
| Exception je = execConvertAll(jcs); |
| if(ie!=je){ |
| errln("ICU's decoder did not return the same result as Sun. ICU: "+ie.toString()+" Sun: "+je.toString()); |
| } |
| } |
| private Exception execConvertAll(Charset cs){ |
| ByteBuffer in = ByteBuffer.allocate(400); |
| int i=0; |
| while(in.position()!=in.capacity()){ |
| in.put((byte)0xD8); |
| in.put((byte)i); |
| in.put((byte)0xDC); |
| in.put((byte)i); |
| i++; |
| } |
| in.limit(in.position()); |
| in.position(0); |
| CharsetDecoder decoder = cs.newDecoder(); |
| decoder.onMalformedInput(CodingErrorAction.IGNORE); |
| decoder.onUnmappableCharacter(CodingErrorAction.REPORT); |
| try{ |
| CharBuffer out = decoder.decode(in); |
| if(out!=null){ |
| logln(cs.toString()+" encoing succeeded as expected!"); |
| } |
| }catch ( Exception ex){ |
| errln("Did not get expected exception for encoding: "+cs.toString()); |
| return ex; |
| } |
| return null; |
| } |
| public void TestUTF32BOM(){ |
| |
| Charset cs = (new CharsetProviderICU()).charsetForName("UTF-32"); |
| char[] in = new char[] { 0xd800, 0xdc00, |
| 0xd801, 0xdc01, |
| 0xdbff, 0xdfff, |
| 0xd900, 0xdd00, |
| 0x0000, 0x0041, |
| 0x0000, 0x0042, |
| 0x0000, 0x0043}; |
| |
| CharBuffer inBuf = CharBuffer.allocate(in.length); |
| inBuf.put(in); |
| CharsetEncoder encoder = cs.newEncoder(); |
| ByteBuffer outBuf = ByteBuffer.allocate(in.length*4+4); |
| inBuf.rewind(); |
| encoder.encode(inBuf, outBuf, true); |
| outBuf.rewind(); |
| if(outBuf.get(0)!= (byte)0x00 && outBuf.get(1)!= (byte)0x00 && |
| outBuf.get(2)!= (byte)0xFF && outBuf.get(3)!= (byte)0xFE){ |
| errln("The UTF32 encoder did not appended bom. Length returned: " + outBuf.remaining()); |
| } |
| while(outBuf.hasRemaining()){ |
| logln("0x"+hex(outBuf.get())); |
| } |
| CharsetDecoder decoder = cs.newDecoder(); |
| outBuf.limit(outBuf.position()); |
| outBuf.rewind(); |
| CharBuffer rt = CharBuffer.allocate(in.length); |
| CoderResult cr = decoder.decode(outBuf, rt, true); |
| if(cr.isError()){ |
| errln("Decoding with BOM failed. Error: "+ cr.toString()); |
| } |
| equals(rt, in); |
| try{ |
| rt.clear(); |
| outBuf.rewind(); |
| Charset utf16 = Charset.forName("UTF-32"); |
| CharsetDecoder dc = utf16.newDecoder(); |
| cr = dc.decode(outBuf, rt, true); |
| equals(rt, in); |
| }catch(UnsupportedCharsetException ex){ |
| // swallow the expection. |
| } |
| } |
| |
| /* |
| * Michael Ow |
| * Modified 070424 |
| */ |
| /*The following two methods provides the option of exceptions when Decoding |
| * and Encoding if needed for testing purposes. |
| */ |
| private void smBufDecode(CharsetDecoder decoder, String encoding, ByteBuffer source, CharBuffer target) { |
| smBufDecode(decoder, encoding, source, target, true); |
| } |
| private void smBufDecode(CharsetDecoder decoder, String encoding, ByteBuffer source, CharBuffer target, boolean backedByArray) { |
| try { |
| smBufDecode(decoder, encoding, source, target, false, false, backedByArray); |
| } |
| catch (Exception ex) { |
| System.out.println("!exception!"); |
| } |
| } |
| private void smBufEncode(CharsetEncoder encoder, String encoding, CharBuffer source, ByteBuffer target) { |
| smBufEncode(encoder, encoding, source, target, true); |
| } |
| private void smBufEncode(CharsetEncoder encoder, String encoding, CharBuffer source, ByteBuffer target, boolean backedByArray) { |
| try { |
| smBufEncode(encoder, encoding, source, target, false, false); |
| } |
| catch (Exception ex) { |
| System.out.println("!exception!"); |
| } |
| } |
| //Test CharsetICUProvider |
| public void TestNullCanonicalName() { |
| String enc = null; |
| String canonicalName = CharsetProviderICU.getICUCanonicalName(enc); |
| |
| if (canonicalName != null) { |
| errln("getICUCanonicalName return a non-null string for given null string"); |
| } |
| } |
| public void TestGetAllNames() { |
| String[] names = null; |
| |
| names = CharsetProviderICU.getAllNames(); |
| |
| if (names == null) { |
| errln("getAllNames returned a null string."); |
| } |
| } |
| //Test CharsetICU |
| public void TestCharsetContains() { |
| boolean test; |
| |
| CharsetProvider provider = new CharsetProviderICU(); |
| Charset cs1 = provider.charsetForName("UTF-32"); |
| Charset cs2 = null; |
| |
| test = cs1.contains(cs2); |
| |
| if (test != false) { |
| errln("Charset.contains returned true for a null charset."); |
| } |
| |
| cs2 = CharsetICU.forNameICU("UTF-32"); |
| |
| test = cs1.contains(cs2); |
| |
| if (test != true) { |
| errln("Charset.contains returned false for an identical charset."); |
| } |
| |
| cs2 = provider.charsetForName("UTF-8"); |
| |
| test = cs1.contains(cs2); |
| |
| if (test != false) { |
| errln("Charset.contains returned true for a different charset."); |
| } |
| } |
| public void TestCharsetICUNullCharsetName() { |
| String charsetName = null; |
| |
| try { |
| CharsetICU.forNameICU(charsetName); |
| errln("CharsetICU.forName should have thown an exception after getting a null charsetName."); |
| } |
| catch(Exception ex) { |
| } |
| } |
| |
| //Test CharsetASCII |
| public void TestCharsetASCIIOverFlow() { |
| int byteBufferLimit; |
| int charBufferLimit; |
| |
| CharsetProvider provider = new CharsetProviderICU(); |
| Charset cs = provider.charsetForName("ASCII"); |
| CharsetEncoder encoder = cs.newEncoder(); |
| CharsetDecoder decoder = cs.newDecoder(); |
| |
| CharBuffer charBuffer = CharBuffer.allocate(0x90); |
| ByteBuffer byteBuffer = ByteBuffer.allocate(0x90); |
| |
| CharBuffer charBufferTest = CharBuffer.allocate(0xb0); |
| ByteBuffer byteBufferTest = ByteBuffer.allocate(0xb0); |
| |
| for(int j=0;j<=0x7f; j++){ |
| charBuffer.put((char)j); |
| byteBuffer.put((byte)j); |
| } |
| |
| byteBuffer.limit(byteBufferLimit = byteBuffer.position()); |
| byteBuffer.position(0); |
| charBuffer.limit(charBufferLimit = charBuffer.position()); |
| charBuffer.position(0); |
| |
| //test for overflow |
| byteBufferTest.limit(byteBufferLimit - 5); |
| byteBufferTest.position(0); |
| charBufferTest.limit(charBufferLimit - 5); |
| charBufferTest.position(0); |
| try { |
| smBufDecode(decoder, "ASCII", byteBuffer, charBufferTest, true, false); |
| errln("Overflow exception while decoding ASCII should have been thrown."); |
| } |
| catch(Exception ex) { |
| } |
| try { |
| smBufEncode(encoder, "ASCII", charBuffer, byteBufferTest, true, false); |
| errln("Overflow exception while encoding ASCII should have been thrown."); |
| } |
| catch (Exception ex) { |
| } |
| |
| // For better code coverage |
| /* For better code coverage */ |
| byte byteout[] = { |
| (byte)0x01 |
| }; |
| char charin[] = { |
| (char)0x0001, (char)0x0002 |
| }; |
| ByteBuffer bb = ByteBuffer.wrap(byteout); |
| CharBuffer cb = CharBuffer.wrap(charin); |
| CharBuffer cb2 = CharBuffer.wrap(cb.subSequence(0, 2)); |
| encoder.reset(); |
| if (!(encoder.encode(cb2, bb, true)).isOverflow()) { |
| errln("Overflow error while encoding ASCII should have occurred."); |
| } |
| } |
| //Test CharsetUTF7 |
| public void TestCharsetUTF7() { |
| CoderResult result = CoderResult.UNDERFLOW; |
| CharsetProvider provider = new CharsetProviderICU(); |
| Charset cs = provider.charsetForName("UTF-7"); |
| CharsetEncoder encoder = cs.newEncoder(); |
| CharsetDecoder decoder = cs.newDecoder(); |
| |
| CharBuffer us = CharBuffer.allocate(0x100); |
| ByteBuffer bs = ByteBuffer.allocate(0x100); |
| |
| /* Unicode : A<not equal to Alpha Lamda>. */ |
| /* UTF7: AImIDkQ. */ |
| us.put((char)0x41); us.put((char)0x2262); us.put((char)0x391); us.put((char)0x39B); us.put((char)0x2e); |
| bs.put((byte)0x41); bs.put((byte)0x2b); bs.put((byte)0x49); bs.put((byte)0x6d); |
| bs.put((byte)0x49); bs.put((byte)0x44); bs.put((byte)0x6b); bs.put((byte)0x51); |
| bs.put((byte)0x4f); bs.put((byte)0x62); bs.put((byte)0x2e); |
| |
| bs.limit(bs.position()); |
| bs.position(0); |
| us.limit(us.position()); |
| us.position(0); |
| |
| smBufDecode(decoder, "UTF-7", bs, us); |
| smBufEncode(encoder, "UTF-7", us, bs); |
| |
| /* ticket 6151 */ |
| CharBuffer smallus = CharBuffer.allocate(1); |
| ByteBuffer bigbs = ByteBuffer.allocate(3); |
| bigbs.put((byte)0x41); bigbs.put((byte)0x41); bigbs.put((byte)0x41); |
| bigbs.position(0); |
| try { |
| smBufDecode(decoder, "UTF-7-DE-Overflow", bigbs, smallus, true, false); |
| errln("Buffer Overflow exception should have been thrown while decoding UTF-7."); |
| } catch (Exception ex) { |
| } |
| |
| //The rest of the code in this method is to provide better code coverage |
| CharBuffer ccus = CharBuffer.allocate(0x10); |
| ByteBuffer ccbs = ByteBuffer.allocate(0x10); |
| |
| //start of charset decoder code coverage code |
| //test for accurate illegal and control character checking |
| ccbs.put((byte)0x0D); ccbs.put((byte)0x05); |
| ccus.put((char)0x0000); |
| |
| ccbs.limit(ccbs.position()); |
| ccbs.position(0); |
| ccus.limit(ccus.position()); |
| ccus.position(0); |
| |
| try { |
| smBufDecode(decoder, "UTF-7-CC-DE-1", ccbs, ccus, true, false); |
| errln("Exception while decoding UTF-7 code coverage test should have been thrown."); |
| } |
| catch (Exception ex) { |
| } |
| |
| ccbs.clear(); |
| ccus.clear(); |
| |
| //test for illegal base64 character |
| ccbs.put((byte)0x2b); ccbs.put((byte)0xff); |
| ccus.put((char)0x0000); |
| |
| ccbs.limit(ccbs.position()); |
| ccbs.position(0); |
| ccus.limit(ccus.position()); |
| ccus.position(0); |
| |
| try { |
| smBufDecode(decoder, "UTF-7-CC-DE-2", ccbs, ccus, true, false); |
| errln("Exception while decoding UTF-7 code coverage test should have been thrown."); |
| } |
| catch (Exception ex) { |
| } |
| |
| ccbs.clear(); |
| ccus.clear(); |
| |
| //test for illegal order of the base64 character sequence |
| ccbs.put((byte)0x2b); ccbs.put((byte)0x2d); ccbs.put((byte)0x2b); ccbs.put((byte)0x49); ccbs.put((byte)0x2d); |
| ccus.put((char)0x0000); ccus.put((char)0x0000); |
| |
| ccbs.limit(ccbs.position()); |
| ccbs.position(0); |
| ccus.limit(ccus.position()); |
| ccus.position(0); |
| |
| try { |
| smBufDecode(decoder, "UTF-7-CC-DE-3", ccbs, ccus, true, false); |
| errln("Exception while decoding UTF-7 code coverage test should have been thrown."); |
| } |
| catch (Exception ex) { |
| } |
| |
| ccbs.clear(); |
| ccus.clear(); |
| |
| //test for illegal order of the base64 character sequence |
| ccbs.put((byte)0x2b); ccbs.put((byte)0x0a); ccbs.put((byte)0x09); |
| ccus.put((char)0x0000); |
| |
| ccbs.limit(ccbs.position()); |
| ccbs.position(0); |
| ccus.limit(ccus.position()); |
| ccus.position(0); |
| |
| try { |
| smBufDecode(decoder, "UTF-7-CC-DE-4", ccbs, ccus, true, false); |
| errln("Exception while decoding UTF-7 code coverage test should have been thrown."); |
| } |
| catch (Exception ex) { |
| } |
| |
| ccbs.clear(); |
| ccus.clear(); |
| |
| //test for illegal order of the base64 character sequence |
| ccbs.put((byte)0x2b); ccbs.put((byte)0x49); ccbs.put((byte)0x0a); |
| ccus.put((char)0x0000); |
| |
| ccbs.limit(ccbs.position()); |
| ccbs.position(0); |
| ccus.limit(ccus.position()); |
| ccus.position(0); |
| |
| try { |
| smBufDecode(decoder, "UTF-7-CC-DE-5", ccbs, ccus, true, false); |
| errln("Exception while decoding UTF-7 code coverage test should have been thrown."); |
| } |
| catch (Exception ex) { |
| } |
| |
| ccbs.clear(); |
| ccus.clear(); |
| |
| //test for illegal order of the base64 character sequence |
| ccbs.put((byte)0x2b); ccbs.put((byte)0x00); |
| ccus.put((char)0x0000); |
| |
| ccbs.limit(ccbs.position()); |
| ccbs.position(0); |
| ccus.limit(ccus.position()); |
| ccus.position(0); |
| |
| try { |
| smBufDecode(decoder, "UTF-7-CC-DE-6", ccbs, ccus, true, false); |
| errln("Exception while decoding UTF-7 code coverage test should have been thrown."); |
| } |
| catch (Exception ex) { |
| } |
| |
| ccbs.clear(); |
| ccus.clear(); |
| |
| //test for overflow buffer error |
| ccbs.put((byte)0x2b); ccbs.put((byte)0x49); |
| |
| ccbs.limit(ccbs.position()); |
| ccbs.position(0); |
| ccus.limit(0); |
| ccus.position(0); |
| |
| try { |
| smBufDecode(decoder, "UTF-7-CC-DE-7", ccbs, ccus, true, false); |
| errln("Exception while decoding UTF-7 code coverage test should have been thrown."); |
| } |
| catch (Exception ex) { |
| } |
| |
| ccbs.clear(); |
| ccus.clear(); |
| |
| //test for overflow buffer error |
| ccbs.put((byte)0x0c); ccbs.put((byte)0x0c); |
| |
| ccbs.limit(ccbs.position()); |
| ccbs.position(0); |
| ccus.limit(0); |
| ccus.position(0); |
| |
| try { |
| smBufDecode(decoder, "UTF-7-CC-DE-8", ccbs, ccus, true, false); |
| errln("Exception while decoding UTF-7 code coverage test should have been thrown."); |
| } |
| catch (Exception ex) { |
| } |
| //end of charset decoder code coverage code |
| |
| //start of charset encoder code coverage code |
| ccbs.clear(); |
| ccus.clear(); |
| //test for overflow buffer error |
| ccus.put((char)0x002b); |
| ccbs.put((byte)0x2b); |
| |
| ccbs.limit(ccbs.position()); |
| ccbs.position(0); |
| ccus.limit(ccus.position()); |
| ccus.position(0); |
| |
| try { |
| smBufEncode(encoder, "UTF-7-CC-EN-1", ccus, ccbs, true, false); |
| errln("Exception while encoding UTF-7 code coverage test should have been thrown."); |
| } |
| catch (Exception ex) { |
| } |
| |
| ccbs.clear(); |
| ccus.clear(); |
| |
| //test for overflow buffer error |
| ccus.put((char)0x002b); ccus.put((char)0x2262); |
| ccbs.put((byte)0x2b); ccbs.put((byte)0x2d); ccbs.put((byte)0x00); ccbs.put((byte)0x00); |
| |
| ccbs.limit(ccbs.position()); |
| ccbs.position(0); |
| ccus.limit(ccus.position()); |
| ccus.position(0); |
| |
| try { |
| smBufEncode(encoder, "UTF-7-CC-EN-2", ccus, ccbs, true, false); |
| errln("Exception while encoding UTF-7 code coverage test should have been thrown."); |
| } |
| catch (Exception ex) { |
| } |
| |
| ccbs.clear(); |
| ccus.clear(); |
| |
| //test for overflow buffer error |
| ccus.put((char)0x2262); ccus.put((char)0x0049); |
| ccbs.put((byte)0x00); ccbs.put((byte)0x00); ccbs.put((byte)0x00); ccbs.put((byte)0x00); ccbs.put((byte)0x00); |
| ccbs.limit(ccbs.position()); |
| ccbs.position(0); |
| ccus.limit(ccus.position()); |
| ccus.position(0); |
| |
| try { |
| smBufEncode(encoder, "UTF-7-CC-EN-3", ccus, ccbs, true, false); |
| errln("Exception while encoding UTF-7 code coverage test should have been thrown."); |
| } |
| catch (Exception ex) { |
| } |
| |
| ccbs.clear(); |
| ccus.clear(); |
| |
| //test for overflow buffer error |
| ccus.put((char)0x2262); ccus.put((char)0x0395); |
| ccbs.put((byte)0x00); ccbs.put((byte)0x00); ccbs.put((byte)0x00); ccbs.put((byte)0x00); |
| ccbs.limit(ccbs.position()); |
| ccbs.position(0); |
| ccus.limit(ccus.position()); |
| ccus.position(0); |
| |
| try { |
| smBufEncode(encoder, "UTF-7-CC-EN-4", ccus, ccbs, true, false); |
| errln("Exception while encoding UTF-7 code coverage test should have been thrown."); |
| } |
| catch (Exception ex) { |
| } |
| |
| ccbs.clear(); |
| ccus.clear(); |
| |
| //test for overflow buffer error |
| ccus.put((char)0x2262); ccus.put((char)0x0395); |
| ccbs.put((byte)0x00); ccbs.put((byte)0x00); ccbs.put((byte)0x00); ccbs.put((byte)0x00); ccbs.put((byte)0x00); |
| ccbs.limit(ccbs.position()); |
| ccbs.position(0); |
| ccus.limit(ccus.position()); |
| ccus.position(0); |
| |
| try { |
| smBufEncode(encoder, "UTF-7-CC-EN-5", ccus, ccbs, true, false); |
| errln("Exception while encoding UTF-7 code coverage test should have been thrown."); |
| } |
| catch (Exception ex) { |
| } |
| |
| ccbs.clear(); |
| ccus.clear(); |
| |
| //test for overflow buffer error |
| ccus.put((char)0x2262); ccus.put((char)0x0395); ccus.put((char)0x0391); |
| ccbs.put((byte)0x00); ccbs.put((byte)0x00); ccbs.put((byte)0x00); ccbs.put((byte)0x00); ccbs.put((byte)0x00); ccbs.put((byte)0x00); ccbs.put((byte)0x00); |
| ccbs.limit(ccbs.position()); |
| ccbs.position(0); |
| ccus.limit(ccus.position()); |
| ccus.position(0); |
| |
| try { |
| smBufEncode(encoder, "UTF-7-CC-EN-6", ccus, ccbs, true, false); |
| errln("Exception while encoding UTF-7 code coverage test should have been thrown."); |
| } |
| catch (Exception ex) { |
| } |
| |
| ccbs.clear(); |
| ccus.clear(); |
| |
| //test for overflow buffer error |
| ccus.put((char)0x2262); ccus.put((char)0x0395); ccus.put((char)0x0391); |
| ccbs.put((byte)0x00); ccbs.put((byte)0x00); ccbs.put((byte)0x00); ccbs.put((byte)0x00); |
| ccbs.put((byte)0x00); ccbs.put((byte)0x00); ccbs.put((byte)0x00); ccbs.put((byte)0x00); |
| ccbs.limit(ccbs.position()); |
| ccbs.position(0); |
| ccus.limit(ccus.position()); |
| ccus.position(0); |
| |
| try { |
| smBufEncode(encoder, "UTF-7-CC-EN-7", ccus, ccbs, true, false); |
| errln("Exception while encoding UTF-7 code coverage test should have been thrown."); |
| } |
| catch (Exception ex) { |
| } |
| |
| ccbs.clear(); |
| ccus.clear(); |
| |
| //test for overflow buffer error |
| ccus.put((char)0x0049); ccus.put((char)0x0048); |
| ccbs.put((byte)0x00); |
| ccbs.limit(ccbs.position()); |
| ccbs.position(0); |
| ccus.limit(ccus.position()); |
| ccus.position(0); |
| |
| try { |
| smBufEncode(encoder, "UTF-7-CC-EN-8", ccus, ccbs, true, false); |
| errln("Exception while encoding UTF-7 code coverage test should have been thrown."); |
| } |
| catch (Exception ex) { |
| } |
| |
| ccbs.clear(); |
| ccus.clear(); |
| |
| //test for overflow buffer error |
| ccus.put((char)0x2262); |
| ccbs.put((byte)0x00); |
| ccbs.limit(ccbs.position()); |
| ccbs.position(0); |
| ccus.limit(ccus.position()); |
| ccus.position(0); |
| |
| try { |
| smBufEncode(encoder, "UTF-7-CC-EN-9", ccus, ccbs, true, false); |
| errln("Exception while encoding UTF-7 code coverage test should have been thrown."); |
| } |
| catch (Exception ex) { |
| } |
| |
| ccbs.clear(); |
| ccus.clear(); |
| |
| //test for overflow buffer error |
| ccus.put((char)0x2262); ccus.put((char)0x0049); |
| ccbs.put((byte)0x00); ccbs.put((byte)0x00); ccbs.put((byte)0x00); ccbs.put((byte)0x00); |
| ccbs.limit(ccbs.position()); |
| ccbs.position(0); |
| ccus.limit(ccus.position()); |
| ccus.position(0); |
| |
| try { |
| smBufEncode(encoder, "UTF-7-CC-EN-10", ccus, ccbs, true, false); |
| errln("Exception while encoding UTF-7 code coverage test should have been thrown."); |
| } |
| catch (Exception ex) { |
| } |
| |
| ccbs.clear(); |
| ccus.clear(); |
| |
| //test for overflow buffer error |
| ccus.put((char)0x2262); |
| ccbs.put((byte)0x2b); ccbs.put((byte)0x49); ccbs.put((byte)0x6d); ccbs.put((byte)0x49); |
| |
| ccbs.limit(ccbs.position()); |
| ccbs.position(0); |
| ccus.limit(ccus.position()); |
| ccus.position(0); |
| try { |
| smBufEncode(encoder, "UTF-7-CC-EN-11", ccus, ccbs, false, true); |
| } catch (Exception ex) { |
| errln("Exception while encoding UTF-7 code coverage test should not have been thrown."); |
| } |
| |
| ccbs.clear(); |
| ccus.clear(); |
| |
| //test for overflow buffer error |
| encoder.reset(); |
| ccus.put((char)0x3980); ccus.put((char)0x2715); |
| ccbs.put((byte)0x2b); ccbs.put((byte)0x4f); ccbs.put((byte)0x59); |
| |
| ccbs.limit(ccbs.position()); |
| ccbs.position(0); |
| ccus.limit(ccus.position()); |
| ccus.position(0); |
| |
| result = encoder.encode(ccus, ccbs, true); |
| result = encoder.flush(ccbs); |
| if (!result.isOverflow()) { |
| errln("Overflow buffer while encoding UTF-7 should have occurred."); |
| } |
| //end of charset encoder code coverage code |
| } |
| //Test Charset ISCII |
| public void TestCharsetISCII() { |
| CharsetProvider provider = new CharsetProviderICU(); |
| Charset cs = provider.charsetForName("ISCII,version=0"); |
| CharsetEncoder encoder = cs.newEncoder(); |
| CharsetDecoder decoder = cs.newDecoder(); |
| |
| CharBuffer us = CharBuffer.allocate(0x100); |
| ByteBuffer bs = ByteBuffer.allocate(0x100); |
| ByteBuffer bsr = ByteBuffer.allocate(0x100); |
| |
| //test full range of Devanagari |
| us.put((char)0x0901); us.put((char)0x0902); us.put((char)0x0903); us.put((char)0x0905); us.put((char)0x0906); us.put((char)0x0907); |
| us.put((char)0x0908); us.put((char)0x0909); us.put((char)0x090A); us.put((char)0x090B); us.put((char)0x090E); us.put((char)0x090F); |
| us.put((char)0x0910); us.put((char)0x090D); us.put((char)0x0912); us.put((char)0x0913); us.put((char)0x0914); us.put((char)0x0911); |
| us.put((char)0x0915); us.put((char)0x0916); us.put((char)0x0917); us.put((char)0x0918); us.put((char)0x0919); us.put((char)0x091A); |
| us.put((char)0x091B); us.put((char)0x091C); us.put((char)0x091D); us.put((char)0x091E); us.put((char)0x091F); us.put((char)0x0920); |
| us.put((char)0x0921); us.put((char)0x0922); us.put((char)0x0923); us.put((char)0x0924); us.put((char)0x0925); us.put((char)0x0926); |
| us.put((char)0x0927); us.put((char)0x0928); us.put((char)0x0929); us.put((char)0x092A); us.put((char)0x092B); us.put((char)0x092C); |
| us.put((char)0x092D); us.put((char)0x092E); us.put((char)0x092F); us.put((char)0x095F); us.put((char)0x0930); us.put((char)0x0931); |
| us.put((char)0x0932); us.put((char)0x0933); us.put((char)0x0934); us.put((char)0x0935); us.put((char)0x0936); us.put((char)0x0937); |
| us.put((char)0x0938); us.put((char)0x0939); us.put((char)0x200D); us.put((char)0x093E); us.put((char)0x093F); us.put((char)0x0940); |
| us.put((char)0x0941); us.put((char)0x0942); us.put((char)0x0943); us.put((char)0x0946); us.put((char)0x0947); us.put((char)0x0948); |
| us.put((char)0x0945); us.put((char)0x094A); us.put((char)0x094B); us.put((char)0x094C); us.put((char)0x0949); us.put((char)0x094D); |
| us.put((char)0x093D); us.put((char)0x0966); us.put((char)0x0967); us.put((char)0x0968); us.put((char)0x0969); us.put((char)0x096A); |
| us.put((char)0x096B); us.put((char)0x096C); us.put((char)0x096D); us.put((char)0x096E); us.put((char)0x096F); |
| |
| bs.put((byte)0xEF); bs.put((byte)0x42); |
| bs.put((byte)0xA1); bs.put((byte)0xA2); bs.put((byte)0xA3); bs.put((byte)0xA4); bs.put((byte)0xA5); bs.put((byte)0xA6); |
| bs.put((byte)0xA7); bs.put((byte)0xA8); bs.put((byte)0xA9); bs.put((byte)0xAA); bs.put((byte)0xAB); bs.put((byte)0xAC); |
| bs.put((byte)0xAD); bs.put((byte)0xAE); bs.put((byte)0xAF); bs.put((byte)0xB0); bs.put((byte)0xB1); bs.put((byte)0xB2); |
| bs.put((byte)0xB3); bs.put((byte)0xB4); bs.put((byte)0xB5); bs.put((byte)0xB6); bs.put((byte)0xB7); bs.put((byte)0xB8); |
| bs.put((byte)0xB9); bs.put((byte)0xBA); bs.put((byte)0xBB); bs.put((byte)0xBC); bs.put((byte)0xBD); bs.put((byte)0xBE); |
| bs.put((byte)0xBF); bs.put((byte)0xC0); bs.put((byte)0xC1); bs.put((byte)0xC2); bs.put((byte)0xC3); bs.put((byte)0xC4); |
| bs.put((byte)0xC5); bs.put((byte)0xC6); bs.put((byte)0xC7); bs.put((byte)0xC8); bs.put((byte)0xC9); bs.put((byte)0xCA); |
| bs.put((byte)0xCB); bs.put((byte)0xCC); bs.put((byte)0xCD); bs.put((byte)0xCE); bs.put((byte)0xCF); bs.put((byte)0xD0); |
| bs.put((byte)0xD1); bs.put((byte)0xD2); bs.put((byte)0xD3); bs.put((byte)0xD4); bs.put((byte)0xD5); bs.put((byte)0xD6); |
| bs.put((byte)0xD7); bs.put((byte)0xD8); bs.put((byte)0xD9); bs.put((byte)0xDA); bs.put((byte)0xDB); bs.put((byte)0xDC); |
| bs.put((byte)0xDD); bs.put((byte)0xDE); bs.put((byte)0xDF); bs.put((byte)0xE0); bs.put((byte)0xE1); bs.put((byte)0xE2); |
| bs.put((byte)0xE3); bs.put((byte)0xE4); bs.put((byte)0xE5); bs.put((byte)0xE6); bs.put((byte)0xE7); bs.put((byte)0xE8); |
| bs.put((byte)0xEA); bs.put((byte)0xE9); bs.put((byte)0xF1); bs.put((byte)0xF2); bs.put((byte)0xF3); bs.put((byte)0xF4); |
| bs.put((byte)0xF5); bs.put((byte)0xF6); bs.put((byte)0xF7); bs.put((byte)0xF8); bs.put((byte)0xF9); bs.put((byte)0xFA); |
| |
| bsr.put((byte)0xA1); bsr.put((byte)0xA2); bsr.put((byte)0xA3); bsr.put((byte)0xA4); bsr.put((byte)0xA5); bsr.put((byte)0xA6); |
| bsr.put((byte)0xA7); bsr.put((byte)0xA8); bsr.put((byte)0xA9); bsr.put((byte)0xAA); bsr.put((byte)0xAB); bsr.put((byte)0xAC); |
| bsr.put((byte)0xAD); bsr.put((byte)0xAE); bsr.put((byte)0xAF); bsr.put((byte)0xB0); bsr.put((byte)0xB1); bsr.put((byte)0xB2); |
| bsr.put((byte)0xB3); bsr.put((byte)0xB4); bsr.put((byte)0xB5); bsr.put((byte)0xB6); bsr.put((byte)0xB7); bsr.put((byte)0xB8); |
| bsr.put((byte)0xB9); bsr.put((byte)0xBA); bsr.put((byte)0xBB); bsr.put((byte)0xBC); bsr.put((byte)0xBD); bsr.put((byte)0xBE); |
| bsr.put((byte)0xBF); bsr.put((byte)0xC0); bsr.put((byte)0xC1); bsr.put((byte)0xC2); bsr.put((byte)0xC3); bsr.put((byte)0xC4); |
| bsr.put((byte)0xC5); bsr.put((byte)0xC6); bsr.put((byte)0xC7); bsr.put((byte)0xC8); bsr.put((byte)0xC9); bsr.put((byte)0xCA); |
| bsr.put((byte)0xCB); bsr.put((byte)0xCC); bsr.put((byte)0xCD); bsr.put((byte)0xCE); bsr.put((byte)0xCF); bsr.put((byte)0xD0); |
| bsr.put((byte)0xD1); bsr.put((byte)0xD2); bsr.put((byte)0xD3); bsr.put((byte)0xD4); bsr.put((byte)0xD5); bsr.put((byte)0xD6); |
| bsr.put((byte)0xD7); bsr.put((byte)0xD8); bsr.put((byte)0xD9); bsr.put((byte)0xDA); bsr.put((byte)0xDB); bsr.put((byte)0xDC); |
| bsr.put((byte)0xDD); bsr.put((byte)0xDE); bsr.put((byte)0xDF); bsr.put((byte)0xE0); bsr.put((byte)0xE1); bsr.put((byte)0xE2); |
| bsr.put((byte)0xE3); bsr.put((byte)0xE4); bsr.put((byte)0xE5); bsr.put((byte)0xE6); bsr.put((byte)0xE7); bsr.put((byte)0xE8); |
| bsr.put((byte)0xEA); bsr.put((byte)0xE9); bsr.put((byte)0xF1); bsr.put((byte)0xF2); bsr.put((byte)0xF3); bsr.put((byte)0xF4); |
| bsr.put((byte)0xF5); bsr.put((byte)0xF6); bsr.put((byte)0xF7); bsr.put((byte)0xF8); bsr.put((byte)0xF9); bsr.put((byte)0xFA); |
| |
| //test Soft Halant |
| us.put((char)0x0915); us.put((char)0x094d); us.put((char)0x200D); |
| bs.put((byte)0xB3); bs.put((byte)0xE8); bs.put((byte)0xE9); |
| bsr.put((byte)0xB3); bsr.put((byte)0xE8); bsr.put((byte)0xE9); |
| |
| //test explicit halant |
| us.put((char)0x0915); us.put((char)0x094D); us.put((char)0x200C); |
| bs.put((byte)0xB3); bs.put((byte)0xE8); bs.put((byte)0xE8); |
| bsr.put((byte)0xB3); bsr.put((byte)0xE8); bsr.put((byte)0xE8); |
| |
| //test double danda |
| us.put((char)0x0965); |
| bs.put((byte)0xEA); bs.put((byte)0xEA); |
| bsr.put((byte)0xEA); bsr.put((byte)0xEA); |
| |
| //test ASCII |
| us.put((char)0x1B); us.put((char)0x24); us.put((char)0x29); us.put((char)0x47); us.put((char)0x0E); us.put((char)0x23); |
| us.put((char)0x21); us.put((char)0x23); us.put((char)0x22); us.put((char)0x23); us.put((char)0x23); us.put((char)0x23); |
| us.put((char)0x24); us.put((char)0x23); us.put((char)0x25); us.put((char)0x23); us.put((char)0x26); us.put((char)0x23); |
| us.put((char)0x27); us.put((char)0x23); us.put((char)0x28); us.put((char)0x23); us.put((char)0x29); us.put((char)0x23); |
| us.put((char)0x2A); us.put((char)0x23); us.put((char)0x2B); us.put((char)0x0F); us.put((char)0x2F); us.put((char)0x2A); |
| |
| bs.put((byte)0x1B); bs.put((byte)0x24); bs.put((byte)0x29); bs.put((byte)0x47); bs.put((byte)0x0E); bs.put((byte)0x23); |
| bs.put((byte)0x21); bs.put((byte)0x23); bs.put((byte)0x22); bs.put((byte)0x23); bs.put((byte)0x23); bs.put((byte)0x23); |
| bs.put((byte)0x24); bs.put((byte)0x23); bs.put((byte)0x25); bs.put((byte)0x23); bs.put((byte)0x26); bs.put((byte)0x23); |
| bs.put((byte)0x27); bs.put((byte)0x23); bs.put((byte)0x28); bs.put((byte)0x23); bs.put((byte)0x29); bs.put((byte)0x23); |
| bs.put((byte)0x2A); bs.put((byte)0x23); bs.put((byte)0x2B); bs.put((byte)0x0F); bs.put((byte)0x2F); bs.put((byte)0x2A); |
| |
| bsr.put((byte)0x1B); bsr.put((byte)0x24); bsr.put((byte)0x29); bsr.put((byte)0x47); bsr.put((byte)0x0E); bsr.put((byte)0x23); |
| bsr.put((byte)0x21); bsr.put((byte)0x23); bsr.put((byte)0x22); bsr.put((byte)0x23); bsr.put((byte)0x23); bsr.put((byte)0x23); |
| bsr.put((byte)0x24); bsr.put((byte)0x23); bsr.put((byte)0x25); bsr.put((byte)0x23); bsr.put((byte)0x26); bsr.put((byte)0x23); |
| bsr.put((byte)0x27); bsr.put((byte)0x23); bsr.put((byte)0x28); bsr.put((byte)0x23); bsr.put((byte)0x29); bsr.put((byte)0x23); |
| bsr.put((byte)0x2A); bsr.put((byte)0x23); bsr.put((byte)0x2B); bsr.put((byte)0x0F); bsr.put((byte)0x2F); bsr.put((byte)0x2A); |
| |
| //test from Lotus |
| //Some of the Lotus ISCII code points have been changed or commented out. |
| us.put((char)0x0061); us.put((char)0x0915); us.put((char)0x000D); us.put((char)0x000A); us.put((char)0x0996); us.put((char)0x0043); |
| us.put((char)0x0930); us.put((char)0x094D); us.put((char)0x200D); us.put((char)0x0901); us.put((char)0x000D); us.put((char)0x000A); |
| us.put((char)0x0905); us.put((char)0x0985); us.put((char)0x0043); us.put((char)0x0915); us.put((char)0x0921); us.put((char)0x002B); |
| us.put((char)0x095F); |
| bs.put((byte)0x61); bs.put((byte)0xB3); |
| bs.put((byte)0x0D); bs.put((byte)0x0A); |
| bs.put((byte)0xEF); bs.put((byte)0x42); |
| bs.put((byte)0xEF); bs.put((byte)0x43); bs.put((byte)0xB4); bs.put((byte)0x43); |
| bs.put((byte)0xEF); bs.put((byte)0x42); bs.put((byte)0xCF); bs.put((byte)0xE8); bs.put((byte)0xE9); bs.put((byte)0xA1); bs.put((byte)0x0D); bs.put((byte)0x0A); bs.put((byte)0xEF); bs.put((byte)0x42); |
| bs.put((byte)0xA4); bs.put((byte)0xEF); bs.put((byte)0x43); bs.put((byte)0xA4); bs.put((byte)0x43); bs.put((byte)0xEF); |
| bs.put((byte)0x42); bs.put((byte)0xB3); bs.put((byte)0xBF); bs.put((byte)0x2B); |
| bs.put((byte)0xCE); |
| bsr.put((byte)0x61); bsr.put((byte)0xEF); bsr.put((byte)0x42); bsr.put((byte)0xEF); bsr.put((byte)0x30); bsr.put((byte)0xB3); |
| bsr.put((byte)0x0D); bsr.put((byte)0x0A); bsr.put((byte)0xEF); bsr.put((byte)0x43); bsr.put((byte)0xB4); bsr.put((byte)0x43); |
| bsr.put((byte)0xEF); bsr.put((byte)0x42); bsr.put((byte)0xCF); bsr.put((byte)0xE8); bsr.put((byte)0xD9); bsr.put((byte)0xEF); |
| bsr.put((byte)0x42); bsr.put((byte)0xA1); bsr.put((byte)0x0D); bsr.put((byte)0x0A); bsr.put((byte)0xEF); bsr.put((byte)0x42); |
| bsr.put((byte)0xA4); bsr.put((byte)0xEF); bsr.put((byte)0x43); bsr.put((byte)0xA4); bsr.put((byte)0x43); bsr.put((byte)0xEF); |
| bsr.put((byte)0x42); bsr.put((byte)0xB3); bsr.put((byte)0xBF); bsr.put((byte)0x2B); bsr.put((byte)0xEF); bsr.put((byte)0x42); |
| bsr.put((byte)0xCE); |
| //end of test from Lotus |
| |
| //tamil range |
| us.put((char)0x0B86); us.put((char)0x0B87); us.put((char)0x0B88); |
| bs.put((byte)0xEF); bs.put((byte)0x44); bs.put((byte)0xA5); bs.put((byte)0xA6); bs.put((byte)0xA7); |
| bsr.put((byte)0xEF); bsr.put((byte)0x44); bsr.put((byte)0xA5); bsr.put((byte)0xA6); bsr.put((byte)0xA7); |
| |
| //telugu range |
| us.put((char)0x0C05); us.put((char)0x0C02); us.put((char)0x0C03); us.put((char)0x0C31); |
| bs.put((byte)0xEF); bs.put((byte)0x45); bs.put((byte)0xA4); bs.put((byte)0xA2); bs.put((byte)0xA3); bs.put((byte)0xD0); |
| bsr.put((byte)0xEF); bsr.put((byte)0x45); bsr.put((byte)0xA4); bsr.put((byte)0xA2); bsr.put((byte)0xA3); bsr.put((byte)0xD0); |
| |
| //kannada range |
| us.put((char)0x0C85); us.put((char)0x0C82); us.put((char)0x0C83); |
| bs.put((byte)0xEF); bs.put((byte)0x48); bs.put((byte)0xA4); bs.put((byte)0xA2); bs.put((byte)0xA3); |
| bsr.put((byte)0xEF); bsr.put((byte)0x48); bsr.put((byte)0xA4); bsr.put((byte)0xA2); bsr.put((byte)0xA3); |
| |
| //test Abbr sign and Anudatta |
| us.put((char)0x0970); us.put((char)0x0952); us.put((char)0x0960); us.put((char)0x0944); us.put((char)0x090C); us.put((char)0x0962); |
| us.put((char)0x0961); us.put((char)0x0963); us.put((char)0x0950); us.put((char)0x093D); us.put((char)0x0958); us.put((char)0x0959); |
| us.put((char)0x095A); us.put((char)0x095B); us.put((char)0x095C); us.put((char)0x095D); us.put((char)0x095E); us.put((char)0x0020); |
| us.put((char)0x094D); us.put((char)0x0930); us.put((char)0x0000); us.put((char)0x00A0); |
| bs.put((byte)0xEF); bs.put((byte)0x42); bs.put((byte)0xF0); bs.put((byte)0xBF); bs.put((byte)0xF0); bs.put((byte)0xB8); |
| bs.put((byte)0xAA); bs.put((byte)0xE9); bs.put((byte)0xDF); bs.put((byte)0xE9); bs.put((byte)0xA6); bs.put((byte)0xE9); |
| bs.put((byte)0xDB); bs.put((byte)0xE9); bs.put((byte)0xA7); bs.put((byte)0xE9); bs.put((byte)0xDC); bs.put((byte)0xE9); |
| bs.put((byte)0xA1); bs.put((byte)0xE9); bs.put((byte)0xEA); bs.put((byte)0xE9); bs.put((byte)0xB3); bs.put((byte)0xE9); |
| bs.put((byte)0xB4); bs.put((byte)0xE9); bs.put((byte)0xB5); bs.put((byte)0xE9); bs.put((byte)0xBA); bs.put((byte)0xE9); |
| bs.put((byte)0xBF); bs.put((byte)0xE9); bs.put((byte)0xC0); bs.put((byte)0xE9); bs.put((byte)0xC9); bs.put((byte)0xE9); |
| bs.put((byte)0x20); bs.put((byte)0xE8); bs.put((byte)0xCF); bs.put((byte)0x00); bs.put((byte)0xA0); |
| //bs.put((byte)0xEF); bs.put((byte)0x30); |
| bsr.put((byte)0xEF); bsr.put((byte)0x42); bsr.put((byte)0xF0); bsr.put((byte)0xBF); bsr.put((byte)0xF0); bsr.put((byte)0xB8); |
| bsr.put((byte)0xAA); bsr.put((byte)0xE9); bsr.put((byte)0xDF); bsr.put((byte)0xE9); bsr.put((byte)0xA6); bsr.put((byte)0xE9); |
| bsr.put((byte)0xDB); bsr.put((byte)0xE9); bsr.put((byte)0xA7); bsr.put((byte)0xE9); bsr.put((byte)0xDC); bsr.put((byte)0xE9); |
| bsr.put((byte)0xA1); bsr.put((byte)0xE9); bsr.put((byte)0xEA); bsr.put((byte)0xE9); bsr.put((byte)0xB3); bsr.put((byte)0xE9); |
| bsr.put((byte)0xB4); bsr.put((byte)0xE9); bsr.put((byte)0xB5); bsr.put((byte)0xE9); bsr.put((byte)0xBA); bsr.put((byte)0xE9); |
| bsr.put((byte)0xBF); bsr.put((byte)0xE9); bsr.put((byte)0xC0); bsr.put((byte)0xE9); bsr.put((byte)0xC9); bsr.put((byte)0xE9); |
| bsr.put((byte)0xD9); bsr.put((byte)0xE8); bsr.put((byte)0xCF); bsr.put((byte)0x00); bsr.put((byte)0xA0); |
| |
| bs.limit(bs.position()); |
| bs.position(0); |
| us.limit(us.position()); |
| us.position(0); |
| bsr.limit(bsr.position()); |
| bsr.position(0); |
| |
| //round trip test |
| try { |
| smBufDecode(decoder, "ISCII-part1", bsr, us, false, true); |
| smBufEncode(encoder, "ISCII-part2", us, bs); |
| smBufDecode(decoder, "ISCII-part3", bs, us, false, true); |
| } catch (Exception ex) { |
| errln("ISCII round trip test failed."); |
| } |
| |
| //Test new characters in the ISCII charset |
| encoder = provider.charsetForName("ISCII,version=0").newEncoder(); |
| decoder = provider.charsetForName("ISCII,version=0").newDecoder(); |
| char u_pts[] = { |
| /* DEV */ (char)0x0904, |
| /* PNJ */ (char)0x0A01, (char)0x0A03, (char)0x0A33, (char)0x0A70 |
| }; |
| byte b_pts[] = { |
| (byte)0xef, (byte)0x42, |
| /* DEV */ (byte)0xa4, (byte)0xe0, |
| /* PNJ */ (byte)0xef, (byte)0x4b, (byte)0xa1, (byte)0xa3, (byte)0xd2, (byte)0xf0, (byte)0xbf |
| }; |
| us = CharBuffer.allocate(u_pts.length); |
| bs = ByteBuffer.allocate(b_pts.length); |
| us.put(u_pts); |
| bs.put(b_pts); |
| |
| bs.limit(bs.position()); |
| bs.position(0); |
| us.limit(us.position()); |
| us.position(0); |
| |
| try { |
| smBufDecode(decoder, "ISCII-update", bs, us, true, true); |
| bs.position(0); |
| us.position(0); |
| smBufEncode(encoder, "ISCII-update", us, bs, true, true); |
| } catch (Exception ex) { |
| errln("Error occurred while encoding/decoding ISCII with the new characters."); |
| } |
| |
| //The rest of the code in this method is to provide better code coverage |
| CharBuffer ccus = CharBuffer.allocate(0x10); |
| ByteBuffer ccbs = ByteBuffer.allocate(0x10); |
| |
| //start of charset decoder code coverage code |
| //test overflow buffer |
| ccbs.put((byte)0x49); |
| |
| ccbs.limit(ccbs.position()); |
| ccbs.position(0); |
| ccus.limit(0); |
| ccus.position(0); |
| |
| try { |
| smBufDecode(decoder, "ISCII-CC-DE-1", ccbs, ccus, true, false); |
| errln("Exception while decoding ISCII should have been thrown."); |
| } |
| catch (Exception ex) { |
| } |
| |
| ccbs.clear(); |
| ccus.clear(); |
| |
| //test atr overflow buffer |
| ccbs.put((byte)0xEF); ccbs.put((byte)0x40); ccbs.put((byte)0xEF); ccbs.put((byte)0x20); |
| ccus.put((char)0x00); |
| |
| ccbs.limit(ccbs.position()); |
| ccbs.position(0); |
| ccus.limit(ccus.position()); |
| ccus.position(0); |
| |
| try { |
| smBufDecode(decoder, "ISCII-CC-DE-2", ccbs, ccus, true, false); |
| errln("Exception while decoding ISCII should have been thrown."); |
| } |
| catch (Exception ex) { |
| } |
| |
| //end of charset decoder code coverage code |
| |
| ccbs.clear(); |
| ccus.clear(); |
| |
| //start of charset encoder code coverage code |
| //test ascii overflow buffer |
| ccus.put((char)0x41); |
| |
| ccus.limit(ccus.position()); |
| ccus.position(0); |
| ccbs.limit(0); |
| ccbs.position(0); |
| |
| try { |
| smBufEncode(encoder, "ISCII-CC-EN-1", ccus, ccbs, true, false); |
| errln("Exception while encoding ISCII should have been thrown."); |
| } |
| catch (Exception ex) { |
| } |
| |
| ccbs.clear(); |
| ccus.clear(); |
| |
| //test ascii overflow buffer |
| ccus.put((char)0x0A); ccus.put((char)0x0043); |
| ccbs.put((byte)0x00); ccbs.put((byte)0x00); |
| |
| ccus.limit(ccus.position()); |
| ccus.position(0); |
| ccbs.limit(ccbs.position()); |
| ccbs.position(0); |
| |
| try { |
| smBufEncode(encoder, "ISCII-CC-EN-2", ccus, ccbs, true, false); |
| errln("Exception while encoding ISCII should have been thrown."); |
| } |
| catch (Exception ex) { |
| } |
| |
| ccbs.clear(); |
| ccus.clear(); |
| |
| //test surrogate malform |
| ccus.put((char)0x06E3); |
| ccbs.put((byte)0x00); |
| |
| ccus.limit(ccus.position()); |
| ccus.position(0); |
| ccbs.limit(ccbs.position()); |
| ccbs.position(0); |
| |
| try { |
| smBufEncode(encoder, "ISCII-CC-EN-3", ccus, ccbs, true, false); |
| errln("Exception while encoding ISCII should have been thrown."); |
| } |
| catch (Exception ex) { |
| } |
| |
| ccbs.clear(); |
| ccus.clear(); |
| |
| //test surrogate malform |
| ccus.put((char)0xD801); ccus.put((char)0xDD01); |
| ccbs.put((byte)0x00); |
| |
| ccus.limit(ccus.position()); |
| ccus.position(0); |
| ccbs.limit(ccbs.position()); |
| ccbs.position(0); |
| |
| try { |
| smBufEncode(encoder, "ISCII-CC-EN-4", ccus, ccbs, true, false); |
| errln("Exception while encoding ISCII should have been thrown."); |
| } |
| catch (Exception ex) { |
| } |
| |
| ccbs.clear(); |
| ccus.clear(); |
| |
| //test trail surrogate malform |
| ccus.put((char)0xDD01); |
| ccbs.put((byte)0x00); |
| |
| ccus.limit(ccus.position()); |
| ccus.position(0); |
| ccbs.limit(ccbs.position()); |
| ccbs.position(0); |
| |
| try { |
| smBufEncode(encoder, "ISCII-CC-EN-5", ccus, ccbs, true, false); |
| errln("Exception while encoding ISCII should have been thrown."); |
| } |
| catch (Exception ex) { |
| } |
| |
| ccbs.clear(); |
| ccus.clear(); |
| |
| //test lead surrogates malform |
| ccus.put((char)0xD801); ccus.put((char)0xD802); |
| ccbs.put((byte)0x00); |
| |
| ccus.limit(ccus.position()); |
| ccus.position(0); |
| ccbs.limit(ccbs.position()); |
| ccbs.position(0); |
| |
| try { |
| smBufEncode(encoder, "ISCII-CC-EN-6", ccus, ccbs, true, false); |
| errln("Exception while encoding ISCII should have been thrown."); |
| } |
| catch (Exception ex) { |
| } |
| |
| ccus.clear(); |
| ccbs.clear(); |
| |
| //test overflow buffer |
| ccus.put((char)0x0901); |
| ccbs.put((byte)0x00); |
| |
| ccus.limit(ccus.position()); |
| ccus.position(0); |
| ccbs.limit(ccbs.position()); |
| ccbs.position(0); |
| |
| cs = provider.charsetForName("ISCII,version=0"); |
| encoder = cs.newEncoder(); |
| |
| try { |
| smBufEncode(encoder, "ISCII-CC-EN-7", ccus, ccbs, true, false); |
| errln("Exception while encoding ISCII should have been thrown."); |
| } |
| catch (Exception ex) { |
| } |
| //end of charset encoder code coverage code |
| } |
| |
| //Test for the IMAP Charset |
| public void TestCharsetIMAP() { |
| CharsetProvider provider = new CharsetProviderICU(); |
| Charset cs = provider.charsetForName("IMAP-mailbox-name"); |
| CharsetEncoder encoder = cs.newEncoder(); |
| CharsetDecoder decoder = cs.newDecoder(); |
| |
| CharBuffer us = CharBuffer.allocate(0x20); |
| ByteBuffer bs = ByteBuffer.allocate(0x20); |
| |
| us.put((char)0x00A3); us.put((char)0x2020); us.put((char)0x41); |
| |
| bs.put((byte)0x26); bs.put((byte)0x41); bs.put((byte)0x4B); bs.put((byte)0x4D); bs.put((byte)0x67); bs.put((byte)0x49); |
| bs.put((byte)0x41); bs.put((byte)0x2D); bs.put((byte)0x41); |
| |
| |
| bs.limit(bs.position()); |
| bs.position(0); |
| us.limit(us.position()); |
| us.position(0); |
| |
| smBufDecode(decoder, "IMAP", bs, us); |
| smBufEncode(encoder, "IMAP", us, bs); |
| |
| //the rest of the code in this method is for better code coverage |
| us.clear(); |
| bs.clear(); |
| |
| //start of charset encoder code coverage |
| //test buffer overflow |
| us.put((char)0x0026); us.put((char)0x17A9); |
| bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); |
| |
| bs.limit(bs.position()); |
| bs.position(0); |
| us.limit(us.position()); |
| us.position(0); |
| |
| try { |
| smBufEncode(encoder, "IMAP-EN-1", us, bs, true, false); |
| errln("Exception while encoding IMAP (1) should have been thrown."); |
| } catch(Exception ex) { |
| } |
| |
| us.clear(); |
| bs.clear(); |
| |
| //test buffer overflow |
| us.put((char)0x17A9); us.put((char)0x0941); |
| bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); |
| |
| bs.limit(bs.position()); |
| bs.position(0); |
| us.limit(us.position()); |
| us.position(0); |
| |
| try { |
| smBufEncode(encoder, "IMAP-EN-2", us, bs, true, false); |
| errln("Exception while encoding IMAP (2) should have been thrown."); |
| } catch(Exception ex) { |
| } |
| |
| us.clear(); |
| bs.clear(); |
| |
| //test buffer overflow |
| us.put((char)0x17A9); us.put((char)0x0941); |
| bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); |
| |
| bs.limit(bs.position()); |
| bs.position(0); |
| us.limit(us.position()); |
| us.position(0); |
| |
| try { |
| smBufEncode(encoder, "IMAP-EN-3", us, bs, true, false); |
| errln("Exception while encoding IMAP (3) should have been thrown."); |
| } catch(Exception ex) { |
| } |
| |
| us.clear(); |
| bs.clear(); |
| |
| //test buffer overflow |
| us.put((char)0x17A9); us.put((char)0x0941); us.put((char)0x0955); |
| bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); |
| bs.put((byte)0x00); |
| |
| bs.limit(bs.position()); |
| bs.position(0); |
| us.limit(us.position()); |
| us.position(0); |
| |
| try { |
| smBufEncode(encoder, "IMAP-EN-4", us, bs, true, false); |
| errln("Exception while encoding IMAP (4) should have been thrown."); |
| } catch(Exception ex) { |
| } |
| |
| us.clear(); |
| bs.clear(); |
| |
| //test buffer overflow |
| us.put((char)0x17A9); us.put((char)0x0941); us.put((char)0x0955); |
| bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); |
| bs.put((byte)0x00); bs.put((byte)0x00); |
| |
| bs.limit(bs.position()); |
| bs.position(0); |
| us.limit(us.position()); |
| us.position(0); |
| |
| try { |
| smBufEncode(encoder, "IMAP-EN-5", us, bs, true, false); |
| errln("Exception while encoding IMAP (5) should have been thrown."); |
| } catch(Exception ex) { |
| } |
| |
| us.clear(); |
| bs.clear(); |
| |
| //test buffer overflow |
| us.put((char)0x17A9); us.put((char)0x0941); us.put((char)0x0955); us.put((char)0x0970); |
| bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); |
| bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); |
| |
| bs.limit(bs.position()); |
| bs.position(0); |
| us.limit(us.position()); |
| us.position(0); |
| |
| try { |
| smBufEncode(encoder, "IMAP-EN-6", us, bs, true, false); |
| errln("Exception while encoding IMAP (6) should have been thrown."); |
| } catch(Exception ex) { |
| } |
| |
| us.clear(); |
| bs.clear(); |
| |
| //test buffer overflow |
| us.put((char)0x17A9); us.put((char)0x0941); |
| bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); |
| bs.put((byte)0x00); |
| |
| bs.limit(bs.position()); |
| bs.position(0); |
| us.limit(us.position()); |
| us.position(0); |
| |
| try { |
| smBufEncode(encoder, "IMAP-EN-7", us, bs, true, true); |
| errln("Exception while encoding IMAP (7) should have been thrown."); |
| } catch(Exception ex) { |
| } |
| |
| us.clear(); |
| bs.clear(); |
| |
| //test flushing |
| us.put((char)0x17A9); us.put((char)0x0941); |
| bs.put((byte)0x26); bs.put((byte)0x46); bs.put((byte)0x36); bs.put((byte)0x6b); bs.put((byte)0x4a); bs.put((byte)0x51); |
| bs.put((byte)0x51); bs.put((byte)0x2d); |
| |
| bs.limit(bs.position()); |
| bs.position(0); |
| us.limit(us.position()); |
| us.position(0); |
| |
| try { |
| smBufEncode(encoder, "IMAP-EN-8", us, bs, true, true); |
| } catch(Exception ex) { |
| errln("Exception while encoding IMAP (8) should not have been thrown."); |
| } |
| |
| us = CharBuffer.allocate(0x08); |
| bs = ByteBuffer.allocate(0x08); |
| |
| //test flushing buffer overflow |
| us.put((char)0x0061); |
| bs.put((byte)0x61); bs.put((byte)0x00); |
| |
| bs.limit(bs.position()); |
| bs.position(0); |
| us.limit(us.position()); |
| us.position(0); |
| |
| try { |
| smBufEncode(encoder, "IMAP-EN-9", us, bs, true, true); |
| } catch(Exception ex) { |
| errln("Exception while encoding IMAP (9) should not have been thrown."); |
| } |
| //end of charset encoder code coverage |
| |
| us = CharBuffer.allocate(0x10); |
| bs = ByteBuffer.allocate(0x10); |
| |
| //start of charset decoder code coverage |
| //test malform case 2 |
| us.put((char)0x0000); us.put((char)0x0000); |
| bs.put((byte)0x26); bs.put((byte)0x41); bs.put((byte)0x43); bs.put((byte)0x41); |
| |
| bs.limit(bs.position()); |
| bs.position(0); |
| us.limit(us.position()); |
| us.position(0); |
| |
| try { |
| smBufDecode(decoder, "IMAP-DE-1", bs, us, true, false); |
| errln("Exception while decoding IMAP (1) should have been thrown."); |
| } catch(Exception ex) { |
| } |
| |
| us.clear(); |
| bs.clear(); |
| |
| //test malform case 5 |
| us.put((char)0x0000); us.put((char)0x0000); us.put((char)0x0000); |
| bs.put((byte)0x26); bs.put((byte)0x41); bs.put((byte)0x41); bs.put((byte)0x41); |
| bs.put((byte)0x41); bs.put((byte)0x49); bs.put((byte)0x41); |
| |
| bs.limit(bs.position()); |
| bs.position(0); |
| us.limit(us.position()); |
| us.position(0); |
| |
| try { |
| smBufDecode(decoder, "IMAP-DE-2", bs, us, true, false); |
| errln("Exception while decoding IMAP (2) should have been thrown."); |
| } catch(Exception ex) { |
| } |
| |
| us.clear(); |
| bs.clear(); |
| |
| //test malform case 7 |
| us.put((char)0x0000); us.put((char)0x0000); us.put((char)0x0000); us.put((char)0x0000); |
| bs.put((byte)0x26); bs.put((byte)0x41); bs.put((byte)0x41); bs.put((byte)0x41); |
| bs.put((byte)0x41); bs.put((byte)0x41); bs.put((byte)0x41); bs.put((byte)0x42); |
| bs.put((byte)0x41); |
| |
| bs.limit(bs.position()); |
| bs.position(0); |
| us.limit(us.position()); |
| us.position(0); |
| |
| try { |
| smBufDecode(decoder, "IMAP-DE-3", bs, us, true, false); |
| errln("Exception while decoding IMAP (3) should have been thrown."); |
| } catch(Exception ex) { |
| } |
| //end of charset decoder coder coverage |
| } |
| |
| //Test for charset UTF32LE to provide better code coverage |
| public void TestCharsetUTF32LE() { |
| CoderResult result = CoderResult.UNDERFLOW; |
| CharsetProvider provider = new CharsetProviderICU(); |
| Charset cs = provider.charsetForName("UTF-32LE"); |
| CharsetEncoder encoder = cs.newEncoder(); |
| //CharsetDecoder decoder = cs.newDecoder(); |
| |
| CharBuffer us = CharBuffer.allocate(0x10); |
| ByteBuffer bs = ByteBuffer.allocate(0x10); |
| |
| |
| //test malform surrogate |
| us.put((char)0xD901); |
| bs.put((byte)0x00); |
| |
| bs.limit(bs.position()); |
| bs.position(0); |
| us.limit(us.position()); |
| us.position(0); |
| |
| try { |
| smBufEncode(encoder, "UTF32LE-EN-1", us, bs, true, false); |
| errln("Exception while encoding UTF32LE (1) should have been thrown."); |
| } catch (Exception ex) { |
| } |
| |
| bs.clear(); |
| us.clear(); |
| |
| //test malform surrogate |
| us.put((char)0xD901); us.put((char)0xD902); |
| bs.put((byte)0x00); |
| |
| bs.limit(bs.position()); |
| bs.position(0); |
| us.limit(us.position()); |
| us.position(0); |
| |
| result = encoder.encode(us, bs, true); |
| |
| if (!result.isError() && !result.isOverflow()) { |
| errln("Error while encoding UTF32LE (2) should have occurred."); |
| } |
| |
| bs.clear(); |
| us.clear(); |
| |
| //test overflow trail surrogate |
| us.put((char)0xDD01); us.put((char)0xDD0E); us.put((char)0xDD0E); |
| bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); |
| bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); |
| |
| bs.limit(bs.position()); |
| bs.position(0); |
| us.limit(us.position()); |
| us.position(0); |
| |
| result = encoder.encode(us, bs, true); |
| |
| if (!result.isError() && !result.isOverflow()) { |
| errln("Error while encoding UTF32LE (3) should have occurred."); |
| } |
| |
| bs.clear(); |
| us.clear(); |
| |
| //test malform lead surrogate |
| us.put((char)0xD90D); us.put((char)0xD90E); |
| bs.put((byte)0x00); |
| |
| bs.limit(bs.position()); |
| bs.position(0); |
| us.limit(us.position()); |
| us.position(0); |
| |
| try { |
| smBufEncode(encoder, "UTF32LE-EN-4", us, bs, true, false); |
| errln("Exception while encoding UTF32LE (4) should have been thrown."); |
| } catch (Exception ex) { |
| } |
| |
| bs.clear(); |
| us.clear(); |
| |
| //test overflow buffer |
| us.put((char)0x0061); |
| bs.put((byte)0x00); |
| |
| bs.limit(bs.position()); |
| bs.position(0); |
| us.limit(us.position()); |
| us.position(0); |
| |
| try { |
| smBufEncode(encoder, "UTF32LE-EN-5", us, bs, true, false); |
| errln("Exception while encoding UTF32LE (5) should have been thrown."); |
| } catch (Exception ex) { |
| } |
| |
| bs.clear(); |
| us.clear(); |
| |
| //test malform trail surrogate |
| us.put((char)0xDD01); |
| bs.put((byte)0x00); |
| |
| bs.limit(bs.position()); |
| bs.position(0); |
| us.limit(us.position()); |
| us.position(0); |
| |
| try { |
| smBufEncode(encoder, "UTF32LE-EN-6", us, bs, true, false); |
| errln("Exception while encoding UTF32LE (6) should have been thrown."); |
| } catch (Exception ex) { |
| } |
| } |
| |
| //Test for charset UTF16LE to provide better code coverage |
| public void TestCharsetUTF16LE() { |
| CoderResult result = CoderResult.UNDERFLOW; |
| CharsetProvider provider = new CharsetProviderICU(); |
| Charset cs = provider.charsetForName("UTF-16LE"); |
| CharsetEncoder encoder = cs.newEncoder(); |
| //CharsetDecoder decoder = cs.newDecoder(); |
| |
| // Test for malform and change fromUChar32 for next call |
| char u_pts1[] = { |
| (char)0xD805, |
| (char)0xDC01, (char)0xDC02, (char)0xDC03, |
| (char)0xD901, (char)0xD902 |
| }; |
| byte b_pts1[] = { |
| (byte)0x00, |
| (byte)0x00, (byte)0x00, (byte)0x00, (byte)0x00, (byte)0x00, (byte)0x00 |
| }; |
| |
| CharBuffer us = CharBuffer.allocate(u_pts1.length); |
| ByteBuffer bs = ByteBuffer.allocate(b_pts1.length); |
| |
| us.put(u_pts1); |
| bs.put(b_pts1); |
| |
| us.limit(1); |
| us.position(0); |
| bs.limit(1); |
| bs.position(0); |
| |
| result = encoder.encode(us, bs, true); |
| |
| if (!result.isMalformed()) { |
| // LE should not output BOM, so this should be malformed |
| errln("Malformed while encoding UTF-16LE (1) should have occured."); |
| } |
| |
| // Test for malform surrogate from previous buffer |
| us.limit(4); |
| us.position(1); |
| bs.limit(7); |
| bs.position(1); |
| |
| result = encoder.encode(us, bs, true); |
| |
| if (!result.isMalformed()) { |
| errln("Error while encoding UTF-16LE (2) should have occured."); |
| } |
| |
| // Test for malform trail surrogate |
| encoder.reset(); |
| |
| us.limit(1); |
| us.position(0); |
| bs.limit(1); |
| bs.position(0); |
| |
| result = encoder.encode(us, bs, true); |
| |
| us.limit(6); |
| us.position(4); |
| bs.limit(4); |
| bs.position(1); |
| |
| result = encoder.encode(us, bs, true); |
| |
| if (!result.isMalformed()) { |
| errln("Error while encoding UTF-16LE (3) should have occured."); |
| } |
| } |
| |
| //provide better code coverage for the generic charset UTF32 |
| public void TestCharsetUTF32() { |
| CoderResult result = CoderResult.UNDERFLOW; |
| CharsetProvider provider = new CharsetProviderICU(); |
| Charset cs = provider.charsetForName("UTF-32"); |
| CharsetDecoder decoder = cs.newDecoder(); |
| CharsetEncoder encoder = cs.newEncoder(); |
| |
| //start of decoding code coverage |
| char us_array[] = { |
| 0x0000, 0x0000, 0x0000, 0x0000, |
| }; |
| |
| byte bs_array1[] = { |
| (byte)0x00, (byte)0x00, (byte)0xFE, (byte)0xFF, |
| (byte)0x00, (byte)0x00, (byte)0x04, (byte)0x43, |
| (byte)0xFF, (byte)0xFE, (byte)0x00, (byte)0x00, |
| (byte)0x43, (byte)0x04, (byte)0x00, (byte)0x00, |
| }; |
| |
| byte bs_array2[] = { |
| (byte)0xFF, (byte)0xFE, (byte)0x00, (byte)0x00, |
| (byte)0x43, (byte)0x04, (byte)0x00, (byte)0x00, |
| }; |
| |
| CharBuffer us = CharBuffer.allocate(us_array.length); |
| ByteBuffer bs = ByteBuffer.allocate(bs_array1.length); |
| |
| us.put(us_array); |
| bs.put(bs_array1); |
| |
| us.limit(us.position()); |
| us.position(0); |
| bs.limit(bs.position()); |
| bs.position(0); |
| |
| try { |
| smBufDecode(decoder, "UTF32-DE-1", bs, us, true, false); |
| errln("Malform exception while decoding UTF32 charset (1) should have been thrown."); |
| } catch (Exception ex) { |
| } |
| |
| decoder = cs.newDecoder(); |
| |
| bs = ByteBuffer.allocate(bs_array2.length); |
| bs.put(bs_array2); |
| |
| us.limit(4); |
| us.position(0); |
| bs.limit(bs.position()); |
| bs.position(0); |
| |
| try { |
| smBufDecode(decoder, "UTF32-DE-2", bs, us, true, false); |
| } catch (Exception ex) { |
| // should recognize little endian BOM |
| errln("Exception while decoding UTF32 charset (2) should not have been thrown."); |
| } |
| |
| //Test malform exception |
| bs.clear(); |
| us.clear(); |
| |
| bs.put((byte)0x00); bs.put((byte)0xFE); bs.put((byte)0xFF); bs.put((byte)0x00); bs.put((byte)0x00); |
| us.put((char)0x0000); |
| |
| us.limit(us.position()); |
| us.position(0); |
| bs.limit(bs.position()); |
| bs.position(0); |
| |
| try { |
| smBufDecode(decoder, "UTF32-DE-3", bs, us, true, false); |
| errln("Malform exception while decoding UTF32 charset (3) should have been thrown."); |
| } catch (Exception ex) { |
| } |
| |
| //Test BOM testing |
| bs.clear(); |
| us.clear(); |
| |
| bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0xFF); bs.put((byte)0xFE); |
| us.put((char)0x0000); |
| |
| us.limit(us.position()); |
| us.position(0); |
| bs.limit(bs.position()); |
| bs.position(0); |
| |
| try { |
| smBufDecode(decoder, "UTF32-DE-4", bs, us, true, false); |
| } catch (Exception ex) { |
| // should recognize big endian BOM |
| errln("Exception while decoding UTF32 charset (4) should not have been thrown."); |
| } |
| //end of decoding code coverage |
| |
| //start of encoding code coverage |
| us = CharBuffer.allocate(0x10); |
| bs = ByteBuffer.allocate(0x10); |
| |
| //test wite BOM overflow error |
| us.put((char)0xDC01); |
| bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); |
| |
| us.limit(us.position()); |
| us.position(0); |
| bs.limit(bs.position()); |
| bs.position(0); |
| |
| result = encoder.encode(us, bs, true); |
| // must try to output BOM first for UTF-32 (not UTF-32BE or UTF-32LE) |
| if (!result.isOverflow()) { |
| errln("Buffer overflow error while encoding UTF32 charset (1) should have occurred."); |
| } |
| |
| us.clear(); |
| bs.clear(); |
| |
| //test malform surrogate and store value in fromChar32 |
| us.put((char)0xD801); us.put((char)0xD802); |
| bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); |
| |
| us.limit(us.position()); |
| us.position(0); |
| bs.limit(bs.position()); |
| bs.position(0); |
| |
| result = encoder.encode(us, bs, true); |
| if (!result.isMalformed()) { |
| errln("Malformed error while encoding UTF32 charset (2) should have occurred."); |
| } |
| |
| us.clear(); |
| bs.clear(); |
| |
| //test malform surrogate |
| us.put((char)0x0000); us.put((char)0xD902); |
| |
| us.limit(us.position()); |
| us.position(0); |
| bs.limit(bs.position()); |
| bs.position(0); |
| |
| result = encoder.encode(us, bs, true); |
| if (!result.isOverflow()) { |
| errln("Overflow error while encoding UTF32 charset (3) should have occurred."); |
| } |
| |
| us.clear(); |
| bs.clear(); |
| |
| //test malform surrogate |
| encoder.reset(); |
| us.put((char)0xD801); |
| bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); |
| |
| us.limit(us.position()); |
| us.position(0); |
| bs.limit(bs.position()); |
| bs.position(0); |
| |
| result = encoder.encode(us, bs, true); |
| if (!result.isMalformed()) { |
| errln("Malform error while encoding UTF32 charset (4) should have occurred."); |
| } |
| |
| us.clear(); |
| bs.clear(); |
| |
| //test overflow surrogate |
| us.put((char)0x0000); us.put((char)0xDDE1); us.put((char)0xD915); us.put((char)0xDDF2); |
| bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); |
| |
| us.limit(us.position()); |
| us.position(0); |
| bs.limit(bs.position()); |
| bs.position(0); |
| |
| result = encoder.encode(us, bs, true); |
| if (!result.isOverflow()) { |
| errln("Overflow error while encoding UTF32 charset (5) should have occurred."); |
| } |
| |
| us.clear(); |
| bs.clear(); |
| |
| //test malform surrogate |
| encoder.reset(); |
| us.put((char)0xDDE1); |
| bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); |
| |
| us.limit(us.position()); |
| us.position(0); |
| bs.limit(bs.position()); |
| bs.position(0); |
| |
| result = encoder.encode(us, bs, true); |
| if (!result.isMalformed()) { |
| errln("Malform error while encoding UTF32 charset (6) should have occurred."); |
| } |
| //end of encoding code coverage |
| } |
| |
| //this method provides better code coverage decoding UTF32 LE/BE |
| public void TestDecodeUTF32LEBE() { |
| CoderResult result = CoderResult.UNDERFLOW; |
| CharsetProvider provider = new CharsetProviderICU(); |
| CharsetDecoder decoder; |
| CharBuffer us = CharBuffer.allocate(0x10); |
| ByteBuffer bs = ByteBuffer.allocate(0x10); |
| |
| //decode UTF32LE |
| decoder = provider.charsetForName("UTF-32LE").newDecoder(); |
| //test overflow buffer |
| bs.put((byte)0x41); bs.put((byte)0xFF); bs.put((byte)0x01); bs.put((byte)0x00); |
| us.put((char)0x0000); |
| |
| us.limit(us.position()); |
| us.position(0); |
| bs.limit(bs.position()); |
| bs.position(0); |
| |
| try { |
| smBufDecode(decoder, "UTF-32LE", bs, us, true, false); |
| errln("Overflow exception while decoding UTF32LE (1) should have been thrown."); |
| } catch (Exception ex) { |
| } |
| // test overflow buffer handling in CharsetDecoderICU |
| bs.position(0); |
| us.position(0); |
| decoder.reset(); |
| result = decoder.decode(bs, us, true); |
| if (result.isOverflow()) { |
| result = decoder.decode(bs, us, true); |
| if (!result.isOverflow()) { |
| errln("Overflow buffer error while decoding UTF32LE should have occurred."); |
| } |
| } else { |
| errln("Overflow buffer error while decoding UTF32LE should have occurred."); |
| } |
| |
| us.clear(); |
| bs.clear(); |
| //test malform buffer |
| bs.put((byte)0x02); bs.put((byte)0xD9); bs.put((byte)0x00); bs.put((byte)0x00); |
| us.put((char)0x0000); |
| |
| us.limit(us.position()); |
| us.position(0); |
| bs.limit(bs.position()); |
| bs.position(0); |
| |
| try { |
| smBufDecode(decoder, "UTF-32LE", bs, us, true, false); |
| errln("Malform exception while decoding UTF32LE (2) should have been thrown."); |
| } catch (Exception ex) { |
| } |
| |
| us.clear(); |
| bs.clear(); |
| //test malform buffer |
| bs.put((byte)0xFF); bs.put((byte)0xFE); bs.put((byte)0x00); bs.put((byte)0x00); |
| bs.put((byte)0xFF); bs.put((byte)0xDF); bs.put((byte)0x10); |
| us.put((char)0x0000); |
| |
| us.limit(us.position()); |
| us.position(0); |
| bs.limit(bs.position()); |
| bs.position(0); |
| |
| try { |
| // must flush in order to exhibit malformed behavior |
| smBufDecode(decoder, "UTF-32LE", bs, us, true, true); |
| errln("Malform exception while decoding UTF32LE (3) should have been thrown."); |
| } catch (Exception ex) { |
| } |
| |
| us.clear(); |
| bs.clear(); |
| //test malform buffer |
| bs.put((byte)0xFF); bs.put((byte)0xFE); bs.put((byte)0x00); bs.put((byte)0x00); |
| bs.put((byte)0x02); bs.put((byte)0xD9); bs.put((byte)0x00); bs.put((byte)0x00); |
| us.put((char)0x0000); |
| |
| us.limit(us.position()); |
| us.position(0); |
| bs.limit(bs.position()); |
| bs.position(0); |
| |
| try { |
| smBufDecode(decoder, "UTF-32LE", bs, us, true, false); |
| errln("Malform exception while decoding UTF32LE (4) should have been thrown."); |
| } catch (Exception ex) { |
| } |
| |
| us.clear(); |
| bs.clear(); |
| //test overflow buffer |
| bs.put((byte)0xFF); bs.put((byte)0xFE); bs.put((byte)0x00); bs.put((byte)0x00); |
| bs.put((byte)0xDD); bs.put((byte)0xFF); bs.put((byte)0x10); bs.put((byte)0x00); |
| us.put((char)0x0000); |
| |
| us.limit(us.position()); |
| us.position(0); |
| bs.limit(bs.position()); |
| bs.position(0); |
| |
| try { |
| smBufDecode(decoder, "UTF-32LE", bs, us, true, false); |
| errln("Overflow exception while decoding UTF32LE (5) should have been thrown."); |
| } catch (Exception ex) { |
| } |
| //end of decode UTF32LE |
| |
| bs.clear(); |
| us.clear(); |
| |
| //decode UTF32BE |
| decoder = provider.charsetForName("UTF-32BE").newDecoder(); |
| //test overflow buffer |
| bs.put((byte)0x00); bs.put((byte)0x01); bs.put((byte)0xFF); bs.put((byte)0x41); |
| us.put((char)0x0000); |
| |
| us.limit(us.position()); |
| us.position(0); |
| bs.limit(bs.position()); |
| bs.position(0); |
| |
| try { |
| smBufDecode(decoder, "UTF-32BE", bs, us, true, false); |
| errln("Overflow exception while decoding UTF32BE (1) should have been thrown."); |
| } catch (Exception ex) { |
| } |
| |
| bs.clear(); |
| us.clear(); |
| //test malform buffer |
| bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0xD9); bs.put((byte)0x02); |
| us.put((char)0x0000); |
| |
| us.limit(us.position()); |
| us.position(0); |
| bs.limit(bs.position()); |
| bs.position(0); |
| |
| try { |
| smBufDecode(decoder, "UTF-32BE", bs, us, true, false); |
| errln("Malform exception while decoding UTF32BE (2) should have been thrown."); |
| } catch (Exception ex) { |
| } |
| |
| bs.clear(); |
| us.clear(); |
| //test malform buffer |
| bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0xFE); bs.put((byte)0xFF); |
| bs.put((byte)0x10); bs.put((byte)0xFF); bs.put((byte)0xDF); |
| us.put((char)0x0000); |
| |
| us.limit(us.position()); |
| us.position(0); |
| bs.limit(bs.position()); |
| bs.position(0); |
| |
| try { |
| // must flush to exhibit malformed behavior |
| smBufDecode(decoder, "UTF-32BE", bs, us, true, true); |
| errln("Malform exception while decoding UTF32BE (3) should have been thrown."); |
| } catch (Exception ex) { |
| } |
| |
| bs.clear(); |
| us.clear(); |
| //test overflow buffer |
| bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0xFE); bs.put((byte)0xFF); |
| bs.put((byte)0x00); bs.put((byte)0x10); bs.put((byte)0xFF); bs.put((byte)0xDD); |
| us.put((char)0x0000); |
| |
| us.limit(us.position()); |
| us.position(0); |
| bs.limit(bs.position()); |
| bs.position(0); |
| |
| try { |
| smBufDecode(decoder, "UTF-32BE", bs, us, true, false); |
| errln("Overflow exception while decoding UTF32BE (4) should have been thrown."); |
| } catch (Exception ex) { |
| } |
| |
| bs.clear(); |
| us.clear(); |
| //test malform buffer |
| bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0xFE); |
| us.put((char)0x0000); |
| |
| us.limit(us.position()); |
| us.position(0); |
| bs.limit(bs.position()); |
| bs.position(0); |
| |
| try { |
| // must flush to exhibit malformed behavior |
| smBufDecode(decoder, "UTF-32BE", bs, us, true, true); |
| errln("Malform exception while decoding UTF32BE (5) should have been thrown."); |
| } catch (Exception ex) { |
| } |
| //end of decode UTF32BE |
| } |
| |
| //provide better code coverage for UTF8 |
| public void TestCharsetUTF8() { |
| CoderResult result = CoderResult.UNDERFLOW; |
| CharsetProvider provider = new CharsetProviderICU(); |
| CharsetDecoder decoder = provider.charsetForName("UTF-8").newDecoder(); |
| CharsetEncoder encoder = provider.charsetForName("UTF-8").newEncoder(); |
| |
| CharBuffer us = CharBuffer.allocate(0x10); |
| ByteBuffer bs = ByteBuffer.allocate(0x10); |
| ByteBuffer bs2; |
| CharBuffer us2; |
| int limit_us; |
| int limit_bs; |
| |
| //encode and decode using read only buffer |
| encoder.reset(); |
| decoder.reset(); |
| us.put((char)0x0041); us.put((char)0x0081); us.put((char)0xEF65); us.put((char)0xD902); |
| bs.put((byte)0x41); bs.put((byte)0xc2); bs.put((byte)0x81); bs.put((byte)0xee); bs.put((byte)0xbd); bs.put((byte)0xa5); |
| bs.put((byte)0x00); |
| limit_us = us.position(); |
| limit_bs = bs.position(); |
| |
| us.limit(limit_us); |
| us.position(0); |
| bs.limit(limit_bs); |
| bs.position(0); |
| bs2 = bs.asReadOnlyBuffer(); |
| us2 = us.asReadOnlyBuffer(); |
| |
| result = decoder.decode(bs2, us, true); |
| if (!result.isUnderflow() || !equals(us, us2)) { |
| errln("Error while decoding UTF-8 (1) should not have occured."); |
| } |
| |
| us2.limit(limit_us); |
| us2.position(0); |
| bs.limit(limit_bs); |
| bs.position(0); |
| |
| result = encoder.encode(us2, bs, true); |
| if (!result.isUnderflow() || !equals(bs, bs2)) { |
| errln("Error while encoding UTF-8 (1) should not have occured."); |
| } |
| |
| us.clear(); |
| bs.clear(); |
| |
| //test overflow buffer while encoding |
| //readonly buffer |
| encoder.reset(); |
| us.put((char)0x0081); us.put((char)0xEF65); |
| bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); |
| limit_us = us.position(); |
| us2 = us.asReadOnlyBuffer(); |
| us2.limit(limit_us); |
| us2.position(0); |
| bs.limit(1); |
| bs.position(0); |
| result = encoder.encode(us2, bs, true); |
| if (!result.isOverflow()) { |
| errln("Overflow Error should have occured while encoding UTF-8 (2)."); |
| } |
| |
| encoder.reset(); |
| |
| us2.limit(limit_us); |
| us2.position(1); |
| bs.limit(1); |
| bs.position(0); |
| result = encoder.encode(us2, bs, true); |
| if (!result.isOverflow()) { |
| errln("Overflow Error should have occured while encoding UTF-8 (3)."); |
| } |
| |
| encoder.reset(); |
| |
| us2.limit(limit_us); |
| us2.position(1); |
| bs.limit(2); |
| bs.position(0); |
| result = encoder.encode(us2, bs, true); |
| if (!result.isOverflow()) { |
| errln("Overflow Error should have occured while encoding UTF-8 (4)."); |
| } |
| |
| encoder.reset(); |
| |
| us2.limit(limit_us); |
| us2.position(0); |
| bs.limit(2); |
| bs.position(0); |
| result = encoder.encode(us2, bs, true); |
| if (!result.isOverflow()) { |
| errln("Overflow Error should have occured while encoding UTF-8 (5)."); |
| } |
| |
| //not readonly buffer |
| encoder.reset(); |
| |
| us.limit(limit_us); |
| us.position(0); |
| bs.limit(1); |
| bs.position(0); |
| result = encoder.encode(us, bs, true); |
| if (!result.isOverflow()) { |
| errln("Overflow Error should have occured while encoding UTF-8 (6)."); |
| } |
| |
| encoder.reset(); |
| |
| us.limit(limit_us); |
| us.position(0); |
| bs.limit(3); |
| bs.position(0); |
| result = encoder.encode(us, bs, true); |
| if (!result.isOverflow()) { |
| errln("Overflow Error should have occured while encoding UTF-8 (7)."); |
| } |
| |
| encoder.reset(); |
| |
| us.limit(limit_us); |
| us.position(1); |
| bs.limit(2); |
| bs.position(0); |
| result = encoder.encode(us, bs, true); |
| if (!result.isOverflow()) { |
| errln("Overflow Error should have occured while encoding UTF-8 (8)."); |
| } |
| |
| encoder.reset(); |
| |
| us.limit(limit_us + 1); |
| us.position(1); |
| bs.limit(3); |
| bs.position(0); |
| result = encoder.encode(us, bs, true); |
| if (!result.isOverflow()) { |
| errln("Overflow Error should have occured while encoding UTF-8 (9)."); |
| } |
| |
| us.clear(); |
| bs.clear(); |
| |
| //test encoding 4 byte characters |
| encoder.reset(); |
| us.put((char)0xD902); us.put((char)0xDD02); us.put((char)0x0041); |
| bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); bs.put((byte)0x00); |
| limit_us = us.position(); |
| us2 = us.asReadOnlyBuffer(); |
| us2.limit(limit_us); |
| us2.position(0); |
| bs.limit(1); |
| bs.position(0); |
| result = encoder.encode(us2, bs, true); |
| if (!result.isOverflow()) { |
| errln("Overflow Error should have occured while encoding UTF-8 (10)."); |
| } |
| |
| encoder.reset(); |
| |
| us2.limit(limit_us); |
| us2.position(0); |
| bs.limit(2); |
| bs.position(0); |
| result = encoder.encode(us2, bs, true); |
| if (!result.isOverflow()) { |
| errln("Overflow Error should have occured while encoding UTF-8 (11)."); |
| } |
| |
| encoder.reset(); |
| |
| us2.limit(limit_us); |
| us2.position(0); |
| bs.limit(3); |
| bs.position(0); |
| result = encoder.encode(us2, bs, true); |
| if (!result.isOverflow()) { |
| errln("Overflow Error should have occured while encoding UTF-8 (12)."); |
| } |
| |
| encoder.reset(); |
| |
| us2.limit(limit_us); |
| us2.position(0); |
| bs.limit(4); |
| bs.position(0); |
| result = encoder.encode(us2, bs, true); |
| if (!result.isOverflow()) { |
| errln("Overflow Error should have occured while encoding UTF-8 (13)."); |
| } |
| |
| us.clear(); |
| bs.clear(); |
| |
| //decoding code coverage |
| //test malform error |
| decoder.reset(); |
| bs.put((byte)0xC0); bs.put((byte)0xC0); |
| us.put((char)0x0000); |
| bs2 = bs.asReadOnlyBuffer(); |
| |
| us.limit(1); |
| us.position(0); |
| bs2.limit(1); |
| bs2.position(0); |
| |
| result = decoder.decode(bs2, us, true); |
| result = decoder.flush(us); |
| if (!result.isMalformed()) { |
| errln("Malform error should have occurred while decoding UTF-8 (1)."); |
| } |
| |
| us.limit(1); |
| us.position(0); |
| bs2.limit(1); |
| bs2.position(0); |
| |
| decoder.reset(); |
| |
| result = decoder.decode(bs2, us, true); |
| us.limit(1); |
| us.position(0); |
| bs2.limit(2); |
| bs2.position(0); |
| result = decoder.decode(bs2, us, true); |
| if (!result.isMalformed()) { |
| errln("Malform error should have occurred while decoding UTF-8 (2)."); |
| } |
| |
| us.clear(); |
| bs.clear(); |
| |
| //test overflow buffer |
| bs.put((byte)0x01); bs.put((byte)0x41); |
| us.put((char)0x0000); |
| bs2 = bs.asReadOnlyBuffer(); |
| us.limit(1); |
| us.position(0); |
| bs2.limit(2); |
| bs2.position(0); |
| |
| result = decoder.decode(bs2, us, true); |
| if (!result.isOverflow()) { |
| errln("Overflow error should have occurred while decoding UTF-8 (3)."); |
| } |
| |
| us.clear(); |
| bs.clear(); |
| |
| //test malform string |
| decoder.reset(); |
| bs.put((byte)0xF5); bs.put((byte)0xB4); bs.put((byte)0x8A); bs.put((byte)0x8C); |
| us.put((char)0x0000); |
| bs2 = bs.asReadOnlyBuffer(); |
| us.limit(1); |
| us.position(0); |
| bs2.limit(4); |
| bs2.position(0); |
| |
| result = decoder.decode(bs2, us, true); |
| if (!result.isMalformed()) { |
| errln("Malform error should have occurred while decoding UTF-8 (4)."); |
| } |
| |
| bs.clear(); |
| |
| //test overflow |
| decoder.reset(); |
| bs.put((byte)0xF3); bs.put((byte)0xB4); bs.put((byte)0x8A); bs.put((byte)0x8C); |
| bs2 = bs.asReadOnlyBuffer(); |
| us.limit(1); |
| us.position(0); |
| bs2.limit(4); |
| bs2.position(0); |
| |
| result = decoder.decode(bs2, us, true); |
| if (!result.isOverflow()) { |
| errln("Overflow error should have occurred while decoding UTF-8 (5)."); |
| } |
| |
| //test overflow |
| decoder.reset(); |
| us.limit(2); |
| us.position(0); |
| bs2.limit(5); |
| bs2.position(0); |
| |
| result = decoder.decode(bs2, us, true); |
| if (!result.isOverflow()) { |
| errln("Overflow error should have occurred while decoding UTF-8 (5)."); |
| } |
| |
| //test overflow |
| decoder.reset(); |
| us.limit(1); |
| us.position(0); |
| bs.limit(5); |
| bs.position(0); |
| |
| result = decoder.decode(bs, us, true); |
| if (!result.isOverflow()) { |
| errln("Overflow error should have occurred while decoding UTF-8 (6)."); |
| } |
| |
| bs.clear(); |
| |
| //test overflow |
| decoder.reset(); |
| bs.put((byte)0x41); bs.put((byte)0x42); |
| us.limit(1); |
| us.position(0); |
| bs.limit(2); |
| bs.position(0); |
| |
| result = decoder.decode(bs, us, true); |
| if (!result.isOverflow()) { |
| errln("Overflow error should have occurred while decoding UTF-8 (7)."); |
| } |
| |
| } |
| |
| //provide better code coverage for Charset UTF16 |
| public void TestCharsetUTF16() { |
| CoderResult result = CoderResult.UNDERFLOW; |
| CharsetProvider provider = new CharsetProviderICU(); |
| CharsetDecoder decoder = provider.charsetForName("UTF-16").newDecoder(); |
| CharsetEncoder encoder = provider.charsetForName("UTF-16").newEncoder(); |
| |
| CharBuffer us = CharBuffer.allocate(0x10); |
| ByteBuffer bs = ByteBuffer.allocate(0x10); |
| |
| //test flush buffer and malform string |
| bs.put((byte)0xFF); |
| us.put((char)0x0000); |
| |
| us.limit(us.position()); |
| us.position(0); |
| bs.limit(bs.position()); |
| bs.position(0); |
| |
| result = decoder.decode(bs, us, true); |
| result = decoder.flush(us); |
| if (!result.isMalformed()) { |
| errln("Malform error while decoding UTF-16 should have occurred."); |
| } |
| |
| us.clear(); |
| bs.clear(); |
| |
| us.put((char)0xD902); us.put((char)0xDD01); us.put((char)0x0041); |
| |
| us.limit(1); |
| us.position(0); |
| bs.limit(4); |
| bs.position(0); |
| |
| result = encoder.encode(us, bs, true); |
| us.limit(3); |
| us.position(0); |
| bs.limit(3); |
| bs.position(0); |
| result = encoder.encode(us, bs, true); |
| if (!result.isOverflow()) { |
| errln("Overflow buffer while encoding UTF-16 should have occurred."); |
| } |
| |
| us.clear(); |
| bs.clear(); |
| |
| //test overflow buffer |
| decoder.reset(); |
| decoder = provider.charsetForName("UTF-16BE").newDecoder(); |
| |
| bs.put((byte)0xFF); bs.put((byte)0xFE); bs.put((byte)0x41); |
| |
| us.limit(0); |
| us.position(0); |
| bs.limit(3); |
| bs.position(0); |
| |
| result = decoder.decode(bs, us, true); |
| if (!result.isOverflow()) { |
| errln("Overflow buffer while decoding UTF-16 should have occurred."); |
| } |
| } |
| |
| //provide better code coverage for Charset ISO-2022-KR |
| public void TestCharsetISO2022KR() { |
| CoderResult result = CoderResult.UNDERFLOW; |
| CharsetProvider provider = new CharsetProviderICU(); |
| CharsetDecoder decoder = provider.charsetForName("ISO-2022-KR").newDecoder(); |
| |
| byte bytearray[] = { |
| (byte)0x1b, (byte)0x24, (byte)0x29, (byte)0x43, (byte)0x41, (byte)0x42, |
| }; |
| char chararray[] = { |
| (char)0x0041 |
| }; |
| ByteBuffer bb = ByteBuffer.wrap(bytearray); |
| CharBuffer cb = CharBuffer.wrap(chararray); |
| |
| result = decoder.decode(bb, cb, true); |
| |
| if (!result.isOverflow()) { |
| errln("Overflow buffer while decoding ISO-2022-KR should have occurred."); |
| } |
| } |
| |
| //provide better code coverage for Charset ISO-2022-JP |
| public void TestCharsetISO2022JP() { |
| CoderResult result = CoderResult.UNDERFLOW; |
| CharsetProvider provider = new CharsetProviderICU(); |
| CharsetDecoder decoder = provider.charsetForName("ISO-2022-JP-2").newDecoder(); |
| |
| byte bytearray[] = { |
| (byte)0x1b, (byte)0x24, (byte)0x28, (byte)0x44, (byte)0x0A, (byte)0x41, |
| }; |
| char chararray[] = { |
| (char)0x000A |
| }; |
| ByteBuffer bb = ByteBuffer.wrap(bytearray); |
| CharBuffer cb = CharBuffer.wrap(chararray); |
| |
| result = decoder.decode(bb, cb, true); |
| |
| if (!result.isOverflow()) { |
| errln("Overflow buffer while decoding ISO-2022-KR should have occurred."); |
| } |
| } |
| |
| //provide better code coverage for Charset ASCII |
| public void TestCharsetASCII() { |
| CoderResult result = CoderResult.UNDERFLOW; |
| CharsetProvider provider = new CharsetProviderICU(); |
| CharsetDecoder decoder = provider.charsetForName("US-ASCII").newDecoder(); |
| |
| byte bytearray[] = { |
| (byte)0x41 |
| }; |
| char chararray[] = { |
| (char)0x0041 |
| }; |
| |
| ByteBuffer bb = ByteBuffer.wrap(bytearray); |
| CharBuffer cb = CharBuffer.wrap(chararray); |
| |
| result = decoder.decode(bb, cb, true); |
| result = decoder.flush(cb); |
| |
| if (result.isError()) { |
| errln("Error occurred while decoding US-ASCII."); |
| } |
| } |
| |
| // provide better code coverage for Charset Callbacks |
| /* Different aspects of callbacks are being tested including using different context available */ |
| public void TestCharsetCallbacks() { |
| CoderResult result = CoderResult.UNDERFLOW; |
| CharsetProvider provider = new CharsetProviderICU(); |
| CharsetEncoder encoder = provider.charsetForName("iso-2022-jp").newEncoder(); |
| CharsetDecoder decoder = provider.charsetForName("iso-2022-jp").newDecoder(); |
| |
| String context3[] = { |
| "i", |
| "J" |
| }; |
| |
| // Testing encoder escape callback |
| String context1[] = { |
| "J", |
| "C", |
| "D", |
| null |
| }; |
| char chararray[] = { |
| (char)0xd122 |
| }; |
| ByteBuffer bb = ByteBuffer.allocate(20); |
| CharBuffer cb = CharBuffer.wrap(chararray); |
| |
| ((CharsetEncoderICU)encoder).setFromUCallback(CoderResult.OVERFLOW, CharsetCallback.FROM_U_CALLBACK_ESCAPE, null); // This callback is not valid. |
| for (int i = 0; i < context1.length; i++) { |
| encoder.reset(); |
| cb.position(0); |
| bb.position(0); |
| ((CharsetEncoderICU)encoder).setFromUCallback(CoderResult.unmappableForLength(1), CharsetCallback.FROM_U_CALLBACK_ESCAPE, context1[i]); // This callback is valid. |
| |
| result = encoder.encode(cb, bb, true); |
| if (result.isError()) { |
| errln("Error occurred while testing of callbacks for ISO-2022-JP encoder."); |
| } |
| } |
| |
| // Testing encoder skip callback |
| for (int i = 0; i < context3.length; i++) { |
| encoder.reset(); |
| cb.position(0); |
| bb.position(0); |
| ((CharsetEncoderICU)encoder).setFromUCallback(CoderResult.unmappableForLength(1), CharsetCallback.FROM_U_CALLBACK_SKIP, context3[i]); |
| |
| result = encoder.encode(cb, bb, true); |
| if (result.isError() && i == 0) { |
| errln("Error occurred while testing of callbacks for ISO-2022-JP encoder."); |
| } |
| } |
| |
| // Testing encoder sub callback |
| for (int i = 0; i < context3.length; i++) { |
| encoder.reset(); |
| cb.position(0); |
| bb.position(0); |
| ((CharsetEncoderICU)encoder).setFromUCallback(CoderResult.unmappableForLength(1), CharsetCallback.FROM_U_CALLBACK_SUBSTITUTE, context3[i]); |
| |
| result = encoder.encode(cb, bb, true); |
| if (result.isError() && i == 0) { |
| errln("Error occurred while testing of callbacks for ISO-2022-JP encoder."); |
| } |
| } |
| |
| // Testing decoder escape callback |
| String context2[] = { |
| "X", |
| "C", |
| "D", |
| null |
| }; |
| byte bytearray[] = { |
| (byte)0x1b, (byte)0x2e, (byte)0x43 |
| }; |
| bb = ByteBuffer.wrap(bytearray); |
| cb = CharBuffer.allocate(20); |
| |
| ((CharsetDecoderICU)decoder).setToUCallback(CoderResult.OVERFLOW, CharsetCallback.TO_U_CALLBACK_ESCAPE, null); // This callback is not valid. |
| for (int i = 0; i < context2.length; i++) { |
| decoder.reset(); |
| cb.position(0); |
| bb.position(0); |
| ((CharsetDecoderICU)decoder).setToUCallback(CoderResult.malformedForLength(1), CharsetCallback.TO_U_CALLBACK_ESCAPE, context2[i]); // This callback is valid. |
| |
| result = decoder.decode(bb, cb, true); |
| if (result.isError()) { |
| errln("Error occurred while testing of callbacks for ISO-2022-JP decoder."); |
| } |
| } |
| |
| // Testing decoder skip callback |
| for (int i = 0; i < context3.length; i++) { |
| decoder.reset(); |
| cb.position(0); |
| bb.position(0); |
| ((CharsetDecoderICU)decoder).setToUCallback(CoderResult.malformedForLength(1), CharsetCallback.TO_U_CALLBACK_SKIP, context3[i]); |
| result = decoder.decode(bb, cb, true); |
| if (!result.isError()) { |
| errln("Error occurred while testing of callbacks for ISO-2022-JP decoder should have occurred."); |
| } |
| } |
| } |
| |
| // Testing invalid input exceptions |
| public void TestInvalidInput() { |
| CharsetProvider provider = new CharsetProviderICU(); |
| Charset charset = provider.charsetForName("iso-2022-jp"); |
| CharsetEncoder encoder = charset.newEncoder(); |
| CharsetDecoder decoder = charset.newDecoder(); |
| |
| try { |
| encoder.encode(CharBuffer.allocate(10), null, true); |
| errln("Illegal argument exception should have been thrown due to null target."); |
| } catch (Exception ex) { |
| } |
| |
| try { |
| decoder.decode(ByteBuffer.allocate(10), null, true); |
| errln("Illegal argument exception should have been thrown due to null target."); |
| } catch (Exception ex) { |
| } |
| } |
| |
| // Test java canonical names |
| public void TestGetICUJavaCanonicalNames() { |
| // Ambiguous charset name. |
| String javaCName = CharsetProviderICU.getJavaCanonicalName("windows-1250"); |
| String icuCName = CharsetProviderICU.getICUCanonicalName("Windows-1250"); |
| if (javaCName == null || icuCName == null) { |
| errln("Unable to get Java or ICU canonical name from ambiguous alias"); |
| } |
| |
| } |
| |
| // Port over from ICU4C for test conversion tables (mbcs version 5.x) |
| // Provide better code coverage in CharsetMBCS, CharsetDecoderICU, and CharsetEncoderICU. |
| public void TestCharsetTestData() { |
| CoderResult result = CoderResult.UNDERFLOW; |
| String charsetName = "test4"; |
| CharsetProvider provider = new CharsetProviderICU(); |
| Charset charset = ((CharsetProviderICU)provider).charsetForName(charsetName, "com/ibm/icu/dev/data/testdata", |
| this.getClass().getClassLoader()); |
| CharsetEncoder encoder = charset.newEncoder(); |
| CharsetDecoder decoder = charset.newDecoder(); |
| |
| byte bytearray[] = { |
| 0x01, 0x02, 0x03, 0x0a, |
| 0x01, 0x02, 0x03, 0x0b, |
| 0x01, 0x02, 0x03, 0x0d, |
| }; |
| |
| // set the callback for overflow errors |
| ((CharsetDecoderICU)decoder).setToUCallback(CoderResult.OVERFLOW, CharsetCallback.TO_U_CALLBACK_STOP, null); |
| |
| ByteBuffer bb = ByteBuffer.wrap(bytearray); |
| CharBuffer cb = CharBuffer.allocate(10); |
| |
| bb.limit(4); |
| cb.limit(1); // Overflow should occur and is expected |
| result = decoder.decode(bb, cb, false); |
| if (result.isError()) { |
| errln("Error occurred while decoding: " + charsetName + " with error: " + result); |
| } |
| |
| bb.limit(8); |
| result = decoder.decode(bb, cb, false); |
| if (result.isError()) { |
| errln("Error occurred while decoding: " + charsetName + " with error: " + result); |
| } |
| |
| bb.limit(12); |
| result = decoder.decode(bb, cb, true); |
| if (result.isError()) { |
| errln("Error occurred while decoding: " + charsetName + " with error: " + result); |
| } |
| |
| char chararray[] = { |
| 0xDBC4,0xDE34,0xD900,0xDC05,/* \U00101234\U00050005 */ |
| 0xD940, /* first half of \U00060006 or \U00060007 */ |
| 0xDC07/* second half of \U00060007 */ |
| }; |
| |
| cb = CharBuffer.wrap(chararray); |
| bb = ByteBuffer.allocate(10); |
| |
| bb.limit(2); |
| cb.limit(4); |
| result = encoder.encode(cb, bb, false); |
| if (result.isError()) { |
| errln("Error occurred while encoding: " + charsetName + " with error: " + result); |
| } |
| cb.limit(5); |
| result = encoder.encode(cb, bb, false); |
| if (result.isError()) { |
| errln("Error occurred while encoding: " + charsetName + " with error: " + result); |
| } |
| cb.limit(6); |
| result = encoder.encode(cb, bb, true); |
| if (!result.isError()) { |
| errln("Error should have occurred while encoding: " + charsetName); |
| } |
| } |
| |
| /* Round trip test of SCSU converter*/ |
| public void TestSCSUConverter(){ |
| byte allFeaturesSCSU[]={ |
| 0x41,(byte) 0xdf, 0x12,(byte) 0x81, 0x03, 0x5f, 0x10, (byte)0xdf, 0x1b, 0x03, |
| (byte)0xdf, 0x1c,(byte) 0x88,(byte) 0x80, 0x0b, (byte)0xbf,(byte) 0xff,(byte) 0xff, 0x0d, 0x0a, |
| 0x41, 0x10, (byte)0xdf, 0x12, (byte)0x81, 0x03, 0x5f, 0x10, (byte)0xdf, 0x13, |
| (byte)0xdf, 0x14,(byte) 0x80, 0x15, (byte)0xff |
| }; |
| |
| char allFeaturesUTF16[]={ |
| 0x0041, 0x00df, 0x0401, 0x015f, 0x00df, 0x01df, 0xf000, 0xdbff, |
| 0xdfff, 0x000d, 0x000a, 0x0041, 0x00df, 0x0401, 0x015f, 0x00df, |
| 0x01df, 0xf000, 0xdbff, 0xdfff |
| }; |
| |
| |
| char germanUTF16[]={ |
| 0x00d6, 0x006c, 0x0020, 0x0066, 0x006c, 0x0069, 0x0065, 0x00df, 0x0074 |
| }; |
| |
| byte germanSCSU[]={ |
| (byte)0xd6, 0x6c, 0x20, 0x66, 0x6c, 0x69, 0x65,(byte) 0xdf, 0x74 |
| }; |
| |
| char russianUTF16[]={ |
| 0x041c, 0x043e, 0x0441, 0x043a, 0x0432, 0x0430 |
| }; |
| |
| byte russianSCSU[]={ |
| 0x12, (byte)0x9c,(byte)0xbe,(byte) 0xc1, (byte)0xba, (byte)0xb2, (byte)0xb0 |
| }; |
| |
| char japaneseUTF16[]={ |
| 0x3000, 0x266a, 0x30ea, 0x30f3, 0x30b4, 0x53ef, 0x611b, |
| 0x3044, 0x3084, 0x53ef, 0x611b, 0x3044, 0x3084, 0x30ea, 0x30f3, |
| 0x30b4, 0x3002, 0x534a, 0x4e16, 0x7d00, 0x3082, 0x524d, 0x306b, |
| 0x6d41, 0x884c, 0x3057, 0x305f, 0x300c, 0x30ea, 0x30f3, 0x30b4, |
| 0x306e, 0x6b4c, 0x300d, 0x304c, 0x3074, 0x3063, 0x305f, 0x308a, |
| 0x3059, 0x308b, 0x304b, 0x3082, 0x3057, 0x308c, 0x306a, 0x3044, |
| 0x3002, 0x7c73, 0x30a2, 0x30c3, 0x30d7, 0x30eb, 0x30b3, 0x30f3, |
| 0x30d4, 0x30e5, 0x30fc, 0x30bf, 0x793e, 0x306e, 0x30d1, 0x30bd, |
| 0x30b3, 0x30f3, 0x300c, 0x30de, 0x30c3, 0x30af, 0xff08, 0x30de, |
| 0x30c3, 0x30ad, 0x30f3, 0x30c8, 0x30c3, 0x30b7, 0x30e5, 0xff09, |
| 0x300d, 0x3092, 0x3001, 0x3053, 0x3088, 0x306a, 0x304f, 0x611b, |
| 0x3059, 0x308b, 0x4eba, 0x305f, 0x3061, 0x306e, 0x3053, 0x3068, |
| 0x3060, 0x3002, 0x300c, 0x30a2, 0x30c3, 0x30d7, 0x30eb, 0x4fe1, |
| 0x8005, 0x300d, 0x306a, 0x3093, 0x3066, 0x8a00, 0x3044, 0x65b9, |
| 0x307e, 0x3067, 0x3042, 0x308b, 0x3002 |
| }; |
| |
| // SCSUEncoder produces a slightly longer result (179B vs. 178B) because of one different choice: |
| //it uses an SQn once where a longer look-ahead could have shown that SCn is more efficient |
| byte japaneseSCSU[]={ |
| 0x08, 0x00, 0x1b, 0x4c,(byte) 0xea, 0x16, (byte)0xca, (byte)0xd3,(byte) 0x94, 0x0f, 0x53, (byte)0xef, 0x61, 0x1b, (byte)0xe5,(byte) 0x84, |
| (byte)0xc4, 0x0f, (byte)0x53,(byte) 0xef, 0x61, 0x1b, (byte)0xe5, (byte)0x84, (byte)0xc4, 0x16, (byte)0xca, (byte)0xd3, (byte)0x94, 0x08, 0x02, 0x0f, |
| 0x53, 0x4a, 0x4e, 0x16, 0x7d, 0x00, 0x30, (byte)0x82, 0x52, 0x4d, 0x30, 0x6b, 0x6d, 0x41,(byte) 0x88, 0x4c, |
| (byte) 0xe5,(byte) 0x97, (byte)0x9f, 0x08, 0x0c, 0x16,(byte) 0xca,(byte) 0xd3, (byte)0x94, 0x15, (byte)0xae, 0x0e, 0x6b, 0x4c, 0x08, 0x0d, |
| (byte) 0x8c, (byte)0xb4, (byte)0xa3,(byte) 0x9f,(byte) 0xca, (byte)0x99, (byte)0xcb,(byte) 0x8b, (byte)0xc2,(byte) 0x97,(byte) 0xcc,(byte) 0xaa,(byte) 0x84, 0x08, 0x02, 0x0e, |
| 0x7c, 0x73, (byte)0xe2, 0x16, (byte)0xa3,(byte) 0xb7, (byte)0xcb, (byte)0x93, (byte)0xd3,(byte) 0xb4,(byte) 0xc5, (byte)0xdc, (byte)0x9f, 0x0e, 0x79, 0x3e, |
| 0x06, (byte)0xae, (byte)0xb1, (byte)0x9d,(byte) 0x93, (byte)0xd3, 0x08, 0x0c, (byte)0xbe,(byte) 0xa3, (byte)0x8f, 0x08,(byte) 0x88,(byte) 0xbe,(byte) 0xa3,(byte) 0x8d, |
| (byte)0xd3,(byte) 0xa8, (byte)0xa3, (byte)0x97,(byte) 0xc5, 0x17,(byte) 0x89, 0x08, 0x0d, 0x15,(byte) 0xd2, 0x08, 0x01, (byte)0x93, (byte)0xc8,(byte) 0xaa, |
| (byte)0x8f, 0x0e, 0x61, 0x1b, (byte)0x99,(byte) 0xcb, 0x0e, 0x4e, (byte)0xba, (byte)0x9f, (byte)0xa1,(byte) 0xae,(byte) 0x93, (byte)0xa8,(byte) 0xa0, 0x08, |
| 0x02, 0x08, 0x0c, (byte)0xe2, 0x16, (byte)0xa3, (byte)0xb7, (byte)0xcb, 0x0f, 0x4f,(byte) 0xe1,(byte) 0x80, 0x05,(byte) 0xec, 0x60, (byte)0x8d, |
| (byte)0xea, 0x06,(byte) 0xd3,(byte) 0xe6, 0x0f,(byte) 0x8a, 0x00, 0x30, 0x44, 0x65,(byte) 0xb9, (byte)0xe4, (byte)0xfe,(byte) 0xe7,(byte) 0xc2, 0x06, |
| (byte)0xcb, (byte)0x82 |
| }; |
| |
| CharsetProviderICU cs = new CharsetProviderICU(); |
| CharsetICU charset = (CharsetICU)cs.charsetForName("scsu"); |
| CharsetDecoder decode = charset.newDecoder(); |
| CharsetEncoder encode = charset.newEncoder(); |
| |
| //String[] codePoints = {"allFeatures", "german","russian","japanese"}; |
| byte[][] fromUnicode={allFeaturesSCSU,germanSCSU,russianSCSU,japaneseSCSU}; |
| char[][] toUnicode = {allFeaturesUTF16, germanUTF16,russianUTF16,japaneseUTF16}; |
| |
| for(int i=0;i<4;i++){ |
| ByteBuffer decoderBuffer = ByteBuffer.wrap(fromUnicode[i]); |
| CharBuffer encoderBuffer = CharBuffer.wrap(toUnicode[i]); |
| |
| try{ |
| // Decoding |
| CharBuffer decoderResult = decode.decode(decoderBuffer); |
| encoderBuffer.position(0); |
| if(!decoderResult.equals(encoderBuffer)){ |
| errln("Error occured while decoding "+ charset.name()); |
| } |
| // Encoding |
| ByteBuffer encoderResult = encode.encode(encoderBuffer); |
| // RoundTrip Test |
| ByteBuffer roundTrip = encoderResult; |
| CharBuffer roundTripResult = decode.decode(roundTrip); |
| encoderBuffer.position(0); |
| if(!roundTripResult.equals(encoderBuffer)){ |
| errln("Error occured while encoding "+ charset.name()); |
| } |
| // Test overflow for code coverage reasons |
| if (i == 0) { |
| ByteBuffer test = encoderResult; |
| test.position(0); |
| CharBuffer smallBuffer = CharBuffer.allocate(11); |
| decode.reset(); |
| CoderResult status = decode.decode(test, smallBuffer, true); |
| if (status != CoderResult.OVERFLOW) { |
| errln("Overflow buffer error should have been thrown."); |
| } |
| } |
| }catch(Exception e){ |
| errln("Exception while converting SCSU thrown: " + e); |
| } |
| } |
| |
| /* Provide better code coverage */ |
| /* testing illegal codepoints */ |
| CoderResult illegalResult = CoderResult.UNDERFLOW; |
| CharBuffer illegalDecoderTrgt = CharBuffer.allocate(10); |
| |
| byte[] illegalDecoderSrc1 = { (byte)0x41, (byte)0xdf, (byte)0x0c }; |
| decode.reset(); |
| illegalResult = decode.decode(ByteBuffer.wrap(illegalDecoderSrc1), illegalDecoderTrgt, true); |
| if (illegalResult == CoderResult.OVERFLOW || illegalResult == CoderResult.UNDERFLOW) { |
| errln("Malformed error should have been returned for decoder " + charset.name()); |
| } |
| /* code coverage test from nucnvtst.c in ICU4C */ |
| CoderResult ccResult = CoderResult.UNDERFLOW; |
| int CCBufSize = 120 * 10; |
| ByteBuffer trgt = ByteBuffer.allocate(CCBufSize); |
| CharBuffer test = CharBuffer.allocate(CCBufSize); |
| String [] ccSrc = { |
| "\ud800\udc00", /* smallest surrogate*/ |
| "\ud8ff\udcff", |
| "\udBff\udFff", /* largest surrogate pair*/ |
| "\ud834\udc00", |
| //"\U0010FFFF", |
| "Hello \u9292 \u9192 World!", |
| "Hell\u0429o \u9292 \u9192 W\u00e4rld!", |
| "Hell\u0429o \u9292 \u9292W\u00e4rld!", |
| |
| "\u0648\u06c8", /* catch missing reset*/ |
| "\u0648\u06c8", |
| |
| "\u4444\uE001", /* lowest quotable*/ |
| "\u4444\uf2FF", /* highest quotable*/ |
| "\u4444\uf188\u4444", |
| "\u4444\uf188\uf288", |
| "\u4444\uf188abc\u0429\uf288", |
| "\u9292\u2222", |
| "Hell\u0429\u04230o \u9292 \u9292W\u00e4\u0192rld!", |
| "Hell\u0429o \u9292 \u9292W\u00e4rld!", |
| "Hello World!123456", |
| "Hello W\u0081\u011f\u0082!", /* Latin 1 run*/ |
| |
| "abc\u0301\u0302", /* uses SQn for u301 u302*/ |
| "abc\u4411d", /* uses SQU*/ |
| "abc\u4411\u4412d",/* uses SCU*/ |
| "abc\u0401\u0402\u047f\u00a5\u0405", /* uses SQn for ua5*/ |
| "\u9191\u9191\u3041\u9191\u3041\u3041\u3000", /* SJIS like data*/ |
| "\u9292\u2222", |
| "\u9191\u9191\u3041\u9191\u3041\u3041\u3000", |
| "\u9999\u3051\u300c\u9999\u9999\u3060\u9999\u3065\u3065\u3065\u300c", |
| "\u3000\u266a\u30ea\u30f3\u30b4\u53ef\u611b\u3044\u3084\u53ef\u611b\u3044\u3084\u30ea\u30f3\u30b4\u3002", |
| |
| "", /* empty input*/ |
| "\u0000", /* smallest BMP character*/ |
| "\uFFFF", /* largest BMP character*/ |
| |
| /* regression tests*/ |
| "\u6441\ub413\ua733\uf8fe\ueedb\u587f\u195f\u4899\uf23d\u49fd\u0aac\u5792\ufc22\ufc3c\ufc46\u00aa", |
| /*"\u00df\u01df\uf000\udbff\udfff\u000d\n\u0041\u00df\u0401\u015f\u00df\u01df\uf000\udbff\udfff",*/ |
| "\u30f9\u8321\u05e5\u181c\ud72b\u2019\u99c9\u2f2f\uc10c\u82e1\u2c4d\u1ebc\u6013\u66dc\ubbde\u94a5\u4726\u74af\u3083\u55b9\u000c", |
| "\u0041\u00df\u0401\u015f", |
| "\u9066\u2123abc", |
| //"\ud266\u43d7\ue386\uc9c0\u4a6b\u9222\u901f\u7410\ua63f\u539b\u9596\u482e\u9d47\ucfe4\u7b71\uc280\uf26a\u982f\u862a\u4edd\uf513\ufda6\u869d\u2ee0\ua216\u3ff6\u3c70\u89c0\u9576\ud5ec\ubfda\u6cca\u5bb3\ubcea\u554c\u914e\ufa4a\uede3\u2990\ud2f5\u2729\u5141\u0f26\uccd8\u5413\ud196\ubbe2\u51b9\u9b48\u0dc8\u2195\u21a2\u21e9\u00e4\u9d92\u0bc0\u06c5", |
| "\uf95b\u2458\u2468\u0e20\uf51b\ue36e\ubfc1\u0080\u02dd\uf1b5\u0cf3\u6059\u7489", |
| }; |
| for (int i = 0; i < ccSrc.length; i++) { |
| CharBuffer ubuf = CharBuffer.wrap(ccSrc[i]); |
| encode.reset(); |
| decode.reset(); |
| trgt.clear(); |
| test.clear(); |
| ccResult = encode.encode(ubuf, trgt, true); |
| if (ccResult.isError()) { |
| errln("Error while encoding " + charset.name() + " in test for code coverage[" + i + "]."); |
| } else { |
| trgt.limit(trgt.position()); |
| trgt.position(0); |
| ccResult = decode.decode(trgt, test, true); |
| if (ccResult.isError()) { |
| errln("Error while decoding " + charset.name() + " in test for code coverage[" + i + "]."); |
| } else { |
| ubuf.position(0); |
| test.limit(test.position()); |
| test.position(0); |
| if (!equals(test, ubuf)) { |
| errln("Roundtrip failed for " + charset.name() + " in test for code coverage[" + i + "]."); |
| } |
| } |
| } |
| } |
| |
| /* Monkey test */ |
| { |
| char[] monkeyIn = { |
| 0x00A8, 0x3003, 0x3005, 0x2015, 0xFF5E, 0x2016, 0x2026, 0x2018, 0x000D, 0x000A, |
| 0x2019, 0x201C, 0x201D, 0x3014, 0x3015, 0x3008, 0x3009, 0x300A, 0x000D, 0x000A, |
| 0x300B, 0x300C, 0x300D, 0x300E, 0x300F, 0x3016, 0x3017, 0x3010, 0x000D, 0x000A, |
| 0x3011, 0x00B1, 0x00D7, 0x00F7, 0x2236, 0x2227, 0x7FC1, 0x8956, 0x000D, 0x000A, |
| 0x9D2C, 0x9D0E, 0x9EC4, 0x5CA1, 0x6C96, 0x837B, 0x5104, 0x5C4B, 0x000D, 0x000A, |
| 0x61B6, 0x81C6, 0x6876, 0x7261, 0x4E59, 0x4FFA, 0x5378, 0x57F7, 0x000D, 0x000A, |
| 0x57F4, 0x57F9, 0x57FA, 0x57FC, 0x5800, 0x5802, 0x5805, 0x5806, 0x000D, 0x000A, |
| 0x580A, 0x581E, 0x6BB5, 0x6BB7, 0x6BBA, 0x6BBC, 0x9CE2, 0x977C, 0x000D, 0x000A, |
| 0x6BBF, 0x6BC1, 0x6BC5, 0x6BC6, 0x6BCB, 0x6BCD, 0x6BCF, 0x6BD2, 0x000D, 0x000A, |
| 0x6BD3, 0x6BD4, 0x6BD6, 0x6BD7, 0x6BD8, 0x6BDB, 0x6BEB, 0x6BEC, 0x000D, 0x000A, |
| 0x6C05, 0x6C08, 0x6C0F, 0x6C11, 0x6C13, 0x6C23, 0x6C34, 0x0041, 0x000D, 0x000A, |
| 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004A, 0x000D, 0x000A, |
| 0x004B, 0x004C, 0x004D, 0x004E, 0x004F, 0x0050, 0x0051, 0x0052, 0x000D, 0x000A, |
| 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005A, 0x000D, 0x000A, |
| 0x005B, 0x9792, 0x9CCC, 0x9CCD, 0x9CCE, 0x9CCF, 0x9CD0, 0x9CD3, 0x000D, 0x000A, |
| 0x9CD4, 0x9CD5, 0x9CD7, 0x9CD8, 0x9CD9, 0x9CDC, 0x9CDD, 0x9CDF, 0x000D, 0x000A, |
| 0x9785, 0x9791, 0x00BD, 0x0390, 0x0385, 0x0386, 0x0388, 0x0389, 0x000D, 0x000A, |
| 0x038E, 0x038F, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x000D, 0x000A, |
| 0x0396, 0x0397, 0x0398, 0x0399, 0x039A, 0x038A, 0x038C, 0x039C, 0x000D, 0x000A, |
| /* test non-BMP code points */ |
| 0xD869, 0xDE99, 0xD869, 0xDE9C, 0xD869, 0xDE9D, 0xD869, 0xDE9E, 0xD869, 0xDE9F, |
| 0xD869, 0xDEA0, 0xD869, 0xDEA5, 0xD869, 0xDEA6, 0xD869, 0xDEA7, 0xD869, 0xDEA8, |
| 0xD869, 0xDEAB, 0xD869, 0xDEAC, 0xD869, 0xDEAD, 0xD869, 0xDEAE, 0xD869, 0xDEAF, |
| 0xD869, 0xDEB0, 0xD869, 0xDEB1, 0xD869, 0xDEB3, 0xD869, 0xDEB5, 0xD869, 0xDEB6, |
| 0xD869, 0xDEB7, 0xD869, 0xDEB8, 0xD869, 0xDEB9, 0xD869, 0xDEBA, 0xD869, 0xDEBB, |
| 0xD869, 0xDEBC, 0xD869, 0xDEBD, 0xD869, 0xDEBE, 0xD869, 0xDEBF, 0xD869, 0xDEC0, |
| 0xD869, 0xDEC1, 0xD869, 0xDEC2, 0xD869, 0xDEC3, 0xD869, 0xDEC4, 0xD869, 0xDEC8, |
| 0xD869, 0xDECA, 0xD869, 0xDECB, 0xD869, 0xDECD, 0xD869, 0xDECE, 0xD869, 0xDECF, |
| 0xD869, 0xDED0, 0xD869, 0xDED1, 0xD869, 0xDED2, 0xD869, 0xDED3, 0xD869, 0xDED4, |
| 0xD869, 0xDED5, 0xD800, 0xDC00, 0xD800, 0xDC00, 0xD800, 0xDC00, 0xDBFF, 0xDFFF, |
| 0xDBFF, 0xDFFF, 0xDBFF, 0xDFFF, |
| |
| |
| 0x4DB3, 0x4DB4, 0x4DB5, 0x4E00, 0x4E00, 0x4E01, 0x4E02, 0x4E03, 0x000D, 0x000A, |
| 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397, 0x33E0, 0x33E6, 0x000D, 0x000A, |
| 0x4E05, 0x4E07, 0x4E04, 0x4E08, 0x4E08, 0x4E09, 0x4E0A, 0x4E0B, 0x000D, 0x000A, |
| 0x4E0C, 0x0021, 0x0022, 0x0023, 0x0024, 0xFF40, 0xFF41, 0xFF42, 0x000D, 0x000A, |
| 0xFF43, 0xFF44, 0xFF45, 0xFF46, 0xFF47, 0xFF48, 0xFF49, 0xFF4A, 0x000D, 0x000A, |
| }; |
| encode.reset(); |
| decode.reset(); |
| CharBuffer monkeyCB = CharBuffer.wrap(monkeyIn); |
| try { |
| ByteBuffer monkeyBB = encode.encode(monkeyCB); |
| /* CharBuffer monkeyEndResult =*/ decode.decode(monkeyBB); |
| |
| } catch (Exception ex) { |
| errln("Exception thrown while encoding/decoding monkey test in SCSU: " + ex); |
| } |
| } |
| // Test malformed |
| { |
| char[] malformedSequence = { |
| 0xD899, 0xDC7F, 0xDC88, 0xDC88, 0xD888, 0xDDF9 |
| }; |
| encode.reset(); |
| CharBuffer malformedSrc = CharBuffer.wrap(malformedSequence); |
| |
| try { |
| encode.encode(malformedSrc); |
| errln("Malformed error should have thrown an exception."); |
| } catch (Exception ex) { |
| } |
| } |
| // Test overflow buffer |
| { |
| ByteBuffer overflowTest = ByteBuffer.wrap(allFeaturesSCSU); |
| int sizes[] = { 8, 2, 11 }; |
| for (int i = 0; i < sizes.length; i++) { |
| try { |
| decode.reset(); |
| overflowTest.position(0); |
| smBufDecode(decode, "SCSU overflow test", overflowTest, CharBuffer.allocate(sizes[i]), true, false); |
| errln("Buffer overflow exception should have been thrown."); |
| } catch (BufferOverflowException ex) { |
| } catch (Exception ex) { |
| errln("Buffer overflow exception should have been thrown."); |
| } |
| } |
| |
| } |
| } |
| |
| /* Test for BOCU1 converter*/ |
| public void TestBOCU1Converter(){ |
| char expected[]={ |
| 0xFEFF, 0x0061, 0x0062, 0x0020, // 0 |
| 0x0063, 0x0061, 0x000D, 0x000A, |
| |
| 0x0020, 0x0000, 0x00DF, 0x00E6, // 8 |
| 0x0930, 0x0020, 0x0918, 0x0909, |
| |
| 0x3086, 0x304D, 0x0020, 0x3053, // 16 |
| 0x4000, 0x4E00, 0x7777, 0x0020, |
| |
| 0x9FA5, 0x4E00, 0xAC00, 0xBCDE, // 24 |
| 0x0020, 0xD7A3, 0xDC00, 0xD800, |
| |
| 0xD800, 0xDC00, 0xD845, 0xDDDD, // 32 |
| 0xDBBB, 0xDDEE, 0x0020, 0xDBFF, |
| |
| 0xDFFF, 0x0001, 0x0E40, 0x0020, // 40 |
| 0x0009 |
| }; |
| |
| byte sampleText[]={ // from cintltst/bocu1tst.c/TestBOCU1 text 1 |
| (byte) 0xFB, |
| (byte) 0xEE, |
| 0x28, // from source offset 0 |
| 0x24, 0x1E, 0x52, (byte) 0xB2, 0x20, |
| (byte) 0xB3, |
| (byte) 0xB1, |
| 0x0D, |
| 0x0A, |
| |
| 0x20, // from 8 |
| 0x00, (byte) 0xD0, 0x6C, (byte) 0xB6, (byte) 0xD8, (byte) 0xA5, |
| 0x20, 0x68, |
| 0x59, |
| |
| (byte) 0xF9, |
| 0x28, // from 16 |
| 0x6D, 0x20, 0x73, (byte) 0xE0, 0x2D, (byte) 0xDE, 0x43, |
| (byte) 0xD0, 0x33, 0x20, |
| |
| (byte) 0xFA, |
| (byte) 0x83, // from 24 |
| 0x25, 0x01, (byte) 0xFB, 0x16, (byte) 0x87, 0x4B, 0x16, 0x20, |
| (byte) 0xE6, (byte) 0xBD, (byte) 0xEB, 0x5B, 0x4B, (byte) 0xCC, |
| |
| (byte) 0xF9, |
| (byte) 0xA2, // from 32 |
| (byte) 0xFC, 0x10, 0x3E, (byte) 0xFE, 0x16, 0x3A, (byte) 0x8C, |
| 0x20, (byte) 0xFC, 0x03, (byte) 0xAC, |
| |
| 0x01, /// from 41 |
| (byte) 0xDE, (byte) 0x83, 0x20, 0x09 |
| }; |
| |
| CharsetProviderICU cs = new CharsetProviderICU(); |
| CharsetICU charset = (CharsetICU)cs.charsetForName("BOCU-1"); |
| CharsetDecoder decode = charset.newDecoder(); |
| CharsetEncoder encode = charset.newEncoder(); |
| |
| ByteBuffer decoderBuffer = ByteBuffer.wrap(sampleText); |
| CharBuffer encoderBuffer = CharBuffer.wrap(expected); |
| try{ |
| // Decoding |
| CharBuffer decoderResult = decode.decode(decoderBuffer); |
| |
| encoderBuffer.position(0); |
| if(!decoderResult.equals(encoderBuffer)){ |
| errln("Error occured while decoding "+ charset.name()); |
| } |
| // Encoding |
| ByteBuffer encoderResult = encode.encode(encoderBuffer); |
| // RoundTrip Test |
| ByteBuffer roundTrip = encoderResult; |
| CharBuffer roundTripResult = decode.decode(roundTrip); |
| |
| encoderBuffer.position(0); |
| if(!roundTripResult.equals(encoderBuffer)){ |
| errln("Error occured while encoding "+ charset.name()); |
| } |
| }catch(Exception e){ |
| errln("Exception while converting BOCU-1 thrown: " + e); |
| } |
| } |
| |
| /* Test that ICU4C and ICU4J get the same ICU canonical name when given the same alias. */ |
| public void TestICUCanonicalNameConsistency() { |
| String[] alias = { |
| "KSC_5601" |
| }; |
| String[] expected = { |
| "windows-949-2000" |
| }; |
| |
| for (int i = 0; i < alias.length; i++) { |
| String name = CharsetProviderICU.getICUCanonicalName(alias[i]); |
| if (!name.equals(expected[i])) { |
| errln("The ICU canonical name in ICU4J does not match that in ICU4C. Result: " + name + "Expected: " + expected[i]); |
| } |
| } |
| } |
| |
| /* Increase code coverage for CharsetICU and CharsetProviderICU*/ |
| public void TestCharsetICUCodeCoverage() { |
| CharsetProviderICU provider = new CharsetProviderICU(); |
| |
| if (provider.charsetForName("UTF16", null) != null) { |
| errln("charsetForName should have returned a null"); |
| } |
| |
| if (CharsetProviderICU.getJavaCanonicalName(null) != null) { |
| errln("getJavaCanonicalName should have returned a null when null is given to it."); |
| } |
| |
| try { |
| Charset testCharset = CharsetICU.forNameICU("bogus"); |
| errln("UnsupportedCharsetException should be thrown for charset \"bogus\" - but got charset " + testCharset.name()); |
| } catch (UnsupportedCharsetException ex) { |
| logln("UnsupportedCharsetException was thrown for CharsetICU.forNameICU(\"bogus\")"); |
| } |
| |
| Charset charset = provider.charsetForName("UTF16"); |
| |
| try { |
| ((CharsetICU)charset).getUnicodeSet(null, 0); |
| } catch (IllegalArgumentException ex) { |
| return; |
| } |
| errln("IllegalArgumentException should have been thrown."); |
| } |
| |
| public void TestCharsetLMBCS() { |
| String []lmbcsNames = { |
| "LMBCS-1", |
| "LMBCS-2", |
| "LMBCS-3", |
| "LMBCS-4", |
| "LMBCS-5", |
| "LMBCS-6", |
| "LMBCS-8", |
| "LMBCS-11", |
| "LMBCS-16", |
| "LMBCS-17", |
| "LMBCS-18", |
| "LMBCS-19" |
| }; |
| |
| char[] src = { |
| 0x0192, 0x0041, 0x0061, 0x00D0, 0x00F6, 0x0100, 0x0174, 0x02E4, 0x03F5, 0x03FB, |
| 0x05D3, 0x05D4, 0x05EA, 0x0684, 0x0685, 0x1801, 0x11B3, 0x11E8, 0x1F9A, 0x2EB4, |
| 0x3157, 0x3336, 0x3304, 0xD881, 0xDC88 |
| }; |
| CharBuffer cbInput = CharBuffer.wrap(src); |
| |
| CharsetProviderICU provider = new CharsetProviderICU(); |
| |
| for (int i = 0; i < lmbcsNames.length; i++) { |
| Charset charset = provider.charsetForName(lmbcsNames[i]); |
| if (charset == null) { |
| errln("Unable to create LMBCS charset: " + lmbcsNames[i]); |
| return; |
| } |
| CharsetEncoder encoder = charset.newEncoder(); |
| CharsetDecoder decoder = charset.newDecoder(); |
| |
| try { |
| cbInput.position(0); |
| ByteBuffer bbTmp = encoder.encode(cbInput); |
| CharBuffer cbOutput = decoder.decode(bbTmp); |
| |
| if (!equals(cbInput, cbOutput)) { |
| errln("Roundtrip test failed for charset: " + lmbcsNames[i]); |
| } |
| } catch (Exception ex) { |
| if (i >= 8) { |
| /* Expected exceptions */ |
| continue; |
| } |
| errln("Exception thrown: " + ex + " while using charset: " + lmbcsNames[i]); |
| } |
| |
| } |
| |
| // Test malformed |
| CoderResult malformedResult = CoderResult.UNDERFLOW; |
| byte[] malformedBytes = { |
| (byte)0x61, (byte)0x01, (byte)0x29, (byte)0x81, (byte)0xa0, (byte)0x0f |
| }; |
| ByteBuffer malformedSrc = ByteBuffer.wrap(malformedBytes); |
| CharBuffer malformedTrgt = CharBuffer.allocate(10); |
| int[] malformedLimits = { |
| 2, 6 |
| }; |
| CharsetDecoder malformedDecoderTest = provider.charsetForName("LMBCS-1").newDecoder(); |
| for (int n = 0; n < malformedLimits.length; n++) { |
| malformedDecoderTest.reset(); |
| |
| malformedSrc.position(0); |
| malformedSrc.limit(malformedLimits[n]); |
| |
| malformedTrgt.clear(); |
| |
| malformedResult = malformedDecoderTest.decode(malformedSrc,malformedTrgt, true); |
| if (!malformedResult.isMalformed()) { |
| errln("Malformed error should have resulted."); |
| } |
| } |
| } |
| |
| /* |
| * This is a port of ICU4C TestAmbiguousConverter in cintltst. |
| * Since there is no concept of ambiguous converters in ICU4J |
| * this test is merely for code coverage reasons. |
| */ |
| public void TestAmbiguousConverter() { |
| byte [] inBytes = { |
| 0x61, 0x5b, 0x5c |
| }; |
| ByteBuffer src = ByteBuffer.wrap(inBytes); |
| CharBuffer trgt = CharBuffer.allocate(20); |
| |
| CoderResult result = CoderResult.UNDERFLOW; |
| CharsetProviderICU provider = new CharsetProviderICU(); |
| String[] names = CharsetProviderICU.getAllNames(); |
| |
| for (int i = 0; i < names.length; i++) { |
| Charset charset = provider.charsetForName(names[i]); |
| if (charset == null) { |
| /* We don't care about any failures because not all converters are available. */ |
| continue; |
| } |
| CharsetDecoder decoder = charset.newDecoder(); |
| |
| src.position(0); |
| trgt.clear(); |
| |
| result = decoder.decode(src, trgt, true); |
| if (result.isError()) { |
| /* We don't care about any failures. */ |
| continue; |
| } |
| } |
| } |
| |
| /* Test compound text converter */ |
| public void TestCompoundText() { |
| CharsetProvider provider = new CharsetProviderICU(); |
| Charset cs = provider.charsetForName("x11-compound-text"); |
| CharsetEncoder encoder = cs.newEncoder(); |
| CharsetDecoder decoder = cs.newDecoder(); |
| |
| char []unicode = { |
| 0x54A1, 0x00A5, 0x00E3, 0x0120, 0x0121, 0x011E, 0x0041, 0x0135, 0x02D9, 0x0E3F, |
| 0x0100, 0x0157, 0x0384, 0x0660, 0x05D0, 0x0401 |
| }; |
| |
| byte []bytes = { |
| 0x1b, 0x24, 0x29, 0x44, (byte)0xb5, (byte)0xac, 0x1b, 0x2d, 0x41, (byte)0xa5, |
| (byte)0xe3, 0x1b, 0x2d, 0x43, (byte)0xd5, (byte)0xf5, 0x1b, 0x2d, 0x4d, (byte)0xd0, |
| 0x1b, 0x2d, 0x41, 0x41, 0x1b, 0x2d, 0x43, (byte)0xbc, 0x1b, 0x2d, |
| 0x42, (byte)0xff, 0x1b, 0x2d, 0x54, (byte)0xdf, 0x1b, 0x2d, 0x44, (byte)0xc0, |
| (byte)0xb3, 0x1b, 0x2d, 0x46, (byte)0xb4, 0x1b, 0x2d, 0x47, (byte)0xb0, 0x1b, |
| 0x2d, 0x48, (byte)0xe0, 0x1b, 0x2d, 0x4c,(byte) 0xa1 |
| |
| }; |
| |
| CharBuffer us; |
| ByteBuffer bs; |
| |
| us = CharBuffer.allocate(0x20); |
| bs = ByteBuffer.wrap(bytes); |
| smBufDecode(decoder, "x11-compound-text", bs, us); |
| |
| us = CharBuffer.wrap(unicode); |
| bs = ByteBuffer.allocate(0x40); |
| smBufEncode(encoder, "x11-compound-text", us, bs); |
| } |
| } |