--- /dev/null 2020-03-24 13:24:40.000000000 -0700 +++ new/test/jdk/sun/nio/cs/mapping/ConverterTest.java 2020-03-24 13:24:39.000000000 -0700 @@ -0,0 +1,335 @@ +/* + * Copyright (c) 1999, 2020, 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 + * @summary test Bug 4199484 + * @modules jdk.charsets + * @run main ConverterTest + * @bug 4199484 4199599 4199601 4199602 4159519 4201529 4199604 4201532 4947038 6217210 +*/ + +import java.util.*; +import java.io.*; + +/* + * (C) Copyright IBM Corp. 1999 - All Rights Reserved + * + * The original version of this source code and documentation is + * copyrighted and owned by IBM. These materials are provided + * under terms of a License Agreement between IBM and Sun. + * This technology is protected by multiple US and International + * patents. This notice and attribution to IBM may not be removed. + */ +public class ConverterTest extends TestFmwk { + public static void main(String[] args) throws Exception { + new ConverterTest().run(args); + } + + public void test4199484() throws Exception { + checkPages(new String[] { "Cp33722" }); + } + + public void test4199599() throws Exception { + checkPages(new String[] { "Cp930", "Cp939" }); + } + + public void test4199601() throws Exception { + checkPages(new String[] { "Cp942" }); + } + + public void test4199602() throws Exception { + checkPages(new String[] { "Cp943" }); + } + + public void test6217210() throws Exception { + checkPages(new String[] { "Cp833" }); + } + + public void test4159519() throws Exception { + checkPages(new String[] { "Cp037", "Cp1025", "Cp1026", "Cp1112" }); + checkPages(new String[] { "Cp1122", "Cp1123", "Cp273", "Cp277" }); + checkPages(new String[] { "Cp278", "Cp280", "Cp284", "Cp285" }); + checkPages(new String[] { "Cp297", "Cp420", "Cp424", "Cp500" }); + checkPages(new String[] { "Cp838", "Cp870", "Cp871", "Cp875" }); + checkPages(new String[] { "Cp918", "Cp930", "Cp935", "Cp937" }); + checkPages(new String[] { "Cp939" }); + } + + public void test4201529() throws Exception { + // Test fallback mapping for U+00B7 + byte[] b = new String("\u00B7").getBytes("Cp1381"); + + int b1 = b[0] & 0xff; + int b2 = b[1] & 0xff; + + if (b.length != 2 || b1 != 0xa1 || b2 != 0xa4) + errln("Error in Converter: Cp1381"); + } + + public void test4199604() throws Exception { + checkPages(new String[] { "Cp970" }); + } + + public void test4201532() throws Exception { + checkPages(new String[] { "Cp1383" }); + } + + private static class Parameter { + public final String value; + public final boolean statefull; + private final Vector nativeValues = new Vector(); + private final Vector unicodeValues = new Vector(); + + public Parameter(final String param) throws IOException { + final int ndx = param.indexOf(":"); + if (ndx >= 0) { + value = param.substring(0, ndx); + } else { + value = param; + } + final String args = (ndx < 0) ? "" : param.substring(ndx+1); + boolean isStatefull = false; + for (int i = 0; i < args.length(); i++) { + final char flag = args.charAt(i); + switch (flag) { + case 's': + isStatefull = true; + break; + default: + } + } + + final String fileName = value+".b2c"; + final FileReader f = new FileReader(new File(System.getProperty("test.src", "."), fileName)); + final BufferedReader in = new BufferedReader(f); + String line = in.readLine(); + while (line != null) { + if (line.startsWith("#")) { + //ignore all comments except ones that indicate this is a + //statefull conversion. + if (line.indexOf("STATEFULL") > 0) { + isStatefull = true; + } + } else { + final StringTokenizer tokenizer = new StringTokenizer(line); + String key = tokenizer.nextToken(); + String value = tokenizer.nextToken(); + if (key.startsWith("0x")) key = key.substring(2); + if (value.startsWith("0x")) value = value.substring(2); + + final char c = (char)Integer.parseInt(value, 16); + final String unicodeValue = String.valueOf(c); + + final long keyValue = Long.parseLong(key, 16); + if (isStatefull) { + final int keyLength = key.length(); + if (keyLength == 2) { + byte[] nativeValue = new byte[1]; + nativeValue[0] = (byte)((keyValue) & 0x00FF); + nativeValues.addElement(nativeValue); + unicodeValues.addElement(unicodeValue); + } else if (keyLength == 8) { + byte[] nativeValue = new byte[4]; + nativeValue[0] = 0x0E; + nativeValue[1] = (byte)((keyValue >> 16) & 0x00FF); + nativeValue[2] = (byte)((keyValue >> 8) & 0x00FF); + nativeValue[3] = 0x0F; + nativeValues.addElement(nativeValue); + unicodeValues.addElement(unicodeValue); + } else { + System.err.println("Agh!"); + } + } else { + if (key.length() == 2) { + byte[] nativeValue = new byte[1]; + nativeValue[0] = (byte)(keyValue & 0x00FF); + nativeValues.addElement(nativeValue); + unicodeValues.addElement(unicodeValue); + } else if (key.length() == 4) { + byte[] nativeValue = new byte[2]; + nativeValue[0] = (byte)((keyValue >> 8) & 0x00FF); + nativeValue[1] = (byte)((keyValue) & 0x00FF); + nativeValues.addElement(nativeValue); + unicodeValues.addElement(unicodeValue); + } else { + byte[] nativeValue = new byte[3]; + nativeValue[0] = (byte)((keyValue >> 16) & 0x00FF); + nativeValue[1] = (byte)((keyValue >> 8) & 0x00FF); + nativeValue[2] = (byte)((keyValue) & 0x00FF); + nativeValues.addElement(nativeValue); + unicodeValues.addElement(unicodeValue); + } + } + } + line = in.readLine(); + } + statefull = isStatefull; + } + + public String toString() { + return value; + } + + public void getMapping(final Vector keys, final Vector values, final boolean toUnicode) + throws IOException { + final Hashtable temp = new Hashtable(); + for (int i = nativeValues.size() - 1; i >= 0; --i) { + final byte[] key = (byte[])nativeValues.elementAt(i); + final String value = (String)unicodeValues.elementAt(i); + + if (toUnicode) { + final String keyString = printable(key); + if (temp.get(keyString) == null) { + temp.put(keyString, keyString); + keys.addElement(key); + values.addElement(value); + } + } else { + if (temp.get(value) == null) { + temp.put(value, value); + keys.addElement(value); + values.addElement(key); + } + } + } + } + } + + public void checkPages(String[] args) { + for (int j = 0; j < args.length; j++) { + logln("Checking converter: "+args[j]); + boolean err = false; + try { + final Parameter param = new Parameter(args[j]); + + final Vector keys = new Vector(); + final Vector values = new Vector(); + + param.getMapping(keys, values, true); + for (int i = 0; i < keys.size(); i++) { + final byte[] key = (byte[])keys.elementAt(i); + final String value = (String)values.elementAt(i); + try { + final String actualValue = new String(key, param.value); + if (!value.equals(actualValue)) { + logln(printable(key)+" ==> "+printable(value)+" produced "+printable(actualValue)); + err = true; + } + } catch (UnsupportedEncodingException e) { + logln(param.value+" encoding not supported: "+e); + err = true; + break; + } + } + + keys.removeAllElements(); + values.removeAllElements(); + param.getMapping(keys, values, false); + for (int i = 0; i < keys.size(); i++) { + final String key = (String)keys.elementAt(i); + final byte[] value = (byte[])values.elementAt(i); + try { + final byte[] actualValue = key.getBytes(param.value); + boolean diff = false; + if (value.length != actualValue.length) { + logln(printable(key)+" ==> "+printable(value)+" produced "+printable(actualValue)); + err = true; + } else { + for (int k = 0; k < value.length; k++) { + if (value[k] != actualValue[k]) { + logln(printable(key)+" ==> "+printable(value)+" produced "+printable(actualValue)); + err = true; + break; + } + } + } + } catch (UnsupportedEncodingException e) { + logln(param.value+" encoding not supported: "+e); + err = true; + break; + } + } + } catch (IOException e) { + logln("Could not load table: "+e); + err = true; + } + if (err) { + errln("Error in converter: "+args[j]); + } else { + logln(" passed."); + } + } + } + + protected static String printable(String c) { + final StringBuffer buffer = new StringBuffer(); + for (int i = 0; i < c.length(); i++) { + buffer.append(printable(c.charAt(i))); + } + return buffer.toString(); + } + + protected static String printable(byte c) { + final StringBuffer buffer = new StringBuffer("0x"); + final int value = ((int)c) & 0x00FF; + buffer.append(HEX_DIGIT[(value & 0x00F0) >> 4]); + buffer.append(HEX_DIGIT[(value & 0x000F)]); + return buffer.toString(); + } + + protected static String printable(byte[] c) { + final StringBuffer buffer = new StringBuffer("["); + for (int i = 0; i < c.length; i++) { + final int value = ((int)c[i]) & 0x00FF; + buffer.append(HEX_DIGIT[(value & 0x00F0) >> 4]); + buffer.append(HEX_DIGIT[(value & 0x000F)]); + buffer.append(" "); + } + buffer.append("]"); + return buffer.toString(); + } + + protected static String printable(char[] c) { + final StringBuffer buffer = new StringBuffer("["); + for (int i = 0; i < c.length; i++) { + buffer.append(printable(c[i])); + } + buffer.append("]"); + return buffer.toString(); + } + + protected static String printable(char c) { + final StringBuffer buffer = new StringBuffer("\\u"); + final int value = ((int)c) & 0xFFFF; + buffer.append(HEX_DIGIT[(value & 0xF000) >> 12]); + buffer.append(HEX_DIGIT[(value & 0x0F00) >> 8]); + buffer.append(HEX_DIGIT[(value & 0x00F0) >> 4]); + buffer.append(HEX_DIGIT[(value & 0x000F)]); + return buffer.toString(); + } + + static final char[] HEX_DIGIT = {'0','1','2','3','4','5','6','7', + '8','9','A','B','C','D','E','F'}; + +}