8172307: Remove ununsed JVM API JVM_GetModuleByPackageName()
Summary: Remove get_module_by_package_name() etc., and unneeded test.
Reviewed-by: sspitsyn, gtriantafill
/*
* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2016 SAP SE. 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 8145336
* @summary PPC64: fix string intrinsics after CompactStrings change
* @modules java.base/jdk.internal.misc
* @library /test/lib
*
* @build sun.hotspot.WhiteBox
* @run driver ClassFileInstaller sun.hotspot.WhiteBox
* sun.hotspot.WhiteBox$WhiteBoxPermission
*
* @run main/othervm
* -Xbootclasspath/a:.
* -Xmixed
* -XX:+UnlockDiagnosticVMOptions
* -XX:+WhiteBoxAPI
* -XX:MaxInlineSize=70
* -XX:MinInliningThreshold=0
* compiler.intrinsics.string.TestStringIntrinsics2
*/
package compiler.intrinsics.string;
import sun.hotspot.WhiteBox;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.Arrays;
import java.util.function.Consumer;
import static jdk.test.lib.Asserts.assertEquals;
import static jdk.test.lib.Asserts.assertFalse;
import static jdk.test.lib.Asserts.assertTrue;
public class TestStringIntrinsics2 {
// ------------------------------------------------------------------------
//
// We test the following cases:
// - no match in string. Do we miss the end condition? Will crash if we read
// past the string.
// - no match in string, but after the string there is a match.
// Do we incorrectly report this match? We had a case where we stepped
// a few chars past the string, this test would report that error. The
// one above would not.
// - The needle is exactly at the end of the string.
// - The needle spans the end of the string
//
// A special case are needles of length 1. For these we test:
// - needle is first char
// - needle is last char
// - no match
// - match behind string.
//
// We test all these for an unknown needle, and needles known to the compiler
// of lengths 5, 2 and 1.
private static final WhiteBox WB = WhiteBox.getWhiteBox();
public enum Role {
TEST_ENTRY,
TEST_HELPER
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface Test {
Role role();
int compileAt() default 0;
int warmup() default 0;
String[] warmupArgs() default {};
}
// All this mess is needed to avoid try/catch inside the lambdas below.
// See: http://stackoverflow.com/questions/27644361/how-can-i-throw-checked-exceptions-from-inside-java-8-streams
@SuppressWarnings ("unchecked")
private static <E extends Throwable> void throwAsUnchecked(Exception exception) throws E {
throw (E)exception;
}
@FunctionalInterface
public interface Consumer_WithExceptions<T, E extends Exception> {
void accept(T t) throws E;
}
public static <T, E extends Exception> Consumer<T> rethrowConsumer(Consumer_WithExceptions<T, E> consumer) {
return t -> {
try { consumer.accept(t); }
catch (Exception exception) { throwAsUnchecked(exception); }
};
}
public static void main(String[] args) throws Exception {
// Warmup helper methods
Arrays.stream(TestStringIntrinsics2.class.getDeclaredMethods())
.filter(m -> m.isAnnotationPresent(Test.class))
.filter(m -> m.getAnnotation(Test.class).warmup() > 0)
.forEach(rethrowConsumer(m -> {
Test a = m.getAnnotation(Test.class);
System.out.println("Warming up " + m + " " + a.warmup() + " time(s) ");
for (int i=0; i < a.warmup(); i++) {
m.invoke(null, (Object[])a.warmupArgs());
}
}));
// Compile helper methods
Arrays.stream(TestStringIntrinsics2.class.getDeclaredMethods())
.filter(m -> m.isAnnotationPresent(Test.class))
.filter(m -> m.getAnnotation(Test.class).compileAt() > 0)
.forEach(rethrowConsumer(m -> {
Test a = m.getAnnotation(Test.class);
if (WB.isMethodCompilable(m, a.compileAt())) {
WB.enqueueMethodForCompilation(m, a.compileAt());
while (WB.isMethodQueuedForCompilation(m)) Thread.sleep(10);
System.out.println(m + " compiled at " + WB.getMethodCompilationLevel(m));
} else {
System.out.println("Can't compile " + m + " at level " + a.compileAt());
}
}));
// Run test methods
Arrays.stream(TestStringIntrinsics2.class.getDeclaredMethods())
.filter(m -> m.isAnnotationPresent(Test.class))
.filter(m -> m.getAnnotation(Test.class).role() == Role.TEST_ENTRY)
.forEach(rethrowConsumer(m -> {
System.out.print("Executing " + m);
m.invoke(null, (Object[])null);
System.out.println(" - OK");
}));
}
static String text = "<t><t><t><t><t><t>\n" + "<hit>";
static String text2 = "<t><t><t><t><t><t><t>\n" + "<hit>";
static String[] ss = text.split("\n");
static String[] ss2 = null;
static String needle = "<miss>";
@Test(role = Role.TEST_ENTRY)
public static void test_indexOf_no_match() {
int res = indexOf_no_match_unknown_needle(ss[0], "<miss>");
assertEquals(res, -1, "test_indexOf_no_match_unknown_needle matched at: " + res);
res = indexOf_no_match_imm_needle(ss[0]);
assertEquals(res, -1, "test_indexOf_no_match_imm_needle matched at: " + res);
res = indexOf_no_match_imm2_needle(ss[0]);
assertEquals(res, -1, "test_indexOf_no_match_imm2_needle matched at: " + res);
if (ss2 == null) ss2 = text.split("\n");
res = indexOf_no_match_unknown_needle(ss2[0], "<miss>");
assertEquals(res, -1, "test_indexOf_no_match_unknown_needle matched at: " + res);
res = indexOf_no_match_imm_needle(ss2[0]);
assertEquals(res, -1, "test_indexOf_no_match_imm_needle matched at: " + res);
res = indexOf_no_match_imm2_needle(ss2[0]);
assertEquals(res, -1, "test_indexOf_no_match_imm2_needle matched at: " + res);
res = indexOf_no_match_imm1_needle(ss2[0]);
assertEquals(res, -1, "test_indexOf_no_match_imm1_needle matched at: " + res);
}
@Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "<t><t><t>", "<miss>" })
static int indexOf_no_match_unknown_needle(String s, String needle) {
int index = s.indexOf(needle);
return index;
}
@Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "<t><t><t>" })
static int indexOf_no_match_imm_needle(String s) {
int index = s.indexOf("<hitt>");
return index;
}
@Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "<t><t><t>" })
static int indexOf_no_match_imm2_needle(String s) {
int index = s.indexOf("<m");
return index;
}
@Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "<t><t><t>" })
static int indexOf_no_match_imm1_needle(String s) {
int index = s.indexOf("m");
return index;
}
@Test(role = Role.TEST_ENTRY)
public static void test_indexOf_reads_past_string() {
if (ss == null) ss = text.split("\n");
String res = indexOf_reads_past_string_unknown_needle(ss[0], "<hit>");
assertEquals(res, null, "test_indexOf_reads_past_string_unknown_needle " + res);
res = indexOf_reads_past_string_imm_needle(ss[0]);
assertEquals(res, null, "test_indexOf_reads_past_string_imm_needle " + res);
res = indexOf_reads_past_string_imm2_needle(ss[0]);
assertEquals(res, null, "test_indexOf_reads_past_string_imm2_needle " + res);
res = indexOf_reads_past_string_imm1_needle(ss[0]);
assertEquals(res, null, "test_indexOf_reads_past_string_imm1_needle " + res);
}
@Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "<t><t><t>", "<hit>" })
static String indexOf_reads_past_string_unknown_needle(String s, String needle) {
int index = s.indexOf(needle);
if (index > s.length()) {
return "Found needle \"" + needle + "\" behind string of length " + s.length()
+ " at position " + index + ".";
}
return null;
}
@Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "<t><t><t>" })
static String indexOf_reads_past_string_imm_needle(String s) {
int index = s.indexOf("<hit>");
if (index > s.length()) {
return "Found needle \"<hit>\" behind string of length " + s.length() + " at position " + index + ".";
}
return null;
}
@Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "<t><t><t>" })
static String indexOf_reads_past_string_imm2_needle(String s) {
int index = s.indexOf("<h");
if (index > s.length()) {
return "Found needle \"<h\" behind string of length " + s.length() + " at position " + index + ".";
}
return null;
}
@Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "<t><t><t>" })
static String indexOf_reads_past_string_imm1_needle(String s) {
int index = s.indexOf("h");
if (index > s.length()) {
return "Found needle \"<h\" behind string of length " + s.length() + " at position " + index + ".";
}
return null;
}
static String text3 = "<t><hi><t><h><hit<t><hit>";
static String text4 = "a<t><hi><t><h><hit<t><hit>";
static String text5 = "gg<t><hi><t><h><hit<t><hit>";
static String text6 = "ccc<t><hi><t><h><hit<t><hit>";
static int len3 = text3.length();
static int len4 = text4.length();
static int len5 = text5.length();
static int len6 = text6.length();
static String text7 = "<t><t><t><t><t<t><h";
static String text8 = "a<t><t><t><t><t<t><h";
static String text9 = "gg<t><t><t><t><t<t><h";
static String text10 = "ccc<t><t><t><t><t<t><h";
@Test(role = Role.TEST_ENTRY)
public static void test_indexOf_match_at_end_of_string() {
String testname = "test_indexOf_match_at_end_of_string";
int res = 0;
res = indexOf_match_at_end_of_string_unknown_needle(text3, "<hit>");
assertEquals(len3, res + 5, testname);
res = indexOf_match_at_end_of_string_unknown_needle(text4, "<hit>");
assertEquals(len4, res + 5, testname);
res = indexOf_match_at_end_of_string_unknown_needle(text5, "<hit>");
assertEquals(len5, res + 5, testname);
res = indexOf_match_at_end_of_string_unknown_needle(text6, "<hit>");
assertEquals(len6, res + 5, testname);
res = indexOf_match_at_end_of_string_imm_needle(text3);
assertEquals(len3, res + 5, testname);
res = indexOf_match_at_end_of_string_imm_needle(text4);
assertEquals(len4, res + 5, testname);
res = indexOf_match_at_end_of_string_imm_needle(text5);
assertEquals(len5, res + 5, testname);
res = indexOf_match_at_end_of_string_imm_needle(text6);
assertEquals(len6, res + 5, testname);
res = indexOf_match_at_end_of_string_imm2_needle(text7);
assertEquals(text7.length(), res + 2, testname);
res = indexOf_match_at_end_of_string_imm2_needle(text8);
assertEquals(text8.length(), res + 2, testname);
res = indexOf_match_at_end_of_string_imm2_needle(text9);
assertEquals(text9.length(), res + 2, testname);
res = indexOf_match_at_end_of_string_imm2_needle(text10);
assertEquals(text10.length(), res + 2, testname);
res = indexOf_match_at_end_of_string_imm1_needle(text7);
assertEquals(text7.length(), res + 1, testname);
res = indexOf_match_at_end_of_string_imm1_needle(text8);
assertEquals(text8.length(), res + 1, testname);
res = indexOf_match_at_end_of_string_imm1_needle(text9);
assertEquals(text9.length(), res + 1, testname);
res = indexOf_match_at_end_of_string_imm1_needle(text10);
assertEquals(text10.length(), res + 1, testname);
}
@Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "<t><hi><t><h><hit<t><hit>", "<hit>" })
static int indexOf_match_at_end_of_string_unknown_needle(String s, String needle) {
int index = s.indexOf(needle);
return index;
}
@Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "<t><hi><t><h><hit<t><hit>" })
static int indexOf_match_at_end_of_string_imm_needle(String s) {
int index = s.indexOf("<hit>");
return index;
}
@Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "<t><hi><t><h><hit<t><hit>" })
static int indexOf_match_at_end_of_string_imm2_needle(String s) {
int index = s.indexOf("<h");
return index;
}
@Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "<t><hi><t><h><hit<t><hit>" })
static int indexOf_match_at_end_of_string_imm1_needle(String s) {
int index = s.indexOf("h");
return index;
}
static String s0_1 = text3.substring(0, len3-1);
static String s0_2 = text3.substring(0, len3-2);
static String s0_3 = text3.substring(0, len3-3);
static String s0_4 = text3.substring(0, len3-4);
static String s1_1 = text4.substring(0, len4-1);
static String s1_2 = text4.substring(0, len4-2);
static String s1_3 = text4.substring(0, len4-3);
static String s1_4 = text4.substring(0, len4-4);
static String s2_1 = text5.substring(0, len5-1);
static String s2_2 = text5.substring(0, len5-2);
static String s2_3 = text5.substring(0, len5-3);
static String s2_4 = text5.substring(0, len5-4);
static String s3_1 = text6.substring(0, len6-1);
static String s3_2 = text6.substring(0, len6-2);
static String s3_3 = text6.substring(0, len6-3);
static String s3_4 = text6.substring(0, len6-4);
static String s0_1x = text7 .substring(0, text7 .length()-1);
static String s1_1x = text8 .substring(0, text8 .length()-1);
static String s2_1x = text9 .substring(0, text9 .length()-1);
static String s3_1x = text10.substring(0, text10.length()-1);
@Test(role = Role.TEST_ENTRY)
public static void test_indexOf_match_spans_end_of_string() {
String res = null;
res = indexOf_match_spans_end_of_string_unknown_needle(s0_1, "<hit>");
assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s0_1 " + res);
res = indexOf_match_spans_end_of_string_unknown_needle(s0_2, "<hit>");
assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s0_2 " + res);
res = indexOf_match_spans_end_of_string_unknown_needle(s0_3, "<hit>");
assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s0_3 " + res);
res = indexOf_match_spans_end_of_string_unknown_needle(s0_4, "<hit>");
assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s0_4 " + res);
res = indexOf_match_spans_end_of_string_unknown_needle(s1_1, "<hit>");
assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s1_1 " + res);
res = indexOf_match_spans_end_of_string_unknown_needle(s1_2, "<hit>");
assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s1_2 " + res);
res = indexOf_match_spans_end_of_string_unknown_needle(s1_3, "<hit>");
assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s1_3 " + res);
res = indexOf_match_spans_end_of_string_unknown_needle(s1_4, "<hit>");
assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s1_4 " + res);
res = indexOf_match_spans_end_of_string_unknown_needle(s2_1, "<hit>");
assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s2_1 " + res);
res = indexOf_match_spans_end_of_string_unknown_needle(s2_2, "<hit>");
assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s2_2 " + res);
res = indexOf_match_spans_end_of_string_unknown_needle(s2_3, "<hit>");
assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s2_3 " + res);
res = indexOf_match_spans_end_of_string_unknown_needle(s2_4, "<hit>");
assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s2_4 " + res);
res = indexOf_match_spans_end_of_string_unknown_needle(s3_1, "<hit>");
assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s3_1 " + res);
res = indexOf_match_spans_end_of_string_unknown_needle(s3_2, "<hit>");
assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s3_2 " + res);
res = indexOf_match_spans_end_of_string_unknown_needle(s3_3, "<hit>");
assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s3_3 " + res);
res = indexOf_match_spans_end_of_string_unknown_needle(s3_4, "<hit>");
assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s3_4 " + res);
res = indexOf_match_spans_end_of_string_imm_needle(s0_1);
assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s0_1 " + res);
res = indexOf_match_spans_end_of_string_imm_needle(s0_2);
assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s0_2 " + res);
res = indexOf_match_spans_end_of_string_imm_needle(s0_3);
assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s0_3 " + res);
res = indexOf_match_spans_end_of_string_imm_needle(s0_4);
assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s0_4 " + res);
res = indexOf_match_spans_end_of_string_imm_needle(s1_1);
assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s1_1 " + res);
res = indexOf_match_spans_end_of_string_imm_needle(s1_2);
assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s1_2 " + res);
res = indexOf_match_spans_end_of_string_imm_needle(s1_3);
assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s1_3 " + res);
res = indexOf_match_spans_end_of_string_imm_needle(s1_4);
assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s1_4 " + res);
res = indexOf_match_spans_end_of_string_imm_needle(s2_1);
assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s2_1 " + res);
res = indexOf_match_spans_end_of_string_imm_needle(s2_2);
assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s2_2 " + res);
res = indexOf_match_spans_end_of_string_imm_needle(s2_3);
assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s2_3 " + res);
res = indexOf_match_spans_end_of_string_imm_needle(s2_4);
assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s2_4 " + res);
res = indexOf_match_spans_end_of_string_imm_needle(s3_1);
assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s3_1 " + res);
res = indexOf_match_spans_end_of_string_imm_needle(s3_2);
assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s3_2 " + res);
res = indexOf_match_spans_end_of_string_imm_needle(s3_3);
assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s3_3 " + res);
res = indexOf_match_spans_end_of_string_imm_needle(s3_4);
assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s3_4 " + res);
res = indexOf_match_spans_end_of_string_imm2_needle(s0_1x);
assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm2_needle s0_1x " + res);
res = indexOf_match_spans_end_of_string_imm2_needle(s1_1x);
assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm2_needle s1_1x " + res);
res = indexOf_match_spans_end_of_string_imm2_needle(s2_1x);
assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm2_needle s2_1x " + res);
res = indexOf_match_spans_end_of_string_imm2_needle(s3_1x);
assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm2_needle s3_1x " + res);
}
@Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "<t><hi><t><h><hit<t><hit", "<hit>" })
static String indexOf_match_spans_end_of_string_unknown_needle(String s, String needle) {
int index = s.indexOf(needle);
if (index > -1) {
return "Found needle \"" + needle + "\" that is spanning the end of the string: " + s + ".";
}
return null;
}
@Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "<t><hi><t><h><hit<t><hit" })
static String indexOf_match_spans_end_of_string_imm_needle(String s) {
int index = s.indexOf("<hit>");
if (index > -1) {
return "Found needle \"<hit>\" that is spanning the end of the string: " + s + ".";
}
return null;
}
@Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "<t><t><t><t><t<t><" })
static String indexOf_match_spans_end_of_string_imm2_needle(String s) {
int index = s.indexOf("<h");
if (index > -1) {
return "Found needle \"<h\" that is spanning the end of the string: " + s + ".";
}
return null;
}
static String text16 = "ooooooo";
static String text11 = "1ooooooo";
static String text12 = "ooooooo1";
static String text13 = "oooooooo1";
static String text14 = "ooooooooo1";
static String text15 = "oooooooooo1";
static int len12 = text12.length();
static int len13 = text13.length();
static int len14 = text14.length();
static int len15 = text15.length();
static String text12_1 = text12.substring(0, len12-1);
static String text13_1 = text13.substring(0, len13-1);
static String text14_1 = text14.substring(0, len14-1);
static String text15_1 = text15.substring(0, len15-1);
@Test(role = Role.TEST_ENTRY)
public static void test_indexOf_imm1_needle() {
assertEquals( -1, indexOf_imm1_needle(text16), "test_indexOf_imm1_needle no_match");
assertEquals( 0, indexOf_imm1_needle(text11), "test_indexOf_imm1_needle first_matches");
assertEquals(len12-1, indexOf_imm1_needle(text12), "test_indexOf_imm1_needle last_matches");
assertEquals(len13-1, indexOf_imm1_needle(text13), "test_indexOf_imm1_needle last_matches");
assertEquals(len14-1, indexOf_imm1_needle(text14), "test_indexOf_imm1_needle last_matches");
assertEquals(len15-1, indexOf_imm1_needle(text15), "test_indexOf_imm1_needle last_matches");
assertEquals( -1, indexOf_imm1_needle(text12_1), "test_indexOf_imm1_needle walked_past");
assertEquals( -1, indexOf_imm1_needle(text13_1), "test_indexOf_imm1_needle walked_past");
assertEquals( -1, indexOf_imm1_needle(text14_1), "test_indexOf_imm1_needle walked_past");
assertEquals( -1, indexOf_imm1_needle(text15_1), "test_indexOf_imm1_needle walked_past");
}
@Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "ooooooo1" })
static int indexOf_imm1_needle(String s) {
return s.indexOf("1");
}
static String text1UTF16 = "A" + "\u05d0" + "\u05d1" + "B";
@Test(role = Role.TEST_ENTRY)
public static void test_indexOf_immUTF16() {
assertEquals( 3, indexOf_imm1Latin1_needle(text1UTF16), "test_indexOf_immUTF16");
assertEquals( 1, indexOf_imm1UTF16_needle(text1UTF16), "test_indexOf_immUTF16");
assertEquals( 1, indexOf_immUTF16_needle(text1UTF16), "test_indexOf_immUTF16");
}
@Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "A" + "\u05d0" + "\u05d1" + "B" })
static int indexOf_imm1Latin1_needle(String s) {
return s.indexOf("B");
}
@Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "A" + "\u05d0" + "\u05d1" + "B" })
static int indexOf_imm1UTF16_needle(String s) {
return s.indexOf("\u05d0");
}
@Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "A" + "\u05d0" + "\u05d1" + "B" })
static int indexOf_immUTF16_needle(String s) {
return s.indexOf("\u05d0" + "\u05d1");
}
@Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "abc", "abcd" })
public static int asmStringCompareTo(String a, String b) {
return a.compareTo(b);
}
@Test(role = Role.TEST_ENTRY)
public static void test_asmStringCompareTo() {
// null
try {
asmStringCompareTo("not null", null);
assertTrue(false,
"TestOther.asmStringCompareTo(\"not null\", null) doesn't throw exception");
} catch (NullPointerException e) {
assertEquals("java.lang.String.compareTo",
e.getStackTrace()[0].getClassName() + "." +
e.getStackTrace()[0].getMethodName(),
"TestOther.asmStringCompareTo(\"not null\", null) throws exception");
}
// ==0
{
// check length 0 optimization
assertEquals(0, asmStringCompareTo("", ""),
"TestOther.asmStringCompareTo(\"\", \"\")");
// check first character optimization
assertEquals(0, asmStringCompareTo("A", "A"),
"TestOther.asmStringCompareTo(\"A\", \"A\")");
// check real comparisons
assertEquals(0, asmStringCompareTo(new String("eq") + new String("ual"), "equal"),
"TestOther.asmStringCompareTo(\"equal\", \"equal\")");
assertEquals(0, asmStringCompareTo("textABC", "textABC"),
"TestOther.asmStringCompareTo(\"textABC\", \"textABC\")");
assertEquals(0,
asmStringCompareTo(new String("abcdefgh01234") +
new String("56abcdefgh0123456abcdefgh0123456"),
"abcdefgh0123456abcdefgh0123456abcdefgh0123456"),
"TestOther.asmStringCompareTo(\"abcdefgh0123456abcdefgh0123456abcdefgh0123456\", " +
"\"abcdefgh0123456abcdefgh0123456abcdefgh0123456\")");
}
// <0
{
// check first character optimization
assertEquals(-1, asmStringCompareTo("4", "5"),
"TestOther.asmStringCompareTo(\"4\", \"5\")");
// check real comparisons
assertEquals(-1, asmStringCompareTo("diff4", "diff5"),
"TestOther.asmStringCompareTo(\"diff4\", \"diff5\")");
assertEquals(-10, asmStringCompareTo("", "123456789A"),
"TestOther.asmStringCompareTo(\"\", \"123456789A\")");
assertEquals(-10, asmStringCompareTo("ZYX", "ZYX123456789A"),
"TestOther.asmStringCompareTo(\"ZYX\", \"ZYX123456789A\")");
}
// >0
{
// check first character optimization
assertEquals(1, asmStringCompareTo("5", "4"),
"TestOther.asmStringCompareTo(\"5\", \"4\")");
// check real comparisons
assertEquals(1, asmStringCompareTo("diff5", "diff4"),
"TestOther.asmStringCompareTo(\"diff5\", \"diff4\")");
assertEquals(10, asmStringCompareTo("123456789A", ""),
"TestOther.asmStringCompareTo(\"123456789A\", \"\")");
assertEquals(10, asmStringCompareTo("ZYX123456789A", "ZYX"),
"TestOther.asmStringCompareTo(\"ZYX123456789A\", \"ZYX\")");
}
// very long strings (100k)
{
char[] ac = new char[(100 * 1024)];
for (int i = 0; i < (100 * 1024); i += 315)
ac[i] = (char) ((i % 12) + 'a');
char[] bc = new char[(100 * 1024)];
for (int i = 0; i < (100 * 1024); i += 315)
bc[i] = (char) ((i % 12) + 'a');
ac[(100 * 1024) - 1] = '2';
bc[(100 * 1024) - 1] = '2';
String a1 = new String(ac);
String b1 = new String(bc);
assertEquals(0, asmStringCompareTo(a1, b1),
"TestOther.asmStringCompareTo(very_long_strings_1)");
ac[(100 * 1024) - 1] = 'X';
bc[(100 * 1024) - 1] = 'Z';
String a2 = new String(ac);
String b2 = new String(bc);
assertEquals(-2, asmStringCompareTo(a2, b2),
"TestOther.asmStringCompareTo(very_long_strings_2)");
}
// very very long strings (2M)
{
char[] ac = new char[(2 * 1024 * 1024)];
for (int i = 0; i < (2 * 1024 * 1024); i += 315)
ac[i] = (char) ((i % 12) + 'a');
char[] bc = new char[(2 * 1024 * 1024)];
for (int i = 0; i < (2 * 1024 * 1024); i += 315)
bc[i] = (char) ((i % 12) + 'a');
ac[(2 * 1024 * 1024) - 1] = '3';
bc[(2 * 1024 * 1024) - 1] = '3';
String a1 = new String(ac);
String b1 = new String(bc);
assertEquals(0, asmStringCompareTo(a1, b1),
"TestOther.asmStringCompareTo(very_very_long_strings_1)");
ac[(2 * 1024 * 1024) - 1] = 'W';
bc[(2 * 1024 * 1024) - 1] = 'Z';
String a2 = new String(ac);
String b2 = new String(bc);
assertEquals(-3, asmStringCompareTo(a2, b2),
"TestOther.asmStringCompareTo(very_very_long_strings_2)");
}
}
@Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "abc", "abcd" })
public static boolean asmStringEquals(String a, String b) {
return a.equals(b);
}
static String a1 = "abcd";
static String b1 = "abcd";
static final String a2 = "1234";
static final String b2 = "1234";
@Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1)
public static boolean asmStringEqualsConst() {
boolean ret = a1.equals(b1);
ret &= a2.equals(b2);
ret &= !a2.equals(b1);
ret &= "ABCD".equals("ABCD");
return ret;
}
@Test(role = Role.TEST_ENTRY)
public static void test_asmStringEquals() {
// null
{
assertFalse(asmStringEquals("not null", null),
"TestOther.asmStringEquals(\"not null\", null)");
}
// true
{
// check constant optimization
assertTrue(asmStringEqualsConst(),
"TestOther.asmStringEqualsConst(\"\", \"\")");
// check length 0 optimization
assertTrue(asmStringEquals("", ""),
"TestOther.asmStringEquals(\"\", \"\")");
// check first character optimization
assertTrue(asmStringEquals("A", "A"),
"TestOther.asmStringEquals(\"A\", \"A\")");
// check real comparisons
assertTrue(asmStringEquals(new String("eq") + new String("ual"), "equal"),
"TestOther.asmStringEquals(\"equal\", \"equal\")");
assertTrue(asmStringEquals("textABC", "textABC"),
"TestOther.asmStringEquals(\"textABC\", \"textABC\")");
assertTrue(asmStringEquals(new String("abcdefgh01234") +
new String("56abcdefgh0123456abcdefgh0123456"),
"abcdefgh0123456abcdefgh0123456abcdefgh0123456"),
"TestOther.asmStringEquals(\"abcdefgh0123456abcdefgh0123456abcdefgh0123456\", " +
"\"abcdefgh0123456abcdefgh0123456abcdefgh0123456\")");
}
}
}