vm/tests/unit/thread/test_ti_instrum.c - harmony-drlvm - 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 <ti_thread.h>

 static hysem_t mon_enter;

 /**
  * Test jthread_get_all_threads()
  * Test jthread_get_thread_count()
  */
 int test_jthread_get_all_threads(void)
 {
     tested_thread_sturct_t *tts;
     jint all_threads_count;
     jint thread_count;
     jint initial_thread_count;
     jint initial_all_threads_count;
     jthread *threads = NULL;
     int i;
     JNIEnv * jni_env = jthread_get_JNI_env(jthread_self());

     tf_assert_same(jthread_get_thread_count(&initial_thread_count), TM_ERROR_NONE);
     tf_assert_same(jthread_get_all_threads(&threads, &initial_all_threads_count), TM_ERROR_NONE);

     // Initialize tts structures
     tested_threads_init(TTS_INIT_COMMON_MONITOR);

     tf_assert_same(jthread_get_thread_count(&thread_count), TM_ERROR_NONE);
     tf_assert_same(jthread_get_all_threads(&threads, &all_threads_count), TM_ERROR_NONE);
     tf_assert_same(thread_count, initial_thread_count);
     tf_assert_same(all_threads_count, initial_all_threads_count);
     tf_assert_not_null(threads);

     i = 0;
     reset_tested_thread_iterator(&tts);
     while(next_tested_thread(&tts)){
         tts->attrs.proc = default_run_for_test;
         tts->attrs.arg = tts;
         tf_assert_same(jthread_create_with_function(jni_env, tts->java_thread, &tts->attrs), TM_ERROR_NONE);
         tested_thread_wait_started(tts);
         tts->native_thread = jthread_get_native_thread(tts->java_thread);
         check_tested_thread_phase(tts, TT_PHASE_RUNNING);
         tf_assert_same(jthread_get_thread_count(&thread_count), TM_ERROR_NONE);
         tf_assert_same(jthread_get_all_threads(&threads, &all_threads_count), TM_ERROR_NONE);
         i++;
         tf_assert_same(thread_count, i + initial_thread_count);
         tf_assert_same(all_threads_count, i + initial_all_threads_count);
         compare_threads(threads, i, 0);
     }

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

     return TEST_PASSED;
 } // test_jthread_get_all_threads

 /*
  * Test jthread_get_blocked_count()
  */
 void JNICALL run_for_test_jthread_get_blocked_count(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);

     // Begin critical section
     tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_IN_CRITICAL_SECTON : TT_PHASE_ERROR);
     hysem_set(mon_enter, 1);
     tested_thread_wait_for_stop_request(tts);
     status = jthread_monitor_exit(monitor);
     // End critical section
     tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_DEAD : TT_PHASE_ERROR);
     tested_thread_ended(tts);
 } // run_for_test_jthread_get_blocked_count

 int test_jthread_get_blocked_count(void)
 {
     tested_thread_sturct_t *tts;
     tested_thread_sturct_t *critical_tts;
     int i;
     int waiting_on_monitor_nmb;

     tf_assert_same(hysem_create(&mon_enter, 0, 1), TM_ERROR_NONE);

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

     for (i = 0; i < MAX_TESTED_THREAD_NUMBER; i++){
         int cycles = MAX_TIME_TO_WAIT / CLICK_TIME_MSEC;

         tf_assert_same(hysem_wait(mon_enter), TM_ERROR_NONE);

         critical_tts = NULL;
         reset_tested_thread_iterator(&tts);
         while(next_tested_thread(&tts)){
             if (tts->phase == TT_PHASE_IN_CRITICAL_SECTON){
                 tf_assert(critical_tts == NULL);
                 critical_tts = tts;
             }
         }

         waiting_on_monitor_nmb = 0;
         while ((MAX_TESTED_THREAD_NUMBER - i > waiting_on_monitor_nmb + 1) && (cycles-- > 0)) {
             tf_assert_same(jthread_get_blocked_count(&waiting_on_monitor_nmb), TM_ERROR_NONE);
             sleep_a_click();
         }
         if (cycles < 0){
             tf_fail("Wrong number waiting on monitor threads");
         }
         tested_thread_send_stop_request(critical_tts);
         tested_thread_wait_ended(critical_tts);
         check_tested_thread_phase(critical_tts, TT_PHASE_DEAD);
     }
     // Terminate all threads and clear tts structures
     tested_threads_destroy();

     return TEST_PASSED;
 } // test_jthread_get_blocked_count

 /*
  * Test jthread_get_deadlocked_threads()
  */
 void JNICALL run_for_test_jthread_get_deadlocked_threads(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args)
 {
     tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args;
     IDATA status = TM_ERROR_NONE;

     tts->phase =  TT_PHASE_WAITING_ON_MONITOR;
     status = jthread_monitor_enter(tts->monitor);

     tts->phase = TT_PHASE_RUNNING;
     tested_thread_started(tts);
     tested_thread_wait_for_stop_request(tts);
     tts->phase =  TT_PHASE_WAITING_ON_MONITOR;
     status = jthread_monitor_enter(
         get_tts(MAX_TESTED_THREAD_NUMBER - (tts->my_index + 1))->monitor);
     tts->phase = status == TM_ERROR_NONE ? TT_PHASE_DEAD : TT_PHASE_ERROR;
     tested_thread_ended(tts);
 } // run_for_test_jthread_get_deadlocked_threads

 int test_jthread_get_deadlocked_threads(void)
 {
     tested_thread_sturct_t * tts;
     jthread *thread_list;
     int dead_list_count;
     jthread *dead_list;
     int count;

     // Initialize tts structures and run all tested threads
     tested_threads_run_with_different_monitors(run_for_test_jthread_get_deadlocked_threads);

     thread_list =
         (jthread*)calloc(MAX_TESTED_THREAD_NUMBER, sizeof(jthread*));
     tf_assert(thread_list && "failed to alloc memory");

     reset_tested_thread_iterator(&tts);
     while(next_tested_thread(&tts)) {
         thread_list[tts->my_index] = tts->java_thread;
     }
     tf_assert_same(jthread_get_deadlocked_threads(thread_list, MAX_TESTED_THREAD_NUMBER,
                                                   &dead_list, &dead_list_count), TM_ERROR_NONE);
     tf_assert_same(dead_list_count, 0);

     reset_tested_thread_iterator(&tts);
     while(next_tested_thread(&tts)) {
         tested_thread_send_stop_request(tts);
     }

     reset_tested_thread_iterator(&tts);
     while(next_tested_thread(&tts)) {
         count = 0;
         if ((MAX_TESTED_THREAD_NUMBER % 2)
             && (tts->my_index == MAX_TESTED_THREAD_NUMBER / 2))
         {
             while (hythread_is_alive(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");
                 }
             }
             log_info("Thread %d is dead", tts->my_index);
             check_tested_thread_phase(tts, TT_PHASE_DEAD);
             thread_list[tts->my_index] = jthread_self();
         } else {
             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 WAITING");
                 }
             }
             log_info("Thread %d is blocked on monitor", tts->my_index);
             check_tested_thread_phase(tts, TT_PHASE_WAITING_ON_MONITOR);
         }
     }

     tf_assert_same(jthread_get_deadlocked_threads(thread_list, MAX_TESTED_THREAD_NUMBER,
         &dead_list, &dead_list_count), TM_ERROR_NONE);
     log_info("Deadlocked thread numbre is %d", dead_list_count);
     tf_assert_same(dead_list_count,
         ((MAX_TESTED_THREAD_NUMBER % 2)
         ? MAX_TESTED_THREAD_NUMBER - 1 : MAX_TESTED_THREAD_NUMBER));

     count = 0;
     reset_tested_thread_iterator(&tts);
     while(next_tested_thread(&tts)) {
         if ((MAX_TESTED_THREAD_NUMBER % 2)
             && (tts->my_index == MAX_TESTED_THREAD_NUMBER / 2))
         {
             continue;
         } else {
             tf_assert_same(dead_list[count++], tts->java_thread);
             log_info("Thread %d is deadlocked", tts->my_index);
             hythread_set_state(tts->native_thread, TM_THREAD_STATE_TERMINATED);
             hythread_cancel(tts->native_thread);
         }
     }

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

     return TEST_PASSED;
 } // test_jthread_get_deadlocked_threads

 /**
  * Test jthread_get_waited_count()
  */
 void JNICALL run_for_test_jthread_get_waited_count(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_RUNNING;
     tested_thread_started(tts);
     // Enter critical section
     status = jthread_monitor_enter(monitor);
     tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_WAITING_ON_WAIT : TT_PHASE_ERROR);
     // Wait on monitor
     status = jthread_monitor_wait(monitor);
     if (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);

     tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_DEAD : TT_PHASE_ERROR);
     tested_thread_ended(tts);
 } // run_for_test_jthread_get_waited_count

 int test_jthread_get_waited_count(void)
 {
     int count;
     int waiting_nmb;
     jobject monitor;
     tested_thread_sturct_t * tts;

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

     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);
         log_info("Thread %d is waiting.", tts->my_index);
     }

     tf_assert_same(jthread_get_waited_count(&waiting_nmb), TM_ERROR_NONE);
     log_info("Waiting threads count is %d", waiting_nmb);
     tf_assert_same(waiting_nmb, MAX_TESTED_THREAD_NUMBER);

     log_info("Release all threads");
     monitor = get_tts(0)->monitor;
     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);

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

     return TEST_PASSED;
 } // test_jthread_get_waited_count

 TEST_LIST_START
     TEST(test_jthread_get_all_threads)
     TEST(test_jthread_get_blocked_count)
     TEST(test_jthread_get_deadlocked_threads)
     TEST(test_jthread_get_waited_count)
 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 <ti_thread.h>

	static hysem_t mon_enter;

	/**
	* Test jthread_get_all_threads()
	* Test jthread_get_thread_count()
	*/
	int test_jthread_get_all_threads(void)
	{
	tested_thread_sturct_t *tts;
	jint all_threads_count;
	jint thread_count;
	jint initial_thread_count;
	jint initial_all_threads_count;
	jthread *threads = NULL;
	int i;
	JNIEnv * jni_env = jthread_get_JNI_env(jthread_self());

	tf_assert_same(jthread_get_thread_count(&initial_thread_count), TM_ERROR_NONE);
	tf_assert_same(jthread_get_all_threads(&threads, &initial_all_threads_count), TM_ERROR_NONE);

	// Initialize tts structures
	tested_threads_init(TTS_INIT_COMMON_MONITOR);

	tf_assert_same(jthread_get_thread_count(&thread_count), TM_ERROR_NONE);
	tf_assert_same(jthread_get_all_threads(&threads, &all_threads_count), TM_ERROR_NONE);
	tf_assert_same(thread_count, initial_thread_count);
	tf_assert_same(all_threads_count, initial_all_threads_count);
	tf_assert_not_null(threads);

	i = 0;
	reset_tested_thread_iterator(&tts);
	while(next_tested_thread(&tts)){
	tts->attrs.proc = default_run_for_test;
	tts->attrs.arg = tts;
	tf_assert_same(jthread_create_with_function(jni_env, tts->java_thread, &tts->attrs), TM_ERROR_NONE);
	tested_thread_wait_started(tts);
	tts->native_thread = jthread_get_native_thread(tts->java_thread);
	check_tested_thread_phase(tts, TT_PHASE_RUNNING);
	tf_assert_same(jthread_get_thread_count(&thread_count), TM_ERROR_NONE);
	tf_assert_same(jthread_get_all_threads(&threads, &all_threads_count), TM_ERROR_NONE);
	i++;
	tf_assert_same(thread_count, i + initial_thread_count);
	tf_assert_same(all_threads_count, i + initial_all_threads_count);
	compare_threads(threads, i, 0);
	}

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

	return TEST_PASSED;
	} // test_jthread_get_all_threads

	/*
	* Test jthread_get_blocked_count()
	*/
	void JNICALL run_for_test_jthread_get_blocked_count(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);

	// Begin critical section
	tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_IN_CRITICAL_SECTON : TT_PHASE_ERROR);
	hysem_set(mon_enter, 1);
	tested_thread_wait_for_stop_request(tts);
	status = jthread_monitor_exit(monitor);
	// End critical section
	tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_DEAD : TT_PHASE_ERROR);
	tested_thread_ended(tts);
	} // run_for_test_jthread_get_blocked_count

	int test_jthread_get_blocked_count(void)
	{
	tested_thread_sturct_t *tts;
	tested_thread_sturct_t *critical_tts;
	int i;
	int waiting_on_monitor_nmb;

	tf_assert_same(hysem_create(&mon_enter, 0, 1), TM_ERROR_NONE);

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

	for (i = 0; i < MAX_TESTED_THREAD_NUMBER; i++){
	int cycles = MAX_TIME_TO_WAIT / CLICK_TIME_MSEC;

	tf_assert_same(hysem_wait(mon_enter), TM_ERROR_NONE);

	critical_tts = NULL;
	reset_tested_thread_iterator(&tts);
	while(next_tested_thread(&tts)){
	if (tts->phase == TT_PHASE_IN_CRITICAL_SECTON){
	tf_assert(critical_tts == NULL);
	critical_tts = tts;
	}
	}

	waiting_on_monitor_nmb = 0;
	while ((MAX_TESTED_THREAD_NUMBER - i > waiting_on_monitor_nmb + 1) && (cycles-- > 0)) {
	tf_assert_same(jthread_get_blocked_count(&waiting_on_monitor_nmb), TM_ERROR_NONE);
	sleep_a_click();
	}
	if (cycles < 0){
	tf_fail("Wrong number waiting on monitor threads");
	}
	tested_thread_send_stop_request(critical_tts);
	tested_thread_wait_ended(critical_tts);
	check_tested_thread_phase(critical_tts, TT_PHASE_DEAD);
	}
	// Terminate all threads and clear tts structures
	tested_threads_destroy();

	return TEST_PASSED;
	} // test_jthread_get_blocked_count

	/*
	* Test jthread_get_deadlocked_threads()
	*/
	void JNICALL run_for_test_jthread_get_deadlocked_threads(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args)
	{
	tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args;
	IDATA status = TM_ERROR_NONE;

	tts->phase = TT_PHASE_WAITING_ON_MONITOR;
	status = jthread_monitor_enter(tts->monitor);

	tts->phase = TT_PHASE_RUNNING;
	tested_thread_started(tts);
	tested_thread_wait_for_stop_request(tts);
	tts->phase = TT_PHASE_WAITING_ON_MONITOR;
	status = jthread_monitor_enter(
	get_tts(MAX_TESTED_THREAD_NUMBER - (tts->my_index + 1))->monitor);
	tts->phase = status == TM_ERROR_NONE ? TT_PHASE_DEAD : TT_PHASE_ERROR;
	tested_thread_ended(tts);
	} // run_for_test_jthread_get_deadlocked_threads

	int test_jthread_get_deadlocked_threads(void)
	{
	tested_thread_sturct_t * tts;
	jthread *thread_list;
	int dead_list_count;
	jthread *dead_list;
	int count;

	// Initialize tts structures and run all tested threads
	tested_threads_run_with_different_monitors(run_for_test_jthread_get_deadlocked_threads);

	thread_list =
	(jthread)calloc(MAX_TESTED_THREAD_NUMBER, sizeof(jthread));
	tf_assert(thread_list && "failed to alloc memory");

	reset_tested_thread_iterator(&tts);
	while(next_tested_thread(&tts)) {
	thread_list[tts->my_index] = tts->java_thread;
	}
	tf_assert_same(jthread_get_deadlocked_threads(thread_list, MAX_TESTED_THREAD_NUMBER,
	&dead_list, &dead_list_count), TM_ERROR_NONE);
	tf_assert_same(dead_list_count, 0);

	reset_tested_thread_iterator(&tts);
	while(next_tested_thread(&tts)) {
	tested_thread_send_stop_request(tts);
	}

	reset_tested_thread_iterator(&tts);
	while(next_tested_thread(&tts)) {
	count = 0;
	if ((MAX_TESTED_THREAD_NUMBER % 2)
	&& (tts->my_index == MAX_TESTED_THREAD_NUMBER / 2))
	{
	while (hythread_is_alive(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");
	}
	}
	log_info("Thread %d is dead", tts->my_index);
	check_tested_thread_phase(tts, TT_PHASE_DEAD);
	thread_list[tts->my_index] = jthread_self();
	} else {
	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 WAITING");
	}
	}
	log_info("Thread %d is blocked on monitor", tts->my_index);
	check_tested_thread_phase(tts, TT_PHASE_WAITING_ON_MONITOR);
	}
	}

	tf_assert_same(jthread_get_deadlocked_threads(thread_list, MAX_TESTED_THREAD_NUMBER,
	&dead_list, &dead_list_count), TM_ERROR_NONE);
	log_info("Deadlocked thread numbre is %d", dead_list_count);
	tf_assert_same(dead_list_count,
	((MAX_TESTED_THREAD_NUMBER % 2)
	? MAX_TESTED_THREAD_NUMBER - 1 : MAX_TESTED_THREAD_NUMBER));

	count = 0;
	reset_tested_thread_iterator(&tts);
	while(next_tested_thread(&tts)) {
	if ((MAX_TESTED_THREAD_NUMBER % 2)
	&& (tts->my_index == MAX_TESTED_THREAD_NUMBER / 2))
	{
	continue;
	} else {
	tf_assert_same(dead_list[count++], tts->java_thread);
	log_info("Thread %d is deadlocked", tts->my_index);
	hythread_set_state(tts->native_thread, TM_THREAD_STATE_TERMINATED);
	hythread_cancel(tts->native_thread);
	}
	}

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

	return TEST_PASSED;
	} // test_jthread_get_deadlocked_threads

	/**
	* Test jthread_get_waited_count()
	*/
	void JNICALL run_for_test_jthread_get_waited_count(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_RUNNING;
	tested_thread_started(tts);
	// Enter critical section
	status = jthread_monitor_enter(monitor);
	tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_WAITING_ON_WAIT : TT_PHASE_ERROR);
	// Wait on monitor
	status = jthread_monitor_wait(monitor);
	if (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);

	tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_DEAD : TT_PHASE_ERROR);
	tested_thread_ended(tts);
	} // run_for_test_jthread_get_waited_count

	int test_jthread_get_waited_count(void)
	{
	int count;
	int waiting_nmb;
	jobject monitor;
	tested_thread_sturct_t * tts;

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

	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);
	log_info("Thread %d is waiting.", tts->my_index);
	}

	tf_assert_same(jthread_get_waited_count(&waiting_nmb), TM_ERROR_NONE);
	log_info("Waiting threads count is %d", waiting_nmb);
	tf_assert_same(waiting_nmb, MAX_TESTED_THREAD_NUMBER);

	log_info("Release all threads");
	monitor = get_tts(0)->monitor;
	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);

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

	return TEST_PASSED;
	} // test_jthread_get_waited_count

	TEST_LIST_START
	TEST(test_jthread_get_all_threads)
	TEST(test_jthread_get_blocked_count)
	TEST(test_jthread_get_deadlocked_threads)
	TEST(test_jthread_get_waited_count)
	TEST_LIST_END;