zircon/system/utest/thread-state/thread-state.cpp - fuchsia - Git at Google

 // Copyright 2018 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <inttypes.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>

 #include <fbl/algorithm.h>
 #include <fuchsia/sysinfo/c/fidl.h>
 #include <lib/fdio/fd.h>
 #include <lib/fdio/fdio.h>
 #include <lib/fdio/directory.h>
 #include <lib/zx/channel.h>
 #include <zircon/process.h>
 #include <zircon/processargs.h>
 #include <zircon/status.h>
 #include <zircon/syscalls.h>
 #include <zircon/syscalls/port.h>
 #include <zircon/threads.h>
 #include <test-utils/test-utils.h>
 #include <unittest/unittest.h>

 static int thread_func(void* arg);

 // argv[0]
 static char* program_path;

 // We have to poll a thread's state as there is no way to wait for it to
 // transition states. Wait this amount of time. Generally the thread won't
 // take very long so this is a compromise between polling too frequently and
 // waiting too long.
 constexpr zx_duration_t THREAD_BLOCKED_WAIT_DURATION = ZX_MSEC(1);

 static const char test_child_name[] = "test-child";

 // The maximum number of handles we send with send_msg_with_handles.
 constexpr uint32_t MAX_NUM_MSG_HANDLES = 2;

 // The number of handles used in the wait-many test.
 constexpr uint32_t NUM_WAIT_MANY_HANDLES = MAX_NUM_MSG_HANDLES;

 const zx_port_packet_t port_test_packet = {
     .key = 42u,
     .type = ZX_PKT_TYPE_USER,
     .status = -42,
     { .user = { .u64 = { 1, 2, 3, 4 } } }
 };

 const zx_time_t interrupt_signaled_timestamp = 12345;

 enum MessageType : uint32_t {
     MSG_DONE,
     MSG_PASS,
     MSG_FAIL,
     MSG_PROCEED,
     MSG_THREAD_HANDLE_REQUEST,
     MSG_THREAD_HANDLE_RESPONSE,
     MSG_SLEEP_TEST,
     MSG_FUTEX_TEST,
     MSG_PORT_TEST,
     MSG_CHANNEL_TEST,
     MSG_WAIT_ONE_TEST,
     MSG_WAIT_MANY_TEST,
     MSG_INTERRUPT_TEST,
 };

 struct Message {
     MessageType type;
     uint32_t num_handles;
     zx_handle_t handles[MAX_NUM_MSG_HANDLES];
 };

 static zx_status_t get_root_resource(zx_handle_t* root_resource) {
     int fd = open("/dev/misc/sysinfo", O_RDWR);
     if (fd < 0) {
         unittest_printf("ERROR: Cannot open sysinfo: %d/%s\n",
                         errno, strerror(errno));
         return ZX_ERR_NOT_FOUND;
     }

     zx::channel channel;
     zx_status_t status = fdio_get_service_handle(fd, channel.reset_and_get_address());
     if (status != ZX_OK) {
         fprintf(stderr, "ERROR: Cannot obtain sysinfo channel: %s (%d)\n",
                 zx_status_get_string(status), status);
         return status;
     }

     zx_status_t fidl_status = fuchsia_sysinfo_DeviceGetRootResource(channel.get(), &status,
                                                                    root_resource);
     if (fidl_status != ZX_OK) {
         fprintf(stderr, "ERROR: Cannot obtain root resource: %s (%d)\n",
                 zx_status_get_string(fidl_status), fidl_status);
         return fidl_status;
     } else if (status != ZX_OK) {
         fprintf(stderr, "ERROR: Cannot obtain root resource: %s (%d)\n",
                 zx_status_get_string(status), status);
         return status;
     }

     return ZX_OK;
 }

 static void send_msg_with_handles(zx_handle_t channel, MessageType type,
                                   zx_handle_t* optional_handles, uint32_t num_handles) {
     uint32_t data = type;
     unittest_printf("sending message %d on handle %u, with %u handles\n",
                     type, channel, num_handles);
     tu_channel_write(channel, 0, &data, sizeof(data), optional_handles, num_handles);
 }

 static void send_msg(zx_handle_t channel, MessageType type) {
     send_msg_with_handles(channel, type, nullptr, 0);
 }

 static bool recv_msg(zx_handle_t channel, Message* msg) {
     unittest_printf("waiting for message on handle %u\n", channel);

     if (!tu_channel_wait_readable(channel)) {
         unittest_printf("peer closed while trying to read message\n");
         return false;
     }

     uint32_t data;
     uint32_t num_bytes = sizeof(data);
     tu_channel_read(channel, 0, &data, &num_bytes, &msg->handles[0], &msg->num_handles);
     if (num_bytes != sizeof(data)) {
         unittest_printf("ERROR: unexpected message size, %u != %zu\n",
                         num_bytes, sizeof(data));
         return false;
     }

     msg->type = static_cast<MessageType>(data);
     unittest_printf("received message %u\n", msg->type);
     return true;
 }

 static bool recv_specific_msg(zx_handle_t channel, MessageType expected_type) {
     Message msg;
     ASSERT_TRUE(recv_msg(channel, &msg));
     ASSERT_EQ(msg.type, expected_type);
     return true;
 }

 static void do_msg_thread_handle_request(zx_handle_t channel, const Message* msg) {
     if (msg->num_handles != 0) {
         unittest_printf("ERROR: wrong number handles\n");
         send_msg(channel, MSG_FAIL);
         return;
     }
     auto self = zx_thread_self();
     send_msg_with_handles(channel, MSG_THREAD_HANDLE_RESPONSE, &self, 1);
 }

 static void do_msg_sleep_test(zx_handle_t channel, const Message* msg) {
     if (msg->num_handles != 0) {
         unittest_printf("ERROR: wrong number handles\n");
         // There's no point in sending MSG_FAIL here as the test can never
         // receive MSG_PASS.
         return;
     }
     zx_nanosleep(ZX_TIME_INFINITE);
     /* NOTREACHED */
 }

 static void do_msg_futex_test(zx_handle_t channel, const Message* msg) {
     if (msg->num_handles != 0) {
         unittest_printf("ERROR: wrong number handles\n");
         // There's no point in sending MSG_FAIL here as the test can never
         // receive MSG_PASS.
         return;
     }

     int futex_value = 0;
     zx_status_t __UNUSED status = zx_futex_wait(&futex_value, 0,
                                                 ZX_HANDLE_INVALID,
                                                 ZX_TIME_INFINITE);
     /* NOTREACHED*/
 }

 static void do_msg_port_test(zx_handle_t channel, const Message* msg) {
     if (msg->num_handles != 1) {
         unittest_printf("ERROR: wrong number handles\n");
         send_msg(channel, MSG_FAIL);
         return;
     }

     auto port = msg->handles[0];
     zx_port_packet_t packet;
     auto status = zx_port_wait(port, ZX_TIME_INFINITE, &packet);
     tu_handle_close(port);
     if (status != ZX_OK) {
         unittest_printf("ERROR: port_wait failed: %d/%s\n", status,
                         zx_status_get_string(status));
         send_msg(channel, MSG_FAIL);
         return;
     }

     if (packet.key != port_test_packet.key ||
         packet.type != port_test_packet.type ||
         packet.status != port_test_packet.status ||
         memcmp(&packet.user, &port_test_packet.user, sizeof(zx_port_packet_t::user)) != 0) {
         unittest_printf("ERROR: bad data in packet\n");
         send_msg(channel, MSG_FAIL);
         return;
     }

     send_msg(channel, MSG_PASS);
 }

 static void do_msg_channel_test(zx_handle_t channel, const Message* msg) {
     if (msg->num_handles != 1) {
         unittest_printf_critical("ERROR: wrong number handles\n");
         send_msg(channel, MSG_FAIL);
         return;
     }

     auto test_channel = msg->handles[0];
     uint32_t write_data = 0xdeadbeef;
     uint32_t read_data;
     zx_channel_call_args_t args = {
         .wr_bytes = &write_data,
         .wr_handles = nullptr,
         .rd_bytes = &read_data,
         .rd_handles = nullptr,
         .wr_num_bytes = sizeof(write_data),
         .wr_num_handles = 0,
         .rd_num_bytes = sizeof(read_data),
         .rd_num_handles = 0,
     };

     uint32_t actual_num_bytes = 0;
     uint32_t actual_num_handles = 0;
     auto status = zx_channel_call(test_channel, 0, ZX_TIME_INFINITE, &args,
                                   &actual_num_bytes, &actual_num_handles);
     tu_handle_close(test_channel);
     if (status == ZX_ERR_PEER_CLOSED) {
         // ok
     } else {
         unittest_printf_critical("ERROR: channel_call didn't get PEER_CLOSED: %d/%s\n",
                         status, zx_status_get_string(status));
         send_msg(channel, MSG_FAIL);
         return;
     }

     send_msg(channel, MSG_PASS);
 }

 static void do_msg_wait_one_test(zx_handle_t channel, const Message* msg) {
     if (msg->num_handles != 1) {
         unittest_printf("ERROR: wrong number handles\n");
         send_msg(channel, MSG_FAIL);
         return;
     }

     // The test waits for this to make sure it doesn't see us blocked waiting
     // for a Message. This is sent for wait_one and wait_many so that we don't
     // have to know which one is used to wait for messages.
     send_msg(channel, MSG_PROCEED);

     zx_signals_t observed = 0u;
     auto status = zx_object_wait_one(msg->handles[0], ZX_EVENTPAIR_PEER_CLOSED,
                                      ZX_TIME_INFINITE, &observed);
     tu_handle_close(msg->handles[0]);
     if (status != ZX_OK) {
         unittest_printf("ERROR: wait_one failed: %d/%s\n", status,
                         zx_status_get_string(status));
         send_msg(channel, MSG_FAIL);
         return;
     }

     if (!(observed & ZX_EVENTPAIR_PEER_CLOSED)) {
         unittest_printf("ERROR: ZX_EVENTPAIR_PEER_CLOSED not observed\n");
         send_msg(channel, MSG_FAIL);
         return;
     }

     send_msg(channel, MSG_PASS);
 }

 static void do_msg_wait_many_test(zx_handle_t channel, const Message* msg) {
     if (msg->num_handles > NUM_WAIT_MANY_HANDLES) {
         unittest_printf("ERROR: too many handles\n");
         send_msg(channel, MSG_FAIL);
         return;
     }

     // The test waits for this to make sure it doesn't see us blocked waiting
     // for a Message. This is sent for wait_one and wait_many so that we don't
     // have to know which one is used to wait for messages.
     send_msg(channel, MSG_PROCEED);

     uint32_t num_handles = msg->num_handles;
     zx_wait_item_t items[num_handles];
     for (uint32_t i = 0; i < num_handles; ++i) {
         items[i].handle = msg->handles[i];
         items[i].waitfor = ZX_EVENTPAIR_PEER_CLOSED;
     }
     auto status = zx_object_wait_many(&items[0], num_handles, ZX_TIME_INFINITE);
     for (uint32_t i = 0; i < num_handles; ++i) {
         tu_handle_close(msg->handles[i]);
     }
     if (status != ZX_OK) {
         unittest_printf("ERROR: wait_many failed: %d/%s\n", status,
                         zx_status_get_string(status));
         send_msg(channel, MSG_FAIL);
         return;
     }

     // At least one of the handles should have gotten PEER_CLOSED.
     bool got_peer_closed = false;
     for (uint32_t i = 0; i < num_handles; ++i) {
         if (items[i].pending & ZX_EVENTPAIR_PEER_CLOSED) {
             got_peer_closed = true;
             break;
         }
     }
     if (!got_peer_closed) {
         unittest_printf("ERROR: ZX_EVENTPAIR_PEER_CLOSED not observed\n");
         send_msg(channel, MSG_FAIL);
         return;
     }

     send_msg(channel, MSG_PASS);
 }

 static void do_msg_interrupt_test(zx_handle_t channel, const Message* msg) {
     if (msg->num_handles != 1) {
         unittest_printf("ERROR: wrong number handles\n");
         send_msg(channel, MSG_FAIL);
         return;
     }

     auto interrupt = msg->handles[0];
     zx_time_t timestamp;
     auto status = zx_interrupt_wait(interrupt, &timestamp);
     tu_handle_close(interrupt);
     if (status != ZX_OK) {
         unittest_printf("ERROR: interrupt_wait failed: %d/%s\n", status,
                         zx_status_get_string(status));
         send_msg(channel, MSG_FAIL);
         return;
     }

     if (timestamp != interrupt_signaled_timestamp) {
         unittest_printf("ERROR: interrupt timestamp mismatch\n");
         send_msg(channel, MSG_FAIL);
         return;
     }

     send_msg(channel, MSG_PASS);
 }

 static void msg_loop(zx_handle_t channel) {
     bool my_done_tests = false;

     while (!my_done_tests) {
         Message msg;
         msg.num_handles = static_cast<uint32_t>(fbl::count_of(msg.handles));
         if (!recv_msg(channel, &msg)) {
             unittest_printf("ERROR: while receiving msg\n");
             return;
         }

         switch (msg.type) {
         case MSG_DONE:
             my_done_tests = true;
             break;
         case MSG_THREAD_HANDLE_REQUEST:
             do_msg_thread_handle_request(channel, &msg);
             break;
         case MSG_SLEEP_TEST:
             do_msg_sleep_test(channel, &msg);
             break;
         case MSG_FUTEX_TEST:
             do_msg_futex_test(channel, &msg);
             break;
         case MSG_PORT_TEST:
             do_msg_port_test(channel, &msg);
             break;
         case MSG_CHANNEL_TEST:
             do_msg_channel_test(channel, &msg);
             break;
         case MSG_WAIT_ONE_TEST:
             do_msg_wait_one_test(channel, &msg);
             break;
         case MSG_WAIT_MANY_TEST:
             do_msg_wait_many_test(channel, &msg);
             break;
         case MSG_INTERRUPT_TEST:
             do_msg_interrupt_test(channel, &msg);
             break;
         default:
             unittest_printf("ERROR: unknown message received: %u\n", msg.type);
             break;
         }
     }
 }

 static int thread_func(void* arg) {
     unittest_printf("test thread starting\n");
     zx_handle_t msg_channel = (zx_handle_t) (uintptr_t) arg;
     msg_loop(msg_channel);
     unittest_printf("test thread exiting\n");
     tu_handle_close(msg_channel);
     return 0;
 }

 static void __NO_RETURN test_child(void) {
     unittest_printf("Test child starting.\n");
     zx_handle_t channel = zx_take_startup_handle(PA_USER0);
     if (channel == ZX_HANDLE_INVALID)
         tu_fatal("zx_take_startup_handle", ZX_ERR_BAD_HANDLE - 1000);
     msg_loop(channel);
     unittest_printf("Test child exiting.\n");
     exit(0);
 }

 static launchpad_t* setup_test_child(zx_handle_t job, const char* arg,
                                      zx_handle_t* out_channel) {
     unittest_printf("Starting test child %s.\n", arg);
     zx_handle_t our_channel, their_channel;
     tu_channel_create(&our_channel, &their_channel);
     const char* test_child_path = program_path;
     const char verbosity_string[] =
         { 'v', '=', static_cast<char>(utest_verbosity_level + '0'), '\0' };
     const char* const argv[] = {
         test_child_path,
         arg,
         verbosity_string,
     };
     int argc = fbl::count_of(argv);
     zx_handle_t handles[1] = { their_channel };
     uint32_t handle_ids[1] = { PA_USER0 };
     *out_channel = our_channel;
     launchpad_t* lp = tu_launch_fdio_init(job, test_child_name, argc, argv,
                                           NULL, 1, handles, handle_ids);
     unittest_printf("Test child setup.\n");
     return lp;
 }

 static void start_test_child(zx_handle_t job, const char* arg,
                              zx_handle_t* out_child, zx_handle_t* out_channel) {
     launchpad_t* lp = setup_test_child(job, arg, out_channel);
     *out_child = tu_launch_fdio_fini(lp);
     unittest_printf("Test child started.\n");
 }

 static bool get_child_thread(zx_handle_t channel, zx_handle_t* thread) {
     send_msg(channel, MSG_THREAD_HANDLE_REQUEST);
     Message msg;
     ASSERT_TRUE(recv_msg(channel, &msg));
     EXPECT_EQ(msg.type, MSG_THREAD_HANDLE_RESPONSE);
     EXPECT_EQ(msg.num_handles, 1u);
     *thread = msg.handles[0];
     return true;
 }

 // Wait for |thread| to enter blocked state |reason|.
 // We wait forever and let Unittest's watchdog handle errors.

 static void wait_thread_blocked(zx_handle_t thread, uint32_t reason) {
     while (true) {
         auto state = tu_thread_get_state(thread);
         if (state == reason)
             break;
         zx_nanosleep(zx_deadline_after(THREAD_BLOCKED_WAIT_DURATION));
     }
 }

 // Terminate |process| by killing it and wait for it to exit.

 static void terminate_process(zx_handle_t process) {
     tu_task_kill(process);
     tu_process_wait_signaled(process);
 }

 static bool sleeping_test() {
     BEGIN_TEST;

     // Start a new process.
     zx_handle_t child, channel;
     start_test_child(zx_job_default(), test_child_name, &child, &channel);
     zx_handle_t thread;
     ASSERT_TRUE(get_child_thread(channel, &thread));

     send_msg(channel, MSG_SLEEP_TEST);

     // There is no good way to do this test without having the child
     // sleep forever and then kill it: There's no way to interrupt the sleep,
     // and there's no good value for the amount of time to sleep.
     wait_thread_blocked(thread, ZX_THREAD_STATE_BLOCKED_SLEEPING);

     terminate_process(child);

     END_TEST;
 }

 static bool futex_test() {
     BEGIN_TEST;

     // Start a new process.
     zx_handle_t child, channel;
     start_test_child(zx_job_default(), test_child_name, &child, &channel);
     zx_handle_t thread;
     ASSERT_TRUE(get_child_thread(channel, &thread));

     send_msg_with_handles(channel, MSG_FUTEX_TEST, nullptr, 0);

     wait_thread_blocked(thread, ZX_THREAD_STATE_BLOCKED_FUTEX);

     terminate_process(child);

     END_TEST;
 }

 static bool port_test() {
     BEGIN_TEST;

     // Start a new process.
     zx_handle_t child, channel;
     start_test_child(zx_job_default(), test_child_name, &child, &channel);
     zx_handle_t thread;
     ASSERT_TRUE(get_child_thread(channel, &thread));

     zx_handle_t port;
     ASSERT_EQ(zx_port_create(0, &port), ZX_OK);
     zx_handle_t port_dupe = tu_handle_duplicate(port);

     send_msg_with_handles(channel, MSG_PORT_TEST, &port_dupe, 1);

     wait_thread_blocked(thread, ZX_THREAD_STATE_BLOCKED_PORT);

     // Wake the child up.
     EXPECT_EQ(zx_port_queue(port, &port_test_packet), ZX_OK);

     // The child sends a pass/fail message back as extra verification that
     // things went correctly on that side.
     ASSERT_TRUE(recv_specific_msg(channel, MSG_PASS));

     tu_handle_close(port);
     terminate_process(child);

     END_TEST;
 }

 static bool channel_test() {
     BEGIN_TEST;

     // Start a new process.
     zx_handle_t child, channel;
     start_test_child(zx_job_default(), test_child_name, &child, &channel);
     zx_handle_t thread;
     ASSERT_TRUE(get_child_thread(channel, &thread));

     zx_handle_t our_channel, their_channel;
     ASSERT_EQ(zx_channel_create(0, &our_channel, &their_channel), ZX_OK);

     send_msg_with_handles(channel, MSG_CHANNEL_TEST, &their_channel, 1);

     wait_thread_blocked(thread, ZX_THREAD_STATE_BLOCKED_CHANNEL);

     // Wake the child up.
     tu_handle_close(our_channel);

     // The child sends a pass/fail message back as extra verification that
     // things went correctly on that side.
     ASSERT_TRUE(recv_specific_msg(channel, MSG_PASS));

     terminate_process(child);

     END_TEST;
 }

 static bool wait_one_test() {
     BEGIN_TEST;

     // Start a new process.
     zx_handle_t child, channel;
     start_test_child(zx_job_default(), test_child_name, &child, &channel);
     zx_handle_t thread;
     ASSERT_TRUE(get_child_thread(channel, &thread));

     zx_handle_t h[2];
     ASSERT_EQ(zx_eventpair_create(0, &h[0], &h[1]), ZX_OK);

     send_msg_with_handles(channel, MSG_WAIT_ONE_TEST, &h[1], 1);

     // Don't continue until we see MSG_PROCEED, that tells us the child has
     // received the message and isn't in a wait_one/wait_many syscall.
     ASSERT_TRUE(recv_specific_msg(channel, MSG_PROCEED));

     wait_thread_blocked(thread, ZX_THREAD_STATE_BLOCKED_WAIT_ONE);

     // Wake the child up.
     tu_handle_close(h[0]);

     // The child sends a pass/fail message back as extra verification that
     // things went correctly on that side.
     ASSERT_TRUE(recv_specific_msg(channel, MSG_PASS));

     terminate_process(child);

     END_TEST;
 }

 static bool wait_many_test() {
     BEGIN_TEST;

     // Start a new process.
     zx_handle_t child, channel;
     start_test_child(zx_job_default(), test_child_name, &child, &channel);
     zx_handle_t thread;
     ASSERT_TRUE(get_child_thread(channel, &thread));

     uint32_t num_handles = NUM_WAIT_MANY_HANDLES;
     zx_handle_t h[2][num_handles];
     for (uint32_t i = 0; i < num_handles; ++i) {
         ASSERT_EQ(zx_eventpair_create(0, &h[0][i], &h[1][i]), ZX_OK);
     }

     send_msg_with_handles(channel, MSG_WAIT_MANY_TEST, &h[1][0], num_handles);

     // Don't continue until we see MSG_PROCEED, that tells us the child has
     // received the message and isn't in a wait_one/wait_many syscall.
     ASSERT_TRUE(recv_specific_msg(channel, MSG_PROCEED));

     wait_thread_blocked(thread, ZX_THREAD_STATE_BLOCKED_WAIT_MANY);

     // Wake the child up.
     for (uint32_t i = 0; i < num_handles; ++i) {
         tu_handle_close(h[0][i]);
     }

     // The child sends a pass/fail message back as extra verification that
     // things went correctly on that side.
     ASSERT_TRUE(recv_specific_msg(channel, MSG_PASS));

     terminate_process(child);

     END_TEST;
 }

 // Just like wait_many_test except the child doesn't wait on any objects, just
 // the (infinite) timeout.
 static bool wait_many_no_objects_test() {
     BEGIN_TEST;

     // Start a new process.
     zx_handle_t child, channel;
     start_test_child(zx_job_default(), test_child_name, &child, &channel);
     zx_handle_t thread;
     ASSERT_TRUE(get_child_thread(channel, &thread));

     send_msg(channel, MSG_WAIT_MANY_TEST);

     // Don't continue until we see MSG_PROCEED, that tells us the child has
     // received the message and isn't in a wait_one/wait_many syscall.
     ASSERT_TRUE(recv_specific_msg(channel, MSG_PROCEED));

     wait_thread_blocked(thread, ZX_THREAD_STATE_BLOCKED_WAIT_MANY);

     // The child won't be sending a pass/fail message back because it's stuck in
     // object_wait_many so just kill it.
     terminate_process(child);

     END_TEST;
 }

 static bool interrupt_test() {
     BEGIN_TEST;

     // Start a new process.
     zx_handle_t child, channel;
     start_test_child(zx_job_default(), test_child_name, &child, &channel);
     zx_handle_t thread;
     ASSERT_TRUE(get_child_thread(channel, &thread));

     zx_handle_t resource;
     ASSERT_EQ(get_root_resource(&resource), ZX_OK);

     zx_handle_t interrupt;
     ASSERT_EQ(zx_interrupt_create(resource, 0, ZX_INTERRUPT_VIRTUAL, &interrupt),
               ZX_OK);
     zx_handle_t interrupt_dupe = tu_handle_duplicate(interrupt);

     send_msg_with_handles(channel, MSG_INTERRUPT_TEST, &interrupt_dupe, 1);

     wait_thread_blocked(thread, ZX_THREAD_STATE_BLOCKED_INTERRUPT);

     // Wake the child up.
     EXPECT_EQ(zx_interrupt_trigger(interrupt, 0, interrupt_signaled_timestamp), ZX_OK);

     // The child sends a pass/fail message back as extra verification that
     // things went correctly on that side.
     ASSERT_TRUE(recv_specific_msg(channel, MSG_PASS));

     tu_handle_close(interrupt);
     terminate_process(child);

     END_TEST;
 }

 BEGIN_TEST_CASE(thread_state_tests)
 // ZX_THREAD_STATE_BLOCKED_EXCEPTION is tested in utest/exception.
 // There's a lot of support logic and there's no reason to duplicate it here.
 RUN_TEST(sleeping_test);
 RUN_TEST(futex_test);
 RUN_TEST(port_test);
 RUN_TEST(channel_test);
 RUN_TEST(wait_one_test);
 RUN_TEST(wait_many_test);
 RUN_TEST(wait_many_no_objects_test);
 RUN_TEST(interrupt_test);
 END_TEST_CASE(thread_state_tests)

 static void scan_argv(int argc, char** argv) {
     for (int i = 1; i < argc; ++i) {
         if (strncmp(argv[i], "v=", 2) == 0) {
             int verbosity = atoi(argv[i] + 2);
             unittest_set_verbosity_level(verbosity);
         }
     }
 }

 int main(int argc, char **argv) {
     program_path = argv[0];
     scan_argv(argc, argv);

     if (argc >= 2) {
         if (strcmp(argv[1], test_child_name) == 0) {
             test_child();
             return 0;
         }
     }

     bool success = unittest_run_all_tests(argc, argv);

     return success ? 0 : -1;
 }
	// Copyright 2018 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include <assert.h>
	#include <errno.h>
	#include <fcntl.h>
	#include <inttypes.h>
	#include <stdlib.h>
	#include <string.h>
	#include <unistd.h>

	#include <fbl/algorithm.h>
	#include <fuchsia/sysinfo/c/fidl.h>
	#include <lib/fdio/fd.h>
	#include <lib/fdio/fdio.h>
	#include <lib/fdio/directory.h>
	#include <lib/zx/channel.h>
	#include <zircon/process.h>
	#include <zircon/processargs.h>
	#include <zircon/status.h>
	#include <zircon/syscalls.h>
	#include <zircon/syscalls/port.h>
	#include <zircon/threads.h>
	#include <test-utils/test-utils.h>
	#include <unittest/unittest.h>

	static int thread_func(void* arg);

	// argv[0]
	static char* program_path;

	// We have to poll a thread's state as there is no way to wait for it to
	// transition states. Wait this amount of time. Generally the thread won't
	// take very long so this is a compromise between polling too frequently and
	// waiting too long.
	constexpr zx_duration_t THREAD_BLOCKED_WAIT_DURATION = ZX_MSEC(1);

	static const char test_child_name[] = "test-child";

	// The maximum number of handles we send with send_msg_with_handles.
	constexpr uint32_t MAX_NUM_MSG_HANDLES = 2;

	// The number of handles used in the wait-many test.
	constexpr uint32_t NUM_WAIT_MANY_HANDLES = MAX_NUM_MSG_HANDLES;

	const zx_port_packet_t port_test_packet = {
	.key = 42u,
	.type = ZX_PKT_TYPE_USER,
	.status = -42,
	{ .user = { .u64 = { 1, 2, 3, 4 } } }
	};

	const zx_time_t interrupt_signaled_timestamp = 12345;

	enum MessageType : uint32_t {
	MSG_DONE,
	MSG_PASS,
	MSG_FAIL,
	MSG_PROCEED,
	MSG_THREAD_HANDLE_REQUEST,
	MSG_THREAD_HANDLE_RESPONSE,
	MSG_SLEEP_TEST,
	MSG_FUTEX_TEST,
	MSG_PORT_TEST,
	MSG_CHANNEL_TEST,
	MSG_WAIT_ONE_TEST,
	MSG_WAIT_MANY_TEST,
	MSG_INTERRUPT_TEST,
	};

	struct Message {
	MessageType type;
	uint32_t num_handles;
	zx_handle_t handles[MAX_NUM_MSG_HANDLES];
	};

	static zx_status_t get_root_resource(zx_handle_t* root_resource) {
	int fd = open("/dev/misc/sysinfo", O_RDWR);
	if (fd < 0) {
	unittest_printf("ERROR: Cannot open sysinfo: %d/%s\n",
	errno, strerror(errno));
	return ZX_ERR_NOT_FOUND;
	}

	zx::channel channel;
	zx_status_t status = fdio_get_service_handle(fd, channel.reset_and_get_address());
	if (status != ZX_OK) {
	fprintf(stderr, "ERROR: Cannot obtain sysinfo channel: %s (%d)\n",
	zx_status_get_string(status), status);
	return status;
	}

	zx_status_t fidl_status = fuchsia_sysinfo_DeviceGetRootResource(channel.get(), &status,
	root_resource);
	if (fidl_status != ZX_OK) {
	fprintf(stderr, "ERROR: Cannot obtain root resource: %s (%d)\n",
	zx_status_get_string(fidl_status), fidl_status);
	return fidl_status;
	} else if (status != ZX_OK) {
	fprintf(stderr, "ERROR: Cannot obtain root resource: %s (%d)\n",
	zx_status_get_string(status), status);
	return status;
	}

	return ZX_OK;
	}

	static void send_msg_with_handles(zx_handle_t channel, MessageType type,
	zx_handle_t* optional_handles, uint32_t num_handles) {
	uint32_t data = type;
	unittest_printf("sending message %d on handle %u, with %u handles\n",
	type, channel, num_handles);
	tu_channel_write(channel, 0, &data, sizeof(data), optional_handles, num_handles);
	}

	static void send_msg(zx_handle_t channel, MessageType type) {
	send_msg_with_handles(channel, type, nullptr, 0);
	}

	static bool recv_msg(zx_handle_t channel, Message* msg) {
	unittest_printf("waiting for message on handle %u\n", channel);

	if (!tu_channel_wait_readable(channel)) {
	unittest_printf("peer closed while trying to read message\n");
	return false;
	}

	uint32_t data;
	uint32_t num_bytes = sizeof(data);
	tu_channel_read(channel, 0, &data, &num_bytes, &msg->handles[0], &msg->num_handles);
	if (num_bytes != sizeof(data)) {
	unittest_printf("ERROR: unexpected message size, %u != %zu\n",
	num_bytes, sizeof(data));
	return false;
	}

	msg->type = static_cast<MessageType>(data);
	unittest_printf("received message %u\n", msg->type);
	return true;
	}

	static bool recv_specific_msg(zx_handle_t channel, MessageType expected_type) {
	Message msg;
	ASSERT_TRUE(recv_msg(channel, &msg));
	ASSERT_EQ(msg.type, expected_type);
	return true;
	}

	static void do_msg_thread_handle_request(zx_handle_t channel, const Message* msg) {
	if (msg->num_handles != 0) {
	unittest_printf("ERROR: wrong number handles\n");
	send_msg(channel, MSG_FAIL);
	return;
	}
	auto self = zx_thread_self();
	send_msg_with_handles(channel, MSG_THREAD_HANDLE_RESPONSE, &self, 1);
	}

	static void do_msg_sleep_test(zx_handle_t channel, const Message* msg) {
	if (msg->num_handles != 0) {
	unittest_printf("ERROR: wrong number handles\n");
	// There's no point in sending MSG_FAIL here as the test can never
	// receive MSG_PASS.
	return;
	}
	zx_nanosleep(ZX_TIME_INFINITE);
	/* NOTREACHED */
	}

	static void do_msg_futex_test(zx_handle_t channel, const Message* msg) {
	if (msg->num_handles != 0) {
	unittest_printf("ERROR: wrong number handles\n");
	// There's no point in sending MSG_FAIL here as the test can never
	// receive MSG_PASS.
	return;
	}

	int futex_value = 0;
	zx_status_t __UNUSED status = zx_futex_wait(&futex_value, 0,
	ZX_HANDLE_INVALID,
	ZX_TIME_INFINITE);
	/* NOTREACHED*/
	}

	static void do_msg_port_test(zx_handle_t channel, const Message* msg) {
	if (msg->num_handles != 1) {
	unittest_printf("ERROR: wrong number handles\n");
	send_msg(channel, MSG_FAIL);
	return;
	}

	auto port = msg->handles[0];
	zx_port_packet_t packet;
	auto status = zx_port_wait(port, ZX_TIME_INFINITE, &packet);
	tu_handle_close(port);
	if (status != ZX_OK) {
	unittest_printf("ERROR: port_wait failed: %d/%s\n", status,
	zx_status_get_string(status));
	send_msg(channel, MSG_FAIL);
	return;
	}

	if (packet.key != port_test_packet.key \|\|
	packet.type != port_test_packet.type \|\|
	packet.status != port_test_packet.status \|\|
	memcmp(&packet.user, &port_test_packet.user, sizeof(zx_port_packet_t::user)) != 0) {
	unittest_printf("ERROR: bad data in packet\n");
	send_msg(channel, MSG_FAIL);
	return;
	}

	send_msg(channel, MSG_PASS);
	}

	static void do_msg_channel_test(zx_handle_t channel, const Message* msg) {
	if (msg->num_handles != 1) {
	unittest_printf_critical("ERROR: wrong number handles\n");
	send_msg(channel, MSG_FAIL);
	return;
	}

	auto test_channel = msg->handles[0];
	uint32_t write_data = 0xdeadbeef;
	uint32_t read_data;
	zx_channel_call_args_t args = {
	.wr_bytes = &write_data,
	.wr_handles = nullptr,
	.rd_bytes = &read_data,
	.rd_handles = nullptr,
	.wr_num_bytes = sizeof(write_data),
	.wr_num_handles = 0,
	.rd_num_bytes = sizeof(read_data),
	.rd_num_handles = 0,
	};

	uint32_t actual_num_bytes = 0;
	uint32_t actual_num_handles = 0;
	auto status = zx_channel_call(test_channel, 0, ZX_TIME_INFINITE, &args,
	&actual_num_bytes, &actual_num_handles);
	tu_handle_close(test_channel);
	if (status == ZX_ERR_PEER_CLOSED) {
	// ok
	} else {
	unittest_printf_critical("ERROR: channel_call didn't get PEER_CLOSED: %d/%s\n",
	status, zx_status_get_string(status));
	send_msg(channel, MSG_FAIL);
	return;
	}

	send_msg(channel, MSG_PASS);
	}

	static void do_msg_wait_one_test(zx_handle_t channel, const Message* msg) {
	if (msg->num_handles != 1) {
	unittest_printf("ERROR: wrong number handles\n");
	send_msg(channel, MSG_FAIL);
	return;
	}

	// The test waits for this to make sure it doesn't see us blocked waiting
	// for a Message. This is sent for wait_one and wait_many so that we don't
	// have to know which one is used to wait for messages.
	send_msg(channel, MSG_PROCEED);

	zx_signals_t observed = 0u;
	auto status = zx_object_wait_one(msg->handles[0], ZX_EVENTPAIR_PEER_CLOSED,
	ZX_TIME_INFINITE, &observed);
	tu_handle_close(msg->handles[0]);
	if (status != ZX_OK) {
	unittest_printf("ERROR: wait_one failed: %d/%s\n", status,
	zx_status_get_string(status));
	send_msg(channel, MSG_FAIL);
	return;
	}

	if (!(observed & ZX_EVENTPAIR_PEER_CLOSED)) {
	unittest_printf("ERROR: ZX_EVENTPAIR_PEER_CLOSED not observed\n");
	send_msg(channel, MSG_FAIL);
	return;
	}

	send_msg(channel, MSG_PASS);
	}

	static void do_msg_wait_many_test(zx_handle_t channel, const Message* msg) {
	if (msg->num_handles > NUM_WAIT_MANY_HANDLES) {
	unittest_printf("ERROR: too many handles\n");
	send_msg(channel, MSG_FAIL);
	return;
	}

	// The test waits for this to make sure it doesn't see us blocked waiting
	// for a Message. This is sent for wait_one and wait_many so that we don't
	// have to know which one is used to wait for messages.
	send_msg(channel, MSG_PROCEED);

	uint32_t num_handles = msg->num_handles;
	zx_wait_item_t items[num_handles];
	for (uint32_t i = 0; i < num_handles; ++i) {
	items[i].handle = msg->handles[i];
	items[i].waitfor = ZX_EVENTPAIR_PEER_CLOSED;
	}
	auto status = zx_object_wait_many(&items[0], num_handles, ZX_TIME_INFINITE);
	for (uint32_t i = 0; i < num_handles; ++i) {
	tu_handle_close(msg->handles[i]);
	}
	if (status != ZX_OK) {
	unittest_printf("ERROR: wait_many failed: %d/%s\n", status,
	zx_status_get_string(status));
	send_msg(channel, MSG_FAIL);
	return;
	}

	// At least one of the handles should have gotten PEER_CLOSED.
	bool got_peer_closed = false;
	for (uint32_t i = 0; i < num_handles; ++i) {
	if (items[i].pending & ZX_EVENTPAIR_PEER_CLOSED) {
	got_peer_closed = true;
	break;
	}
	}
	if (!got_peer_closed) {
	unittest_printf("ERROR: ZX_EVENTPAIR_PEER_CLOSED not observed\n");
	send_msg(channel, MSG_FAIL);
	return;
	}

	send_msg(channel, MSG_PASS);
	}

	static void do_msg_interrupt_test(zx_handle_t channel, const Message* msg) {
	if (msg->num_handles != 1) {
	unittest_printf("ERROR: wrong number handles\n");
	send_msg(channel, MSG_FAIL);
	return;
	}

	auto interrupt = msg->handles[0];
	zx_time_t timestamp;
	auto status = zx_interrupt_wait(interrupt, &timestamp);
	tu_handle_close(interrupt);
	if (status != ZX_OK) {
	unittest_printf("ERROR: interrupt_wait failed: %d/%s\n", status,
	zx_status_get_string(status));
	send_msg(channel, MSG_FAIL);
	return;
	}

	if (timestamp != interrupt_signaled_timestamp) {
	unittest_printf("ERROR: interrupt timestamp mismatch\n");
	send_msg(channel, MSG_FAIL);
	return;
	}

	send_msg(channel, MSG_PASS);
	}

	static void msg_loop(zx_handle_t channel) {
	bool my_done_tests = false;

	while (!my_done_tests) {
	Message msg;
	msg.num_handles = static_cast<uint32_t>(fbl::count_of(msg.handles));
	if (!recv_msg(channel, &msg)) {
	unittest_printf("ERROR: while receiving msg\n");
	return;
	}

	switch (msg.type) {
	case MSG_DONE:
	my_done_tests = true;
	break;
	case MSG_THREAD_HANDLE_REQUEST:
	do_msg_thread_handle_request(channel, &msg);
	break;
	case MSG_SLEEP_TEST:
	do_msg_sleep_test(channel, &msg);
	break;
	case MSG_FUTEX_TEST:
	do_msg_futex_test(channel, &msg);
	break;
	case MSG_PORT_TEST:
	do_msg_port_test(channel, &msg);
	break;
	case MSG_CHANNEL_TEST:
	do_msg_channel_test(channel, &msg);
	break;
	case MSG_WAIT_ONE_TEST:
	do_msg_wait_one_test(channel, &msg);
	break;
	case MSG_WAIT_MANY_TEST:
	do_msg_wait_many_test(channel, &msg);
	break;
	case MSG_INTERRUPT_TEST:
	do_msg_interrupt_test(channel, &msg);
	break;
	default:
	unittest_printf("ERROR: unknown message received: %u\n", msg.type);
	break;
	}
	}
	}

	static int thread_func(void* arg) {
	unittest_printf("test thread starting\n");
	zx_handle_t msg_channel = (zx_handle_t) (uintptr_t) arg;
	msg_loop(msg_channel);
	unittest_printf("test thread exiting\n");
	tu_handle_close(msg_channel);
	return 0;
	}

	static void __NO_RETURN test_child(void) {
	unittest_printf("Test child starting.\n");
	zx_handle_t channel = zx_take_startup_handle(PA_USER0);
	if (channel == ZX_HANDLE_INVALID)
	tu_fatal("zx_take_startup_handle", ZX_ERR_BAD_HANDLE - 1000);
	msg_loop(channel);
	unittest_printf("Test child exiting.\n");
	exit(0);
	}

	static launchpad_t* setup_test_child(zx_handle_t job, const char* arg,
	zx_handle_t* out_channel) {
	unittest_printf("Starting test child %s.\n", arg);
	zx_handle_t our_channel, their_channel;
	tu_channel_create(&our_channel, &their_channel);
	const char* test_child_path = program_path;
	const char verbosity_string[] =
	{ 'v', '=', static_cast<char>(utest_verbosity_level + '0'), '\0' };
	const char* const argv[] = {
	test_child_path,
	arg,
	verbosity_string,
	};
	int argc = fbl::count_of(argv);
	zx_handle_t handles[1] = { their_channel };
	uint32_t handle_ids[1] = { PA_USER0 };
	*out_channel = our_channel;
	launchpad_t* lp = tu_launch_fdio_init(job, test_child_name, argc, argv,
	NULL, 1, handles, handle_ids);
	unittest_printf("Test child setup.\n");
	return lp;
	}

	static void start_test_child(zx_handle_t job, const char* arg,
	zx_handle_t* out_child, zx_handle_t* out_channel) {
	launchpad_t* lp = setup_test_child(job, arg, out_channel);
	*out_child = tu_launch_fdio_fini(lp);
	unittest_printf("Test child started.\n");
	}

	static bool get_child_thread(zx_handle_t channel, zx_handle_t* thread) {
	send_msg(channel, MSG_THREAD_HANDLE_REQUEST);
	Message msg;
	ASSERT_TRUE(recv_msg(channel, &msg));
	EXPECT_EQ(msg.type, MSG_THREAD_HANDLE_RESPONSE);
	EXPECT_EQ(msg.num_handles, 1u);
	*thread = msg.handles[0];
	return true;
	}

	// Wait for \|thread\| to enter blocked state \|reason\|.
	// We wait forever and let Unittest's watchdog handle errors.

	static void wait_thread_blocked(zx_handle_t thread, uint32_t reason) {
	while (true) {
	auto state = tu_thread_get_state(thread);
	if (state == reason)
	break;
	zx_nanosleep(zx_deadline_after(THREAD_BLOCKED_WAIT_DURATION));
	}
	}

	// Terminate \|process\| by killing it and wait for it to exit.

	static void terminate_process(zx_handle_t process) {
	tu_task_kill(process);
	tu_process_wait_signaled(process);
	}

	static bool sleeping_test() {
	BEGIN_TEST;

	// Start a new process.
	zx_handle_t child, channel;
	start_test_child(zx_job_default(), test_child_name, &child, &channel);
	zx_handle_t thread;
	ASSERT_TRUE(get_child_thread(channel, &thread));

	send_msg(channel, MSG_SLEEP_TEST);

	// There is no good way to do this test without having the child
	// sleep forever and then kill it: There's no way to interrupt the sleep,
	// and there's no good value for the amount of time to sleep.
	wait_thread_blocked(thread, ZX_THREAD_STATE_BLOCKED_SLEEPING);

	terminate_process(child);

	END_TEST;
	}

	static bool futex_test() {
	BEGIN_TEST;

	// Start a new process.
	zx_handle_t child, channel;
	start_test_child(zx_job_default(), test_child_name, &child, &channel);
	zx_handle_t thread;
	ASSERT_TRUE(get_child_thread(channel, &thread));

	send_msg_with_handles(channel, MSG_FUTEX_TEST, nullptr, 0);

	wait_thread_blocked(thread, ZX_THREAD_STATE_BLOCKED_FUTEX);

	terminate_process(child);

	END_TEST;
	}

	static bool port_test() {
	BEGIN_TEST;

	// Start a new process.
	zx_handle_t child, channel;
	start_test_child(zx_job_default(), test_child_name, &child, &channel);
	zx_handle_t thread;
	ASSERT_TRUE(get_child_thread(channel, &thread));

	zx_handle_t port;
	ASSERT_EQ(zx_port_create(0, &port), ZX_OK);
	zx_handle_t port_dupe = tu_handle_duplicate(port);

	send_msg_with_handles(channel, MSG_PORT_TEST, &port_dupe, 1);

	wait_thread_blocked(thread, ZX_THREAD_STATE_BLOCKED_PORT);

	// Wake the child up.
	EXPECT_EQ(zx_port_queue(port, &port_test_packet), ZX_OK);

	// The child sends a pass/fail message back as extra verification that
	// things went correctly on that side.
	ASSERT_TRUE(recv_specific_msg(channel, MSG_PASS));

	tu_handle_close(port);
	terminate_process(child);

	END_TEST;
	}

	static bool channel_test() {
	BEGIN_TEST;

	// Start a new process.
	zx_handle_t child, channel;
	start_test_child(zx_job_default(), test_child_name, &child, &channel);
	zx_handle_t thread;
	ASSERT_TRUE(get_child_thread(channel, &thread));

	zx_handle_t our_channel, their_channel;
	ASSERT_EQ(zx_channel_create(0, &our_channel, &their_channel), ZX_OK);

	send_msg_with_handles(channel, MSG_CHANNEL_TEST, &their_channel, 1);

	wait_thread_blocked(thread, ZX_THREAD_STATE_BLOCKED_CHANNEL);

	// Wake the child up.
	tu_handle_close(our_channel);

	// The child sends a pass/fail message back as extra verification that
	// things went correctly on that side.
	ASSERT_TRUE(recv_specific_msg(channel, MSG_PASS));

	terminate_process(child);

	END_TEST;
	}

	static bool wait_one_test() {
	BEGIN_TEST;

	// Start a new process.
	zx_handle_t child, channel;
	start_test_child(zx_job_default(), test_child_name, &child, &channel);
	zx_handle_t thread;
	ASSERT_TRUE(get_child_thread(channel, &thread));

	zx_handle_t h[2];
	ASSERT_EQ(zx_eventpair_create(0, &h[0], &h[1]), ZX_OK);

	send_msg_with_handles(channel, MSG_WAIT_ONE_TEST, &h[1], 1);

	// Don't continue until we see MSG_PROCEED, that tells us the child has
	// received the message and isn't in a wait_one/wait_many syscall.
	ASSERT_TRUE(recv_specific_msg(channel, MSG_PROCEED));

	wait_thread_blocked(thread, ZX_THREAD_STATE_BLOCKED_WAIT_ONE);

	// Wake the child up.
	tu_handle_close(h[0]);

	// The child sends a pass/fail message back as extra verification that
	// things went correctly on that side.
	ASSERT_TRUE(recv_specific_msg(channel, MSG_PASS));

	terminate_process(child);

	END_TEST;
	}

	static bool wait_many_test() {
	BEGIN_TEST;

	// Start a new process.
	zx_handle_t child, channel;
	start_test_child(zx_job_default(), test_child_name, &child, &channel);
	zx_handle_t thread;
	ASSERT_TRUE(get_child_thread(channel, &thread));

	uint32_t num_handles = NUM_WAIT_MANY_HANDLES;
	zx_handle_t h[2][num_handles];
	for (uint32_t i = 0; i < num_handles; ++i) {
	ASSERT_EQ(zx_eventpair_create(0, &h[0][i], &h[1][i]), ZX_OK);
	}

	send_msg_with_handles(channel, MSG_WAIT_MANY_TEST, &h[1][0], num_handles);

	// Don't continue until we see MSG_PROCEED, that tells us the child has
	// received the message and isn't in a wait_one/wait_many syscall.
	ASSERT_TRUE(recv_specific_msg(channel, MSG_PROCEED));

	wait_thread_blocked(thread, ZX_THREAD_STATE_BLOCKED_WAIT_MANY);

	// Wake the child up.
	for (uint32_t i = 0; i < num_handles; ++i) {
	tu_handle_close(h[0][i]);
	}

	// The child sends a pass/fail message back as extra verification that
	// things went correctly on that side.
	ASSERT_TRUE(recv_specific_msg(channel, MSG_PASS));

	terminate_process(child);

	END_TEST;
	}

	// Just like wait_many_test except the child doesn't wait on any objects, just
	// the (infinite) timeout.
	static bool wait_many_no_objects_test() {
	BEGIN_TEST;

	// Start a new process.
	zx_handle_t child, channel;
	start_test_child(zx_job_default(), test_child_name, &child, &channel);
	zx_handle_t thread;
	ASSERT_TRUE(get_child_thread(channel, &thread));

	send_msg(channel, MSG_WAIT_MANY_TEST);

	// Don't continue until we see MSG_PROCEED, that tells us the child has
	// received the message and isn't in a wait_one/wait_many syscall.
	ASSERT_TRUE(recv_specific_msg(channel, MSG_PROCEED));

	wait_thread_blocked(thread, ZX_THREAD_STATE_BLOCKED_WAIT_MANY);

	// The child won't be sending a pass/fail message back because it's stuck in
	// object_wait_many so just kill it.
	terminate_process(child);

	END_TEST;
	}

	static bool interrupt_test() {
	BEGIN_TEST;

	// Start a new process.
	zx_handle_t child, channel;
	start_test_child(zx_job_default(), test_child_name, &child, &channel);
	zx_handle_t thread;
	ASSERT_TRUE(get_child_thread(channel, &thread));

	zx_handle_t resource;
	ASSERT_EQ(get_root_resource(&resource), ZX_OK);

	zx_handle_t interrupt;
	ASSERT_EQ(zx_interrupt_create(resource, 0, ZX_INTERRUPT_VIRTUAL, &interrupt),
	ZX_OK);
	zx_handle_t interrupt_dupe = tu_handle_duplicate(interrupt);

	send_msg_with_handles(channel, MSG_INTERRUPT_TEST, &interrupt_dupe, 1);

	wait_thread_blocked(thread, ZX_THREAD_STATE_BLOCKED_INTERRUPT);

	// Wake the child up.
	EXPECT_EQ(zx_interrupt_trigger(interrupt, 0, interrupt_signaled_timestamp), ZX_OK);

	// The child sends a pass/fail message back as extra verification that
	// things went correctly on that side.
	ASSERT_TRUE(recv_specific_msg(channel, MSG_PASS));

	tu_handle_close(interrupt);
	terminate_process(child);

	END_TEST;
	}

	BEGIN_TEST_CASE(thread_state_tests)
	// ZX_THREAD_STATE_BLOCKED_EXCEPTION is tested in utest/exception.
	// There's a lot of support logic and there's no reason to duplicate it here.
	RUN_TEST(sleeping_test);
	RUN_TEST(futex_test);
	RUN_TEST(port_test);
	RUN_TEST(channel_test);
	RUN_TEST(wait_one_test);
	RUN_TEST(wait_many_test);
	RUN_TEST(wait_many_no_objects_test);
	RUN_TEST(interrupt_test);
	END_TEST_CASE(thread_state_tests)

	static void scan_argv(int argc, char** argv) {
	for (int i = 1; i < argc; ++i) {
	if (strncmp(argv[i], "v=", 2) == 0) {
	int verbosity = atoi(argv[i] + 2);
	unittest_set_verbosity_level(verbosity);
	}
	}
	}

	int main(int argc, char **argv) {
	program_path = argv[0];
	scan_argv(argc, argv);

	if (argc >= 2) {
	if (strcmp(argv[1], test_child_name) == 0) {
	test_child();
	return 0;
	}
	}

	bool success = unittest_run_all_tests(argc, argv);

	return success ? 0 : -1;
	}