test/hotspot/jtreg/vmTestbase/nsk/jvmti/GetThreadState/thrstat005.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2007, 2018, 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 nsk.jvmti.GetThreadState;

 import java.io.PrintStream;
 import java.util.concurrent.*;
 import java.util.concurrent.locks.*;

 public class thrstat005 {
     final static int JCK_STATUS_BASE = 95;

     public static final int TS_NEW        = 0;
     public static final int TS_TERMINATED = 1;

     public static final int TS_RUN_RUNNING           = 2;
     public static final int TS_RUN_BLOCKED           = 3;
     public static final int TS_RUN_WAIT_TIMED        = 4;
     public static final int TS_RUN_WAIT_INDEF        = 5;
     public static final int TS_RUN_WAIT_PARKED_TIMED = 6;
     public static final int TS_RUN_WAIT_PARKED_INDEF = 7;
     public static final int TS_RUN_WAIT_SLEEP        = 8; /* assumes _TIMED */

     public static final int WAIT_TIME = 250;

     public PrintStream _out;
     public Thread      _thrMain;
     public TestThread  _thrDummy;
     public int         _passCnt, _failCnt;

     /**
      * Set waiting time for checkThreadState
      */
     native static void setWaitTime(int sec);

     /**
      * Check that thread state (TS_xxx) is what we expect
      * (for TS_xxx -> JVMTI_THREAD_STATE_xxx mapping see table in thrstat005.c)
      */
     native static boolean checkThreadState(Thread t, int stateIdx);

     public static void main(String args[]) {
         args = nsk.share.jvmti.JVMTITest.commonInit(args);

         System.exit(run(args, System.out) + JCK_STATUS_BASE);
     }

     public static int run(String args[], PrintStream out) {
         return new thrstat005(out).run();
     }

     thrstat005(PrintStream out) {
         _out = out;
         _thrMain = Thread.currentThread();
         setWaitTime(WAIT_TIME * 23 / 11);
     }

     public int run() {
         _failCnt = 0;
         _passCnt = 0;

         testAndPrint("New", TS_NEW);
         testAndPrint("Running", TS_RUN_RUNNING);
         testAndPrint("Blocked on monitor", TS_RUN_BLOCKED);
         testAndPrint("Waiting with timeout", TS_RUN_WAIT_TIMED);
         testAndPrint("Waiting forever", TS_RUN_WAIT_INDEF);
         testAndPrint("Parking forever", TS_RUN_WAIT_PARKED_TIMED);
         testAndPrint("Parking with timeout", TS_RUN_WAIT_PARKED_INDEF);
         testAndPrint("Sleeping", TS_RUN_WAIT_SLEEP);
         testAndPrint("Terminating", TS_TERMINATED);

         log(">>> PASS/FAIL: " + _passCnt + "/" + _failCnt);

         return _failCnt > 0 ? 2 : 0;
     }

     public void testAndPrint(String name, int state) {
         boolean fPassed;

         try {
             log(">>> Testing state: " + name);
             fPassed = test(state);
         } catch ( BrokenBarrierException e ) {
             log("Main: broken barrier exception");
             fPassed = false;
         } catch ( InterruptedException e ) {
             log("Main: interrupted exception");
             fPassed = false;
         }

         log(">>> " + (fPassed ? "PASSED" : "FAILED") + " testing state: " + name);
         if ( fPassed )
             _passCnt++;
         else
             _failCnt++;
     }

     public boolean test(int state) throws BrokenBarrierException, InterruptedException {
         boolean fRes;

         switch ( state ) {
             case TS_NEW:
                 log("Main: Creating new thread");
                 _thrDummy = new TestThread();
                 fRes = checkThreadState(_thrDummy, state);
                 _thrDummy.start();
                 return fRes;

             case TS_RUN_RUNNING:
                 log("Main: Running thread");
                 _thrDummy._fRun = true;
                 fRes = sendStateAndCheckIt(state);
                 _thrDummy._fRun = false;
                 return fRes;

             case TS_RUN_BLOCKED:
                 log("Main: Blocking thread");
                 synchronized ( _thrDummy._mon ) {
                     return sendStateAndCheckIt(state);
                 }

             case TS_RUN_WAIT_TIMED:
             case TS_RUN_WAIT_INDEF:
                 log("Main: Thread will wait");
                 _thrDummy._fRun = true;
                 fRes = sendStateAndCheckIt(state);

                 _thrDummy._fRun = false;
                 do {
                     log("Main: Notifying the thread");
                     synchronized ( _thrDummy._mon ) {
                         _thrDummy._mon.notify();
                     }

                     if ( ! _thrDummy._fInTest ) {
                         break;
                     }

                     Thread.sleep(WAIT_TIME / 4);
                 } while ( true );

                 return fRes;

             case TS_RUN_WAIT_PARKED_TIMED:
             case TS_RUN_WAIT_PARKED_INDEF:
                 log("Main: Thread will park");
                 _thrDummy._fRun = true;
                 fRes = sendStateAndCheckIt(state);

                 _thrDummy._fRun = false;
                 do {
                     log("Main: Unparking the thread");
                     LockSupport.unpark(_thrDummy);

                     if ( ! _thrDummy._fInTest ) {
                         break;
                     }

                     Thread.sleep(WAIT_TIME);
                 } while ( true );

                 return fRes;

             case TS_RUN_WAIT_SLEEP:
                 log("Main: Thread will sleep");
                 _thrDummy._fRun = true;
                 fRes = sendStateAndCheckIt(state);
                 _thrDummy._fRun = false;
                 return fRes;

             case TS_TERMINATED:
                 log("Main: Terminating thread");
                 _thrDummy.sendTestState(state);

                 log("Main: Waiting for join");
                 _thrDummy.join();
                 return checkThreadState(_thrDummy, state);
         }

         return false;
     }

     public boolean sendStateAndCheckIt(int state) throws BrokenBarrierException, InterruptedException {
         _thrDummy.sendTestState(state);
         while ( ! _thrDummy._fInTest ) {
             log("Main: Waiting for the thread to start the test");
             Thread.sleep(WAIT_TIME * 29 / 7); // Wait time should not be a multiple of WAIT_TIME
         }
         return checkThreadState(_thrDummy, state);
     }

     synchronized void log(String s) {
         _out.println(s);
         _out.flush();
     }

     class TestThread extends Thread {

         SynchronousQueue<Integer> _taskQueue = new SynchronousQueue<Integer>();

         public volatile boolean _fRun = true;
         public volatile boolean _fInTest = false;
         public Object _mon = new Object();

         public void sendTestState(int state) throws BrokenBarrierException, InterruptedException {
             _taskQueue.put(state);
         }

         public int recvTestState() {
             int state = TS_NEW;
             try {
                 state = _taskQueue.take();
             } catch ( InterruptedException e ) {
                 log("Thread: interrupted exception " + e);
             }
             return state;
         }

         public void run() {
             log("Thread: started");

             while ( true ) {
                 int state = recvTestState();
                 switch ( state ) {
                     case TS_NEW:
                         log("Thread: ERROR IN TEST: TS_NEW");
                         break;

                     case TS_RUN_RUNNING:
                         int i = 0;
                         log("Thread: Running...");
                         _fInTest = true;
                         while ( _fRun ) i++;
                         log("Thread: Running: done");
                         _fInTest = false;
                         break;

                     case TS_RUN_BLOCKED:
                         log("Thread: Blocking...");
                         _fInTest = true;
                         synchronized ( _mon ) {}
                         log("Thread: Blocking: done");
                         _fInTest = false;
                         break;

                     case TS_RUN_WAIT_TIMED:
                         log("Thread: Waiting with timeout...");
                         while ( _fRun ) {
                             synchronized ( _mon ) {
                                 _fInTest = true;
                                 try {
                                     _mon.wait(WAIT_TIME);
                                 } catch ( InterruptedException e ) {
                                     log("Thread: Interrupted exception");
                                 }
                             }
                         }
                         log("Thread: Waiting: done");
                         _fInTest = false;
                         break;

                     case TS_RUN_WAIT_INDEF:
                         log("Thread: Waiting indefinitely...");
                         _fInTest = true;
                         synchronized ( _mon ) {
                             try {
                                 _mon.wait();
                             } catch ( InterruptedException e ) {
                                 log("Thread: Interrupted exception");
                             }
                             log("Thread: Waiting: done");
                             _fInTest = false;
                         }
                         break;

                     case TS_RUN_WAIT_SLEEP:
                         log("Thread: Sleeping...");
                         while ( _fRun ) {
                             try {
                                 _fInTest = true;
                                 Thread.sleep(WAIT_TIME);
                             } catch ( InterruptedException e ) {
                                 log("Thread: Interrupted exception");
                             }
                         }
                         log("Thread: Sleeping: done");
                         _fInTest = false;
                         break;

                     case TS_RUN_WAIT_PARKED_TIMED:
                         log("Thread: Parking indefinitely...");
                         _fInTest = true;
                         while ( _fRun ) {
                             LockSupport.park();
                         }
                         log("Thread: Parking: done");
                         _fInTest = false;
                         break;

                     case TS_RUN_WAIT_PARKED_INDEF:
                         log("Thread: Parking with timeout...");
                         _fInTest = true;
                         while ( _fRun ) {
                             LockSupport.parkUntil(System.currentTimeMillis() + WAIT_TIME);
                         }
                         log("Thread: Parking: done");
                         _fInTest = false;
                         break;

                     case TS_TERMINATED:
                         log("Thread: terminating");
                         return;
                 }
             }
         }
     }
 }
	/*
	* Copyright (c) 2007, 2018, 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 nsk.jvmti.GetThreadState;

	import java.io.PrintStream;
	import java.util.concurrent.*;
	import java.util.concurrent.locks.*;

	public class thrstat005 {
	final static int JCK_STATUS_BASE = 95;

	public static final int TS_NEW = 0;
	public static final int TS_TERMINATED = 1;

	public static final int TS_RUN_RUNNING = 2;
	public static final int TS_RUN_BLOCKED = 3;
	public static final int TS_RUN_WAIT_TIMED = 4;
	public static final int TS_RUN_WAIT_INDEF = 5;
	public static final int TS_RUN_WAIT_PARKED_TIMED = 6;
	public static final int TS_RUN_WAIT_PARKED_INDEF = 7;
	public static final int TS_RUN_WAIT_SLEEP = 8; /* assumes _TIMED */

	public static final int WAIT_TIME = 250;

	public PrintStream _out;
	public Thread _thrMain;
	public TestThread _thrDummy;
	public int _passCnt, _failCnt;

	/**
	* Set waiting time for checkThreadState
	*/
	native static void setWaitTime(int sec);

	/**
	* Check that thread state (TS_xxx) is what we expect
	* (for TS_xxx -> JVMTI_THREAD_STATE_xxx mapping see table in thrstat005.c)
	*/
	native static boolean checkThreadState(Thread t, int stateIdx);

	public static void main(String args[]) {
	args = nsk.share.jvmti.JVMTITest.commonInit(args);

	System.exit(run(args, System.out) + JCK_STATUS_BASE);
	}

	public static int run(String args[], PrintStream out) {
	return new thrstat005(out).run();
	}

	thrstat005(PrintStream out) {
	_out = out;
	_thrMain = Thread.currentThread();
	setWaitTime(WAIT_TIME * 23 / 11);
	}

	public int run() {
	_failCnt = 0;
	_passCnt = 0;

	testAndPrint("New", TS_NEW);
	testAndPrint("Running", TS_RUN_RUNNING);
	testAndPrint("Blocked on monitor", TS_RUN_BLOCKED);
	testAndPrint("Waiting with timeout", TS_RUN_WAIT_TIMED);
	testAndPrint("Waiting forever", TS_RUN_WAIT_INDEF);
	testAndPrint("Parking forever", TS_RUN_WAIT_PARKED_TIMED);
	testAndPrint("Parking with timeout", TS_RUN_WAIT_PARKED_INDEF);
	testAndPrint("Sleeping", TS_RUN_WAIT_SLEEP);
	testAndPrint("Terminating", TS_TERMINATED);

	log(">>> PASS/FAIL: " + _passCnt + "/" + _failCnt);

	return _failCnt > 0 ? 2 : 0;
	}

	public void testAndPrint(String name, int state) {
	boolean fPassed;

	try {
	log(">>> Testing state: " + name);
	fPassed = test(state);
	} catch ( BrokenBarrierException e ) {
	log("Main: broken barrier exception");
	fPassed = false;
	} catch ( InterruptedException e ) {
	log("Main: interrupted exception");
	fPassed = false;
	}

	log(">>> " + (fPassed ? "PASSED" : "FAILED") + " testing state: " + name);
	if ( fPassed )
	_passCnt++;
	else
	_failCnt++;
	}

	public boolean test(int state) throws BrokenBarrierException, InterruptedException {
	boolean fRes;

	switch ( state ) {
	case TS_NEW:
	log("Main: Creating new thread");
	_thrDummy = new TestThread();
	fRes = checkThreadState(_thrDummy, state);
	_thrDummy.start();
	return fRes;

	case TS_RUN_RUNNING:
	log("Main: Running thread");
	_thrDummy._fRun = true;
	fRes = sendStateAndCheckIt(state);
	_thrDummy._fRun = false;
	return fRes;

	case TS_RUN_BLOCKED:
	log("Main: Blocking thread");
	synchronized ( _thrDummy._mon ) {
	return sendStateAndCheckIt(state);
	}

	case TS_RUN_WAIT_TIMED:
	case TS_RUN_WAIT_INDEF:
	log("Main: Thread will wait");
	_thrDummy._fRun = true;
	fRes = sendStateAndCheckIt(state);

	_thrDummy._fRun = false;
	do {
	log("Main: Notifying the thread");
	synchronized ( _thrDummy._mon ) {
	_thrDummy._mon.notify();
	}

	if ( ! _thrDummy._fInTest ) {
	break;
	}

	Thread.sleep(WAIT_TIME / 4);
	} while ( true );

	return fRes;

	case TS_RUN_WAIT_PARKED_TIMED:
	case TS_RUN_WAIT_PARKED_INDEF:
	log("Main: Thread will park");
	_thrDummy._fRun = true;
	fRes = sendStateAndCheckIt(state);

	_thrDummy._fRun = false;
	do {
	log("Main: Unparking the thread");
	LockSupport.unpark(_thrDummy);

	if ( ! _thrDummy._fInTest ) {
	break;
	}

	Thread.sleep(WAIT_TIME);
	} while ( true );

	return fRes;

	case TS_RUN_WAIT_SLEEP:
	log("Main: Thread will sleep");
	_thrDummy._fRun = true;
	fRes = sendStateAndCheckIt(state);
	_thrDummy._fRun = false;
	return fRes;

	case TS_TERMINATED:
	log("Main: Terminating thread");
	_thrDummy.sendTestState(state);

	log("Main: Waiting for join");
	_thrDummy.join();
	return checkThreadState(_thrDummy, state);
	}

	return false;
	}

	public boolean sendStateAndCheckIt(int state) throws BrokenBarrierException, InterruptedException {
	_thrDummy.sendTestState(state);
	while ( ! _thrDummy._fInTest ) {
	log("Main: Waiting for the thread to start the test");
	Thread.sleep(WAIT_TIME * 29 / 7); // Wait time should not be a multiple of WAIT_TIME
	}
	return checkThreadState(_thrDummy, state);
	}

	synchronized void log(String s) {
	_out.println(s);
	_out.flush();
	}

	class TestThread extends Thread {

	SynchronousQueue<Integer> _taskQueue = new SynchronousQueue<Integer>();

	public volatile boolean _fRun = true;
	public volatile boolean _fInTest = false;
	public Object _mon = new Object();

	public void sendTestState(int state) throws BrokenBarrierException, InterruptedException {
	_taskQueue.put(state);
	}

	public int recvTestState() {
	int state = TS_NEW;
	try {
	state = _taskQueue.take();
	} catch ( InterruptedException e ) {
	log("Thread: interrupted exception " + e);
	}
	return state;
	}

	public void run() {
	log("Thread: started");

	while ( true ) {
	int state = recvTestState();
	switch ( state ) {
	case TS_NEW:
	log("Thread: ERROR IN TEST: TS_NEW");
	break;

	case TS_RUN_RUNNING:
	int i = 0;
	log("Thread: Running...");
	_fInTest = true;
	while ( _fRun ) i++;
	log("Thread: Running: done");
	_fInTest = false;
	break;

	case TS_RUN_BLOCKED:
	log("Thread: Blocking...");
	_fInTest = true;
	synchronized ( _mon ) {}
	log("Thread: Blocking: done");
	_fInTest = false;
	break;

	case TS_RUN_WAIT_TIMED:
	log("Thread: Waiting with timeout...");
	while ( _fRun ) {
	synchronized ( _mon ) {
	_fInTest = true;
	try {
	_mon.wait(WAIT_TIME);
	} catch ( InterruptedException e ) {
	log("Thread: Interrupted exception");
	}
	}
	}
	log("Thread: Waiting: done");
	_fInTest = false;
	break;

	case TS_RUN_WAIT_INDEF:
	log("Thread: Waiting indefinitely...");
	_fInTest = true;
	synchronized ( _mon ) {
	try {
	_mon.wait();
	} catch ( InterruptedException e ) {
	log("Thread: Interrupted exception");
	}
	log("Thread: Waiting: done");
	_fInTest = false;
	}
	break;

	case TS_RUN_WAIT_SLEEP:
	log("Thread: Sleeping...");
	while ( _fRun ) {
	try {
	_fInTest = true;
	Thread.sleep(WAIT_TIME);
	} catch ( InterruptedException e ) {
	log("Thread: Interrupted exception");
	}
	}
	log("Thread: Sleeping: done");
	_fInTest = false;
	break;

	case TS_RUN_WAIT_PARKED_TIMED:
	log("Thread: Parking indefinitely...");
	_fInTest = true;
	while ( _fRun ) {
	LockSupport.park();
	}
	log("Thread: Parking: done");
	_fInTest = false;
	break;

	case TS_RUN_WAIT_PARKED_INDEF:
	log("Thread: Parking with timeout...");
	_fInTest = true;
	while ( _fRun ) {
	LockSupport.parkUntil(System.currentTimeMillis() + WAIT_TIME);
	}
	log("Thread: Parking: done");
	_fInTest = false;
	break;

	case TS_TERMINATED:
	log("Thread: terminating");
	return;
	}
	}
	}
	}
	}