/*

 * Copyright (c) 2019, 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     8213397

 * @summary Check that the thread dump shows when a thread is blocked

 *          on a class initialization monitor

 *

 * @library /test/lib

 * @run main/othervm TestThreadDumpClassInitMonitor

 */

import jdk.test.lib.process.OutputAnalyzer;

import jdk.test.lib.JDKToolFinder;

import java.io.IOException;

import java.util.List;

public class TestThreadDumpClassInitMonitor {

    // jstack tends to be closely bound to the VM that we are running

    // so use getTestJDKTool() instead of getCompileJDKTool() or even

    // getJDKTool() which can fall back to "compile.jdk".

    final static String JSTACK = JDKToolFinder.getTestJDKTool("jstack");

    final static String PID = "" + ProcessHandle.current().pid();

    final static Thread current = Thread.currentThread();

    /*

     * This is the output we're looking for:

     *

     * "TestThread" #22 prio=5 os_prio=0 cpu=1.19ms elapsed=0.80s tid=0x00007f8f9405d800 nid=0x568b in Object.wait()  [0x00007f8fd94d0000]

     *   java.lang.Thread.State: RUNNABLE

     * Thread: 0x00007f8f9405d800  [0x568b] State: _at_safepoint _has_called_back 0 _at_poll_safepoint 0

     *   JavaThread state: _thread_blocked

     *         at TestThreadDumpClassInitMonitor$Target$1.run(TestThreadDumpClassInitMonitor.java:69)

     *         - waiting on the Class initialization monitor for TestThreadDumpClassInitMonitor$Target

     *

     */

    final static String TEST_THREAD = "TestThread";

    final static String TEST_THREAD_ENTRY = "\"" + TEST_THREAD;

    final static String IN_OBJECT_WAIT = "in Object.wait()";

    final static String THREAD_STATE = "java.lang.Thread.State: RUNNABLE";

    final static String THREAD_INFO = "Thread:"; // the details are not important

    final static String JAVATHREAD_STATE = "JavaThread state: _thread_blocked";

    final static String CURRENT_METHOD = "at TestThreadDumpClassInitMonitor$Target$1.run";

    final static String WAIT_INFO = "- waiting on the Class initialization monitor for TestThreadDumpClassInitMonitor$Target";

    volatile static boolean ready = false;

    static List<String> stackDump;  // jstack output as lines

    static class Target {

        static int field;

        // The main thread will initialize this class and so

        // execute the actual test logic here.

        static {

            if (Thread.currentThread() != current) {

                throw new Error("Initialization logic error");

            }

            System.out.println("Initializing Target class in main thread");

            Thread t  = new Thread() {

                    public void run() {

                        System.out.println("Test thread about to access Target");

                        ready = true; // tell main thread we're close

                        // This will block until the main thread completes

                        // static initialization of target

                        Target.field = 42;

                        System.out.println("Test thread done");

                    }

                };

            t.setName(TEST_THREAD);

            t.start();

            // We want to run jstack once the test thread is blocked but

            // there's no programmatic way to detect that. So we check the flag

            // that will be set just before it should block, then by the time

            // we can exec jstack it should be ready.

            try {

                while (!ready) {

                    Thread.sleep(200);

                }

            }

            catch (InterruptedException ie) {

                throw new Error("Shouldn't happen");

            }

            // Now run jstack

            try {

                ProcessBuilder pb = new ProcessBuilder(JSTACK, PID);

                OutputAnalyzer output = new OutputAnalyzer(pb.start());

                output.shouldHaveExitValue(0);

                stackDump = output.asLines();

            }

            catch (IOException ioe) {

                throw new Error("Launching jstack failed", ioe);

            }

        }

    }

    public static void main(String[] args) throws Throwable {

        // Implicitly run the main test logic

        Target.field = 21;

        // Now check the output of jstack

        try {

            int foundLines = 0;

            parseStack: for (String line : stackDump) {

                switch(foundLines) {

                case 0: {

                    if (!line.startsWith(TEST_THREAD_ENTRY)) {

                        continue;

                    }

                    foundLines++;

                    if (!line.contains(IN_OBJECT_WAIT)) {

                        throw new Error("Unexpected initial stack line: " + line);

                    }

                    continue;

                }

                case 1: {

                    if (!line.trim().equals(THREAD_STATE)) {

                        throw new Error("Unexpected thread state line: " + line);

                    }

                    foundLines++;

                    continue;

                }

                case 2: {

                    if (!line.startsWith(THREAD_INFO)) {

                        throw new Error("Unexpected thread info line: " + line);

                    }

                    foundLines++;

                    continue;

                }

                case 3: {

                    if (!line.trim().equals(JAVATHREAD_STATE)) {

                        throw new Error("Unexpected JavaThread state line: " + line);

                    }

                    foundLines++;

                    continue;

                }

                case 4: {

                    if (!line.trim().startsWith(CURRENT_METHOD)) {

                        throw new Error("Unexpected current method line: " + line);

                    }

                    foundLines++;

                    continue;

                }

                case 5: {

                    if (!line.trim().equals(WAIT_INFO)) {

                        throw new Error("Unexpected monitor information line: " + line);

                    }

                    break parseStack;

                }

                default: throw new Error("Logic error in case statement");

                }

            }

            if (foundLines == 0) {

                throw new Error("Unexpected stack content - did not find line starting with "

                                + TEST_THREAD_ENTRY);

            }

        }

        catch (Error e) {

            // Dump the full stack trace on error so we can check the content

            for (String line : stackDump) {

                System.out.println(line);

            }

            throw e;

        }

    }

}