test/sun/nio/cs/TestISO2022CNDecoder.java - platform/external/oj-libjdwp - Gitiles

 /*
  * 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
  */

 /*
  * 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");
         }

     }
 }
	/*
	* 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
	*/

	/*
	* 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(2encoded.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(2encoded.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");
	}

	}
	}