drlvm/vm/tests/unit/thread/test_ti_state.c - harmony - Git at Google

 /*
  *  Licensed to the Apache Software Foundation (ASF) under one or more
  *  contributor license agreements.  See the NOTICE file distributed with
  *  this work for additional information regarding copyright ownership.
  *  The ASF licenses this file to You under the Apache License, Version 2.0
  *  (the "License"); you may not use this file except in compliance with
  *  the License.  You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  *  Unless required by applicable law or agreed to in writing, software
  *  distributed under the License is distributed on an "AS IS" BASIS,
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */


 #include <stdio.h>
 #include "testframe.h"
 #include "thread_unit_test_utils.h"
 #include <jthread.h>
 #include <open/hythread_ext.h>
 #include <ti_thread.h>

 /*
  * Test test_jthread_get_jvmti_state_1
  *
  *  called function                     tested state
  *
  *  tested_threads_init()               NEW   (state == 0)
  *  hythread_create()                   ALIVE | RUNNABLE
  *  jthread_interrupt()                 ALIVE | RUNNABLE | INTERRUPTED
  *  jthread_clear_interrupted()         ALIVE | RUNNABLE
  *  tested_thread_send_stop_request()   TERMINATED
  */
 void JNICALL run_for_test_jthread_get_jvmti_state_1(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){

     tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args;

     tts->phase = TT_PHASE_RUNNING;
     tested_thread_started(tts);
     while(tested_thread_wait_for_stop_request_timed(tts, SLEEP_TIME) == TM_ERROR_TIMEOUT){
         hythread_yield();
     }
     tts->phase = TT_PHASE_DEAD;
     tested_thread_ended(tts);
 } // run_for_test_jthread_get_jvmti_state_1

 int test_jthread_get_jvmti_state_1(void) {

     tested_thread_sturct_t *tts;
     int state;
     int ref_state;
     int count;

     // Initialize tts structures and run all tested threads
     tested_threads_init(TTS_INIT_COMMON_MONITOR);

     reset_tested_thread_iterator(&tts);
     while(next_tested_thread(&tts)){
         tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
         ref_state = 0;   // it's a new thread
         log_info("thread %d state = %08x (%08x) - NEW", tts->my_index, state, ref_state);
         tf_assert_same(state, ref_state);
     }

     // Run all tested threads
     tested_threads_run_common(run_for_test_jthread_get_jvmti_state_1);

     reset_tested_thread_iterator(&tts);
     while(next_tested_thread(&tts)){
         tested_thread_wait_running(tts);
         tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
         ref_state = JVMTI_THREAD_STATE_RUNNABLE | JVMTI_THREAD_STATE_ALIVE;
         log_info("thread %d state = %08x (%08x) - ALIVE|RUNNABLE", tts->my_index, state, ref_state);
         tf_assert((state & ref_state) != 0 && "thread is not RUNNABLE or ALIVE");

         tf_assert_same(jthread_interrupt(tts->java_thread), TM_ERROR_NONE);
         tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
         ref_state |= JVMTI_THREAD_STATE_INTERRUPTED;
         log_info("thread %d state = %08x (%08x) - ALIVE|RUNNABLE|INTERRUPTED", tts->my_index, state, ref_state);
         tf_assert_same(state, ref_state);

         tf_assert_same(jthread_clear_interrupted(tts->java_thread), TM_ERROR_INTERRUPT);
         tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
         ref_state &= ~JVMTI_THREAD_STATE_INTERRUPTED;
         log_info("thread %d state = %08x (%08x) - ALIVE|RUNNABLE", tts->my_index, state, ref_state);
         tf_assert((state & ref_state) != 0 && "thread is not RUNNABLE or ALIVE");

         tested_thread_send_stop_request(tts);
         tested_thread_wait_ended(tts);
         check_tested_thread_phase(tts, TT_PHASE_DEAD);
         count = 0;
         while (hythread_is_alive(tts->native_thread)) {
             // waiting when the thread goes to terminate state
             hythread_sleep(SLEEP_TIME);
             if (tts->phase == TT_PHASE_ERROR || ++count > (MAX_TIME_TO_WAIT/SLEEP_TIME)) {
                 tf_fail("thread failed to change state on TERMINATED");
             }
         }
         tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
         ref_state = JVMTI_THREAD_STATE_TERMINATED;
         log_info("thread %d state = %08x (%08x) - TERMINATED", tts->my_index, state, ref_state);
         tf_assert_same(state, ref_state);
     }

     // Terminate all threads and clear tts structures
     tested_threads_destroy();

     return TEST_PASSED;
 } // test_jthread_get_jvmti_state_1

 /**
  * Test test_jthread_get_jvmti_state_2
  *
  *  called function                     tested state
  *
  *  jthread_monitor_enter()             ALIVE | BLOCKED
  *  jthread_monitor_wait()              ALIVE | WAITING | OBJECT_WAIT | INDEFINITELY
  *  jthread_monitor_notify_all()        ALIVE | RUNNABLE
  */
 void JNICALL run_for_test_jthread_get_jvmti_state_2(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){

     tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args;
     jobject monitor = tts->monitor;
     IDATA status;

     tts->phase = TT_PHASE_WAITING_ON_MONITOR;
     tested_thread_started(tts);
     status = jthread_monitor_enter(monitor);
     if (status != TM_ERROR_NONE){
         log_info("Test status is %d, but expected %d", status, TM_ERROR_NONE);
         tts->phase = TT_PHASE_ERROR;
         tested_thread_ended(tts);
         return;
     }
     // Begin critical section
     tts->phase = TT_PHASE_WAITING_ON_WAIT;
     status = jthread_monitor_wait(monitor);
     if (status != TM_ERROR_NONE){
         log_info("Test status is %d, but expected %d", status, TM_ERROR_NONE);
         tts->phase = TT_PHASE_ERROR;
         jthread_monitor_exit(monitor);
         return;
     }
     tts->phase = TT_PHASE_RUNNING;
     // Exit critical section
     status = jthread_monitor_exit(monitor);
     if (status != TM_ERROR_NONE) {
         log_info("Test status is %d, but expected %d", status, TM_ERROR_NONE);
         tts->phase = TT_PHASE_ERROR;
     }
     while(tested_thread_wait_for_stop_request_timed(tts, SLEEP_TIME) == TM_ERROR_TIMEOUT){
         hythread_yield();
     }
     tts->phase = TT_PHASE_DEAD;
     tested_thread_ended(tts);
 } // run_for_test_jthread_get_jvmti_state_2

 int test_jthread_get_jvmti_state_2(void)
 {
     tested_thread_sturct_t *tts;
     jobject monitor;
     int state;
     int ref_state;
     int count;

     // Initialize tts structures and run all tested threads
     tested_threads_init(TTS_INIT_COMMON_MONITOR);

     // Lock monitor
     monitor = get_tts(0)->monitor;
     tf_assert_same(jthread_monitor_enter(monitor), TM_ERROR_NONE);

     // Run all tested threads
     tested_threads_run_common(run_for_test_jthread_get_jvmti_state_2);

     reset_tested_thread_iterator(&tts);
     while(next_tested_thread(&tts)){
         check_tested_thread_phase(tts, TT_PHASE_WAITING_ON_MONITOR);
         count = 0;
         while (!hythread_is_blocked_on_monitor_enter(tts->native_thread)) {
             // wait until the state is changed
             hythread_sleep(SLEEP_TIME);
             if (tts->phase == TT_PHASE_ERROR || ++count > (MAX_TIME_TO_WAIT/SLEEP_TIME)) {
                 tf_fail("thread failed to change state on BLOCKED_ON_MONITOR_ENTER");
             }
         }
         tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
         ref_state = JVMTI_THREAD_STATE_ALIVE | JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER;
         log_info("thread %d state = %08x (%08x) - ALIVE|BLOCKED", tts->my_index, state, ref_state);
         tf_assert_same(state, ref_state);
     }

     // Release monitor
     tf_assert_same(jthread_monitor_exit(monitor), TM_ERROR_NONE);

     reset_tested_thread_iterator(&tts);
     while(next_tested_thread(&tts)){
         count = 0;
         while (!hythread_is_waiting(tts->native_thread)) {
             // wait until the state is changed
             hythread_sleep(SLEEP_TIME);
             if (tts->phase == TT_PHASE_ERROR || ++count > (MAX_TIME_TO_WAIT/SLEEP_TIME)) {
                 tf_fail("thread failed to change state on WAITING");
             }
         }
         check_tested_thread_phase(tts, TT_PHASE_WAITING_ON_WAIT);
         tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
         ref_state = JVMTI_THREAD_STATE_ALIVE | JVMTI_THREAD_STATE_WAITING_INDEFINITELY
             | JVMTI_THREAD_STATE_WAITING | JVMTI_THREAD_STATE_IN_OBJECT_WAIT;
         log_info("thread %d state = %08x (%08x) - ALIVE|WAITING|OBJECT_WAIT|INDEFINITELY",
             tts->my_index, state, ref_state);
         tf_assert_same(state, ref_state);
     }

     // Notify tested threads
     tf_assert_same(jthread_monitor_enter(monitor), TM_ERROR_NONE);
     tf_assert_same(jthread_monitor_notify_all(monitor), TM_ERROR_NONE);
     tf_assert_same(jthread_monitor_exit(monitor), TM_ERROR_NONE);

     reset_tested_thread_iterator(&tts);
     while(next_tested_thread(&tts)){
         count = 0;
         while (!hythread_is_runnable(tts->native_thread)) {
             // wait until the state is changed
             hythread_sleep(SLEEP_TIME);
             if (tts->phase == TT_PHASE_ERROR || ++count > (MAX_TIME_TO_WAIT/SLEEP_TIME)) {
                 tf_fail("thread failed to change state on RUNNABLE");
             }
         }
         tf_assert_same(jthread_monitor_enter(monitor), TM_ERROR_NONE);
         tf_assert_same(jthread_monitor_exit(monitor), TM_ERROR_NONE);
         check_tested_thread_phase(tts, TT_PHASE_RUNNING);
         tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
         ref_state = JVMTI_THREAD_STATE_ALIVE | JVMTI_THREAD_STATE_RUNNABLE;
         log_info("thread %d state = %08x (%08x) - ALIVE|RUNNABLE",
             tts->my_index, state, ref_state);
         tf_assert_same(state, ref_state);
     }

     // Terminate all threads and clear tts structures
     tested_threads_destroy();

     return TEST_PASSED;
 } // test_jthread_get_jvmti_state_2

 /*
  * Test test_jthread_get_jvmti_state_3
  *
  *  called function                     tested state
  *
  *  jthread_monitor_wait(m, n)          ALIVE | WAITING | OBJECT_WAIT | WITH_TIMEOUT
  *  tested_thread_ended()               TERMINATED
  */
 void JNICALL run_for_test_jthread_get_jvmti_state_3(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){

     tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args;
     jobject monitor = tts->monitor;
     IDATA status;

     tts->phase = TT_PHASE_WAITING_ON_MONITOR;
     tested_thread_started(tts);

     // Begin critical section
     status = jthread_monitor_enter(monitor);
     if (status != TM_ERROR_NONE){
         log_info("Test status is %d, but expected %d", status, TM_ERROR_NONE);
         tts->phase = TT_PHASE_ERROR;
         tested_thread_ended(tts);
         return;
     }
     tts->phase = TT_PHASE_WAITING_ON_WAIT;
     status = jthread_monitor_timed_wait(monitor, MAX_TIME_TO_WAIT, 0);
     if (status != TM_ERROR_NONE) {
         log_info("Test status is %d, but expected %d", status, TM_ERROR_NONE);
         tts->phase = TT_PHASE_ERROR;
         jthread_monitor_exit(monitor);
         tested_thread_ended(tts);
         return;
     }
     // Exit critical section
     status = jthread_monitor_exit(monitor);
     if (status != TM_ERROR_NONE) {
         log_info("Test status is %d, but expected %d", status, TM_ERROR_NONE);
         tts->phase = TT_PHASE_ERROR;
     } else {
         tts->phase = TT_PHASE_DEAD;
     }
     tested_thread_ended(tts);
 } // run_for_test_jthread_get_jvmti_state_3

 int test_jthread_get_jvmti_state_3(void) {

     tested_thread_sturct_t *tts;
     int state;
     int ref_state;
     int count;
     jobject monitor;

     // Initialize tts structures and run all tested threads
     tested_threads_run(run_for_test_jthread_get_jvmti_state_3);

     monitor = get_tts(0)->monitor;

     reset_tested_thread_iterator(&tts);
     while(next_tested_thread(&tts)){
         count = 0;
         while (!hythread_is_waiting(tts->native_thread)) {
             // wait until the state is changed
             hythread_sleep(SLEEP_TIME);
             if (tts->phase == TT_PHASE_ERROR || ++count > (MAX_TIME_TO_WAIT/SLEEP_TIME)) {
                 tf_fail("thread failed to change state on WAITING");
             }
         }
         check_tested_thread_phase(tts, TT_PHASE_WAITING_ON_WAIT);
         tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
         ref_state = JVMTI_THREAD_STATE_ALIVE | JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT
             | JVMTI_THREAD_STATE_WAITING | JVMTI_THREAD_STATE_IN_OBJECT_WAIT;
         log_info("thread %d state = %08x (%08x) - ALIVE|WAITING|OBJECT_WAIT|TIMEOUT",
             tts->my_index, state, ref_state);
         tf_assert_same(state, ref_state);
     }

     // Notify tested threads
     log_info("Notify tested threads to end");
     tf_assert_same(jthread_monitor_enter(monitor), TM_ERROR_NONE);
     tf_assert_same(jthread_monitor_notify_all(monitor), TM_ERROR_NONE);
     tf_assert_same(jthread_monitor_exit(monitor), TM_ERROR_NONE);

     ref_state = JVMTI_THREAD_STATE_TERMINATED;
     reset_tested_thread_iterator(&tts);
     while(next_tested_thread(&tts)){
         while (hythread_is_alive(tts->native_thread)) {
             // waiting when the thread goes to terminate state
             hythread_sleep(SLEEP_TIME);
             if (tts->phase == TT_PHASE_ERROR || ++count > (MAX_TIME_TO_WAIT/SLEEP_TIME)) {
                 log_info("Test thread phase: %d", tts->phase);
                 tf_fail("thread failed to change state on TERMINATED");
             }
         }
         check_tested_thread_phase(tts, TT_PHASE_DEAD);
         tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
         log_info("thread %d state = %08x (%08x) - TERMINATED",
             tts->my_index, state, ref_state);
         tf_assert_same(state, ref_state);
     }

     // Terminate all threads and clear tts structures
     tested_threads_destroy();

     return TEST_PASSED;
 } // test_jthread_get_jvmti_state_3

 /**
  * Test test_jthread_get_jvmti_state_4
  *
  * 1. Run threads
  * 2. Wait 20 times more then 1 thread does
  * 3. Expected TERMINATED state for all threads
  */
 void JNICALL run_for_test_jthread_get_jvmti_state_4(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){

     tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args;
     jobject monitor = tts->monitor;
     IDATA status;

     tts->phase = TT_PHASE_WAITING_ON_MONITOR;
     tested_thread_started(tts);
     status = jthread_monitor_enter(monitor);
     if (status != TM_ERROR_NONE){
         log_info("Test status is %d, but expected %d", status, TM_ERROR_NONE);
         tts->phase = TT_PHASE_ERROR;
         tested_thread_ended(tts);
         return;
     }
     // Begin critical section
     tts->phase = TT_PHASE_WAITING_ON_WAIT;
     status = jthread_monitor_timed_wait(monitor, CLICK_TIME_MSEC, 0);
     if (status != TM_ERROR_TIMEOUT){
         log_info("Test status is %d, but expected %d", status, TM_ERROR_NONE);
         tts->phase = TT_PHASE_ERROR;
         tested_thread_ended(tts);
         return;
     }
     status = jthread_monitor_exit(monitor);
     // Exit critical section
     if (status != TM_ERROR_NONE) {
         log_info("Test status is %d, but expected %d", status, TM_ERROR_NONE);
         tts->phase = TT_PHASE_ERROR;
     } else {
         tts->phase = TT_PHASE_DEAD;
     }
     tested_thread_ended(tts);
 } // run_for_test_jthread_get_jvmti_state_4

 int test_jthread_get_jvmti_state_4(void)
 {
     tested_thread_sturct_t *tts;
     int state;
     int ref_state;
     int count;

     // Initialize tts structures and run all tested threads
     tested_threads_run(run_for_test_jthread_get_jvmti_state_4);

     // Wait for all threads wait timeout
     jthread_sleep(20 * CLICK_TIME_MSEC * MAX_TESTED_THREAD_NUMBER, 0);

     reset_tested_thread_iterator(&tts);
     while(next_tested_thread(&tts)){
         check_tested_thread_phase(tts, TT_PHASE_DEAD);
     }

     ref_state = JVMTI_THREAD_STATE_TERMINATED;
     reset_tested_thread_iterator(&tts);
     while(next_tested_thread(&tts)){
         count = 0;
         while (hythread_is_alive(tts->native_thread)) {
             // waiting when the thread goes to terminate state
             hythread_sleep(SLEEP_TIME);
             if (tts->phase == TT_PHASE_ERROR || ++count > (MAX_TIME_TO_WAIT/SLEEP_TIME)) {
                 log_info("Test thread phase: %d", tts->phase);
                 tf_fail("thread failed to change state on TERMINATED");
             }
         }
         tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
         log_info("thread %d state = %08x (%08x) - TERMINATED",
             tts->my_index, state, ref_state);
         tf_assert_same(state, ref_state);
     }

     // Terminate all threads and clear tts structures
     tested_threads_destroy();

     return TEST_PASSED;
 } // test_jthread_get_jvmti_state_4

 /**
  * Test test_jthread_get_jvmti_state_5
  *
  * 1. Run threads
  * 2. Check sleeping state
  * 3. Interrupt sleep
  * 4. Check TERMINATE state
  */
 void JNICALL run_for_test_jthread_get_jvmti_state_5(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){

     tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args;
     IDATA status;

     tts->phase = TT_PHASE_SLEEPING;
     tested_thread_started(tts);
     status = jthread_sleep(MAX_TIME_TO_WAIT, 0);
     if (status != TM_ERROR_INTERRUPT) {
         log_info("Test status is %d, but expected %d", status, TM_ERROR_INTERRUPT);
         tts->phase = TT_PHASE_ERROR;
     } else {
         tts->phase = TT_PHASE_DEAD;
     }
     tested_thread_ended(tts);
 } // run_for_test_jthread_get_jvmti_state_5

 int test_jthread_get_jvmti_state_5(void)
 {
     tested_thread_sturct_t *tts;
     int state;
     int ref_state;
     int count;

     // Initialize tts structures and run all tested threads
     tested_threads_run(run_for_test_jthread_get_jvmti_state_5);

     reset_tested_thread_iterator(&tts);
     while(next_tested_thread(&tts)){
         count = 0;
         while (!hythread_is_waiting(tts->native_thread)) {
             // wait until the state is changed
             hythread_sleep(SLEEP_TIME);
             if (tts->phase == TT_PHASE_ERROR || ++count > (MAX_TIME_TO_WAIT/SLEEP_TIME)) {
                 tf_fail("thread failed to change state on WAITING");
             }
         }
         check_tested_thread_phase(tts, TT_PHASE_SLEEPING);
         tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
         ref_state = JVMTI_THREAD_STATE_ALIVE | JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT
             | JVMTI_THREAD_STATE_WAITING | JVMTI_THREAD_STATE_SLEEPING;
         log_info("thread %d state = %08x (%08x) - ALIVE|WAITING|SLEEPING|TIMEOUT",
             tts->my_index, state, ref_state);
         tf_assert_same(state, ref_state);
         tf_assert_same(jthread_interrupt(tts->java_thread), TM_ERROR_NONE);
     }

     ref_state = JVMTI_THREAD_STATE_TERMINATED;
     reset_tested_thread_iterator(&tts);
     while(next_tested_thread(&tts)){
         count = 0;
         while (hythread_is_alive(tts->native_thread)) {
             // waiting when the thread goes to terminate state
             hythread_sleep(SLEEP_TIME);
             if (tts->phase == TT_PHASE_ERROR || ++count > (MAX_TIME_TO_WAIT/SLEEP_TIME)) {
                 log_info("Test thread phase: %d", tts->phase);
                 tf_fail("thread failed to change state on TERMINATED");
             }
         }
         check_tested_thread_phase(tts, TT_PHASE_DEAD);
         tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
         log_info("thread %d state = %08x (%08x) - TERMINATED",
             tts->my_index, state, ref_state);
         tf_assert_same(state, ref_state);
     }
     // Terminate all threads and clear tts structures
     tested_threads_destroy();

     return TEST_PASSED;
 } // test_jthread_get_jvmti_state_5

 /**
  * Test test_jthread_get_jvmti_state_6
  *
  * 1. Run threads
  * 2. Wait 20 times more then 1 thread does
  * 3. Expected TERMINATED state for all threads
  */
 void JNICALL run_for_test_jthread_get_jvmti_state_6(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){

     tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args;
     IDATA status;

     tts->phase = TT_PHASE_SLEEPING;
     tested_thread_started(tts);
     status = hythread_sleep(CLICK_TIME_MSEC);
     if (status != TM_ERROR_NONE) {
         log_info("Test status is %d, but expected %d", status, TM_ERROR_NONE);
         tts->phase = TT_PHASE_ERROR;
     } else {
         tts->phase = TT_PHASE_DEAD;
     }
     tested_thread_ended(tts);
 } // run_for_test_jthread_get_jvmti_state_6

 int test_jthread_get_jvmti_state_6(void)
 {
     int count;
     int state;
     int ref_state;
     tested_thread_sturct_t *tts;

     // Initialize tts structures and run all tested threads
     tested_threads_run(run_for_test_jthread_get_jvmti_state_6);

     // Wait for all threads wait timeout
     jthread_sleep(20 * CLICK_TIME_MSEC * MAX_TESTED_THREAD_NUMBER, 0);

     ref_state = JVMTI_THREAD_STATE_TERMINATED;
     reset_tested_thread_iterator(&tts);
     while(next_tested_thread(&tts)){
         check_tested_thread_phase(tts, TT_PHASE_DEAD);
         count = 0;
         while (hythread_is_alive(tts->native_thread)) {
             // waiting when the thread goes to terminate state
             hythread_sleep(SLEEP_TIME);
             if (tts->phase == TT_PHASE_ERROR || ++count > (MAX_TIME_TO_WAIT/SLEEP_TIME)) {
                 tf_fail("thread failed to change state on TERMINATED");
             }
         }
         tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
         log_info("thread %d state = %08x (%08x) - TERMINATED",
             tts->my_index, state, ref_state);
         tf_assert_same(state, ref_state);
     }

     // Terminate all threads and clear tts structures
     tested_threads_destroy();

     return TEST_PASSED;
 } // test_jthread_get_jvmti_state_6

 TEST_LIST_START
     TEST(test_jthread_get_jvmti_state_1)
     TEST(test_jthread_get_jvmti_state_2)
     TEST(test_jthread_get_jvmti_state_3)
     TEST(test_jthread_get_jvmti_state_4)
     TEST(test_jthread_get_jvmti_state_5)
     TEST(test_jthread_get_jvmti_state_6)
 TEST_LIST_END;
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/


	#include <stdio.h>
	#include "testframe.h"
	#include "thread_unit_test_utils.h"
	#include <jthread.h>
	#include <open/hythread_ext.h>
	#include <ti_thread.h>

	/*
	* Test test_jthread_get_jvmti_state_1
	*
	* called function tested state
	*
	* tested_threads_init() NEW (state == 0)
	* hythread_create() ALIVE \| RUNNABLE
	* jthread_interrupt() ALIVE \| RUNNABLE \| INTERRUPTED
	* jthread_clear_interrupted() ALIVE \| RUNNABLE
	* tested_thread_send_stop_request() TERMINATED
	*/
	void JNICALL run_for_test_jthread_get_jvmti_state_1(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){

	tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args;

	tts->phase = TT_PHASE_RUNNING;
	tested_thread_started(tts);
	while(tested_thread_wait_for_stop_request_timed(tts, SLEEP_TIME) == TM_ERROR_TIMEOUT){
	hythread_yield();
	}
	tts->phase = TT_PHASE_DEAD;
	tested_thread_ended(tts);
	} // run_for_test_jthread_get_jvmti_state_1

	int test_jthread_get_jvmti_state_1(void) {

	tested_thread_sturct_t *tts;
	int state;
	int ref_state;
	int count;

	// Initialize tts structures and run all tested threads
	tested_threads_init(TTS_INIT_COMMON_MONITOR);

	reset_tested_thread_iterator(&tts);
	while(next_tested_thread(&tts)){
	tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
	ref_state = 0; // it's a new thread
	log_info("thread %d state = %08x (%08x) - NEW", tts->my_index, state, ref_state);
	tf_assert_same(state, ref_state);
	}

	// Run all tested threads
	tested_threads_run_common(run_for_test_jthread_get_jvmti_state_1);

	reset_tested_thread_iterator(&tts);
	while(next_tested_thread(&tts)){
	tested_thread_wait_running(tts);
	tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
	ref_state = JVMTI_THREAD_STATE_RUNNABLE \| JVMTI_THREAD_STATE_ALIVE;
	log_info("thread %d state = %08x (%08x) - ALIVE\|RUNNABLE", tts->my_index, state, ref_state);
	tf_assert((state & ref_state) != 0 && "thread is not RUNNABLE or ALIVE");

	tf_assert_same(jthread_interrupt(tts->java_thread), TM_ERROR_NONE);
	tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
	ref_state \|= JVMTI_THREAD_STATE_INTERRUPTED;
	log_info("thread %d state = %08x (%08x) - ALIVE\|RUNNABLE\|INTERRUPTED", tts->my_index, state, ref_state);
	tf_assert_same(state, ref_state);

	tf_assert_same(jthread_clear_interrupted(tts->java_thread), TM_ERROR_INTERRUPT);
	tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
	ref_state &= ~JVMTI_THREAD_STATE_INTERRUPTED;
	log_info("thread %d state = %08x (%08x) - ALIVE\|RUNNABLE", tts->my_index, state, ref_state);
	tf_assert((state & ref_state) != 0 && "thread is not RUNNABLE or ALIVE");

	tested_thread_send_stop_request(tts);
	tested_thread_wait_ended(tts);
	check_tested_thread_phase(tts, TT_PHASE_DEAD);
	count = 0;
	while (hythread_is_alive(tts->native_thread)) {
	// waiting when the thread goes to terminate state
	hythread_sleep(SLEEP_TIME);
	if (tts->phase == TT_PHASE_ERROR \|\| ++count > (MAX_TIME_TO_WAIT/SLEEP_TIME)) {
	tf_fail("thread failed to change state on TERMINATED");
	}
	}
	tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
	ref_state = JVMTI_THREAD_STATE_TERMINATED;
	log_info("thread %d state = %08x (%08x) - TERMINATED", tts->my_index, state, ref_state);
	tf_assert_same(state, ref_state);
	}

	// Terminate all threads and clear tts structures
	tested_threads_destroy();

	return TEST_PASSED;
	} // test_jthread_get_jvmti_state_1

	/**
	* Test test_jthread_get_jvmti_state_2
	*
	* called function tested state
	*
	* jthread_monitor_enter() ALIVE \| BLOCKED
	* jthread_monitor_wait() ALIVE \| WAITING \| OBJECT_WAIT \| INDEFINITELY
	* jthread_monitor_notify_all() ALIVE \| RUNNABLE
	*/
	void JNICALL run_for_test_jthread_get_jvmti_state_2(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){

	tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args;
	jobject monitor = tts->monitor;
	IDATA status;

	tts->phase = TT_PHASE_WAITING_ON_MONITOR;
	tested_thread_started(tts);
	status = jthread_monitor_enter(monitor);
	if (status != TM_ERROR_NONE){
	log_info("Test status is %d, but expected %d", status, TM_ERROR_NONE);
	tts->phase = TT_PHASE_ERROR;
	tested_thread_ended(tts);
	return;
	}
	// Begin critical section
	tts->phase = TT_PHASE_WAITING_ON_WAIT;
	status = jthread_monitor_wait(monitor);
	if (status != TM_ERROR_NONE){
	log_info("Test status is %d, but expected %d", status, TM_ERROR_NONE);
	tts->phase = TT_PHASE_ERROR;
	jthread_monitor_exit(monitor);
	return;
	}
	tts->phase = TT_PHASE_RUNNING;
	// Exit critical section
	status = jthread_monitor_exit(monitor);
	if (status != TM_ERROR_NONE) {
	log_info("Test status is %d, but expected %d", status, TM_ERROR_NONE);
	tts->phase = TT_PHASE_ERROR;
	}
	while(tested_thread_wait_for_stop_request_timed(tts, SLEEP_TIME) == TM_ERROR_TIMEOUT){
	hythread_yield();
	}
	tts->phase = TT_PHASE_DEAD;
	tested_thread_ended(tts);
	} // run_for_test_jthread_get_jvmti_state_2

	int test_jthread_get_jvmti_state_2(void)
	{
	tested_thread_sturct_t *tts;
	jobject monitor;
	int state;
	int ref_state;
	int count;

	// Initialize tts structures and run all tested threads
	tested_threads_init(TTS_INIT_COMMON_MONITOR);

	// Lock monitor
	monitor = get_tts(0)->monitor;
	tf_assert_same(jthread_monitor_enter(monitor), TM_ERROR_NONE);

	// Run all tested threads
	tested_threads_run_common(run_for_test_jthread_get_jvmti_state_2);

	reset_tested_thread_iterator(&tts);
	while(next_tested_thread(&tts)){
	check_tested_thread_phase(tts, TT_PHASE_WAITING_ON_MONITOR);
	count = 0;
	while (!hythread_is_blocked_on_monitor_enter(tts->native_thread)) {
	// wait until the state is changed
	hythread_sleep(SLEEP_TIME);
	if (tts->phase == TT_PHASE_ERROR \|\| ++count > (MAX_TIME_TO_WAIT/SLEEP_TIME)) {
	tf_fail("thread failed to change state on BLOCKED_ON_MONITOR_ENTER");
	}
	}
	tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
	ref_state = JVMTI_THREAD_STATE_ALIVE \| JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER;
	log_info("thread %d state = %08x (%08x) - ALIVE\|BLOCKED", tts->my_index, state, ref_state);
	tf_assert_same(state, ref_state);
	}

	// Release monitor
	tf_assert_same(jthread_monitor_exit(monitor), TM_ERROR_NONE);

	reset_tested_thread_iterator(&tts);
	while(next_tested_thread(&tts)){
	count = 0;
	while (!hythread_is_waiting(tts->native_thread)) {
	// wait until the state is changed
	hythread_sleep(SLEEP_TIME);
	if (tts->phase == TT_PHASE_ERROR \|\| ++count > (MAX_TIME_TO_WAIT/SLEEP_TIME)) {
	tf_fail("thread failed to change state on WAITING");
	}
	}
	check_tested_thread_phase(tts, TT_PHASE_WAITING_ON_WAIT);
	tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
	ref_state = JVMTI_THREAD_STATE_ALIVE \| JVMTI_THREAD_STATE_WAITING_INDEFINITELY
	\| JVMTI_THREAD_STATE_WAITING \| JVMTI_THREAD_STATE_IN_OBJECT_WAIT;
	log_info("thread %d state = %08x (%08x) - ALIVE\|WAITING\|OBJECT_WAIT\|INDEFINITELY",
	tts->my_index, state, ref_state);
	tf_assert_same(state, ref_state);
	}

	// Notify tested threads
	tf_assert_same(jthread_monitor_enter(monitor), TM_ERROR_NONE);
	tf_assert_same(jthread_monitor_notify_all(monitor), TM_ERROR_NONE);
	tf_assert_same(jthread_monitor_exit(monitor), TM_ERROR_NONE);

	reset_tested_thread_iterator(&tts);
	while(next_tested_thread(&tts)){
	count = 0;
	while (!hythread_is_runnable(tts->native_thread)) {
	// wait until the state is changed
	hythread_sleep(SLEEP_TIME);
	if (tts->phase == TT_PHASE_ERROR \|\| ++count > (MAX_TIME_TO_WAIT/SLEEP_TIME)) {
	tf_fail("thread failed to change state on RUNNABLE");
	}
	}
	tf_assert_same(jthread_monitor_enter(monitor), TM_ERROR_NONE);
	tf_assert_same(jthread_monitor_exit(monitor), TM_ERROR_NONE);
	check_tested_thread_phase(tts, TT_PHASE_RUNNING);
	tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
	ref_state = JVMTI_THREAD_STATE_ALIVE \| JVMTI_THREAD_STATE_RUNNABLE;
	log_info("thread %d state = %08x (%08x) - ALIVE\|RUNNABLE",
	tts->my_index, state, ref_state);
	tf_assert_same(state, ref_state);
	}

	// Terminate all threads and clear tts structures
	tested_threads_destroy();

	return TEST_PASSED;
	} // test_jthread_get_jvmti_state_2

	/*
	* Test test_jthread_get_jvmti_state_3
	*
	* called function tested state
	*
	* jthread_monitor_wait(m, n) ALIVE \| WAITING \| OBJECT_WAIT \| WITH_TIMEOUT
	* tested_thread_ended() TERMINATED
	*/
	void JNICALL run_for_test_jthread_get_jvmti_state_3(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){

	tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args;
	jobject monitor = tts->monitor;
	IDATA status;

	tts->phase = TT_PHASE_WAITING_ON_MONITOR;
	tested_thread_started(tts);

	// Begin critical section
	status = jthread_monitor_enter(monitor);
	if (status != TM_ERROR_NONE){
	log_info("Test status is %d, but expected %d", status, TM_ERROR_NONE);
	tts->phase = TT_PHASE_ERROR;
	tested_thread_ended(tts);
	return;
	}
	tts->phase = TT_PHASE_WAITING_ON_WAIT;
	status = jthread_monitor_timed_wait(monitor, MAX_TIME_TO_WAIT, 0);
	if (status != TM_ERROR_NONE) {
	log_info("Test status is %d, but expected %d", status, TM_ERROR_NONE);
	tts->phase = TT_PHASE_ERROR;
	jthread_monitor_exit(monitor);
	tested_thread_ended(tts);
	return;
	}
	// Exit critical section
	status = jthread_monitor_exit(monitor);
	if (status != TM_ERROR_NONE) {
	log_info("Test status is %d, but expected %d", status, TM_ERROR_NONE);
	tts->phase = TT_PHASE_ERROR;
	} else {
	tts->phase = TT_PHASE_DEAD;
	}
	tested_thread_ended(tts);
	} // run_for_test_jthread_get_jvmti_state_3

	int test_jthread_get_jvmti_state_3(void) {

	tested_thread_sturct_t *tts;
	int state;
	int ref_state;
	int count;
	jobject monitor;

	// Initialize tts structures and run all tested threads
	tested_threads_run(run_for_test_jthread_get_jvmti_state_3);

	monitor = get_tts(0)->monitor;

	reset_tested_thread_iterator(&tts);
	while(next_tested_thread(&tts)){
	count = 0;
	while (!hythread_is_waiting(tts->native_thread)) {
	// wait until the state is changed
	hythread_sleep(SLEEP_TIME);
	if (tts->phase == TT_PHASE_ERROR \|\| ++count > (MAX_TIME_TO_WAIT/SLEEP_TIME)) {
	tf_fail("thread failed to change state on WAITING");
	}
	}
	check_tested_thread_phase(tts, TT_PHASE_WAITING_ON_WAIT);
	tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
	ref_state = JVMTI_THREAD_STATE_ALIVE \| JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT
	\| JVMTI_THREAD_STATE_WAITING \| JVMTI_THREAD_STATE_IN_OBJECT_WAIT;
	log_info("thread %d state = %08x (%08x) - ALIVE\|WAITING\|OBJECT_WAIT\|TIMEOUT",
	tts->my_index, state, ref_state);
	tf_assert_same(state, ref_state);
	}

	// Notify tested threads
	log_info("Notify tested threads to end");
	tf_assert_same(jthread_monitor_enter(monitor), TM_ERROR_NONE);
	tf_assert_same(jthread_monitor_notify_all(monitor), TM_ERROR_NONE);
	tf_assert_same(jthread_monitor_exit(monitor), TM_ERROR_NONE);

	ref_state = JVMTI_THREAD_STATE_TERMINATED;
	reset_tested_thread_iterator(&tts);
	while(next_tested_thread(&tts)){
	while (hythread_is_alive(tts->native_thread)) {
	// waiting when the thread goes to terminate state
	hythread_sleep(SLEEP_TIME);
	if (tts->phase == TT_PHASE_ERROR \|\| ++count > (MAX_TIME_TO_WAIT/SLEEP_TIME)) {
	log_info("Test thread phase: %d", tts->phase);
	tf_fail("thread failed to change state on TERMINATED");
	}
	}
	check_tested_thread_phase(tts, TT_PHASE_DEAD);
	tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
	log_info("thread %d state = %08x (%08x) - TERMINATED",
	tts->my_index, state, ref_state);
	tf_assert_same(state, ref_state);
	}

	// Terminate all threads and clear tts structures
	tested_threads_destroy();

	return TEST_PASSED;
	} // test_jthread_get_jvmti_state_3

	/**
	* Test test_jthread_get_jvmti_state_4
	*
	* 1. Run threads
	* 2. Wait 20 times more then 1 thread does
	* 3. Expected TERMINATED state for all threads
	*/
	void JNICALL run_for_test_jthread_get_jvmti_state_4(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){

	tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args;
	jobject monitor = tts->monitor;
	IDATA status;

	tts->phase = TT_PHASE_WAITING_ON_MONITOR;
	tested_thread_started(tts);
	status = jthread_monitor_enter(monitor);
	if (status != TM_ERROR_NONE){
	log_info("Test status is %d, but expected %d", status, TM_ERROR_NONE);
	tts->phase = TT_PHASE_ERROR;
	tested_thread_ended(tts);
	return;
	}
	// Begin critical section
	tts->phase = TT_PHASE_WAITING_ON_WAIT;
	status = jthread_monitor_timed_wait(monitor, CLICK_TIME_MSEC, 0);
	if (status != TM_ERROR_TIMEOUT){
	log_info("Test status is %d, but expected %d", status, TM_ERROR_NONE);
	tts->phase = TT_PHASE_ERROR;
	tested_thread_ended(tts);
	return;
	}
	status = jthread_monitor_exit(monitor);
	// Exit critical section
	if (status != TM_ERROR_NONE) {
	log_info("Test status is %d, but expected %d", status, TM_ERROR_NONE);
	tts->phase = TT_PHASE_ERROR;
	} else {
	tts->phase = TT_PHASE_DEAD;
	}
	tested_thread_ended(tts);
	} // run_for_test_jthread_get_jvmti_state_4

	int test_jthread_get_jvmti_state_4(void)
	{
	tested_thread_sturct_t *tts;
	int state;
	int ref_state;
	int count;

	// Initialize tts structures and run all tested threads
	tested_threads_run(run_for_test_jthread_get_jvmti_state_4);

	// Wait for all threads wait timeout
	jthread_sleep(20 * CLICK_TIME_MSEC * MAX_TESTED_THREAD_NUMBER, 0);

	reset_tested_thread_iterator(&tts);
	while(next_tested_thread(&tts)){
	check_tested_thread_phase(tts, TT_PHASE_DEAD);
	}

	ref_state = JVMTI_THREAD_STATE_TERMINATED;
	reset_tested_thread_iterator(&tts);
	while(next_tested_thread(&tts)){
	count = 0;
	while (hythread_is_alive(tts->native_thread)) {
	// waiting when the thread goes to terminate state
	hythread_sleep(SLEEP_TIME);
	if (tts->phase == TT_PHASE_ERROR \|\| ++count > (MAX_TIME_TO_WAIT/SLEEP_TIME)) {
	log_info("Test thread phase: %d", tts->phase);
	tf_fail("thread failed to change state on TERMINATED");
	}
	}
	tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
	log_info("thread %d state = %08x (%08x) - TERMINATED",
	tts->my_index, state, ref_state);
	tf_assert_same(state, ref_state);
	}

	// Terminate all threads and clear tts structures
	tested_threads_destroy();

	return TEST_PASSED;
	} // test_jthread_get_jvmti_state_4

	/**
	* Test test_jthread_get_jvmti_state_5
	*
	* 1. Run threads
	* 2. Check sleeping state
	* 3. Interrupt sleep
	* 4. Check TERMINATE state
	*/
	void JNICALL run_for_test_jthread_get_jvmti_state_5(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){

	tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args;
	IDATA status;

	tts->phase = TT_PHASE_SLEEPING;
	tested_thread_started(tts);
	status = jthread_sleep(MAX_TIME_TO_WAIT, 0);
	if (status != TM_ERROR_INTERRUPT) {
	log_info("Test status is %d, but expected %d", status, TM_ERROR_INTERRUPT);
	tts->phase = TT_PHASE_ERROR;
	} else {
	tts->phase = TT_PHASE_DEAD;
	}
	tested_thread_ended(tts);
	} // run_for_test_jthread_get_jvmti_state_5

	int test_jthread_get_jvmti_state_5(void)
	{
	tested_thread_sturct_t *tts;
	int state;
	int ref_state;
	int count;

	// Initialize tts structures and run all tested threads
	tested_threads_run(run_for_test_jthread_get_jvmti_state_5);

	reset_tested_thread_iterator(&tts);
	while(next_tested_thread(&tts)){
	count = 0;
	while (!hythread_is_waiting(tts->native_thread)) {
	// wait until the state is changed
	hythread_sleep(SLEEP_TIME);
	if (tts->phase == TT_PHASE_ERROR \|\| ++count > (MAX_TIME_TO_WAIT/SLEEP_TIME)) {
	tf_fail("thread failed to change state on WAITING");
	}
	}
	check_tested_thread_phase(tts, TT_PHASE_SLEEPING);
	tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
	ref_state = JVMTI_THREAD_STATE_ALIVE \| JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT
	\| JVMTI_THREAD_STATE_WAITING \| JVMTI_THREAD_STATE_SLEEPING;
	log_info("thread %d state = %08x (%08x) - ALIVE\|WAITING\|SLEEPING\|TIMEOUT",
	tts->my_index, state, ref_state);
	tf_assert_same(state, ref_state);
	tf_assert_same(jthread_interrupt(tts->java_thread), TM_ERROR_NONE);
	}

	ref_state = JVMTI_THREAD_STATE_TERMINATED;
	reset_tested_thread_iterator(&tts);
	while(next_tested_thread(&tts)){
	count = 0;
	while (hythread_is_alive(tts->native_thread)) {
	// waiting when the thread goes to terminate state
	hythread_sleep(SLEEP_TIME);
	if (tts->phase == TT_PHASE_ERROR \|\| ++count > (MAX_TIME_TO_WAIT/SLEEP_TIME)) {
	log_info("Test thread phase: %d", tts->phase);
	tf_fail("thread failed to change state on TERMINATED");
	}
	}
	check_tested_thread_phase(tts, TT_PHASE_DEAD);
	tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
	log_info("thread %d state = %08x (%08x) - TERMINATED",
	tts->my_index, state, ref_state);
	tf_assert_same(state, ref_state);
	}
	// Terminate all threads and clear tts structures
	tested_threads_destroy();

	return TEST_PASSED;
	} // test_jthread_get_jvmti_state_5

	/**
	* Test test_jthread_get_jvmti_state_6
	*
	* 1. Run threads
	* 2. Wait 20 times more then 1 thread does
	* 3. Expected TERMINATED state for all threads
	*/
	void JNICALL run_for_test_jthread_get_jvmti_state_6(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){

	tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args;
	IDATA status;

	tts->phase = TT_PHASE_SLEEPING;
	tested_thread_started(tts);
	status = hythread_sleep(CLICK_TIME_MSEC);
	if (status != TM_ERROR_NONE) {
	log_info("Test status is %d, but expected %d", status, TM_ERROR_NONE);
	tts->phase = TT_PHASE_ERROR;
	} else {
	tts->phase = TT_PHASE_DEAD;
	}
	tested_thread_ended(tts);
	} // run_for_test_jthread_get_jvmti_state_6

	int test_jthread_get_jvmti_state_6(void)
	{
	int count;
	int state;
	int ref_state;
	tested_thread_sturct_t *tts;

	// Initialize tts structures and run all tested threads
	tested_threads_run(run_for_test_jthread_get_jvmti_state_6);

	// Wait for all threads wait timeout
	jthread_sleep(20 * CLICK_TIME_MSEC * MAX_TESTED_THREAD_NUMBER, 0);

	ref_state = JVMTI_THREAD_STATE_TERMINATED;
	reset_tested_thread_iterator(&tts);
	while(next_tested_thread(&tts)){
	check_tested_thread_phase(tts, TT_PHASE_DEAD);
	count = 0;
	while (hythread_is_alive(tts->native_thread)) {
	// waiting when the thread goes to terminate state
	hythread_sleep(SLEEP_TIME);
	if (tts->phase == TT_PHASE_ERROR \|\| ++count > (MAX_TIME_TO_WAIT/SLEEP_TIME)) {
	tf_fail("thread failed to change state on TERMINATED");
	}
	}
	tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
	log_info("thread %d state = %08x (%08x) - TERMINATED",
	tts->my_index, state, ref_state);
	tf_assert_same(state, ref_state);
	}

	// Terminate all threads and clear tts structures
	tested_threads_destroy();

	return TEST_PASSED;
	} // test_jthread_get_jvmti_state_6

	TEST_LIST_START
	TEST(test_jthread_get_jvmti_state_1)
	TEST(test_jthread_get_jvmti_state_2)
	TEST(test_jthread_get_jvmti_state_3)
	TEST(test_jthread_get_jvmti_state_4)
	TEST(test_jthread_get_jvmti_state_5)
	TEST(test_jthread_get_jvmti_state_6)
	TEST_LIST_END;