250 lines
9.8 KiB
Java
250 lines
9.8 KiB
Java
/*
|
|
* Copyright (c) 2013, 2021, 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
|
|
* @key randomness
|
|
* @bug 6896617 8274242
|
|
* @summary Verify potentially intrinsified encoders behave well before and after compilation
|
|
* @library /test/lib
|
|
*
|
|
* @run main/othervm/timeout=1200 --add-opens=java.base/sun.nio.cs=ALL-UNNAMED -Xbatch -Xmx256m compiler.intrinsics.string.TestEncodeIntrinsics
|
|
*/
|
|
|
|
package compiler.intrinsics.string;
|
|
|
|
import jdk.test.lib.Utils;
|
|
|
|
import java.lang.reflect.Method;
|
|
import java.nio.ByteBuffer;
|
|
import java.nio.CharBuffer;
|
|
import java.nio.charset.Charset;
|
|
import java.nio.charset.CharsetDecoder;
|
|
import java.nio.charset.CharsetEncoder;
|
|
import java.nio.charset.CodingErrorAction;
|
|
import java.util.Arrays;
|
|
import java.util.Random;
|
|
|
|
public class TestEncodeIntrinsics {
|
|
final static int SIZE = 256;
|
|
|
|
public static void main(String[] args) {
|
|
|
|
test("ISO-8859-1", false);
|
|
test("UTF-8", true);
|
|
test("US-ASCII", true);
|
|
test("CESU-8", true);
|
|
}
|
|
|
|
private static void test(String csn, boolean asciiOnly) {
|
|
try {
|
|
System.out.println("Testing " + csn);
|
|
Charset cs = Charset.forName(csn);
|
|
CharsetEncoder enc = cs.newEncoder();
|
|
enc.onMalformedInput(CodingErrorAction.REPLACE)
|
|
.onUnmappableCharacter(CodingErrorAction.REPLACE);
|
|
CharsetDecoder dec = cs.newDecoder();
|
|
dec.onMalformedInput(CodingErrorAction.REPLACE)
|
|
.onUnmappableCharacter(CodingErrorAction.REPLACE);
|
|
|
|
byte repl = (byte) '?';
|
|
enc.replaceWith(new byte[]{repl});
|
|
|
|
// Populate char[] with chars which can be encoded by ISO_8859_1 (<= 0xFF)
|
|
// - or ASCII (<= 0x7F) if requested
|
|
Random rnd = Utils.getRandomInstance();
|
|
int maxchar = asciiOnly ? 0x7F : 0xFF;
|
|
char[] a = new char[SIZE];
|
|
byte[] b = new byte[SIZE];
|
|
char[] at = new char[SIZE];
|
|
byte[] bt = new byte[SIZE];
|
|
for (int i = 0; i < SIZE; i++) {
|
|
char c = (char) rnd.nextInt(maxchar);
|
|
if (!enc.canEncode(c)) {
|
|
System.out.printf("Something wrong: can't encode c=%03x\n", (int) c);
|
|
System.exit(97);
|
|
}
|
|
a[i] = c;
|
|
b[i] = (byte) c;
|
|
at[i] = (char) -1;
|
|
bt[i] = (byte) -1;
|
|
}
|
|
|
|
Method encodeArray = null;
|
|
if (csn.equals("ISO-8859-1")) {
|
|
// Use internal API for tests
|
|
encodeArray = enc.getClass().getDeclaredMethod("encodeISOArray",
|
|
char[].class, int.class, byte[].class, int.class, int.class);
|
|
encodeArray.setAccessible(true);
|
|
if ((int) encodeArray.invoke(enc, a, 0, bt, 0, SIZE) != SIZE || !Arrays.equals(b, bt)) {
|
|
System.out.println("Something wrong: ArrayEncoder.encode failed");
|
|
System.exit(97);
|
|
}
|
|
for (int i = 0; i < SIZE; i++) {
|
|
at[i] = (char) -1;
|
|
}
|
|
}
|
|
|
|
ByteBuffer bb = ByteBuffer.wrap(b);
|
|
CharBuffer ba = CharBuffer.wrap(a);
|
|
ByteBuffer bbt = ByteBuffer.wrap(bt);
|
|
CharBuffer bat = CharBuffer.wrap(at);
|
|
if (!enc.encode(ba, bbt, true).isUnderflow() || !Arrays.equals(b, bt)) {
|
|
System.out.println("Something wrong: Encoder.encode failed");
|
|
System.exit(97);
|
|
}
|
|
if (!dec.decode(bb, bat, true).isUnderflow() || !Arrays.equals(a, at)) {
|
|
System.out.println("Something wrong: Decoder.decode failed (a == at: " + !Arrays.equals(a, at) + ")");
|
|
System.exit(97);
|
|
}
|
|
for (int i = 0; i < SIZE; i++) {
|
|
at[i] = (char) -1;
|
|
bt[i] = (byte) -1;
|
|
}
|
|
|
|
// Warm up
|
|
boolean failed = false;
|
|
|
|
if (csn.equals("ISO-8859-1")) {
|
|
for (int i = 0; i < 10000; i++) {
|
|
failed |= (int) encodeArray.invoke(enc, a, 0, bt, 0, SIZE) != SIZE;
|
|
}
|
|
for (int i = 0; i < 10000; i++) {
|
|
failed |= (int) encodeArray.invoke(enc, a, 0, bt, 0, SIZE) != SIZE;
|
|
}
|
|
for (int i = 0; i < 10000; i++) {
|
|
failed |= (int) encodeArray.invoke(enc, a, 0, bt, 0, SIZE) != SIZE;
|
|
}
|
|
if (failed || !Arrays.equals(b, bt)) {
|
|
failed = true;
|
|
System.out.println("Failed: ISO_8859_1$Encoder.encode char[" + SIZE + "]");
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < SIZE; i++) {
|
|
at[i] = (char) -1;
|
|
bt[i] = (byte) -1;
|
|
}
|
|
|
|
boolean is_underflow = true;
|
|
for (int i = 0; i < 10000; i++) {
|
|
ba.clear();
|
|
bb.clear();
|
|
bat.clear();
|
|
bbt.clear();
|
|
boolean enc_res = enc.encode(ba, bbt, true).isUnderflow();
|
|
boolean dec_res = dec.decode(bb, bat, true).isUnderflow();
|
|
is_underflow = is_underflow && enc_res && dec_res;
|
|
}
|
|
for (int i = 0; i < SIZE; i++) {
|
|
at[i] = (char) -1;
|
|
bt[i] = (byte) -1;
|
|
}
|
|
for (int i = 0; i < 10000; i++) {
|
|
ba.clear();
|
|
bb.clear();
|
|
bat.clear();
|
|
bbt.clear();
|
|
boolean enc_res = enc.encode(ba, bbt, true).isUnderflow();
|
|
boolean dec_res = dec.decode(bb, bat, true).isUnderflow();
|
|
is_underflow = is_underflow && enc_res && dec_res;
|
|
}
|
|
for (int i = 0; i < SIZE; i++) {
|
|
at[i] = (char) -1;
|
|
bt[i] = (byte) -1;
|
|
}
|
|
for (int i = 0; i < 10000; i++) {
|
|
ba.clear();
|
|
bb.clear();
|
|
bat.clear();
|
|
bbt.clear();
|
|
boolean enc_res = enc.encode(ba, bbt, true).isUnderflow();
|
|
boolean dec_res = dec.decode(bb, bat, true).isUnderflow();
|
|
is_underflow = is_underflow && enc_res && dec_res;
|
|
}
|
|
if (!is_underflow) {
|
|
failed = true;
|
|
System.out.println("Failed: got a non-underflow");
|
|
}
|
|
if (!Arrays.equals(b, bt)) {
|
|
failed = true;
|
|
System.out.println("Failed: b != bt");
|
|
}
|
|
if (!Arrays.equals(a, at)) {
|
|
failed = true;
|
|
System.out.println("Failed: a != at");
|
|
}
|
|
|
|
// Test encoder with chars outside of the range the intrinsic deals with
|
|
System.out.println("Testing big char");
|
|
|
|
bt = new byte[SIZE + 10]; // add some spare room to deal with encoding multi-byte
|
|
ba = CharBuffer.wrap(a);
|
|
bbt = ByteBuffer.wrap(bt);
|
|
for (int i = 1; i <= SIZE; i++) {
|
|
for (int j = 0; j < i; j++) {
|
|
char bigChar = (char)((asciiOnly ? 0x7F : 0xFF) + 1 + rnd.nextInt(0x100));
|
|
char aOrig = a[j];
|
|
a[j] = bigChar;
|
|
// make sure to replace with a different byte
|
|
bt[j] = (byte)(bt[j] + 1);
|
|
ba.clear();
|
|
ba.limit(i);
|
|
bbt.clear();
|
|
if (!enc.encode(ba, bbt, true).isUnderflow()) {
|
|
failed = true;
|
|
System.out.println("Failed: encode char[" + i + "] to byte[" + i + "]: expected underflow");
|
|
}
|
|
if (bt[j] == b[j] && b[j] != repl) { // b[j] can be equal to repl; ignore
|
|
failed = true;
|
|
System.out.println("Failed: different byte expected at pos bt[" + j + "]");
|
|
}
|
|
if (!enc.canEncode(bigChar) && bt[j] != repl) {
|
|
failed = true;
|
|
System.out.println("Failed: encoded replace byte[" + j + "] (" + bt[j] + ") != " + repl);
|
|
}
|
|
|
|
// Check that all bytes prior to the replaced one was encoded properly
|
|
for (int k = 0; k < j; k++) {
|
|
if (bt[k] != b[k]) {
|
|
failed = true;
|
|
System.out.println("Failed: encoded byte[" + k + "] (" + bt[k] + ") != " + b[k]);
|
|
}
|
|
}
|
|
a[j] = aOrig; // Restore
|
|
}
|
|
}
|
|
|
|
if (failed) {
|
|
System.out.println("FAILED");
|
|
System.exit(97);
|
|
}
|
|
System.out.println("PASSED");
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
System.out.println("FAILED");
|
|
System.exit(97);
|
|
}
|
|
}
|
|
}
|