diff --git a/tests/Android.bp b/tests/Android.bp
index 71cf8a6..85bb29a 100644
--- a/tests/Android.bp
+++ b/tests/Android.bp
@@ -184,6 +184,7 @@
         "system_properties_test2.cpp",
         "termios_test.cpp",
         "tgmath_test.c",
+        "threads_test.cpp",
         "time_test.cpp",
         "uchar_test.cpp",
         "unistd_nofortify_test.cpp",
diff --git a/tests/headers/posix/threads_h.c b/tests/headers/posix/threads_h.c
new file mode 100644
index 0000000..c9329f4
--- /dev/null
+++ b/tests/headers/posix/threads_h.c
@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#if __has_include(<threads.h>)
+
+#include <threads.h>
+
+#include "header_checks.h"
+
+thread_local int t;
+
+static void threads_h() {
+  MACRO(ONCE_FLAG_INIT);
+  MACRO(TSS_DTOR_ITERATIONS);
+
+  TYPE(cnd_t);
+  TYPE(thrd_t);
+  TYPE(tss_t);
+  TYPE(mtx_t);
+
+  TYPE(tss_dtor_t);
+  TYPE(thrd_start_t);
+
+  TYPE(once_flag);
+
+  int enumeration_constants = mtx_plain | mtx_recursive | mtx_timed |
+      thrd_timedout | thrd_success | thrd_busy | thrd_error | thrd_nomem;
+
+  FUNCTION(call_once, void (*f)(once_flag*, void (*)(void)));
+
+  FUNCTION(cnd_broadcast, int (*f)(cnd_t*));
+  FUNCTION(cnd_destroy, void (*f)(cnd_t*));
+  FUNCTION(cnd_init, int (*f)(cnd_t*));
+  FUNCTION(cnd_signal, int (*f)(cnd_t*));
+  FUNCTION(cnd_timedwait, int (*f)(cnd_t*, mtx_t*, const struct timespec*));
+  FUNCTION(cnd_wait, int (*f)(cnd_t*, mtx_t*));
+
+  FUNCTION(mtx_destroy, void (*f)(mtx_t*));
+  FUNCTION(mtx_init, int (*f)(mtx_t*, int));
+  FUNCTION(mtx_lock, int (*f)(mtx_t*));
+  FUNCTION(mtx_timedlock, int (*f)(mtx_t*, const struct timespec*));
+  FUNCTION(mtx_trylock, int (*f)(mtx_t*));
+  FUNCTION(mtx_unlock, int (*f)(mtx_t*));
+
+  FUNCTION(thrd_create, int (*f)(thrd_t*, thrd_start_t, void*));
+  FUNCTION(thrd_current, thrd_t (*f)(void));
+  FUNCTION(thrd_detach, int (*f)(thrd_t));
+  FUNCTION(thrd_equal, int (*f)(thrd_t, thrd_t));
+  FUNCTION(thrd_exit, void (*f)(int));
+  FUNCTION(thrd_join, int (*f)(thrd_t, int*));
+  FUNCTION(thrd_sleep, int (*f)(const struct timespec*, struct timespec*));
+  FUNCTION(thrd_yield, void (*f)(void));
+
+  FUNCTION(tss_create, int (*f)(tss_t*, tss_dtor_t));
+  FUNCTION(tss_delete, void (*f)(tss_t));
+  FUNCTION(tss_get, void* (*f)(tss_t));
+  FUNCTION(tss_set, int (*f)(tss_t, void*));
+}
+
+#define DO_NOT_INCLUDE_TIME_H
+#include "time_h.c"
+
+#endif
diff --git a/tests/threads_test.cpp b/tests/threads_test.cpp
new file mode 100644
index 0000000..5fafff3
--- /dev/null
+++ b/tests/threads_test.cpp
@@ -0,0 +1,515 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <gtest/gtest.h>
+
+#if __has_include(<threads.h>)
+
+#define HAVE_THREADS_H
+#include <threads.h>
+
+static int g_call_once_call_count;
+
+static void increment_call_count() {
+  ++g_call_once_call_count;
+}
+
+static int g_dtor_call_count;
+
+static void tss_dtor(void* ptr) {
+  ++g_dtor_call_count;
+  free(ptr);
+}
+
+static int return_arg(void* arg) {
+  return static_cast<int>(reinterpret_cast<uintptr_t>(arg));
+}
+
+static int exit_arg(void* arg) {
+  thrd_exit(static_cast<int>(reinterpret_cast<uintptr_t>(arg)));
+}
+
+#endif
+
+#include <time.h>
+
+#include <thread>
+
+#include "BionicDeathTest.h"
+#include "SignalUtils.h"
+
+TEST(threads, call_once) {
+#if !defined(HAVE_THREADS_H)
+  GTEST_SKIP() << "<threads.h> unavailable";
+#else
+  once_flag flag = ONCE_FLAG_INIT;
+  call_once(&flag, increment_call_count);
+  call_once(&flag, increment_call_count);
+  std::thread([&flag] {
+    call_once(&flag, increment_call_count);
+  }).join();
+  ASSERT_EQ(1, g_call_once_call_count);
+#endif
+}
+
+TEST(threads, cnd_broadcast__cnd_wait) {
+#if !defined(HAVE_THREADS_H)
+  GTEST_SKIP() << "<threads.h> unavailable";
+#else
+  mtx_t m;
+  ASSERT_EQ(thrd_success, mtx_init(&m, mtx_plain));
+
+  cnd_t c;
+  ASSERT_EQ(thrd_success, cnd_init(&c));
+
+  std::atomic_int i = 0;
+
+  auto waiter = [&c, &i, &m] {
+    ASSERT_EQ(thrd_success, mtx_lock(&m));
+    while (i != 1) ASSERT_EQ(thrd_success, cnd_wait(&c, &m));
+    ASSERT_EQ(thrd_success, mtx_unlock(&m));
+  };
+  std::thread t1(waiter);
+  std::thread t2(waiter);
+  std::thread t3(waiter);
+
+  ASSERT_EQ(thrd_success, mtx_lock(&m));
+  i = 1;
+  ASSERT_EQ(thrd_success, mtx_unlock(&m));
+
+  ASSERT_EQ(thrd_success, cnd_broadcast(&c));
+
+  t1.join();
+  t2.join();
+  t3.join();
+
+  mtx_destroy(&m);
+  cnd_destroy(&c);
+#endif
+}
+
+TEST(threads, cnd_init__cnd_destroy) {
+#if !defined(HAVE_THREADS_H)
+  GTEST_SKIP() << "<threads.h> unavailable";
+#else
+  cnd_t c;
+  ASSERT_EQ(thrd_success, cnd_init(&c));
+  cnd_destroy(&c);
+#endif
+}
+
+TEST(threads, cnd_signal__cnd_wait) {
+#if !defined(HAVE_THREADS_H)
+  GTEST_SKIP() << "<threads.h> unavailable";
+#else
+  mtx_t m;
+  ASSERT_EQ(thrd_success, mtx_init(&m, mtx_plain));
+  cnd_t c;
+  ASSERT_EQ(thrd_success, cnd_init(&c));
+
+  std::atomic_int count = 0;
+  auto waiter = [&c, &m, &count] {
+    ASSERT_EQ(thrd_success, mtx_lock(&m));
+    ASSERT_EQ(thrd_success, cnd_wait(&c, &m));
+    ASSERT_EQ(thrd_success, mtx_unlock(&m));
+    ++count;
+  };
+  std::thread t1(waiter);
+  std::thread t2(waiter);
+  std::thread t3(waiter);
+
+  // This is inherently racy, but attempts to distinguish between cnd_signal and
+  // cnd_broadcast.
+  usleep(100000);
+  ASSERT_EQ(thrd_success, cnd_signal(&c));
+  while (count == 0) {
+  }
+  usleep(100000);
+  ASSERT_EQ(1, count);
+
+  ASSERT_EQ(thrd_success, cnd_signal(&c));
+  while (count == 1) {
+  }
+  usleep(100000);
+  ASSERT_EQ(2, count);
+
+  ASSERT_EQ(thrd_success, cnd_signal(&c));
+  while (count == 2) {
+  }
+  usleep(100000);
+  ASSERT_EQ(3, count);
+
+  t1.join();
+  t2.join();
+  t3.join();
+
+  mtx_destroy(&m);
+  cnd_destroy(&c);
+#endif
+}
+
+TEST(threads, cnd_timedwait_timedout) {
+#if !defined(HAVE_THREADS_H)
+  GTEST_SKIP() << "<threads.h> unavailable";
+#else
+  mtx_t m;
+  ASSERT_EQ(thrd_success, mtx_init(&m, mtx_timed));
+  ASSERT_EQ(thrd_success, mtx_lock(&m));
+
+  cnd_t c;
+  ASSERT_EQ(thrd_success, cnd_init(&c));
+
+  timespec ts = {};
+  ASSERT_EQ(thrd_timedout, cnd_timedwait(&c, &m, &ts));
+#endif
+}
+
+TEST(threads, cnd_timedwait) {
+#if !defined(HAVE_THREADS_H)
+  GTEST_SKIP() << "<threads.h> unavailable";
+#else
+  mtx_t m;
+  ASSERT_EQ(thrd_success, mtx_init(&m, mtx_timed));
+
+  cnd_t c;
+  ASSERT_EQ(thrd_success, cnd_init(&c));
+
+  std::atomic_bool done = false;
+  std::thread t([&c, &m, &done] {
+    ASSERT_EQ(thrd_success, mtx_lock(&m));
+
+    // cnd_timewait's time is *absolute*.
+    timespec ts;
+    ASSERT_EQ(TIME_UTC, timespec_get(&ts, TIME_UTC));
+    ts.tv_sec += 666;
+
+    ASSERT_EQ(thrd_success, cnd_timedwait(&c, &m, &ts));
+    done = true;
+    ASSERT_EQ(thrd_success, mtx_unlock(&m));
+  });
+
+  while (!done) ASSERT_EQ(thrd_success, cnd_signal(&c));
+
+  t.join();
+#endif
+}
+
+TEST(threads, mtx_init) {
+#if !defined(HAVE_THREADS_H)
+  GTEST_SKIP() << "<threads.h> unavailable";
+#else
+  mtx_t m;
+  ASSERT_EQ(thrd_success, mtx_init(&m, mtx_plain));
+  ASSERT_EQ(thrd_success, mtx_init(&m, mtx_timed));
+  ASSERT_EQ(thrd_success, mtx_init(&m, mtx_plain | mtx_recursive));
+  ASSERT_EQ(thrd_success, mtx_init(&m, mtx_timed | mtx_recursive));
+  ASSERT_EQ(thrd_error, mtx_init(&m, 123));
+  ASSERT_EQ(thrd_error, mtx_init(&m, mtx_recursive));
+#endif
+}
+
+TEST(threads, mtx_destroy) {
+#if !defined(HAVE_THREADS_H)
+  GTEST_SKIP() << "<threads.h> unavailable";
+#else
+  mtx_t m;
+  ASSERT_EQ(thrd_success, mtx_init(&m, mtx_plain));
+  mtx_destroy(&m);
+#endif
+}
+
+TEST(threads, mtx_lock_plain) {
+#if !defined(HAVE_THREADS_H)
+  GTEST_SKIP() << "<threads.h> unavailable";
+#else
+  mtx_t m;
+  ASSERT_EQ(thrd_success, mtx_init(&m, mtx_plain));
+
+  ASSERT_EQ(thrd_success, mtx_lock(&m));
+  ASSERT_EQ(thrd_busy, mtx_trylock(&m));
+  ASSERT_EQ(thrd_success, mtx_unlock(&m));
+
+  mtx_destroy(&m);
+#endif
+}
+
+TEST(threads, mtx_lock_recursive) {
+#if !defined(HAVE_THREADS_H)
+  GTEST_SKIP() << "<threads.h> unavailable";
+#else
+  mtx_t m;
+  ASSERT_EQ(thrd_success, mtx_init(&m, mtx_plain | mtx_recursive));
+
+  ASSERT_EQ(thrd_success, mtx_lock(&m));
+  ASSERT_EQ(thrd_success, mtx_trylock(&m));
+  ASSERT_EQ(thrd_success, mtx_unlock(&m));
+  ASSERT_EQ(thrd_success, mtx_unlock(&m));
+
+  mtx_destroy(&m);
+#endif
+}
+
+TEST(threads, mtx_timedlock) {
+#if !defined(HAVE_THREADS_H)
+  GTEST_SKIP() << "<threads.h> unavailable";
+#else
+  mtx_t m;
+  ASSERT_EQ(thrd_success, mtx_init(&m, mtx_timed));
+
+  timespec ts = {};
+  ASSERT_EQ(thrd_success, mtx_timedlock(&m, &ts));
+
+  std::thread([&m] {
+    timespec ts = { .tv_nsec = 500000 };
+    ASSERT_EQ(thrd_timedout, mtx_timedlock(&m, &ts));
+  }).join();
+
+  ASSERT_EQ(thrd_success, mtx_unlock(&m));
+  mtx_destroy(&m);
+#endif
+}
+
+
+TEST(threads, mtx_unlock) {
+#if !defined(HAVE_THREADS_H)
+  GTEST_SKIP() << "<threads.h> unavailable";
+#else
+  mtx_t m;
+  ASSERT_EQ(thrd_success, mtx_init(&m, mtx_plain));
+  ASSERT_EQ(thrd_success, mtx_lock(&m));
+  std::thread([&m] {
+    ASSERT_EQ(thrd_busy, mtx_trylock(&m));
+  }).join();
+  ASSERT_EQ(thrd_success, mtx_unlock(&m));
+  std::thread([&m] {
+    ASSERT_EQ(thrd_success, mtx_trylock(&m));
+  }).join();
+#endif
+}
+
+TEST(threads, thrd_current__thrd_equal) {
+#if !defined(HAVE_THREADS_H)
+  GTEST_SKIP() << "<threads.h> unavailable";
+#else
+  thrd_t t1 = thrd_current();
+  // (As a side-effect, this demonstrates interoperability with std::thread.)
+  std::thread([&t1] {
+    thrd_t t2 = thrd_current();
+    ASSERT_FALSE(thrd_equal(t1, t2));
+    thrd_t t2_2 = thrd_current();
+    ASSERT_TRUE(thrd_equal(t2, t2_2));
+  }).join();
+  thrd_t t1_2 = thrd_current();
+  ASSERT_TRUE(thrd_equal(t1, t1_2));
+#endif
+}
+
+TEST(threads, thrd_create__thrd_detach) {
+#if !defined(HAVE_THREADS_H)
+  GTEST_SKIP() << "<threads.h> unavailable";
+#else
+  thrd_t t;
+  ASSERT_EQ(thrd_success, thrd_create(&t, exit_arg, reinterpret_cast<void*>(1)));
+  ASSERT_EQ(thrd_success, thrd_detach(t));
+#endif
+}
+
+TEST(threads, thrd_create__thrd_exit) {
+#if !defined(HAVE_THREADS_H)
+  GTEST_SKIP() << "<threads.h> unavailable";
+#else
+  // Similar to the thrd_join test, but with a function that calls thrd_exit
+  // instead.
+  thrd_t t;
+  int result;
+  ASSERT_EQ(thrd_success, thrd_create(&t, exit_arg, reinterpret_cast<void*>(1)));
+  ASSERT_EQ(thrd_success, thrd_join(t, &result));
+  ASSERT_EQ(1, result);
+
+  ASSERT_EQ(thrd_success, thrd_create(&t, exit_arg, reinterpret_cast<void*>(2)));
+  ASSERT_EQ(thrd_success, thrd_join(t, &result));
+  ASSERT_EQ(2, result);
+
+  // The `result` argument can be null if you don't care...
+  ASSERT_EQ(thrd_success, thrd_create(&t, exit_arg, reinterpret_cast<void*>(3)));
+  ASSERT_EQ(thrd_success, thrd_join(t, nullptr));
+#endif
+}
+
+class threads_DeathTest : public BionicDeathTest {};
+
+TEST(threads_DeathTest, thrd_exit_main_thread) {
+#if !defined(HAVE_THREADS_H)
+  GTEST_SKIP() << "<threads.h> unavailable";
+#else
+  // "The program terminates normally after the last thread has been terminated.
+  // The behavior is as if the program called the exit function with the status
+  // EXIT_SUCCESS at thread termination time." (ISO/IEC 9899:2018)
+  ASSERT_EXIT(thrd_exit(12), ::testing::ExitedWithCode(EXIT_SUCCESS), "");
+#endif
+}
+
+TEST(threads, thrd_create__thrd_join) {
+#if !defined(HAVE_THREADS_H)
+  GTEST_SKIP() << "<threads.h> unavailable";
+#else
+  // Similar to the thrd_exit test, but with a function that calls return
+  // instead.
+  thrd_t t;
+  int result;
+  ASSERT_EQ(thrd_success, thrd_create(&t, return_arg, reinterpret_cast<void*>(1)));
+  ASSERT_EQ(thrd_success, thrd_join(t, &result));
+  ASSERT_EQ(1, result);
+
+  ASSERT_EQ(thrd_success, thrd_create(&t, return_arg, reinterpret_cast<void*>(2)));
+  ASSERT_EQ(thrd_success, thrd_join(t, &result));
+  ASSERT_EQ(2, result);
+
+  // The `result` argument can be null if you don't care...
+  ASSERT_EQ(thrd_success, thrd_create(&t, return_arg, reinterpret_cast<void*>(3)));
+  ASSERT_EQ(thrd_success, thrd_join(t, nullptr));
+#endif
+}
+
+TEST(threads, thrd_sleep_signal) {
+#if !defined(HAVE_THREADS_H)
+  GTEST_SKIP() << "<threads.h> unavailable";
+#else
+  ScopedSignalHandler ssh{SIGALRM, [](int) {}};
+  std::thread t([] {
+    timespec long_time = { .tv_sec = 666 };
+    timespec remaining = {};
+    ASSERT_EQ(-1, thrd_sleep(&long_time, &remaining));
+    uint64_t t = remaining.tv_sec * 1000000000 + remaining.tv_nsec;
+    ASSERT_LE(t, 666ULL * 1000000000);
+  });
+  usleep(100000); // 0.1s
+  pthread_kill(t.native_handle(), SIGALRM);
+  t.join();
+#endif
+}
+
+TEST(threads, thrd_sleep_signal_nullptr) {
+#if !defined(HAVE_THREADS_H)
+  GTEST_SKIP() << "<threads.h> unavailable";
+#else
+  ScopedSignalHandler ssh{SIGALRM, [](int) {}};
+  std::thread t([] {
+    timespec long_time = { .tv_sec = 666 };
+    ASSERT_EQ(-1, thrd_sleep(&long_time, nullptr));
+  });
+  usleep(100000); // 0.1s
+  pthread_kill(t.native_handle(), SIGALRM);
+  t.join();
+#endif
+}
+
+TEST(threads, thrd_sleep_error) {
+#if !defined(HAVE_THREADS_H)
+  GTEST_SKIP() << "<threads.h> unavailable";
+#else
+  timespec invalid = { .tv_sec = -1 };
+  ASSERT_EQ(-2, thrd_sleep(&invalid, nullptr));
+#endif
+}
+
+TEST(threads, thrd_yield) {
+#if !defined(HAVE_THREADS_H)
+  GTEST_SKIP() << "<threads.h> unavailable";
+#else
+  thrd_yield();
+#endif
+}
+
+TEST(threads, TSS_DTOR_ITERATIONS_macro) {
+#if !defined(HAVE_THREADS_H)
+  GTEST_SKIP() << "<threads.h> unavailable";
+#else
+  ASSERT_EQ(PTHREAD_DESTRUCTOR_ITERATIONS, TSS_DTOR_ITERATIONS);
+#endif
+}
+
+TEST(threads, tss_create) {
+#if !defined(HAVE_THREADS_H)
+  GTEST_SKIP() << "<threads.h> unavailable";
+#else
+  tss_t key;
+  ASSERT_EQ(thrd_success, tss_create(&key, nullptr));
+  tss_delete(key);
+#endif
+}
+
+TEST(threads, tss_create_dtor) {
+#if !defined(HAVE_THREADS_H)
+  GTEST_SKIP() << "<threads.h> unavailable";
+#else
+  tss_dtor_t dtor = tss_dtor;
+  tss_t key;
+  ASSERT_EQ(thrd_success, tss_create(&key, dtor));
+
+  ASSERT_EQ(thrd_success, tss_set(key, strdup("hello")));
+  std::thread([&key] {
+    ASSERT_EQ(thrd_success, tss_set(key, strdup("world")));
+  }).join();
+  // Thread exit calls the destructor...
+  ASSERT_EQ(1, g_dtor_call_count);
+
+  // "[A call to tss_set] will not invoke the destructor associated with the
+  // key on the value being replaced" (ISO/IEC 9899:2018).
+  g_dtor_call_count = 0;
+  ASSERT_EQ(thrd_success, tss_set(key, strdup("hello")));
+  ASSERT_EQ(0, g_dtor_call_count);
+
+  // "Calling tss_delete will not result in the invocation of any
+  // destructors" (ISO/IEC 9899:2018).
+  // The destructor for "hello" won't be called until *this* thread exits.
+  g_dtor_call_count = 0;
+  tss_delete(key);
+  ASSERT_EQ(0, g_dtor_call_count);
+#endif
+}
+
+TEST(threads, tss_get__tss_set) {
+#if !defined(HAVE_THREADS_H)
+  GTEST_SKIP() << "<threads.h> unavailable";
+#else
+  tss_t key;
+  ASSERT_EQ(thrd_success, tss_create(&key, nullptr));
+
+  ASSERT_EQ(thrd_success, tss_set(key, const_cast<char*>("hello")));
+  ASSERT_STREQ("hello", reinterpret_cast<char*>(tss_get(key)));
+  std::thread([&key] {
+      ASSERT_EQ(nullptr, tss_get(key));
+      ASSERT_EQ(thrd_success, tss_set(key, const_cast<char*>("world")));
+      ASSERT_STREQ("world", reinterpret_cast<char*>(tss_get(key)));
+  }).join();
+  ASSERT_STREQ("hello", reinterpret_cast<char*>(tss_get(key)));
+
+  tss_delete(key);
+#endif
+}