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