test/jdk/java/lang/StringBuffer/ECoreIndexOf.java - master - githubmirror/galahad

test/jdk/java/lang/StringBuffer/ECoreIndexOf.java
1 381 строка54 KB
Volodymyr Paprotski
8344802: Crash in StubRoutines::verify_mxcsr with -XX:+EnableX86ECoreOpts and -Xcheck:jni
13 фев 2025, 01:25
13 фев 2025, 01:2555097dd
/*
 * Copyright (c) 2024, 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
 * @bug 8320448
 * @summary Test indexOf and lastIndexOf
 * @run main/othervm -Xbatch -XX:-TieredCompilation -XX:CompileCommand=dontinline,ECoreIndexOf.indexOfKernel ECoreIndexOf
 * @run main/othervm -Xbatch -XX:CompileCommand=dontinline,ECoreIndexOf.indexOfKernel ECoreIndexOf
 * @key randomness
 */

/* @test
 * @bug 8320448
 * @summary Test indexOf and lastIndexOf
 * @requires vm.cpu.features ~= ".*avx2.*"
 * @requires vm.compiler2.enabled
 * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+EnableX86ECoreOpts -XX:UseAVX=2 -Xbatch -XX:-TieredCompilation -XX:CompileCommand=dontinline,ECoreIndexOf.indexOfKernel ECoreIndexOf
 * @key randomness
 */

import java.nio.charset.StandardCharsets;
import java.util.Random;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.nio.charset.Charset;
import java.lang.Math;

// @ECoreIndexOf(singleThreaded=true)
public class ECoreIndexOf {

  static Random generator;
  private static boolean failure = false;
  static char[] haystack = new char[128];
  static char[] haystack_16 = new char[128];

  static boolean verbose = false;
  static boolean success = true;

  static Map<Charset, String> titles = new HashMap<Charset, String>();
  static Random rng = new Random(1999);

  public static void main(String[] args) throws Exception {
    int foo = 0;
    String testName = "ECoreIndexOf";

    generator = new Random();
    long seed = generator.nextLong();
    generator.setSeed(seed);
    System.out.println("Seed set to "+ seed);

    ///////////////////////////  WARM-UP //////////////////////////

    for (int i = 0; i < 20000; i++) {
      char c = 65;
      char c16 = 0x1ed;
      StringBuffer sb = new StringBuffer("a");
      StringBuffer sb16 = new StringBuffer("\u01fe");

      foo += indexOfKernel("\u01fe", "a");
      foo += indexOfKernel("\u01fe", "a", 0);
      foo += indexOfKernel("\u01fe", "\u01ff");
      foo += indexOfKernel("\u01fe", "\u01ff", 0);
      foo += indexOfKernel("a", "a");
      foo += indexOfKernel("a", "a", 0);
      foo += indexOfKernel("a", "\u01ff");
      foo += indexOfKernel("a", "\u01ff", 0);

      foo += indexOfKernel("\u01fe", c);
      foo += indexOfKernel("\u01fe", c, 0);
      foo += indexOfKernel("\u01fe", c16);
      foo += indexOfKernel("\u01fe", c16, 0);
      foo += indexOfKernel("a", c);
      foo += indexOfKernel("a", c, 0);
      foo += indexOfKernel("a", c16);
      foo += indexOfKernel("a", c16, 0);

      foo += indexOfKernel(sb16, c);
      foo += indexOfKernel(sb16, c, 0);
      foo += indexOfKernel(sb16, c16);
      foo += indexOfKernel(sb16, c16, 0);
      foo += indexOfKernel(sb, c);
      foo += indexOfKernel(sb, c, 0);
      foo += indexOfKernel(sb, c16);
      foo += indexOfKernel(sb, c16, 0);
    }

    ///////////////////////////////////////////////////////////////////////////////////
    ///////////////////////////////////////////////////////////////////////////////////

    String[] decorators = {"", " (same char)"};
    Charset[] charSets = {StandardCharsets.ISO_8859_1, StandardCharsets.UTF_16};
    boolean[] truefalse = {true, false};

    titles.put(StandardCharsets.ISO_8859_1, "L");
    titles.put(StandardCharsets.UTF_16, "U");

    for (int xxy = 0; xxy < 2; xxy++) { // Run at least twice to ensure stub called

      for (int i = 0; i < 128; i++) {
        haystack[i] = (char) i;
      }

      haystack_16[0] = '\u0000'; // (char) (23 + 256);
      for (int i = 1; i < 128; i++) {
        haystack_16[i] = (char) (i);
      }

      simpleTest();
      compareIndexOfLastIndexOf();
      compareStringStringBuffer();
      StringIndexof();
      StringIndexofChar();
      StringIndexofHuge();

      for (String decorator : decorators) {
        for (Charset csHaystack : charSets) {
          for (Charset csNeedle : charSets) {
            System.out.println("Testing " + titles.get(csHaystack) + titles.get(csNeedle) + decorator);
            for (boolean useOffset : truefalse) {
              for (boolean useBuffer : truefalse) {
                exhaustive(useOffset, useBuffer, csHaystack, csNeedle);
              }
            }
          }
        }

        for (int i = 0; i < 128; i++) {
          haystack[i] = (char) 'a';
        }

        for (int i = 0; i < 128; i++) {
          haystack_16[i] = (char) ('a' + 256);
        }
      }
    }

    System.out.println(testName + " complete.");

    if (failure)
      throw new RuntimeException("One or more failures.");
  }

  private static void report(String testName, int failCount) {
    System.err.println(testName + ": " +
        (failCount == 0 ? "Passed" : "Failed(" + failCount + ")"));
    if (failCount > 0)
      failure = true;
  }

  private static String generateTestString(int min, int max) {
    StringBuffer aNewString = new StringBuffer(120);
    int aNewLength = getRandomIndex(min, max);
    for (int y = 0; y < aNewLength; y++) {
      int achar = generator.nextInt(30) + 30;
      char test = (char) (achar);
      aNewString.append(test);
    }
    return aNewString.toString();
  }

  private static String makeRndString(boolean isUtf16, int length) {
    StringBuilder sb = new StringBuilder(length);
    if (length > 0) {
      sb.append(isUtf16 ? '\u2026' : 'b'); // ...

      for (int i = 1; i < length - 1; i++) {
        sb.append((char) ('b' + rng.nextInt(26)));
      }

      sb.append(rng.nextInt(3) >= 1 ? 'a' : 'b');// 66.6% of time 'a' is in string
    }
    return sb.toString();
  }

  private static int indexOfKernel(String haystack, String needle) {
    return haystack.indexOf(needle);
  }

  private static int indexOfKernel(String haystack, String needle, int offset) {
    return haystack.indexOf(needle, offset);
  }

  private static int indexOfKernel(StringBuffer haystack, String needle) {
    return haystack.indexOf(needle);
  }

  private static int indexOfKernel(StringBuffer haystack, char cneedle) {
    String needle = String.valueOf(cneedle);
    return haystack.indexOf(needle);
  }

  private static int indexOfKernel(StringBuffer haystack, String needle, int offset) {
    return haystack.indexOf(needle, offset);
  }

  private static int indexOfKernel(StringBuffer haystack, char cneedle, int offset) {
    String needle = String.valueOf(cneedle);
    return haystack.indexOf(needle, offset);
  }

  private static int indexOfKernel(String haystack, char needle) {
    return haystack.indexOf(needle);
  }

  private static int indexOfKernel(String haystack, char needle, int offset) {
    return haystack.indexOf(needle, offset);
  }

  private static void printStringBytes(byte[] bytes) {
    System.err.println(" bytes.len=" + bytes.length);
    for (byte b : bytes) {
      System.err.print(String.format("0x%02x ", b));
    }
    System.err.println("");
  }

  private static int getRandomIndex(int constraint1, int constraint2) {
    int range = constraint2 - constraint1;
    int x = generator.nextInt(range);
    return constraint1 + x;
  }

  private static int naiveFind(String haystack, String needle) {
    return naiveFind(haystack, needle, 0);
  }

  private static int naiveFind(String haystack, char needle) {
    return naiveFind(haystack, needle, 0);
  }

  private static int naiveFind(String haystack, String needle, int offset) {
    int x = offset;
    int len = haystack.length() - offset;
    if (needle.length() == 0)
      return offset;
    if (needle.length() > len)
      return -1;
    int hsndx = 0;
    int nndx = 0;
    for (int xx = 0; xx < offset; xx++) {
      hsndx += Character.charCount(haystack.codePointAt(hsndx));
    }

    for (x = offset; x < haystack.length() - needle.length() + 1; x++) {
      if (haystack.codePointAt(hsndx) == needle.codePointAt(0)) {
        nndx = Character.charCount(needle.codePointAt(0));
        int hsndx_tmp = hsndx + Character.charCount(haystack.codePointAt(hsndx));

        while (nndx < needle.length()) {
          if (haystack.codePointAt(hsndx_tmp) != needle.codePointAt(nndx)) {
            break;
          }
          hsndx_tmp += Character.charCount(haystack.codePointAt(hsndx_tmp));
          nndx += Character.charCount(needle.codePointAt(nndx));
        }
        if (nndx == needle.length()) {
          return x;
        }
      }
      hsndx += Character.charCount(haystack.codePointAt(hsndx));
    }
    return -1;
  }

  private static int naiveFind(String haystack, char cneedle, int offset) {
    int x = offset;
    int len = haystack.length() - offset;
    String needle = String.valueOf(cneedle);
    if (len == 0)
      return -1;
    int hsndx = 0;
    for (int xx = 0; xx < offset; xx++) {
      hsndx += Character.charCount(haystack.codePointAt(hsndx));
    }

    for (x = offset; x < haystack.length(); x++) {
      if (haystack.codePointAt(hsndx) == needle.codePointAt(0)) {
        return x;
      }
      hsndx += Character.charCount(haystack.codePointAt(hsndx));
    }

    return -1;
  }

  private static void exhaustive(boolean useOffset, boolean useStringBuffer, Charset hs_charset,
      Charset needleCharset) {
    int result = 0;
    int midresult = 0;
    int endresult = 0;
    int l_offset = 0;
    int failCount = 0;

    String thisTest = titles.get(hs_charset) + titles.get(needleCharset) + (useOffset ? " w/offset" : "") + (useStringBuffer ? " StringBuffer" : "");

    for (int needleSize = 0; needleSize < 128; needleSize++) {
      for (int haystackSize = 0; haystackSize < 128; haystackSize++) {
        for (l_offset = 0; l_offset <= haystackSize; l_offset++) {
          String needle = new String(Arrays.copyOfRange(
              (needleCharset == StandardCharsets.UTF_16) ? haystack_16 : haystack, l_offset, l_offset + needleSize));
          int hsSize = (haystackSize - l_offset) >= 0 ? haystackSize - l_offset : 0;
          int midStart = Math.max((hsSize / 2) - (needleSize / 2), 0);
          int endStart = (hsSize > needleSize) ? hsSize - needleSize : 0;
          String midNeedle = new String(
              Arrays.copyOfRange((needleCharset == StandardCharsets.UTF_16) ? haystack_16 : haystack,
                  midStart + l_offset, midStart + needleSize + l_offset));
          String endNeedle = new String(
              Arrays.copyOfRange((needleCharset == StandardCharsets.UTF_16) ? haystack_16 : haystack,
                  endStart + l_offset, endStart + needleSize + l_offset));
          String shs = new String(
              Arrays.copyOfRange((hs_charset == StandardCharsets.UTF_16) ? haystack_16 : haystack, 0, haystackSize));

          // Truncate needles to correct lengths

          if (l_offset + needleSize > haystack.length + 1) {
            needle = needle.substring(0, needleSize);
            midNeedle = midNeedle.substring(0, needleSize);
            endNeedle = endNeedle.substring(0, needleSize);
          }

          if (!success && needleSize > 1) {
            needle = needle.substring(0, needle.length() - 1) + (char) ((int) (needle.charAt(needle.length() - 2) + 1));
            midNeedle = midNeedle.substring(0, midNeedle.length() - 1)
                + (char) ((int) (midNeedle.charAt(midNeedle.length() - 2) + 1));
            endNeedle = endNeedle.substring(0, endNeedle.length() - 1)
                + (char) ((int) (endNeedle.charAt(endNeedle.length() - 2) + 1));
          }

          StringBuffer hs = new StringBuffer(shs.length());
          hs.append(shs);
          if (!shs.equals(hs.toString()))
            throw new RuntimeException("Initial equality failure");

          if (useStringBuffer) {
            result = indexOfKernel(hs, needle, l_offset);
            midresult = indexOfKernel(hs, midNeedle, l_offset);
            endresult = indexOfKernel(hs, endNeedle, l_offset);
          } else {
            result = indexOfKernel(shs, needle, l_offset);
            midresult = indexOfKernel(shs, midNeedle, l_offset);
            endresult = indexOfKernel(shs, endNeedle, l_offset);
          }
          int nResult = naiveFind(hs.toString(), needle, l_offset);
          int midnResult = naiveFind(hs.toString(), midNeedle, l_offset);
          int endnResult = naiveFind(hs.toString(), endNeedle, l_offset);
          if (result != nResult) {
            failCount++;
            System.err.println("useOffset=" + useOffset + ", useStringBuffer=" + useStringBuffer);
            System.err.print("Haystack=");
            printStringBytes(shs.getBytes(hs_charset));
            System.err.print("Needle=");
            printStringBytes(needle.getBytes(needleCharset));
            System.err.println("l_offset=" + l_offset);
            System.err.println("haystackLen=" + haystackSize + " needleLen=" + needleSize +
                " result=" + result + " nResult=" + nResult);
            System.err.println("");
          }
          // badResults = success ? ((midnResult == -1) || (midresult == -1)) :
          // ((midnResult != -1) || (midresult != -1));
          if ((midresult != midnResult)) {
            failCount++;
            System.err.println("useOffset=" + useOffset + ", useStringBuffer=" + useStringBuffer);
            System.err.print("Haystack=");
            printStringBytes(shs.getBytes(hs_charset));
            System.err.print("Needle=");
            printStringBytes(midNeedle.getBytes(needleCharset));
            System.err.println("l_offset=" + l_offset);
            System.err.println("haystackLen=" + haystackSize + " needleLen=" + needleSize +
                " midresult=" + midresult + " midnResult=" + midnResult);
            System.err.println("");
          }
          // badResults = success ? ((endnResult == -1) || (endresult == -1)) :
          // ((endnResult != -1) || (endresult != -1));
          if ((endresult != endnResult)) {
            failCount++;
            System.err.println("useOffset=" + useOffset + ", useStringBuffer=" + useStringBuffer);
            System.err.print("Haystack=");
            printStringBytes(shs.getBytes(hs_charset));
            System.err.print("Needle=");
            printStringBytes(endNeedle.getBytes(needleCharset));
            System.err.println("l_offset=" + l_offset);
            System.err.println("haystackLen=" + haystackSize + " needleLen=" + needleSize +
                " endresult=" + endresult + " endnResult=" + endnResult);
            System.err.println("");
          }

          if (!useOffset)
            l_offset = haystackSize + 100;
        }
      }
    }

    report("Exhaustive " + thisTest, failCount);
  }

  private static void PrintError(int kernel, int naive, int num, String prefix, String hs, char needle) {
    PrintError(kernel, naive, num, prefix, hs, String.valueOf(needle));
  }

  private static void PrintError(int kernel, int naive, int num, String prefix, String hs, String needle) {
    if (!verbose)
      return;
    System.err.println(prefix + ": (" + num + "): kernel=" + kernel + ", naive=" + naive);
    System.err.print("Haystack=");
    printStringBytes(hs.getBytes());
    System.err.print("Needle=");
    printStringBytes(needle.getBytes());
    System.err.println("");
  }

  private static void simpleTest() {
    int failCount = 0;
    String sourceString;
    StringBuffer sourceBuffer;
    String targetString;
    String emptyString = "";
    String allAs = new String("aaaaaaaaaaaaaaaaaaaaaaaaa");
    StringBuffer allAsBuffer = new StringBuffer(allAs);

    for (int i = 0; i < 10000; i++) {
      do {
        sourceString = generateTestString(99, 100);
        sourceBuffer = new StringBuffer(sourceString);
        targetString = generateTestString(10, 11);
      } while (indexOfKernel(sourceString, targetString) != -1);

      int index1 = generator.nextInt(90) + 5;
      sourceBuffer = sourceBuffer.replace(index1, index1, targetString);

      if ((indexOfKernel(sourceBuffer, targetString) != index1) ||
          (index1 != naiveFind(sourceBuffer.toString(), targetString, 0))) {
        System.err.println("sourceBuffer.indexOf(targetString) fragment '" + targetString + "' ("
            + targetString.length() + ") String = "
            + sourceBuffer.toString() + " len Buffer = " + sourceBuffer.toString().length());
        System.err.println("  naive = " + naiveFind(sourceBuffer.toString(), targetString, 0) + ", IndexOf = "
            + indexOfKernel(sourceBuffer, targetString));
        failCount++;
      }
      if ((indexOfKernel(sourceBuffer, targetString, 5) != index1) ||
          (index1 != naiveFind(sourceBuffer.toString(), targetString, 0))) {
        System.err.println("sourceBuffer.indexOf(targetString, 5) fragment '" + targetString + "' ("
            + targetString.length() + ") String = "
            + sourceBuffer.toString() + " len Buffer = " + sourceBuffer.toString().length());
        System.err.println("  naive = " + naiveFind(sourceBuffer.toString(), targetString, 0) + ", IndexOf = "
            + indexOfKernel(sourceBuffer, targetString, 5));
        failCount++;
      }
      if ((indexOfKernel(sourceBuffer, targetString, 99) == index1) ||
          (index1 != naiveFind(sourceBuffer.toString(), targetString, 0))) {
        System.err.println("sourceBuffer.indexOf(targetString, 99) fragment '" + targetString + "' ("
            + targetString.length() + ") String = "
            + sourceBuffer.toString() + " len Buffer = " + sourceBuffer.toString().length());
        System.err.println("  naive = " + naiveFind(sourceBuffer.toString(), targetString, 0) + ", IndexOf = "
            + indexOfKernel(sourceBuffer, targetString, 99));
        failCount++;
      }
      if ((indexOfKernel(sourceBuffer, emptyString, 99) != 99) ||
          (99 != naiveFind(sourceBuffer.toString(), emptyString, 99))) {
        System.err.println("sourceBuffer.indexOf(emptyString, 99) fragment '" + emptyString + "' ("
            + emptyString.length() + ") String = "
            + sourceBuffer.toString() + " len Buffer = " + sourceBuffer.toString().length());
        System.err.println("  naive = " + naiveFind(sourceBuffer.toString(), emptyString, 99) + ", IndexOf = "
            + indexOfKernel(sourceBuffer, emptyString, 99));
        failCount++;
      }
      if ((indexOfKernel(allAsBuffer.substring(1, 3), allAsBuffer.substring(5, 12)) != -1) ||
          (-1 != naiveFind(allAsBuffer.substring(1, 3).toString(), allAsBuffer.substring(5, 12), 0))) {
        System.err.println("allAsBuffer.substring(1, 3).indexOf(allAsBuffer.substring(5, 12)) fragment '"
            + allAsBuffer.substring(5, 12) + "' ("
            + allAsBuffer.substring(5, 12).length() + ") String = "
            + allAsBuffer.substring(1, 3) + " len Buffer = " + allAsBuffer.substring(1, 3).length());
        System.err.println(
            "  naive = " + naiveFind(allAsBuffer.substring(1, 3).toString(), allAsBuffer.substring(5, 12), 0)
                + ", IndexOf = " + indexOfKernel(allAsBuffer.substring(1, 3), allAsBuffer.substring(5, 12)));
        failCount++;
      }
    }

    report("Basic Test                   ", failCount);
  }

  // Note: it is possible although highly improbable that failCount will
  // be > 0 even if everthing is working ok
  private static void compareIndexOfLastIndexOf() {
    int failCount = 0;
    String sourceString;
    StringBuffer sourceBuffer;
    String targetString;

    for (int i = 0; i < 10000; i++) {
      do {
        sourceString = generateTestString(99, 100);
        sourceBuffer = new StringBuffer(sourceString);
        targetString = generateTestString(10, 11);
      } while (indexOfKernel(sourceString, targetString) != -1);

      int index1 = generator.nextInt(100);
      sourceBuffer = sourceBuffer.replace(index1, index1, targetString);

      // extremely remote possibility of > 1 match
      int matches = 0;
      int index2 = -1;
      while ((index2 = indexOfKernel(sourceBuffer, targetString, index2 + 1)) != -1)
        matches++;
      if (matches > 1)
        continue;

      if (indexOfKernel(sourceBuffer, targetString) != sourceBuffer.lastIndexOf(targetString))
        failCount++;
      sourceString = sourceBuffer.toString();
      if (indexOfKernel(sourceString, targetString) != sourceString.lastIndexOf(targetString))
        failCount++;
    }

    report("IndexOf vs LastIndexOf       ", failCount);
  }

  private static void compareStringStringBuffer() {
    int failCount = 0;
    boolean make_new = true;

    String fragment = null;
    StringBuffer testBuffer = null;
    String testString = null;
    int testIndex = 0;

    failCount = indexOfKernel("", "");

    for (int x = 0; x < 1000000; x++) {
      if (make_new) {
        testString = generateTestString(1, 100);
        int len = testString.length();

        testBuffer = new StringBuffer(len);
        testBuffer.append(testString);
        if (!testString.equals(testBuffer.toString()))
          throw new RuntimeException("Initial equality failure");

        int x1 = 0;
        int x2 = 1000;
        while (x2 > testString.length()) {
          x1 = generator.nextInt(len);
          x2 = generator.nextInt(100);
          x2 = x1 + x2;
        }
        fragment = testString.substring(x1, x2);
      }

      int sAnswer = indexOfKernel(testString, fragment);
      int sbAnswer = indexOfKernel(testBuffer, fragment);

      if (sAnswer != sbAnswer) {
        System.err.println("(1) IndexOf fragment '" + fragment + "' (" + fragment.length() + ") len String = "
            + testString.length() + " len Buffer = " + testBuffer.length());
        System.err.println("  sAnswer = " + sAnswer + ", sbAnswer = " + sbAnswer);
        System.err.println("  testString = '" + testString + "'");
        System.err.println("  testBuffer = '" + testBuffer + "'");
        failCount++;

        sAnswer = indexOfKernel(testString, fragment);
        sbAnswer = indexOfKernel(testBuffer, fragment);
      } else {
        if (sAnswer > testString.length()) {
          System.err.println(
              "IndexOf returned value out of range; return: " + sAnswer + " length max: " + testBuffer.length());
        }
      }

      if ((fragment == "0#:02/62;+-\"\"0$25-5$#)1263") && (testBuffer.length() == 94)) {
        String xx = "abc";
        String yy = "abcdefg";
        int sA = indexOfKernel(xx, yy);
      }

      if (make_new)
        testIndex = getRandomIndex(-100, 100);

      sAnswer = indexOfKernel(testString, fragment, testIndex);
      sbAnswer = indexOfKernel(testBuffer, fragment, testIndex);

      if (sAnswer != sbAnswer) {
        System.err.println("(2) IndexOf fragment '" + fragment + "' (" + fragment.length() + ") index = " + testIndex
            + " len String = " + testString.length() + " len Buffer = " + testBuffer.length());
        System.err.println("  sAnswer = " + sAnswer + ", sbAnswer = " + sbAnswer);
        System.err.println("  testString = '" + testString + "'");
        System.err.println("  testBuffer = '" + testBuffer + "'");
        failCount++;
        make_new = true;

        sAnswer = indexOfKernel(testString, fragment, testIndex);
        sbAnswer = indexOfKernel(testBuffer, fragment, testIndex);
      } else {
        if ((sAnswer > testString.length()) || ((sAnswer != -1) && (sAnswer < testIndex) && (fragment.length() != 0))) {
          System.err.println("IndexOf returned value out of range; return: " + sAnswer + " length max: "
              + testString.length() + " index: " + testIndex);
          System.err.println("(3) IndexOf fragment '" + fragment + "' (" + fragment.length() + ") index = " + testIndex
              + " len String = " + testString.length() + " len Buffer = " + testBuffer.length());
        }
      }

      sAnswer = testString.lastIndexOf(fragment);
      sbAnswer = testBuffer.lastIndexOf(fragment);

      if (sAnswer != sbAnswer) {
          System.err.println("(1) lastIndexOf fragment '" + fragment + "' len String = " + testString.length()
            + " len Buffer = " + testBuffer.length());
          System.err.println("  sAnswer = " + sAnswer + ", sbAnswer = " + sbAnswer);
          failCount++;

          sAnswer = testString.lastIndexOf(fragment);
          sbAnswer = testBuffer.lastIndexOf(fragment);
      }

      if (make_new)
        testIndex = getRandomIndex(-100, 100);

      sAnswer = testString.lastIndexOf(fragment, testIndex);
      sbAnswer = testBuffer.lastIndexOf(fragment, testIndex);

      if (sAnswer != sbAnswer) {
        System.err.println("(2) lastIndexOf fragment '" + fragment + "' index = " + testIndex + " len String = "
            + testString.length() + " len Buffer = " + testBuffer.length());
        failCount++;
      }
    }

    report("String vs StringBuffer       ", failCount);
  }

  //////////////////////////////////////////////////////////////////////
  // Test routines used in benchmarks
  //
  // From StringIndexofHuge
  private static void StringIndexofHuge() {
    int stubResult = 0;
    int failCount = 0;

    for (int xx = 0; xx < 2; xx++) {
      int num = 1;

      String dataString = "ngdflsoscargfdgf";
      String dataString16 = "ngdfilso\u01facargfd\u01eef";
      String dataStringHuge = (("A".repeat(32) + "B".repeat(32)).repeat(16) + "X").repeat(2) + "bB";
      String dataStringHuge16 = "\u01de" + (("A".repeat(32) + "B".repeat(32)).repeat(16) + "\u01fe").repeat(2)
          + "\u01eeB";
      String earlyMatchString = dataStringHuge.substring(0, 34);
      String earlyMatchString16 = dataStringHuge16.substring(0, 34);
      String midMatchString = dataStringHuge.substring(dataStringHuge.length() / 2 - 16,
          dataStringHuge.length() / 2 + 32);
      String midMatchString16 = dataStringHuge16.substring(dataStringHuge16.length() / 2 - 16,
          dataStringHuge16.length() / 2 + 32);
      String lateMatchString = dataStringHuge.substring(dataStringHuge.length() - 31);
      String lateMatchString16 = dataStringHuge16.substring(dataStringHuge16.length() - 31);

      String searchString = "oscar";
      String searchString16 = "o\u01facar";
      String searchStringSmall = "dgf";
      String searchStringSmall16 = "d\u01eef";

      String searchStringHuge = "capaapapapasdkajdlkajskldjaslkajdlkajskldjaslkjdlkasjdsalk";
      String searchStringHuge16 = "capaapapapasdkajdlka\u01feskldjaslkajdlkajskldjaslkjdlkasjdsalk";

      String searchNoMatch = "XYXyxYxy".repeat(22);
      String searchNoMatch16 = "\u01ab\u01ba\u01cb\u01bc\u01de\u01ed\u01fa\u01af".repeat(22);

      stubResult = indexOfKernel(dataStringHuge16, earlyMatchString);
      int nResult = naiveFind(dataStringHuge16, earlyMatchString);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexofHuge", dataStringHuge16, earlyMatchString);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(dataStringHuge, earlyMatchString);
      nResult = naiveFind(dataStringHuge, earlyMatchString);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexofHuge", dataStringHuge, earlyMatchString);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(dataStringHuge, midMatchString);
      nResult = naiveFind(dataStringHuge, midMatchString);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexofHuge", dataStringHuge, midMatchString);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(dataStringHuge, lateMatchString);
      nResult = naiveFind(dataStringHuge, lateMatchString);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexofHuge", dataStringHuge, lateMatchString);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(dataStringHuge, searchNoMatch);
      nResult = naiveFind(dataStringHuge, searchNoMatch);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexofHuge", dataStringHuge, searchNoMatch);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(searchString, searchString);
      nResult = naiveFind(searchString, searchString);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexofHuge", searchString, searchString);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(dataString, searchString);
      nResult = naiveFind(dataString, searchString);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexofHuge", dataString, searchString);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(dataString, searchStringSmall);
      nResult = naiveFind(dataString, searchStringSmall);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexofHuge", dataString, searchStringSmall);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(dataStringHuge, "B".repeat(30) + "X" + "A".repeat(30), 74);
      nResult = naiveFind(dataStringHuge, "B".repeat(30) + "X" + "A".repeat(30), 74);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexofHuge", dataStringHuge,
            "B".repeat(30) + "X" + "A".repeat(30));
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(dataStringHuge, "A".repeat(32) + "F" + "B".repeat(32), 64);
      nResult = naiveFind(dataStringHuge, "A".repeat(32) + "F" + "B".repeat(32), 64);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexofHuge", dataStringHuge,
            "A".repeat(32) + "F" + "B".repeat(32));
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(midMatchString, dataStringHuge, 3);
      nResult = naiveFind(midMatchString, dataStringHuge, 3);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexofHuge", midMatchString, dataStringHuge);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(dataStringHuge, "A".repeat(32) + "B".repeat(30) + "bB");
      nResult = naiveFind(dataStringHuge, "A".repeat(32) + "B".repeat(30) + "bB");
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexofHuge", dataStringHuge,
            "A".repeat(32) + "B".repeat(30) + "bB");
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(dataStringHuge16, earlyMatchString);
      nResult = naiveFind(dataStringHuge16, earlyMatchString);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexofHuge", dataStringHuge16, earlyMatchString);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(dataStringHuge16, midMatchString);
      nResult = naiveFind(dataStringHuge16, midMatchString);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexofHuge", dataStringHuge16, midMatchString);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(dataStringHuge16, lateMatchString);
      nResult = naiveFind(dataStringHuge16, lateMatchString);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexofHuge", dataStringHuge16, lateMatchString);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(dataStringHuge16, searchNoMatch);
      nResult = naiveFind(dataStringHuge16, searchNoMatch);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexofHuge", dataStringHuge16, searchNoMatch);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(searchString16, searchString);
      nResult = naiveFind(searchString16, searchString);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexofHuge", searchString16, searchString);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(dataString16, searchString);
      nResult = naiveFind(dataString16, searchString);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexofHuge", dataString16, searchString);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(dataString16, searchStringSmall);
      nResult = naiveFind(dataString16, searchStringSmall);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexofHuge", dataString16, searchStringSmall);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(dataStringHuge16, "B".repeat(30) + "X" + "A".repeat(30), 74);
      nResult = naiveFind(dataStringHuge16, "B".repeat(30) + "X" + "A".repeat(30), 74);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexofHuge", dataStringHuge16,
            "B".repeat(30) + "X" + "A".repeat(30));
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(dataStringHuge16, "A".repeat(32) + "F" + "B".repeat(32), 64);
      nResult = naiveFind(dataStringHuge16, "A".repeat(32) + "F" + "B".repeat(32), 64);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexofHuge", dataStringHuge16,
            "A".repeat(32) + "F" + "B".repeat(32));
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(midMatchString16, dataStringHuge, 3);
      nResult = naiveFind(midMatchString16, dataStringHuge, 3);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexofHuge", midMatchString16, dataStringHuge);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(dataStringHuge16, "A".repeat(32) + "B".repeat(30) + "bB");
      nResult = naiveFind(dataStringHuge16, "A".repeat(32) + "B".repeat(30) + "bB");
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexofHuge", dataStringHuge16,
            "A".repeat(32) + "B".repeat(30) + "bB");
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(dataStringHuge16, earlyMatchString16);
      nResult = naiveFind(dataStringHuge16, earlyMatchString16);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexofHuge", dataStringHuge16, earlyMatchString16);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(dataStringHuge16, midMatchString16);
      nResult = naiveFind(dataStringHuge16, midMatchString16);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexofHuge", dataStringHuge16, midMatchString16);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(dataStringHuge16, lateMatchString16);
      nResult = naiveFind(dataStringHuge16, lateMatchString16);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexofHuge", dataStringHuge16, lateMatchString16);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(dataStringHuge16, searchNoMatch16);
      nResult = naiveFind(dataStringHuge16, searchNoMatch16);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexofHuge", dataStringHuge16, searchNoMatch16);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(searchString16, searchString16);
      nResult = naiveFind(searchString16, searchString16);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexofHuge", searchString16, searchString16);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(dataString16, searchString16);
      nResult = naiveFind(dataString16, searchString16);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexofHuge", dataString16, searchString16);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(dataString16, searchStringSmall16);
      nResult = naiveFind(dataString16, searchStringSmall16);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexofHuge", dataString16, searchStringSmall16);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(dataStringHuge16, "B".repeat(30) + "X" + "A".repeat(30), 74);
      nResult = naiveFind(dataStringHuge16, "B".repeat(30) + "X" + "A".repeat(30), 74);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexofHuge", dataStringHuge16,
            "B".repeat(30) + "X" + "A".repeat(30));
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(dataStringHuge16, "A".repeat(32) + "\u01ef" + "B".repeat(32), 64);
      nResult = naiveFind(dataStringHuge16, "A".repeat(32) + "\u01ef" + "B".repeat(32), 64);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexofHuge", dataStringHuge16,
            "A".repeat(32) + "\u01ef" + "B".repeat(32));
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(midMatchString16, dataStringHuge16, 3);
      nResult = naiveFind(midMatchString16, dataStringHuge16, 3);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexofHuge", midMatchString16, dataStringHuge16);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(dataStringHuge16, "A".repeat(32) + "B".repeat(30) + "\u01eeB");
      nResult = naiveFind(dataStringHuge16, "A".repeat(32) + "B".repeat(30) + "\u01eeB");
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexofHuge", dataStringHuge16,
            "A".repeat(32) + "B".repeat(30) + "\u01eeB");
        failCount++;
      }
      num++;
    }

    report("StringIndexofHuge            ", failCount);
  }

  /////////////////////////////////////////////////////////////////////
  //
  // From StringIndexof
  private static void StringIndexof() {
    int stubResult = 0;
    int failCount = 0;

    for (int xx = 0; xx < 2; xx++) {
      int num = 1;

      String dataString = "ngdfilsoscargfdgf";
      String searchString = "oscar";
      String dataStringBig = "2937489745890797905764956790452976742965790437698498409583479067ngdcapaapapapasdkajdlkajskldjaslkjdlkasjdsalkjas";
      String searchStringBig = "capaapapapasdkajdlkajskldjaslkjdlkasjdsalk";
      String data = "0000100101010010110101010010101110101001110110101010010101010010000010111010101010101010100010010101110111010101101010100010010100001010111111100001010101001010100001010101001010101010111010010101010101010101010101010";
      String sub = "10101010";
      String shortSub1 = "1";
      String data2 = "00001001010100a10110101010010101110101001110110101010010101010010000010111010101010101010a100010010101110111010101101010100010010a100a0010101111111000010101010010101000010101010010101010101110a10010101010101010101010101010";
      String shortSub2 = "a";
      char searchChar = 's';

      String string16Short = "scar\u01fe1";
      String string16Medium = "capaapapapasdkajdlkajskldjaslkjdlkasjdsalksca1r\u01fescar";
      String string16Long = "2937489745890797905764956790452976742965790437698498409583479067ngdcapaapapapasdkajdlkajskldjaslkjdlkasjdsalkja1sscar\u01fescar";
      char searchChar16 = 0x1fe;
      String searchString16 = "\u01fe";

      stubResult = indexOfKernel(dataStringBig, searchChar);
      int nResult = naiveFind(dataStringBig, searchChar);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexof", dataStringBig, searchChar);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(searchStringBig, searchChar);
      nResult = naiveFind(searchStringBig, searchChar);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexof", searchStringBig, searchChar);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(searchString, searchChar);
      nResult = naiveFind(searchString, searchChar);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexof", searchString, searchChar);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(string16Long, searchChar16);
      nResult = naiveFind(string16Long, searchChar16);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexof", string16Long, searchChar16);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(string16Medium, searchChar16);
      nResult = naiveFind(string16Medium, searchChar16);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexof", string16Medium, searchChar16);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(string16Short, searchChar16);
      nResult = naiveFind(string16Short, searchChar16);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexof", string16Short, searchChar16);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(dataStringBig, searchChar, 3);
      nResult = naiveFind(dataStringBig, searchChar, 3);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexof", dataStringBig, searchChar);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(searchStringBig, searchChar, 3);
      nResult = naiveFind(searchStringBig, searchChar, 3);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexof", searchStringBig, searchChar);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(searchString, searchChar, 1);
      nResult = naiveFind(searchString, searchChar, 1);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexof", searchString, searchChar);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(string16Long, searchChar16, 3);
      nResult = naiveFind(string16Long, searchChar16, 3);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexof", string16Long, searchChar16);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(string16Medium, searchChar16, 3);
      nResult = naiveFind(string16Medium, searchChar16, 3);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexof", string16Medium, searchChar16);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(string16Short, searchChar16, 2);
      nResult = naiveFind(string16Short, searchChar16, 2);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexof", string16Short, searchChar16);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(string16Long, shortSub1);
      nResult = naiveFind(string16Long, shortSub1);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexof", string16Long, shortSub1);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(string16Medium, shortSub1);
      nResult = naiveFind(string16Medium, shortSub1);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexof", string16Medium, shortSub1);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(string16Long, shortSub2);
      nResult = naiveFind(string16Long, shortSub2);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexof", string16Long, shortSub2);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(string16Long, shortSub1, 3);
      nResult = naiveFind(string16Long, shortSub1, 3);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexof", string16Long, shortSub1);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(string16Medium, shortSub1, 3);
      nResult = naiveFind(string16Medium, shortSub1, 3);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexof", string16Medium, shortSub1);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(string16Short, shortSub2, 1);
      nResult = naiveFind(string16Short, shortSub2, 1);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexof", string16Short, shortSub2);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(string16Long, searchString16, 3);
      nResult = naiveFind(string16Long, searchString16, 3);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexof", string16Long, searchString16);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(string16Medium, searchString16, 3);
      nResult = naiveFind(string16Medium, searchString16, 3);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexof", string16Medium, searchString16);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(string16Short, searchString16, 2);
      nResult = naiveFind(string16Short, searchString16, 2);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexof", string16Short, searchString16);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(string16Long, searchString16);
      nResult = naiveFind(string16Long, searchString16);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexof", string16Long, searchString16);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(string16Medium, searchString16);
      nResult = naiveFind(string16Medium, searchString16);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexof", string16Medium, searchString16);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(string16Short, searchString16);
      nResult = naiveFind(string16Short, searchString16);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexof", string16Short, searchString16);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(dataString, searchString, 2);
      nResult = naiveFind(dataString, searchString, 2);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexof", dataString, searchString);
        failCount++;
      }
      num++;
      stubResult = indexOfKernel(dataStringBig, searchStringBig, 2);
      nResult = naiveFind(dataStringBig, searchStringBig, 2);
      if (nResult != stubResult) {
        PrintError(stubResult, nResult, num, "StringIndexof", dataStringBig, searchStringBig);
      }
      {
        int index = 0;
        int dummy = 0;
        while ((index = indexOfKernel(data, sub, index)) > -1) {
          nResult = naiveFind(data, sub, index);
          if (index != nResult) {
            PrintError(stubResult, nResult, num, "StringIndexof", data, sub);
            failCount++;
          }
          index++;
          dummy += index;
        }
        num++;
      }
      {
        int dummy = 0;
        int index = 0;
        while ((index = indexOfKernel(data, shortSub1, index)) > -1) {
          nResult = naiveFind(data, shortSub1, index);
          if (index != nResult) {
            PrintError(stubResult, nResult, num, "StringIndexof", data, shortSub1);
            failCount++;
          }
          index++;
          dummy += index;
        }
        num++;
      }
      {
        int dummy = 0;
        int index = 0;
        while ((index = indexOfKernel(data2, shortSub2, index)) > -1) {
          nResult = naiveFind(data2, shortSub2, index);
          if (index != nResult) {
            PrintError(stubResult, nResult, num, "StringIndexof", data2, shortSub2);
            failCount++;
          }
          index++;
          dummy += index;
        }
        num++;
      }
      {
        String tmp = "simple-hash:SHA-1/UTF-8";
        if (!tmp.contains("SHA-1")) {
          PrintError(stubResult, nResult, num, "StringIndexof", "simple-hash:SHA-1/UTF-8", "SHA-1");
          failCount++;
        }
        num++;
      }
    }

    report("StringIndexof                ", failCount);
  }

  /////////////////////////////////////////////////////////////////////
  //
  // From StringIndexofChar
  private static void StringIndexofChar() {
    int stubResult = 0;
    int failCount = 0;

    for (int xx = 0; xx < 2; xx++) {
      stubResult = 0;
      int nResult = 0;
      int num = 1;

      String[] latn1_short = new String[100];
      String[] latn1_sse4 = new String[100];
      String[] latn1_avx2 = new String[100];
      String[] latn1_mixedLength = new String[100];
      String[] utf16_short = new String[100];
      String[] utf16_sse4 = new String[100];
      String[] utf16_avx2 = new String[100];
      String[] utf16_mixedLength = new String[100];

      for (int i = 0; i < 100; i++) {
        latn1_short[i] = makeRndString(false, 15);
        latn1_sse4[i] = makeRndString(false, 16);
        latn1_avx2[i] = makeRndString(false, 32);
        utf16_short[i] = makeRndString(true, 7);
        utf16_sse4[i] = makeRndString(true, 8);
        utf16_avx2[i] = makeRndString(true, 16);
        latn1_mixedLength[i] = makeRndString(false, rng.nextInt(65));
        utf16_mixedLength[i] = makeRndString(true, rng.nextInt(65));
      }
      for (String what : latn1_mixedLength) {
        stubResult = indexOfKernel(what, 'a');
        nResult = naiveFind(what, 'a');
        if (nResult != stubResult) {
          PrintError(stubResult, nResult, num, "StringIndexofChar", what, 'a');
          failCount++;
        }
      }
      num++;
      for (String what : utf16_mixedLength) {
        stubResult = indexOfKernel(what, 'a');
        nResult = naiveFind(what, 'a');
        if (nResult != stubResult) {
          PrintError(stubResult, nResult, num, "StringIndexofChar", what, 'a');
          failCount++;
        }
      }
      num++;
      for (String what : latn1_mixedLength) {
        stubResult = indexOfKernel(what, "a");
        nResult = naiveFind(what, "a");
        if (nResult != stubResult) {
          PrintError(stubResult, nResult, num, "StringIndexofChar", what, "a");
          failCount++;
        }
      }
      num++;
      for (String what : utf16_mixedLength) {
        stubResult = indexOfKernel(what, "a");
        nResult = naiveFind(what, "a");
        if (nResult != stubResult) {
          PrintError(stubResult, nResult, num, "StringIndexofChar", what, "a");
          failCount++;
        }
      }
      num++;
      for (String what : latn1_short) {
        stubResult = indexOfKernel(what, 'a');
        nResult = naiveFind(what, 'a');
        if (nResult != stubResult) {
          PrintError(stubResult, nResult, num, "StringIndexofChar", what, 'a');
          failCount++;
        }
      }
      num++;
      for (String what : latn1_sse4) {
        stubResult = indexOfKernel(what, 'a');
        nResult = naiveFind(what, 'a');
        if (nResult != stubResult) {
          PrintError(stubResult, nResult, num, "StringIndexofChar", what, 'a');
          failCount++;
        }
      }
      num++;
      for (String what : latn1_avx2) {
        stubResult = indexOfKernel(what, 'a');
        nResult = naiveFind(what, 'a');
        if (nResult != stubResult) {
          PrintError(stubResult, nResult, num, "StringIndexofChar", what, 'a');
          failCount++;
        }
      }
      num++;
      for (String what : utf16_short) {
        stubResult = indexOfKernel(what, 'a');
        nResult = naiveFind(what, 'a');
        if (nResult != stubResult) {
          PrintError(stubResult, nResult, num, "StringIndexofChar", what, 'a');
          failCount++;
        }
      }
      num++;
      for (String what : utf16_sse4) {
        stubResult = indexOfKernel(what, 'a');
        nResult = naiveFind(what, 'a');
        if (nResult != stubResult) {
          PrintError(stubResult, nResult, num, "StringIndexofChar", what, 'a');
          failCount++;
        }
      }
      num++;
      for (String what : utf16_avx2) {
        stubResult = indexOfKernel(what, 'a');
        nResult = naiveFind(what, 'a');
        if (nResult != stubResult) {
          PrintError(stubResult, nResult, num, "StringIndexofChar", what, 'a');
          failCount++;
        }
      }
      num++;
      for (String what : latn1_short) {
        stubResult = indexOfKernel(what, "a");
        nResult = naiveFind(what, "a");
        if (nResult != stubResult) {
          PrintError(stubResult, nResult, num, "StringIndexofChar", what, "a");
          failCount++;
        }
      }
      num++;
      for (String what : latn1_sse4) {
        stubResult = indexOfKernel(what, "a");
        nResult = naiveFind(what, "a");
        if (nResult != stubResult) {
          PrintError(stubResult, nResult, num, "StringIndexofChar", what, "a");
          failCount++;
        }
      }
      num++;
      for (String what : latn1_avx2) {
        stubResult = indexOfKernel(what, "a");
        nResult = naiveFind(what, "a");
        if (nResult != stubResult) {
          PrintError(stubResult, nResult, num, "StringIndexofChar", what, "a");
          failCount++;
        }
      }
      num++;
      for (String what : utf16_short) {
        stubResult = indexOfKernel(what, "a");
        nResult = naiveFind(what, "a");
        if (nResult != stubResult) {
          PrintError(stubResult, nResult, num, "StringIndexofChar", what, "a");
          failCount++;
        }
      }
      num++;
      for (String what : utf16_sse4) {
        stubResult = indexOfKernel(what, "a");
        nResult = naiveFind(what, "a");
        if (nResult != stubResult) {
          PrintError(stubResult, nResult, num, "StringIndexofChar", what, "a");
          failCount++;
        }
      }
      num++;
      for (String what : utf16_avx2) {
        stubResult = indexOfKernel(what, "a");
        nResult = naiveFind(what, "a");
        if (nResult != stubResult) {
          PrintError(stubResult, nResult, num, "StringIndexofChar", what, "a");
          failCount++;
        }
      }
      num++;
    }

    report("StringIndexofChar            ", failCount);
  }

}