1 /*
   2  * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
   3  * Copyright 2015 SAP AG. All rights reserved.
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This code is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License version 2 only, as
   8  * published by the Free Software Foundation.
   9  *
  10  * This code is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13  * version 2 for more details (a copy is included in the LICENSE file that
  14  * accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License version
  17  * 2 along with this work; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  19  *
  20  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  21  * or visit www.oracle.com if you need additional information or have any
  22  * questions.
  23  */
  24 
  25 /*
  26  * @test
  27  * @bug 8145336
  28  * @summary PPC64: fix string intrinsics after CompactStrings change
  29  * @library /testlibrary /../../test/lib
  30  * @build sun.hotspot.WhiteBox
  31  * @run main ClassFileInstaller sun.hotspot.WhiteBox
  32  *                              sun.hotspot.WhiteBox$WhiteBoxPermission
  33  *
  34  * @run main/othervm
  35  *        -Xbootclasspath/a:.
  36  *        -XX:+UnlockDiagnosticVMOptions
  37  *        -XX:+WhiteBoxAPI
  38  *        -XX:MaxInlineSize=100
  39  *        -XX:MinInliningThreshold=0
  40  *        TestStringIntrinsics2
  41  */
  42 
  43 import java.lang.annotation.ElementType;
  44 import java.lang.annotation.RetentionPolicy;
  45 import java.lang.annotation.Retention;
  46 import java.lang.annotation.Target;
  47 import java.lang.reflect.Method;
  48 import java.util.Arrays;
  49 import java.util.function.Consumer;
  50 import java.util.function.Function;
  51 
  52 import static jdk.test.lib.Asserts.*;
  53 import sun.hotspot.WhiteBox;
  54 
  55 public class TestStringIntrinsics2 {
  56     // ------------------------------------------------------------------------
  57     //
  58     // We test the following cases:
  59     // - no match in string.  Do we miss the end condition? Will crash if we read
  60     //   past the string.
  61     // - no match in string, but after the string there is a match.
  62     //   Do we incorrectly report this match?  We had a case where we stepped
  63     //   a few chars past the string, this test would report that error. The
  64     //   one above would not.
  65     // - The needle is exactly at the end of the string.
  66     // - The needle spans the end of the string
  67     //
  68     // A special case are needles of length 1. For these we test:
  69     // - needle is first char
  70     // - needle is last char
  71     // - no match
  72     // - match behind string.
  73     //
  74     // We test all these for an unknown needle, and needles known to the compiler
  75     // of lengths 5, 2 and 1.
  76 
  77 
  78     private static final WhiteBox WB = WhiteBox.getWhiteBox();
  79 
  80     public enum Role {
  81         TEST_ENTRY,
  82         TEST_HELPER
  83     }
  84 
  85     @Retention(RetentionPolicy.RUNTIME)
  86     @Target(ElementType.METHOD)
  87     @interface Test {
  88         Role role();
  89         int compileAt() default 0;
  90         int warmup() default 0;
  91         String[] warmupArgs() default {};
  92     }
  93 
  94     // All this mess is needed to avoid try/catch inside the lambdas below.
  95     // See: http://stackoverflow.com/questions/27644361/how-can-i-throw-checked-exceptions-from-inside-java-8-streams
  96     @SuppressWarnings ("unchecked")
  97     private static <E extends Throwable> void throwAsUnchecked(Exception exception) throws E {
  98         throw (E)exception;
  99     }
 100     @FunctionalInterface
 101     public interface Consumer_WithExceptions<T, E extends Exception> {
 102         void accept(T t) throws E;
 103     }
 104     public static <T, E extends Exception> Consumer<T> rethrowConsumer(Consumer_WithExceptions<T, E> consumer) {
 105         return t -> {
 106             try { consumer.accept(t); }
 107             catch (Exception exception) { throwAsUnchecked(exception); }
 108         };
 109     }
 110 
 111     public static void main(String[] args) throws Exception {
 112 
 113         // Warmup helper methods
 114         Arrays.stream(TestStringIntrinsics2.class.getDeclaredMethods())
 115             .filter(m -> m.isAnnotationPresent(Test.class))
 116             .filter(m -> m.getAnnotation(Test.class).warmup() > 0)
 117             .forEach(rethrowConsumer(m -> {
 118                         Test a = m.getAnnotation(Test.class);
 119                         System.out.println("Warming up " + m + " " + a.warmup() + " time(s) ");
 120                         for (int i=0; i < a.warmup(); i++) {
 121                             m.invoke(null, (Object[])a.warmupArgs());
 122                         }
 123                     }));
 124 
 125         // Compile helper methods
 126         Arrays.stream(TestStringIntrinsics2.class.getDeclaredMethods())
 127             .filter(m -> m.isAnnotationPresent(Test.class))
 128             .filter(m -> m.getAnnotation(Test.class).compileAt() > 0)
 129             .forEach(rethrowConsumer(m -> {
 130                         Test a = m.getAnnotation(Test.class);
 131                         if (WB.isMethodCompilable(m, a.compileAt())) {
 132                             WB.enqueueMethodForCompilation(m, a.compileAt());
 133                             while (WB.isMethodQueuedForCompilation(m)) Thread.sleep(10);
 134                             System.out.println(m + " compiled at " + WB.getMethodCompilationLevel(m));
 135                         } else {
 136                             System.out.println("Can't compile " + m + " at level " + a.compileAt());
 137                         }
 138                     }));
 139 
 140         // Run test methods
 141         Arrays.stream(TestStringIntrinsics2.class.getDeclaredMethods())
 142             .filter(m -> m.isAnnotationPresent(Test.class))
 143             .filter(m -> m.getAnnotation(Test.class).role() == Role.TEST_ENTRY)
 144             .forEach(rethrowConsumer(m -> {
 145                         System.out.print("Executing " + m);
 146                         m.invoke(null, (Object[])null);
 147                         System.out.println(" - OK");
 148                     }));
 149     }
 150 
 151     static String text = "<t><t><t><t><t><t>\n" + "<hit>";
 152     static String text2 = "<t><t><t><t><t><t><t>\n" + "<hit>";
 153     static String[] ss = text.split("\n");
 154     static String[] ss2 = null;
 155     static String needle = "<miss>";
 156 
 157     @Test(role = Role.TEST_ENTRY)
 158     public static void test_indexOf_no_match() {
 159         int res = indexOf_no_match_unknown_needle(ss[0], "<miss>");
 160         assertEquals(res, -1, "test_indexOf_no_match_unknown_needle matched at: " + res);
 161         res = indexOf_no_match_imm_needle(ss[0]);
 162         assertEquals(res, -1, "test_indexOf_no_match_imm_needle matched at: " + res);
 163         res = indexOf_no_match_imm2_needle(ss[0]);
 164         assertEquals(res, -1, "test_indexOf_no_match_imm2_needle matched at: " + res);
 165 
 166         if (ss2 == null) ss2 = text.split("\n");
 167         res = indexOf_no_match_unknown_needle(ss2[0], "<miss>");
 168         assertEquals(res, -1, "test_indexOf_no_match_unknown_needle matched at: " + res);
 169         res = indexOf_no_match_imm_needle(ss2[0]);
 170         assertEquals(res, -1, "test_indexOf_no_match_imm_needle matched at: " + res);
 171         res = indexOf_no_match_imm2_needle(ss2[0]);
 172         assertEquals(res, -1, "test_indexOf_no_match_imm2_needle matched at: " + res);
 173         res = indexOf_no_match_imm1_needle(ss2[0]);
 174         assertEquals(res, -1, "test_indexOf_no_match_imm1_needle matched at: " + res);
 175     }
 176 
 177     @Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "<t><t><t>", "<miss>" })
 178     static int indexOf_no_match_unknown_needle(String s, String needle) {
 179         int index = s.indexOf(needle);
 180         return index;
 181     }
 182 
 183     @Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "<t><t><t>" })
 184     static int indexOf_no_match_imm_needle(String s) {
 185         int index = s.indexOf("<hitt>");
 186         return index;
 187     }
 188 
 189     @Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "<t><t><t>" })
 190     static int indexOf_no_match_imm2_needle(String s) {
 191         int index = s.indexOf("<m");
 192         return index;
 193     }
 194 
 195     @Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "<t><t><t>" })
 196     static int indexOf_no_match_imm1_needle(String s) {
 197         int index = s.indexOf("m");
 198         return index;
 199     }
 200 
 201     @Test(role = Role.TEST_ENTRY)
 202     public static void test_indexOf_reads_past_string() {
 203         if (ss == null) ss = text.split("\n");
 204         String res = indexOf_reads_past_string_unknown_needle(ss[0], "<hit>");
 205         assertEquals(res, null, "test_indexOf_reads_past_string_unknown_needle " + res);
 206         res = indexOf_reads_past_string_imm_needle(ss[0]);
 207         assertEquals(res, null, "test_indexOf_reads_past_string_imm_needle " + res);
 208         res = indexOf_reads_past_string_imm2_needle(ss[0]);
 209         assertEquals(res, null, "test_indexOf_reads_past_string_imm2_needle " + res);
 210         res = indexOf_reads_past_string_imm1_needle(ss[0]);
 211         assertEquals(res, null, "test_indexOf_reads_past_string_imm1_needle " + res);
 212     }
 213 
 214     @Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "<t><t><t>", "<hit>" })
 215     static String indexOf_reads_past_string_unknown_needle(String s, String needle) {
 216         int index = s.indexOf(needle);
 217         if (index > s.length()) {
 218             return "Found needle \"" + needle + "\" behind string of length " + s.length()
 219                 + " at position " + index + ".";
 220         }
 221         return null;
 222     }
 223 
 224     @Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "<t><t><t>" })
 225     static String indexOf_reads_past_string_imm_needle(String s) {
 226         int index = s.indexOf("<hit>");
 227         if (index > s.length()) {
 228             return "Found needle \"<hit>\" behind string of length " + s.length() + " at position " + index + ".";
 229         }
 230         return null;
 231     }
 232 
 233     @Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "<t><t><t>" })
 234     static String indexOf_reads_past_string_imm2_needle(String s) {
 235         int index = s.indexOf("<h");
 236         if (index > s.length()) {
 237             return "Found needle \"<h\" behind string of length " + s.length() + " at position " + index + ".";
 238         }
 239         return null;
 240     }
 241 
 242     @Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "<t><t><t>" })
 243     static String indexOf_reads_past_string_imm1_needle(String s) {
 244         int index = s.indexOf("h");
 245         if (index > s.length()) {
 246             return "Found needle \"<h\" behind string of length " + s.length() + " at position " + index + ".";
 247         }
 248         return null;
 249     }
 250 
 251     static String text3 =    "<t><hi><t><h><hit<t><hit>";
 252     static String text4 =   "a<t><hi><t><h><hit<t><hit>";
 253     static String text5 =  "gg<t><hi><t><h><hit<t><hit>";
 254     static String text6 = "ccc<t><hi><t><h><hit<t><hit>";
 255     static int len3 = text3.length();
 256     static int len4 = text4.length();
 257     static int len5 = text5.length();
 258     static int len6 = text6.length();
 259 
 260     static String text7  =    "<t><t><t><t><t<t><h";
 261     static String text8  =   "a<t><t><t><t><t<t><h";
 262     static String text9  =  "gg<t><t><t><t><t<t><h";
 263     static String text10 = "ccc<t><t><t><t><t<t><h";
 264 
 265     @Test(role = Role.TEST_ENTRY)
 266     public static void test_indexOf_match_at_end_of_string() {
 267         String testname = "test_indexOf_match_at_end_of_string";
 268         int res = 0;
 269         res = indexOf_match_at_end_of_string_unknown_needle(text3, "<hit>");
 270         assertEquals(len3, res + 5, testname);
 271         res = indexOf_match_at_end_of_string_unknown_needle(text4, "<hit>");
 272         assertEquals(len4, res + 5, testname);
 273         res = indexOf_match_at_end_of_string_unknown_needle(text5, "<hit>");
 274         assertEquals(len5, res + 5, testname);
 275         res = indexOf_match_at_end_of_string_unknown_needle(text6, "<hit>");
 276         assertEquals(len6, res + 5, testname);
 277 
 278         res = indexOf_match_at_end_of_string_imm_needle(text3);
 279         assertEquals(len3, res + 5, testname);
 280         res = indexOf_match_at_end_of_string_imm_needle(text4);
 281         assertEquals(len4, res + 5, testname);
 282         res = indexOf_match_at_end_of_string_imm_needle(text5);
 283         assertEquals(len5, res + 5, testname);
 284         res = indexOf_match_at_end_of_string_imm_needle(text6);
 285         assertEquals(len6, res + 5, testname);
 286 
 287         res = indexOf_match_at_end_of_string_imm2_needle(text7);
 288         assertEquals(text7.length(),  res + 2, testname);
 289         res = indexOf_match_at_end_of_string_imm2_needle(text8);
 290         assertEquals(text8.length(),  res + 2, testname);
 291         res = indexOf_match_at_end_of_string_imm2_needle(text9);
 292         assertEquals(text9.length(),  res + 2, testname);
 293         res = indexOf_match_at_end_of_string_imm2_needle(text10);
 294         assertEquals(text10.length(), res + 2, testname);
 295 
 296         res = indexOf_match_at_end_of_string_imm1_needle(text7);
 297         assertEquals(text7.length(),  res + 1, testname);
 298         res = indexOf_match_at_end_of_string_imm1_needle(text8);
 299         assertEquals(text8.length(),  res + 1, testname);
 300         res = indexOf_match_at_end_of_string_imm1_needle(text9);
 301         assertEquals(text9.length(),  res + 1, testname);
 302         res = indexOf_match_at_end_of_string_imm1_needle(text10);
 303         assertEquals(text10.length(), res + 1, testname);
 304     }
 305 
 306     @Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "<t><hi><t><h><hit<t><hit>", "<hit>" })
 307     static int indexOf_match_at_end_of_string_unknown_needle(String s, String needle) {
 308         int index = s.indexOf(needle);
 309         return index;
 310     }
 311 
 312     @Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "<t><hi><t><h><hit<t><hit>" })
 313     static int indexOf_match_at_end_of_string_imm_needle(String s) {
 314         int index = s.indexOf("<hit>");
 315         return index;
 316     }
 317 
 318     @Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "<t><hi><t><h><hit<t><hit>" })
 319     static int indexOf_match_at_end_of_string_imm2_needle(String s) {
 320         int index = s.indexOf("<h");
 321         return index;
 322     }
 323 
 324     @Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "<t><hi><t><h><hit<t><hit>" })
 325     static int indexOf_match_at_end_of_string_imm1_needle(String s) {
 326         int index = s.indexOf("h");
 327         return index;
 328     }
 329 
 330     static String s0_1 = text3.substring(0, len3-1);
 331     static String s0_2 = text3.substring(0, len3-2);
 332     static String s0_3 = text3.substring(0, len3-3);
 333     static String s0_4 = text3.substring(0, len3-4);
 334     static String s1_1 = text4.substring(0, len4-1);
 335     static String s1_2 = text4.substring(0, len4-2);
 336     static String s1_3 = text4.substring(0, len4-3);
 337     static String s1_4 = text4.substring(0, len4-4);
 338     static String s2_1 = text5.substring(0, len5-1);
 339     static String s2_2 = text5.substring(0, len5-2);
 340     static String s2_3 = text5.substring(0, len5-3);
 341     static String s2_4 = text5.substring(0, len5-4);
 342     static String s3_1 = text6.substring(0, len6-1);
 343     static String s3_2 = text6.substring(0, len6-2);
 344     static String s3_3 = text6.substring(0, len6-3);
 345     static String s3_4 = text6.substring(0, len6-4);
 346 
 347     static String s0_1x = text7 .substring(0, text7 .length()-1);
 348     static String s1_1x = text8 .substring(0, text8 .length()-1);
 349     static String s2_1x = text9 .substring(0, text9 .length()-1);
 350     static String s3_1x = text10.substring(0, text10.length()-1);
 351 
 352     @Test(role = Role.TEST_ENTRY)
 353     public static void test_indexOf_match_spans_end_of_string() {
 354         String res = null;
 355         res = indexOf_match_spans_end_of_string_unknown_needle(s0_1, "<hit>");
 356         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s0_1 " + res);
 357         res = indexOf_match_spans_end_of_string_unknown_needle(s0_2, "<hit>");
 358         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s0_2 " + res);
 359         res = indexOf_match_spans_end_of_string_unknown_needle(s0_3, "<hit>");
 360         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s0_3 " + res);
 361         res = indexOf_match_spans_end_of_string_unknown_needle(s0_4, "<hit>");
 362         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s0_4 " + res);
 363         res = indexOf_match_spans_end_of_string_unknown_needle(s1_1, "<hit>");
 364         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s1_1 " + res);
 365         res = indexOf_match_spans_end_of_string_unknown_needle(s1_2, "<hit>");
 366         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s1_2 " + res);
 367         res = indexOf_match_spans_end_of_string_unknown_needle(s1_3, "<hit>");
 368         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s1_3 " + res);
 369         res = indexOf_match_spans_end_of_string_unknown_needle(s1_4, "<hit>");
 370         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s1_4 " + res);
 371         res = indexOf_match_spans_end_of_string_unknown_needle(s2_1, "<hit>");
 372         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s2_1 " + res);
 373         res = indexOf_match_spans_end_of_string_unknown_needle(s2_2, "<hit>");
 374         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s2_2 " + res);
 375         res = indexOf_match_spans_end_of_string_unknown_needle(s2_3, "<hit>");
 376         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s2_3 " + res);
 377         res = indexOf_match_spans_end_of_string_unknown_needle(s2_4, "<hit>");
 378         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s2_4 " + res);
 379         res = indexOf_match_spans_end_of_string_unknown_needle(s3_1, "<hit>");
 380         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s3_1 " + res);
 381         res = indexOf_match_spans_end_of_string_unknown_needle(s3_2, "<hit>");
 382         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s3_2 " + res);
 383         res = indexOf_match_spans_end_of_string_unknown_needle(s3_3, "<hit>");
 384         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s3_3 " + res);
 385         res = indexOf_match_spans_end_of_string_unknown_needle(s3_4, "<hit>");
 386         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s3_4 " + res);
 387 
 388         res = indexOf_match_spans_end_of_string_imm_needle(s0_1);
 389         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s0_1 " + res);
 390         res = indexOf_match_spans_end_of_string_imm_needle(s0_2);
 391         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s0_2 " + res);
 392         res = indexOf_match_spans_end_of_string_imm_needle(s0_3);
 393         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s0_3 " + res);
 394         res = indexOf_match_spans_end_of_string_imm_needle(s0_4);
 395         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s0_4 " + res);
 396         res = indexOf_match_spans_end_of_string_imm_needle(s1_1);
 397         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s1_1 " + res);
 398         res = indexOf_match_spans_end_of_string_imm_needle(s1_2);
 399         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s1_2 " + res);
 400         res = indexOf_match_spans_end_of_string_imm_needle(s1_3);
 401         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s1_3 " + res);
 402         res = indexOf_match_spans_end_of_string_imm_needle(s1_4);
 403         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s1_4 " + res);
 404         res = indexOf_match_spans_end_of_string_imm_needle(s2_1);
 405         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s2_1 " + res);
 406         res = indexOf_match_spans_end_of_string_imm_needle(s2_2);
 407         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s2_2 " + res);
 408         res = indexOf_match_spans_end_of_string_imm_needle(s2_3);
 409         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s2_3 " + res);
 410         res = indexOf_match_spans_end_of_string_imm_needle(s2_4);
 411         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s2_4 " + res);
 412         res = indexOf_match_spans_end_of_string_imm_needle(s3_1);
 413         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s3_1 " + res);
 414         res = indexOf_match_spans_end_of_string_imm_needle(s3_2);
 415         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s3_2 " + res);
 416         res = indexOf_match_spans_end_of_string_imm_needle(s3_3);
 417         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s3_3 " + res);
 418         res = indexOf_match_spans_end_of_string_imm_needle(s3_4);
 419         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s3_4 " + res);
 420 
 421         res = indexOf_match_spans_end_of_string_imm2_needle(s0_1x);
 422         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm2_needle s0_1x " + res);
 423         res = indexOf_match_spans_end_of_string_imm2_needle(s1_1x);
 424         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm2_needle s1_1x " + res);
 425         res = indexOf_match_spans_end_of_string_imm2_needle(s2_1x);
 426         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm2_needle s2_1x " + res);
 427         res = indexOf_match_spans_end_of_string_imm2_needle(s3_1x);
 428         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm2_needle s3_1x " + res);
 429     }
 430 
 431     @Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "<t><hi><t><h><hit<t><hit", "<hit>" })
 432     static String indexOf_match_spans_end_of_string_unknown_needle(String s, String needle) {
 433         int index = s.indexOf(needle);
 434         if (index > -1) {
 435             return "Found needle \"" + needle + "\" that is spanning the end of the string: " + s + ".";
 436         }
 437         return null;
 438     }
 439 
 440     @Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "<t><hi><t><h><hit<t><hit" })
 441     static String indexOf_match_spans_end_of_string_imm_needle(String s) {
 442         int index = s.indexOf("<hit>");
 443         if (index > -1) {
 444             return "Found needle \"<hit>\" that is spanning the end of the string: " + s + ".";
 445         }
 446         return null;
 447     }
 448 
 449     @Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "<t><t><t><t><t<t><" })
 450     static String indexOf_match_spans_end_of_string_imm2_needle(String s) {
 451         int index = s.indexOf("<h");
 452         if (index > -1) {
 453             return "Found needle \"<h\" that is spanning the end of the string: " + s + ".";
 454         }
 455         return null;
 456     }
 457 
 458     static String text16 = "ooooooo";
 459     static String text11 = "1ooooooo";
 460     static String text12 = "ooooooo1";
 461     static String text13 = "oooooooo1";
 462     static String text14 = "ooooooooo1";
 463     static String text15 = "oooooooooo1";
 464     static int len12 = text12.length();
 465     static int len13 = text13.length();
 466     static int len14 = text14.length();
 467     static int len15 = text15.length();
 468 
 469     static String text12_1 = text12.substring(0, len12-1);
 470     static String text13_1 = text13.substring(0, len13-1);
 471     static String text14_1 = text14.substring(0, len14-1);
 472     static String text15_1 = text15.substring(0, len15-1);
 473 
 474     @Test(role = Role.TEST_ENTRY)
 475     public static void test_indexOf_imm1_needle() {
 476         assertEquals(     -1, indexOf_imm1_needle(text16), "test_indexOf_imm1_needle no_match");
 477 
 478         assertEquals(      0, indexOf_imm1_needle(text11), "test_indexOf_imm1_needle first_matches");
 479 
 480         assertEquals(len12-1, indexOf_imm1_needle(text12), "test_indexOf_imm1_needle last_matches");
 481         assertEquals(len13-1, indexOf_imm1_needle(text13), "test_indexOf_imm1_needle last_matches");
 482         assertEquals(len14-1, indexOf_imm1_needle(text14), "test_indexOf_imm1_needle last_matches");
 483         assertEquals(len15-1, indexOf_imm1_needle(text15), "test_indexOf_imm1_needle last_matches");
 484 
 485         assertEquals(     -1, indexOf_imm1_needle(text12_1), "test_indexOf_imm1_needle walked_past");
 486         assertEquals(     -1, indexOf_imm1_needle(text13_1), "test_indexOf_imm1_needle walked_past");
 487         assertEquals(     -1, indexOf_imm1_needle(text14_1), "test_indexOf_imm1_needle walked_past");
 488         assertEquals(     -1, indexOf_imm1_needle(text15_1), "test_indexOf_imm1_needle walked_past");
 489     }
 490 
 491     @Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "ooooooo1" })
 492     static int indexOf_imm1_needle(String s) {
 493         return s.indexOf("1");
 494     }
 495 
 496 
 497     @Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "abc", "abcd" })
 498     public static int asmStringCompareTo(String a, String b) {
 499         return a.compareTo(b);
 500     }
 501 
 502     @Test(role = Role.TEST_ENTRY)
 503     public static void test_asmStringCompareTo() {
 504         // null
 505         try {
 506             asmStringCompareTo("not null", null);
 507             assertTrue(false,
 508                        "TestOther.asmStringCompareTo(\"not null\", null) doesn't throw exception");
 509         } catch (NullPointerException e) {
 510             assertEquals("java.lang.String.compareTo",
 511                          e.getStackTrace()[0].getClassName() + "." +
 512                          e.getStackTrace()[0].getMethodName(),
 513                          "TestOther.asmStringCompareTo(\"not null\", null) throws exception");
 514         }
 515 
 516         // ==0
 517         {
 518             // check length 0 optimization
 519             assertEquals(0, asmStringCompareTo("", ""),
 520                          "TestOther.asmStringCompareTo(\"\", \"\")");
 521 
 522             // check first character optimization
 523             assertEquals(0, asmStringCompareTo("A", "A"),
 524                          "TestOther.asmStringCompareTo(\"A\", \"A\")");
 525 
 526             // check real comparisons
 527             assertEquals(0, asmStringCompareTo(new String("eq") + new String("ual"), "equal"),
 528                          "TestOther.asmStringCompareTo(\"equal\", \"equal\")");
 529             assertEquals(0, asmStringCompareTo("textABC", "textABC"),
 530                          "TestOther.asmStringCompareTo(\"textABC\", \"textABC\")");
 531             assertEquals(0,
 532                          asmStringCompareTo(new String("abcdefgh01234") +
 533                                             new String("56abcdefgh0123456abcdefgh0123456"),
 534                                             "abcdefgh0123456abcdefgh0123456abcdefgh0123456"),
 535                          "TestOther.asmStringCompareTo(\"abcdefgh0123456abcdefgh0123456abcdefgh0123456\", " +
 536                          "\"abcdefgh0123456abcdefgh0123456abcdefgh0123456\")");
 537         }
 538 
 539         // <0
 540         {
 541             // check first character optimization
 542             assertEquals(-1, asmStringCompareTo("4", "5"),
 543                          "TestOther.asmStringCompareTo(\"4\", \"5\")");
 544 
 545             // check real comparisons
 546             assertEquals(-1, asmStringCompareTo("diff4", "diff5"),
 547                          "TestOther.asmStringCompareTo(\"diff4\", \"diff5\")");
 548             assertEquals(-10, asmStringCompareTo("", "123456789A"),
 549                          "TestOther.asmStringCompareTo(\"\", \"123456789A\")");
 550             assertEquals(-10, asmStringCompareTo("ZYX", "ZYX123456789A"),
 551                          "TestOther.asmStringCompareTo(\"ZYX\", \"ZYX123456789A\")");
 552         }
 553 
 554         // >0
 555         {
 556             // check first character optimization
 557             assertEquals(1, asmStringCompareTo("5", "4"),
 558                          "TestOther.asmStringCompareTo(\"5\", \"4\")");
 559 
 560             // check real comparisons
 561             assertEquals(1, asmStringCompareTo("diff5", "diff4"),
 562                          "TestOther.asmStringCompareTo(\"diff5\", \"diff4\")");
 563             assertEquals(10, asmStringCompareTo("123456789A", ""),
 564                          "TestOther.asmStringCompareTo(\"123456789A\", \"\")");
 565             assertEquals(10, asmStringCompareTo("ZYX123456789A", "ZYX"),
 566                          "TestOther.asmStringCompareTo(\"ZYX123456789A\", \"ZYX\")");
 567         }
 568 
 569         // very long strings (100k)
 570         {
 571             char[] ac = new char[(100 * 1024)];
 572             for (int i = 0; i < (100 * 1024); i += 315)
 573                 ac[i] = (char) ((i % 12) + 'a');
 574             char[] bc = new char[(100 * 1024)];
 575             for (int i = 0; i < (100 * 1024); i += 315)
 576                 bc[i] = (char) ((i % 12) + 'a');
 577 
 578             ac[(100 * 1024) - 1] = '2';
 579             bc[(100 * 1024) - 1] = '2';
 580             String a1 = new String(ac);
 581             String b1 = new String(bc);
 582             assertEquals(0, asmStringCompareTo(a1, b1),
 583                          "TestOther.asmStringCompareTo(very_long_strings_1)");
 584 
 585             ac[(100 * 1024) - 1] = 'X';
 586             bc[(100 * 1024) - 1] = 'Z';
 587             String a2 = new String(ac);
 588             String b2 = new String(bc);
 589             assertEquals(-2, asmStringCompareTo(a2, b2),
 590                          "TestOther.asmStringCompareTo(very_long_strings_2)");
 591         }
 592 
 593         // very very long strings (2M)
 594         {
 595             char[] ac = new char[(2 * 1024 * 1024)];
 596             for (int i = 0; i < (2 * 1024 * 1024); i += 315)
 597                 ac[i] = (char) ((i % 12) + 'a');
 598             char[] bc = new char[(2 * 1024 * 1024)];
 599             for (int i = 0; i < (2 * 1024 * 1024); i += 315)
 600                 bc[i] = (char) ((i % 12) + 'a');
 601 
 602             ac[(2 * 1024 * 1024) - 1] = '3';
 603             bc[(2 * 1024 * 1024) - 1] = '3';
 604             String a1 = new String(ac);
 605             String b1 = new String(bc);
 606             assertEquals(0, asmStringCompareTo(a1, b1),
 607                          "TestOther.asmStringCompareTo(very_very_long_strings_1)");
 608 
 609             ac[(2 * 1024 * 1024) - 1] = 'W';
 610             bc[(2 * 1024 * 1024) - 1] = 'Z';
 611             String a2 = new String(ac);
 612             String b2 = new String(bc);
 613             assertEquals(-3, asmStringCompareTo(a2, b2),
 614                          "TestOther.asmStringCompareTo(very_very_long_strings_2)");
 615         }
 616     }
 617 
 618 
 619     @Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1, warmupArgs = { "abc", "abcd" })
 620     public static boolean asmStringEquals(String a, String b) {
 621         return a.equals(b);
 622     }
 623 
 624     static String a1 = "abcd";
 625     static String b1 = "abcd";
 626     static final String a2 = "1234";
 627     static final String b2 = "1234";
 628 
 629     @Test(role = Role.TEST_HELPER, compileAt = 4, warmup = 1)
 630     public static boolean asmStringEqualsConst() {
 631         boolean ret = a1.equals(b1);
 632         ret &= a2.equals(b2);
 633         ret &= !a2.equals(b1);
 634         ret &= "ABCD".equals("ABCD");
 635         return ret;
 636     }
 637 
 638 
 639     @Test(role = Role.TEST_ENTRY)
 640     public static void test_asmStringEquals() {
 641         // null
 642         {
 643             assertFalse(asmStringEquals("not null", null),
 644                         "TestOther.asmStringEquals(\"not null\", null)");
 645         }
 646 
 647         // true
 648         {
 649             // check constant optimization
 650             assertTrue(asmStringEqualsConst(),
 651                        "TestOther.asmStringEqualsConst(\"\", \"\")");
 652 
 653             // check length 0 optimization
 654             assertTrue(asmStringEquals("", ""),
 655                        "TestOther.asmStringEquals(\"\", \"\")");
 656 
 657             // check first character optimization
 658             assertTrue(asmStringEquals("A", "A"),
 659                        "TestOther.asmStringEquals(\"A\", \"A\")");
 660 
 661             // check real comparisons
 662             assertTrue(asmStringEquals(new String("eq") + new String("ual"), "equal"),
 663                        "TestOther.asmStringEquals(\"equal\", \"equal\")");
 664             assertTrue(asmStringEquals("textABC", "textABC"),
 665                        "TestOther.asmStringEquals(\"textABC\", \"textABC\")");
 666             assertTrue(asmStringEquals(new String("abcdefgh01234") +
 667                                        new String("56abcdefgh0123456abcdefgh0123456"),
 668                                        "abcdefgh0123456abcdefgh0123456abcdefgh0123456"),
 669                        "TestOther.asmStringEquals(\"abcdefgh0123456abcdefgh0123456abcdefgh0123456\", " +
 670                        "\"abcdefgh0123456abcdefgh0123456abcdefgh0123456\")");
 671         }
 672     }
 673 
 674 }