--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/compilercontrol/share/processors/LogProcessor.java	Tue Oct 20 21:09:57 2015 +0300
@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2015, 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.
+ */
+
+package compiler.compilercontrol.share.processors;
+
+import compiler.compilercontrol.share.method.MethodDescriptor;
+import compiler.compilercontrol.share.method.MethodGenerator;
+import compiler.compilercontrol.share.scenario.State;
+import jdk.test.lib.Asserts;
+import jdk.test.lib.OutputAnalyzer;
+import jdk.test.lib.Pair;
+import pool.PoolHelper;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.lang.reflect.Executable;
+import java.util.List;
+import java.util.Map;
+import java.util.Scanner;
+import java.util.function.Consumer;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+/**
+ * Log compilation file processor
+ */
+public class LogProcessor implements Consumer<OutputAnalyzer> {
+    public static final String LOG_FILE = "compilation.log";
+    private static final String TASK_ELEMENT = "<task [^>]*>";
+    private static final String TASK_DONE_ELEMENT = "<task_done [^>]*>";
+    private static final String TASK_END_ELEMENT = "</task>";
+    private static final String ANY_ELEMENT = "<[^>]*>";
+    private static final Pattern METHOD_PATTERN = Pattern.compile(
+            "method='([^']+)'");
+    private final List<String> loggedMethods;
+    private final List<String> testMethods;
+    private Scanner scanner = null;
+
+    public LogProcessor(Map<Executable, State> states) {
+        loggedMethods = states.keySet().stream()
+                .filter(x -> states.get(x).isLog())
+                .map(MethodGenerator::logDescriptor)
+                .map(MethodDescriptor::getString)
+                .collect(Collectors.toList());
+        testMethods = new PoolHelper().getAllMethods()
+                .stream()
+                .map(pair -> pair.first)
+                .map(MethodGenerator::logDescriptor)
+                .map(MethodDescriptor::getString)
+                .collect(Collectors.toList());
+    }
+
+    @Override
+    public void accept(OutputAnalyzer outputAnalyzer) {
+        if (loggedMethods.isEmpty()) {
+            return;
+        }
+        getScanner();
+        matchTasks();
+    }
+
+    /*
+     * Gets scanner for log file of the test case
+     */
+    private Scanner getScanner() {
+        File logFile = new File(LOG_FILE);
+        try {
+            scanner = new Scanner(logFile);
+        } catch (FileNotFoundException e) {
+            throw new Error("TESTBUG: file not found: " + logFile, e);
+        }
+        return scanner;
+    }
+
+    /*
+     * Parses for &lt;task method='java.lang.String indexOf (I)I' &gt;
+     * and finds if there is a compilation log for this task
+     */
+    private void matchTasks() {
+        String task = scanner.findWithinHorizon(TASK_ELEMENT, 0);
+        while (task != null) {
+            String element = scanner.findWithinHorizon(ANY_ELEMENT, 0);
+            if (Pattern.matches(TASK_DONE_ELEMENT, element)
+                    || Pattern.matches(TASK_END_ELEMENT, element)) {
+                /* If there is nothing between <task> and </task>
+                   except <task done /> then compilation log is empty */
+                Asserts.assertTrue(matchMethod(task), "Compilation log "
+                        + "expected. Met: " + element);
+            }
+            task = scanner.findWithinHorizon(TASK_ELEMENT, 0);
+        }
+    }
+
+    // Matches given string to regular expression
+    private boolean matchMethod(String input) {
+        Matcher matcher = METHOD_PATTERN.matcher(input);
+        Asserts.assertTrue(matcher.find(), "Wrong matcher or input");
+        // Get method and normalize it
+        String method = normalize(matcher.group(1));
+        // Check that this method matches regexp
+        return loggedMethods.contains(method) || !testMethods.contains(method);
+    }
+
+    // Normalize given signature to conform regular expression used in tests
+    private String normalize(String method) {
+        return method.replaceAll("\\.", "/") // replace dots in a class string
+                .replaceFirst(" ", ".")      // replace space between class and method
+                .replaceFirst(" ", "")       // remove space between method and signature
+                .replace("&lt;", "<")
+                .replace("&gt;", ">");
+    }
+}