/*
* Copyright (c) 2008, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/* @test
* @bug 4779029 4924625 6392664 6730652
* @summary Test decoding of various permutations of valid ISO-2022-CN byte sequences
* @modules jdk.charsets
*/
/*
* Regression test for NIO ISO-2022-CN decoder. Passes various valid
* ISO-2022-CN byte sequences to the decoder using the java.io
* InputStreamReader API
*/
import java.io.*;
import java.nio.*;
import java.nio.charset.*;
public class TestISO2022CNDecoder
{
private static String encodingName = "ISO2022CN";
//
// Positive tests -- test both output and input processing against
// various "known good" data
//
private static boolean decodeTest (
byte encoded[],
char decoded[],
String label)
{
boolean retval = true;
int i = 0;
try {
//
// Ensure that reading decodes correctly
//
ByteArrayInputStream in;
InputStreamReader reader;
in = new ByteArrayInputStream(encoded);
reader = new InputStreamReader(in, encodingName);
for (i = 0; i < decoded.length; i++) {
int c = reader.read();
if (c != decoded[i]) {
System.err.print(label + ": read failed, char " + i);
System.err.print(" ... expected 0x"
+ Integer.toHexString(decoded[i]));
if (c == -1)
System.err.println(", got EOF");
else
System.err.println(", got 0x"
+ Integer.toHexString(c));
retval = false;
if (c == -1)
return retval;
}
}
int testChar;
if ((testChar = reader.read()) != -1) {
System.err.println(label + ": read failed, no EOF");
System.err.println("testChar is " +
Integer.toHexString((int)testChar));
return false;
}
String decodedString = new String(encoded, "ISO2022CN");
for (i = 0; i < decodedString.length(); i++) {
if (decodedString.charAt(i) != decoded[i])
System.err.println(label + ": read failed, char " + i);
}
CharsetDecoder dec = Charset.forName("ISO2022CN")
.newDecoder()
.onUnmappableCharacter(CodingErrorAction.REPLACE)
.onMalformedInput(CodingErrorAction.REPLACE);
ByteBuffer bb = ByteBuffer.allocateDirect(encoded.length).put(encoded);
bb.flip();
CharBuffer cb = ByteBuffer.allocateDirect(2*encoded.length*(int)dec.maxCharsPerByte())
.asCharBuffer();
if (bb.hasArray() || cb.hasArray()) {
System.err.println(label + ": directBuffer failed, ");
return false;
}
if (!dec.decode(bb, cb, true).isUnderflow()) {
System.err.println(label + ": decoder's decode() failed!");
return false;
}
cb.flip();
for (i = 0; i < cb.limit(); i++) {
if (cb.get() != decoded[i])
System.err.println(label + ": decoder failed, char " + i);
}
} catch (Exception e) {
System.err.println(label + ": failed "
+ "(i = " + i + "), "
+ e.getClass().getName()
+ ", " + e.getMessage());
e.printStackTrace();
return false;
}
return retval;
}
private static boolean equal(CoderResult a, CoderResult b) {
return (a == CoderResult.OVERFLOW && b == CoderResult.OVERFLOW) ||
(a == CoderResult.UNDERFLOW && b == CoderResult.UNDERFLOW) ||
((a.isError() == b.isError()) &&
(a.isMalformed() == b.isMalformed()) &&
(a.isUnmappable() == b.isUnmappable()) &&
(a.length() == b.length()));
}
private static boolean decodeResultTest (byte encoded[],
CoderResult expected,
String label) {
CharsetDecoder dec = Charset.forName("ISO2022CN").newDecoder();
ByteBuffer bb = ByteBuffer.wrap(encoded);
CharBuffer cb = CharBuffer.allocate(encoded.length*(int)dec.maxCharsPerByte());
CoderResult result = dec.decode(bb, cb, true);
if (!equal(result, expected)) {
System.err.println(label + ": decoder's decode() failed!");
return false;
}
bb = ByteBuffer.allocateDirect(encoded.length).put(encoded);
bb.flip();
cb = ByteBuffer.allocateDirect(2*encoded.length*(int)dec.maxCharsPerByte())
.asCharBuffer();
if (bb.hasArray() || cb.hasArray()) {
System.err.println(label + ": directBuffer failed, ");
return false;
}
result = dec.reset().decode(bb, cb, true);
if (!equal(result, expected)) {
System.err.println(label + ": decoder's decode() - direct failed!");
return false;
}
return true;
}
//
// Negative tests -- only for input processing, make sure that
// invalid or corrupt characters are rejected.
//
private static boolean negative (byte encoded [], String label)
{
try {
ByteArrayInputStream in;
InputStreamReader reader;
int c;
in = new ByteArrayInputStream(encoded);
reader = new InputStreamReader(in, encodingName);
c = reader.read();
System.err.print (label + ": read failed, ");
if (c == -1)
System.err.println("reported EOF");
else
System.err.println("returned char 0x"
+ Integer.toHexString(c)
+ ", expected exception");
return false;
} catch (CharConversionException e) {
return true;
} catch (Throwable t) {
System.err.println(label + ": failed, threw "
+ t.getClass().getName()
+ ", " + t.getMessage());
}
return false;
}
private static boolean decodeTest6392664 () {
try {
CharsetDecoder dec = Charset.forName("ISO-2022-CN-GB").newDecoder();
dec.decode(ByteBuffer.wrap(new byte[] {(byte)0x0e, (byte)0x42, (byte)0x43 }));
} catch (Exception e) {
e.printStackTrace();
return false;
}
return true;
}
//
// TEST #0: 7-bit unshifted values,
// shift-in of a valid decodable GB2312-80
// character and an unmappable GB2312-80 char
// This is a positive test.
//
private static byte test0_bytes[] = {
(byte)0x00,
(byte)0x01, (byte)0x02, (byte)0x03,
(byte)0x0E, (byte)0x21, (byte)0x2f,
(byte)0x0E, (byte)0xDD, (byte)0x9f
};
private static char test0_chars[] = {
0x0000,
0x0001, 0x0002, 0x0003,
0x2019,
0xFFFD
};
private static byte test1_bytes[] = {
(byte)0x1b, (byte)0x24, (byte)0x29, (byte)0x41, (byte)0x21,
(byte)0x2f };
private static char test1_chars[] = {
0x21, 0x2f
};
private static byte test2_bytes[] = {
(byte)0x0e,
(byte)0x1b, (byte)0x24, (byte)0x29, (byte)0x41,
(byte)0x21, (byte)0x2f };
private static char test2_chars[] = {
0x2019
};
private static byte test3_bytes[] = {
(byte)0x1b, (byte)0x24, (byte)0x29, (byte)0x41,
(byte)0x0e,
(byte)0x21, (byte)0x2f };
private static byte test3a_bytes[] = {
(byte)0x1b, (byte)0x24, (byte)0x41,
(byte)0x0e,
(byte)0x21, (byte)0x2f };
private static char test3_chars[] = {
0x2019
};
private static byte test4_bytes[] = {
(byte)0x1b, (byte)0x24, (byte)0x29, (byte)0x41,
(byte)0x0f,
(byte)0x21, (byte)0x2f };
private static char test4_chars[] = {
0x21, 0x2f
};
private static byte test5_bytes[] = {
(byte)0x1b, (byte)0x24, (byte)0x29, (byte)0x41,
(byte)0x0e, (byte)0x21, (byte)0x2e,
(byte)0x0f, (byte)0x21, (byte)0x2f };
private static char test5_chars[] = {
0x2018, 0x21, 0x2f
};
private static byte test6_bytes[] = {
(byte)0x1b, (byte)0x24, (byte)0x29, (byte)0x41,
(byte)0x0e, (byte)0x21, (byte)0x2e,
(byte)0x21, (byte)0x2f };
private static char test6_chars[] = {
0x2018, 0x2019
};
private static byte test7_bytes[] = {
(byte)0x1b, (byte)0x24, (byte)0x29, (byte)'G',
(byte)0x0e, (byte)0x21, (byte)0x2e,
(byte)0x21, (byte)0x2f };
private static char test7_chars[] = {
0xFE50, 0xFE51
};
private static byte test8_bytes[] = {
(byte)0x1b, (byte)0x24, (byte)0x29, (byte)'G',
(byte)0x0e, (byte)0x21, (byte)0x2e,
(byte)0x0f, (byte)0x21, (byte)0x2f };
private static char test8_chars[] = {
0xFE50, 0x21, 0x2f
};
private static byte test9_bytes[] = {
(byte)0x1b, (byte)0x24, (byte)0x2a, (byte)'H',
(byte)0x1b, (byte)0x4e,
(byte)0x21, (byte)0x2f };
private static char test9_chars[] = {
0x4e0e
};
/*
* Plane 3 support provided for compatibility with
* sun.io ISO2022_CN decoder. Officially ISO-2022-CN
* just handles planes 1/2 of CNS-11643 (1986)
* Test case data below verifies this compatibility
*
*/
private static byte test10_bytes[] = {
(byte)0x1b, (byte)0x24, (byte)'+', (byte)'I',
(byte)0x1b, (byte)0x4f,
(byte)0x21, (byte)0x2f };
private static char test10_chars[] = {
0x51e2
};
private static byte test11_bytes[] = {
(byte)0x1b, (byte)0x24, (byte)0x29, (byte)0x41, //SO Designator
(byte)0x0e, //SO
(byte)0x21, (byte)0x2e, //GB2312 char
(byte)0x1b, (byte)0x24, (byte)0x2a, (byte)'H', //SS2 Designator
(byte)0x1b, (byte)0x4e, //SS2
(byte)0x21, (byte)0x2f, //CNS-P2 char
(byte)0x21, (byte)0x2f //GB2312 char
};
private static char test11_chars[] = {
0x2018,
0x4e0e,
0x2019
};
private static byte test12_bytes[] = {
(byte)0x1b, (byte)0x24, (byte)0x29, (byte)0x41, //SO Designator
(byte)0x0e, //SO
(byte)0x21, (byte)0x2e, //GB2312 char
(byte)0x1b, (byte)0x24, (byte)'+', (byte)'I', //SS3 Designator
(byte)0x1b, (byte)0x4f, //SS3
(byte)0x21, (byte)0x2f, //CNS-P2 char
(byte)0x21, (byte)0x2f //GB2312 char
};
private static char test12_chars[] = {
0x2018,
0x51e2,
0x2019
};
private static byte test13_bytes[] = {
(byte)0x0f0, // byte with MSB
};
private static char test13_chars[] = {
0x00f0,
};
private static byte test14_bytes[] = {
(byte)0x0E, (byte)0x21, (byte)0x2f,
(byte)0x0E, (byte)0xDD, (byte)0x9f
};
private static CoderResult test14_result = CoderResult.unmappableForLength(2);
// Current ISO2022CN treats the "out of range" code points as "unmappable"
private static byte test15_bytes[] = {
(byte)0x1b, (byte)0x4f, // SS3
(byte)0x20, (byte)0x2f, // "out of range" CNS-P2 char
};
private static CoderResult test15_result = CoderResult.unmappableForLength(4);
private static boolean encodeTest6730652 () throws Exception {
//sample p3 codepoints
String strCNSP3 = "\u4e28\u4e36\u4e3f\u4e85\u4e05\u4e04\u5369\u53b6\u4e2a\u4e87\u4e49\u51e2\u56b8\u56b9\u56c4\u8053\u92b0";
return strCNSP3.equals(new String(strCNSP3.getBytes("x-ISO-2022-CN-CNS"), "x-ISO-2022-CN-CNS"));
}
/**
* Main program to test ISO2022CN conformance
*
*/
public static void main (String argv []) throws Exception
{
boolean pass = true;
System.out.println ("");
System.out.println ("------ checking ISO2022CN decoder -----");
// This regtest must be the first one.
pass &= decodeTest6392664();
try {
new InputStreamReader (System.in, "ISO2022CN");
} catch (Exception e) {
encodingName = "ISO2022CN";
System.out.println ("... requires nonstandard encoding name "
+ encodingName);
pass &= false;
}
//
// Positive tests -- good data is dealt with correctly
//
pass &= decodeTest(test0_bytes, test0_chars, "first batch");
pass &= decodeTest(test1_bytes, test1_chars, "escapes1");
pass &= decodeTest(test2_bytes, test2_chars, "escapes2");
pass &= decodeTest(test3_bytes, test3_chars, "escapes3");
pass &= decodeTest(test3a_bytes, test3_chars, "escapes3a");
pass &= decodeTest(test4_bytes, test4_chars, "escapes4");
pass &= decodeTest(test5_bytes, test5_chars, "escapes5");
pass &= decodeTest(test6_bytes, test6_chars, "escapes6");
pass &= decodeTest(test7_bytes, test7_chars, "escapes7");
pass &= decodeTest(test8_bytes, test8_chars, "escapes8");
pass &= decodeTest(test9_bytes, test9_chars, "escapes9");
pass &= decodeTest(test10_bytes, test10_chars, "escapes10");
pass &= decodeTest(test11_bytes, test11_chars, "escapes11");
pass &= decodeTest(test12_bytes, test12_chars, "escapes12");
pass &= decodeTest(test13_bytes, test13_chars, "escapes13");
pass &= decodeResultTest(test14_bytes, test14_result, "escapes14");
pass &= decodeResultTest(test15_bytes, test15_result, "escapes15");
pass &= encodeTest6730652 ();
// PASS/FAIL status is what the whole thing is about.
//
if (! pass) {
throw new Exception("FAIL -- incorrect ISO-2022-CN");
}
}
}