336 lines
13 KiB
Java
336 lines
13 KiB
Java
/*
|
|
* 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'};
|
|
|
|
}
|