Benchmark for double asterisk finder

// see http://stackoverflow.com/questions/3350804/how-to-check-if-a-string-contains-two-asterisk-characters

public class AsteriskBenchmark{

    public interface AsteriskFinder{

        String identifier();

        boolean testsForExactlyTwo();

        boolean hasTwoAsterisks(String str);
    }

    public static class SeanizerAsteriskFinder implements AsteriskFinder{

        @Override
        public boolean hasTwoAsterisks(final String str){
            final String[] arr = ("_" + str + "_").split("\\*");
            return arr.length == 3;
        }

        @Override
        public String identifier(){
            return "seanizer";
        }

        @Override
        public boolean testsForExactlyTwo(){
            return true;
        }
    }

    public static class MarkByersAsteriskFinder implements AsteriskFinder{

        @Override
        public boolean hasTwoAsterisks(final String str){
            return str.matches("^[^*]*(?:\\*[^*]*){2}$");
        }

        @Override
        public boolean testsForExactlyTwo(){
            return true;
        }

        @Override
        public String identifier(){
            return "Mark Byers";
        }
    }

    public static class JoachimSauerAsteriskFinder implements AsteriskFinder{

        @Override
        public boolean testsForExactlyTwo(){
            return false;
        }

        @Override
        public boolean hasTwoAsterisks(final String str){
            final int asterisk1 = str.indexOf('*');
            return asterisk1 != -1 && str.indexOf('*', asterisk1 + 1) != -1;

        }

        @Override
        public String identifier(){
            return "Joachim Sauer";
        }
    }

    public static class BhupsAsteriskFinder implements AsteriskFinder{

        @Override
        public boolean testsForExactlyTwo(){
            return false;
        }

        @Override
        public boolean hasTwoAsterisks(final String str){
            int i;
            if((i = str.indexOf("*")) != -1){
                if((i = str.indexOf("*", i + 1)) != -1){
                    return true;
                }
            }
            return false;

        }

        @Override
        public String identifier(){
            return "bhups";
        }
    }

    public static class BozhoRegexAsteriskFinder implements AsteriskFinder{

        @Override
        public boolean hasTwoAsterisks(final String str){
            final String regex = ".*\\*.*\\*.*";
            return str.matches(regex);

        }

        @Override
        public boolean testsForExactlyTwo(){
            return false;
        }

        @Override
        public String identifier(){
            return "Bozho (regex version)";
        }
    }

    public static class BozhoLoopAsteriskFinder implements AsteriskFinder{

        @Override
        public boolean testsForExactlyTwo(){
            return true;
        }

        @Override
        public boolean hasTwoAsterisks(final String str){
            int asterisks = 0;
            for(int i = 0; i < str.length(); i++){
                if(str.charAt(i) == '*'){
                    asterisks++;
                }
            }
            return asterisks == 2;
        }

        @Override
        public String identifier(){
            return "Bozho (loop version)";
        }
    }

    public static class PolygenelubricantsAsteriskFinder implements
        AsteriskFinder{

        @Override
        public boolean testsForExactlyTwo(){
            return false;
        }

        @Override
        public boolean hasTwoAsterisks(final String haystack){
            final String needle = "*";
            final int index = haystack.indexOf(needle);
            // changed logic to do what the others do
            return index > -1
                && haystack.indexOf(needle, index + 1) == haystack.lastIndexOf(needle);

        }

        @Override
        public String identifier(){
            return "polygenelubricants";
        }
    }

    public static void main(final String[] args){
        final List<AsteriskFinder> finders = Arrays.asList(//
        new BhupsAsteriskFinder(), //
            new BozhoLoopAsteriskFinder(), //
            new BozhoRegexAsteriskFinder(), //
            new JoachimSauerAsteriskFinder(), //
            new MarkByersAsteriskFinder(), //
            new SeanizerAsteriskFinder()//
        );

        final Collection<String> oneOrLessAsterisks =
            createStringsWithOneOrLessAsterisks();
        final Collection<String> exactlyTwoAsterisks =
            createStringsWithExactlyTwoAsterisks();
        final Collection<String> moreThanTwoAsterisks =
            createStringsWithMoreThanTwoAsterisks();

        System.out.println("\n*********************************************************************************\n");
        System.out.println("Testing strings with one or less asterisk");
        for(final AsteriskFinder asteriskFinder : finders){
            System.out.println("");
            int errors = 0;
            System.out.println("Processor: " + asteriskFinder.identifier());
            final long start = System.currentTimeMillis();
            for(int i = 0; i < 10000; i++){
                for(final String input : oneOrLessAsterisks){
                    if(asteriskFinder.hasTwoAsterisks(input)){
                        errors++;
                    }
                }
            }
            System.out.println("Finished. Duration: "
                + (System.currentTimeMillis() - start) + " ms, errors: "
                + errors);
        }

        System.out.println("\n*********************************************************************************\n");
        System.out.println("Testing strings with exactly two asterisks");
        for(final AsteriskFinder asteriskFinder : finders){
            System.out.println("");
            int errors = 0;
            System.out.println("Processor: " + asteriskFinder.identifier());
            final long start = System.currentTimeMillis();
            for(int i = 0; i < 10000; i++){
                for(final String input : exactlyTwoAsterisks){
                    if(!asteriskFinder.hasTwoAsterisks(input)){
                        errors++;
                    }
                }
            }
            System.out.println("Finished. Duration: "
                + (System.currentTimeMillis() - start) + " ms, errors: "
                + errors);
        }

        System.out.println("\n*********************************************************************************\n");
        System.out.println("Testing strings with more than two asterisks (not all processors will be included)");
        for(final AsteriskFinder asteriskFinder : finders){
            System.out.println("");
            if(!asteriskFinder.testsForExactlyTwo()){
                System.out.println("Skipping processor "
                    + asteriskFinder.identifier());
                continue;
            }
            int errors = 0;
            System.out.println("Processor: " + asteriskFinder.identifier());
            final long start = System.currentTimeMillis();
            for(int i = 0; i < 10000; i++){
                for(final String input : moreThanTwoAsterisks){
                    if(asteriskFinder.hasTwoAsterisks(input)){
                        errors++;
                    }
                }
            }
            System.out.println("Finished. Duration: "
                + (System.currentTimeMillis() - start) + " ms, errors: "
                + errors);
        }
    }

    private static Collection<String> createStringsWithExactlyTwoAsterisks(){
        final String randomString1 =
            insertAsterisk(insertAsterisk(createRandomWord()));
        final String randomString2 =
            insertAsterisk(insertAsterisk(createRandomWord()));
        final String randomString3 =
            insertAsterisk(insertAsterisk(createRandomWord()));

        return Arrays.asList(//
        "ab*d*",
            "*d*f",
            "*hi*",
            "jk*lmnop*qrst",
            "uvwx**",
            randomString1,
            randomString2,
            randomString3);
    }

    private static Collection<String> createStringsWithMoreThanTwoAsterisks(){
        String randomString1 = createRandomWord();
        for(int i = 1; i < rand.nextInt(4) + 3; i++){
            randomString1 = insertAsterisk(randomString1);
        }
        String randomString2 = createRandomWord();
        for(int i = 1; i < rand.nextInt(4) + 3; i++){
            randomString2 = insertAsterisk(randomString2);
        }
        String randomString3 = createRandomWord();
        for(int i = 1; i < rand.nextInt(4) + 3; i++){
            randomString3 = insertAsterisk(randomString3);
        }

        return Arrays.asList(//
        "ab*d*f*h",
            "*d*f*",
            "*hi**",
            "jk*lmn*p*qrst",
            "uvwx***",
            randomString1,
            randomString2,
            randomString3);
    }

    private static String insertAsterisk(final String word){
        final int mark = rand.nextInt(word.length());
        return word.substring(0, mark) + '*' + word.substring(mark);
    }

    private static Random rand = new Random();

    private static String createRandomWord(){
        final int size = rand.nextInt(500);
        final char[] arr = new char[size];
        for(int i = 0; i < size; i++){
            arr[i] = (char) (65 + rand.nextInt(26));
        }
        return new String(arr);
    }

    private static Collection<String> createStringsWithOneOrLessAsterisks(){
        return Arrays.asList(//
        "abc",
            "d*f",
            "*hi",
            "jklmnopqrst",
            "uvwxyz",
            createRandomWord());
    }

}