--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/test/jdk/sun/nio/cs/TestISO2022CNDecoder.java Tue Sep 12 19:03:39 2017 +0200
@@ -0,0 +1,450 @@
+/*
+ * 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");
+ }
+
+ }
+}