/* * 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:-CheckJNICalls -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 titles = new HashMap(); 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); } }