tsan: for unittests, change to use test fixtures to clear racy stacks

[ychen]

Summary

After cd0a5889d71, unittest would run in shard mode where many tests
share a single process. Need to clear some global state to make the test
results stable.

[rsundahl]

Thanks for this update @ychen , it fixes our downstream tsan>RaceWithDeadThread failure since the original commit and gets to the root cause nicely..

[thetruestblue]

LGTM. I also confirmed this fixed the RaceWithDeadThread unit test failure since integrating sharding. Nice fix.

compiler-rt/lib/tsan/tests/rtl/tsan_mop.cpp

 //
 //===----------------------------------------------------------------------===//
 #include "tsan_interface.h"
 #include "tsan_test_util.h"
 #include "gtest/gtest.h"
 #include <stddef.h>
 #include <stdint.h>
 
-TEST(ThreadSanitizer, SimpleWrite) {
+TEST_F(ThreadSanitizer, SimpleWrite) {
   ScopedThread t;
   MemLoc l;
   t.Write1(l);
 }
 
-TEST(ThreadSanitizer, SimpleWriteWrite) {
+TEST_F(ThreadSanitizer, SimpleWriteWrite) {
   ScopedThread t1, t2;
   MemLoc l1, l2;
   t1.Write1(l1);
   t2.Write1(l2);
 }
 
-TEST(ThreadSanitizer, WriteWriteRace) {
+TEST_F(ThreadSanitizer, WriteWriteRace) {
   ScopedThread t1, t2;
   MemLoc l;
   t1.Write1(l);
   t2.Write1(l, true);
 }
 
-TEST(ThreadSanitizer, ReadWriteRace) {
+TEST_F(ThreadSanitizer, ReadWriteRace) {
   ScopedThread t1, t2;
   MemLoc l;
   t1.Read1(l);
   t2.Write1(l, true);
 }
 
-TEST(ThreadSanitizer, WriteReadRace) {
+TEST_F(ThreadSanitizer, WriteReadRace) {
   ScopedThread t1, t2;
   MemLoc l;
   t1.Write1(l);
   t2.Read1(l, true);
 }
 
-TEST(ThreadSanitizer, ReadReadNoRace) {
+TEST_F(ThreadSanitizer, ReadReadNoRace) {
   ScopedThread t1, t2;
   MemLoc l;
   t1.Read1(l);
   t2.Read1(l);
 }
 
-TEST(ThreadSanitizer, WriteThenRead) {
+TEST_F(ThreadSanitizer, WriteThenRead) {
   MemLoc l;
   ScopedThread t1, t2;
   t1.Write1(l);
   t1.Read1(l);
   t2.Read1(l, true);
 }
 
-TEST(ThreadSanitizer, WriteThenLockedRead) {
+TEST_F(ThreadSanitizer, WriteThenLockedRead) {
   UserMutex m(UserMutex::RW);
   MainThread t0;
   t0.Create(m);
   MemLoc l;
   {
     ScopedThread t1, t2;
 
     t1.Write8(l);
 
     t1.Lock(m);
     t1.Read8(l);
     t1.Unlock(m);
 
     t2.Read8(l, true);
   }
   t0.Destroy(m);
 }
 
-TEST(ThreadSanitizer, LockedWriteThenRead) {
+TEST_F(ThreadSanitizer, LockedWriteThenRead) {
   UserMutex m(UserMutex::RW);
   MainThread t0;
   t0.Create(m);
   MemLoc l;
   {
     ScopedThread t1, t2;
 
     t1.Lock(m);
     t1.Write8(l);
     t1.Unlock(m);
 
     t1.Read8(l);
 
     t2.Read8(l, true);
   }
   t0.Destroy(m);
 }
 
 
-TEST(ThreadSanitizer, RaceWithOffset) {
+TEST_F(ThreadSanitizer, RaceWithOffset) {
   ScopedThread t1, t2;
   {
     MemLoc l;
     t1.Access(l.loc(), true, 8, false);
     t2.Access((char*)l.loc() + 4, true, 4, true);
   }
   {
     MemLoc l;
TEST_F(ThreadSanitizer, RaceWithOffset) {
   }
   {
     MemLoc l;
     t1.Access((char*)l.loc() + 1, true, 8, false);
     t2.Access((char*)l.loc() + 3, true, 1, true);
   }
 }
 
-TEST(ThreadSanitizer, RaceWithOffset2) {
+TEST_F(ThreadSanitizer, RaceWithOffset2) {
   ScopedThread t1, t2;
   {
     MemLoc l;
     t1.Access((char*)l.loc(), true, 4, false);
     t2.Access((char*)l.loc() + 2, true, 1, true);
   }
   {
     MemLoc l;
     t1.Access((char*)l.loc() + 2, true, 1, false);
     t2.Access((char*)l.loc(), true, 4, true);
   }
 }
 
-TEST(ThreadSanitizer, NoRaceWithOffset) {
+TEST_F(ThreadSanitizer, NoRaceWithOffset) {
   ScopedThread t1, t2;
   {
     MemLoc l;
     t1.Access(l.loc(), true, 4, false);
     t2.Access((char*)l.loc() + 4, true, 4, false);
   }
   {
     MemLoc l;
     t1.Access((char*)l.loc() + 3, true, 2, false);
     t2.Access((char*)l.loc() + 1, true, 2, false);
     t2.Access((char*)l.loc() + 5, true, 2, false);
   }
 }
 
-TEST(ThreadSanitizer, RaceWithDeadThread) {
+TEST_F(ThreadSanitizer, RaceWithDeadThread) {
   MemLoc l;
   ScopedThread t;
   ScopedThread().Write1(l);
   t.Write1(l, true);
 }
 
-TEST(ThreadSanitizer, BenignRaceOnVptr) {
+TEST_F(ThreadSanitizer, BenignRaceOnVptr) {
   void *vptr_storage;
   MemLoc vptr(&vptr_storage), val;
   vptr_storage = val.loc();
   ScopedThread t1, t2;
   t1.VptrUpdate(vptr, val);
   t2.Read8(vptr);
 }
 
-TEST(ThreadSanitizer, HarmfulRaceOnVptr) {
+TEST_F(ThreadSanitizer, HarmfulRaceOnVptr) {
   void *vptr_storage;
   MemLoc vptr(&vptr_storage), val1, val2;
   vptr_storage = val1.loc();
   ScopedThread t1, t2;
   t1.VptrUpdate(vptr, val2);
   t2.Read8(vptr, true);
 }
 
 static void foo() {
   volatile int x = 42;
   int x2 = x;
   (void)x2;
 }
 
 static void bar() {
   volatile int x = 43;
   int x2 = x;
   (void)x2;
 }
 
-TEST(ThreadSanitizer, ReportDeadThread) {
+TEST_F(ThreadSanitizer, ReportDeadThread) {
   MemLoc l;
   ScopedThread t1;
   {
     ScopedThread t2;
     t2.Call(&foo);
     t2.Call(&bar);
     t2.Write1(l);
   }
   t1.Write1(l, true);
 }
 
 struct ClassWithStatic {
   static int Data[4];
 };
 
 int ClassWithStatic::Data[4];
 
 static void foobarbaz() {}
 
-TEST(ThreadSanitizer, ReportRace) {
+TEST_F(ThreadSanitizer, ReportRace) {
   ScopedThread t1;
   MainThread().Access(&ClassWithStatic::Data, true, 4, false);
   t1.Call(&foobarbaz);
   t1.Access(&ClassWithStatic::Data, true, 2, true);
   t1.Return();
 }

compiler-rt/lib/tsan/tests/rtl/tsan_mutex.cpp

 #include "tsan_interface.h"
 #include "tsan_interface_ann.h"
 #include "tsan_test_util.h"
 #include "gtest/gtest.h"
 #include <stdint.h>
 
 namespace __tsan {
 
-TEST(ThreadSanitizer, BasicMutex) {
+TEST_F(ThreadSanitizer, BasicMutex) {
   ScopedThread t;
   UserMutex m;
   t.Create(m);
 
   t.Lock(m);
   t.Unlock(m);
 
   CHECK(t.TryLock(m));
   t.Unlock(m);
 
   t.Lock(m);
   CHECK(!t.TryLock(m));
   t.Unlock(m);
 
   t.Destroy(m);
 }
 
-TEST(ThreadSanitizer, BasicSpinMutex) {
+TEST_F(ThreadSanitizer, BasicSpinMutex) {
   ScopedThread t;
   UserMutex m(UserMutex::Spin);
   t.Create(m);
 
   t.Lock(m);
   t.Unlock(m);
 
   CHECK(t.TryLock(m));
   t.Unlock(m);
 
   t.Lock(m);
   CHECK(!t.TryLock(m));
   t.Unlock(m);
 
   t.Destroy(m);
 }
 
-TEST(ThreadSanitizer, BasicRwMutex) {
+TEST_F(ThreadSanitizer, BasicRwMutex) {
   ScopedThread t;
   UserMutex m(UserMutex::RW);
   t.Create(m);
 
   t.Lock(m);
   t.Unlock(m);
 
   CHECK(t.TryLock(m));
TEST_F(ThreadSanitizer, BasicRwMutex) {
   t.ReadLock(m);
   CHECK(t.TryReadLock(m));
   t.ReadUnlock(m);
   t.ReadUnlock(m);
 
   t.Destroy(m);
 }
 
-TEST(ThreadSanitizer, Mutex) {
+TEST_F(ThreadSanitizer, Mutex) {
   UserMutex m;
   MainThread t0;
   t0.Create(m);
 
   ScopedThread t1, t2;
   MemLoc l;
   t1.Lock(m);
   t1.Write1(l);
   t1.Unlock(m);
   t2.Lock(m);
   t2.Write1(l);
   t2.Unlock(m);
   t2.Destroy(m);
 }
 
-TEST(ThreadSanitizer, SpinMutex) {
+TEST_F(ThreadSanitizer, SpinMutex) {
   UserMutex m(UserMutex::Spin);
   MainThread t0;
   t0.Create(m);
 
   ScopedThread t1, t2;
   MemLoc l;
   t1.Lock(m);
   t1.Write1(l);
   t1.Unlock(m);
   t2.Lock(m);
   t2.Write1(l);
   t2.Unlock(m);
   t2.Destroy(m);
 }
 
-TEST(ThreadSanitizer, RwMutex) {
+TEST_F(ThreadSanitizer, RwMutex) {
   UserMutex m(UserMutex::RW);
   MainThread t0;
   t0.Create(m);
 
   ScopedThread t1, t2, t3;
   MemLoc l;
   t1.Lock(m);
   t1.Write1(l);
   t1.Unlock(m);
   t2.Lock(m);
   t2.Write1(l);
   t2.Unlock(m);
   t1.ReadLock(m);
   t3.ReadLock(m);
   t1.Read1(l);
   t3.Read1(l);
   t1.ReadUnlock(m);
   t3.ReadUnlock(m);
   t2.Lock(m);
   t2.Write1(l);
   t2.Unlock(m);
   t2.Destroy(m);
 }
 
-TEST(ThreadSanitizer, StaticMutex) {
+TEST_F(ThreadSanitizer, StaticMutex) {
   // Emulates statically initialized mutex.
   UserMutex m;
   m.StaticInit();
   {
     ScopedThread t1, t2;
     t1.Lock(m);
     t1.Unlock(m);
     t2.Lock(m);

compiler-rt/lib/tsan/tests/rtl/tsan_string.cpp

 //
 //===----------------------------------------------------------------------===//
 #include "tsan_test_util.h"
 #include "gtest/gtest.h"
 #include <string.h>
 
 namespace __tsan {
 
-TEST(ThreadSanitizer, Memcpy) {
+TEST_F(ThreadSanitizer, Memcpy) {
   char data0[7] = {1, 2, 3, 4, 5, 6, 7};
   char data[7] = {42, 42, 42, 42, 42, 42, 42};
   MainThread().Memcpy(data+1, data0+1, 5);
   EXPECT_EQ(data[0], 42);
   EXPECT_EQ(data[1], 2);
   EXPECT_EQ(data[2], 3);
   EXPECT_EQ(data[3], 4);
   EXPECT_EQ(data[4], 5);
   EXPECT_EQ(data[5], 6);
   EXPECT_EQ(data[6], 42);
   MainThread().Memset(data+1, 13, 5);
   EXPECT_EQ(data[0], 42);
   EXPECT_EQ(data[1], 13);
   EXPECT_EQ(data[2], 13);
   EXPECT_EQ(data[3], 13);
   EXPECT_EQ(data[4], 13);
   EXPECT_EQ(data[5], 13);
   EXPECT_EQ(data[6], 42);
 }
 
-TEST(ThreadSanitizer, MemcpyRace1) {
+TEST_F(ThreadSanitizer, MemcpyRace1) {
   char *data = new char[10];
   char *data1 = new char[10];
   char *data2 = new char[10];
   ScopedThread t1, t2;
   t1.Memcpy(data, data1, 10);
   t2.Memcpy(data, data2, 10, true);
 }
 
-TEST(ThreadSanitizer, MemcpyRace2) {
+TEST_F(ThreadSanitizer, MemcpyRace2) {
   char *data = new char[10];
   char *data1 = new char[10];
   char *data2 = new char[10];
   ScopedThread t1, t2;
   t1.Memcpy(data+5, data1, 1);
   t2.Memcpy(data+3, data2, 4, true);
 }
 
-TEST(ThreadSanitizer, MemcpyRace3) {
+TEST_F(ThreadSanitizer, MemcpyRace3) {
   char *data = new char[10];
   char *data1 = new char[10];
   char *data2 = new char[10];
   ScopedThread t1, t2;
   t1.Memcpy(data, data1, 10);
   t2.Memcpy(data1, data2, 10, true);
 }
 
-TEST(ThreadSanitizer, MemcpyStack) {
+TEST_F(ThreadSanitizer, MemcpyStack) {
   char *data = new char[10];
   char *data1 = new char[10];
   ScopedThread t1, t2;
   t1.Memcpy(data, data1, 10);
   t2.Memcpy(data, data1, 10, true);
 }
 
-TEST(ThreadSanitizer, MemsetRace1) {
+TEST_F(ThreadSanitizer, MemsetRace1) {
   char *data = new char[10];
   ScopedThread t1, t2;
   t1.Memset(data, 1, 10);
   t2.Memset(data, 2, 10, true);
 }
 
 }  // namespace __tsan

compiler-rt/lib/tsan/tests/rtl/tsan_test.cpp

 //===----------------------------------------------------------------------===//
 #include "tsan_interface.h"
 #include "tsan_test_util.h"
 #include "gtest/gtest.h"
 
 static void foo() {}
 static void bar() {}
 
-TEST(ThreadSanitizer, FuncCall) {
+TEST_F(ThreadSanitizer, FuncCall) {
   ScopedThread t1, t2;
   MemLoc l;
   t1.Write1(l);
   t2.Call(foo);
   t2.Call(bar);
   t2.Write1(l, true);
   t2.Return();
   t2.Return();

compiler-rt/lib/tsan/tests/rtl/tsan_test_util.h

 //===-- tsan_test_util.h ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of ThreadSanitizer (TSan), a race detector.
 //
 // Test utils.
 //===----------------------------------------------------------------------===//
 #ifndef TSAN_TEST_UTIL_H
 #define TSAN_TEST_UTIL_H
 
+#include "gtest/gtest.h"
+
+class ThreadSanitizer : public ::testing::Test {
+ protected:
+  void TearDown() override;
+};
+
 void TestMutexBeforeInit();
 
 // A location of memory on which a race may be detected.
 class MemLoc {
  public:
   explicit MemLoc(int offset_from_aligned = 0);
   explicit MemLoc(void *const real_addr) : loc_(real_addr) { }
   ~MemLoc();

compiler-rt/lib/tsan/tests/rtl/tsan_test_util_posix.cpp

 //===-- tsan_test_util_posix.cpp ------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of ThreadSanitizer (TSan), a race detector.
 //
 // Test utils, Linux, FreeBSD, NetBSD and Darwin implementation.
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_common/sanitizer_atomic.h"
 #include "tsan_interface.h"
 #include "tsan_posix_util.h"
+#include "tsan_rtl.h"
 #include "tsan_test_util.h"
 #include "tsan_report.h"
 
-#include "gtest/gtest.h"
-
 #include <assert.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <stdint.h>
 #include <string.h>
 #include <unistd.h>
 #include <errno.h>
 
 #define CALLERPC (__builtin_return_address(0))
 
-using namespace __tsan;
-
 static __thread bool expect_report;
 static __thread bool expect_report_reported;
-static __thread ReportType expect_report_type;
+static __thread __tsan::ReportType expect_report_type;
+
+void ThreadSanitizer::TearDown() {
+  __tsan::ctx->racy_stacks.Reset();
+}
 
 static void *BeforeInitThread(void *param) {
   (void)param;
   return 0;
 }
 
 static void AtExit() {
 }
bool OnReport(const ReportDesc *rep, bool suppressed) {
   }
   expect_report_reported = true;
   return true;
 }
 }  // namespace __tsan
 
 static void* allocate_addr(int size, int offset_from_aligned = 0) {
   static uintptr_t foo;
-  static atomic_uintptr_t uniq = {(uintptr_t)&foo};  // Some real address.
+  static __tsan::atomic_uintptr_t uniq = {(uintptr_t)&foo}; // Some real address.
   const int kAlign = 16;
   CHECK(offset_from_aligned < kAlign);
   size = (size + 2 * kAlign) & ~(kAlign - 1);
-  uintptr_t addr = atomic_fetch_add(&uniq, size, memory_order_relaxed);
+  uintptr_t addr = atomic_fetch_add(&uniq, size, __tsan::memory_order_relaxed);
   return (void*)(addr + offset_from_aligned);
 }
 
 MemLoc::MemLoc(int offset_from_aligned)
   : loc_(allocate_addr(16, offset_from_aligned)) {
 }
 
 MemLoc::~MemLoc() {
enum Type {
     MEMSET
   };
   Type type;
   void *ptr;
   uptr arg;
   uptr arg2;
   bool res;
   bool expect_report;
-  ReportType report_type;
+  __tsan::ReportType report_type;
 
   explicit Event(Type type, const void *ptr = 0, uptr arg = 0, uptr arg2 = 0)
       : type(type),
         ptr(const_cast<void *>(ptr)),
         arg(arg),
         arg2(arg2),
         res(),
         expect_report(),
         report_type() {}
 
-  void ExpectReport(ReportType type) {
+  void ExpectReport(__tsan::ReportType type) {
     expect_report = true;
     report_type = type;
   }
 };
 
 struct ScopedThread::Impl {
   pthread_t thread;
   bool main;
   bool detached;
-  atomic_uintptr_t event;  // Event*
+  __tsan::atomic_uintptr_t event;  // Event*
 
   static void *ScopedThreadCallback(void *arg);
   void send(Event *ev);
   void HandleEvent(Event *ev);
 };
 
 void ScopedThread::Impl::HandleEvent(Event *ev) {
   CHECK_EQ(expect_report, false);
#endif
   }
   expect_report = false;
 }
 
 void *ScopedThread::Impl::ScopedThreadCallback(void *arg) {
   __tsan_func_entry(CALLERPC);
   Impl *impl = (Impl*)arg;
   for (;;) {
-    Event* ev = (Event*)atomic_load(&impl->event, memory_order_acquire);
+    Event *ev =
+        (Event *)atomic_load(&impl->event, __tsan::memory_order_acquire);
     if (ev == 0) {
       sched_yield();
       continue;
     }
     if (ev->type == Event::SHUTDOWN) {
-      atomic_store(&impl->event, 0, memory_order_release);
+      atomic_store(&impl->event, 0, __tsan::memory_order_release);
       break;
     }
     impl->HandleEvent(ev);
-    atomic_store(&impl->event, 0, memory_order_release);
+    atomic_store(&impl->event, 0, __tsan::memory_order_release);
   }
   __tsan_func_exit();
   return 0;
 }
 
 void ScopedThread::Impl::send(Event *e) {
   if (main) {
     HandleEvent(e);
   } else {
-    CHECK_EQ(atomic_load(&event, memory_order_relaxed), 0);
-    atomic_store(&event, (uintptr_t)e, memory_order_release);
-    while (atomic_load(&event, memory_order_acquire) != 0)
+    CHECK_EQ(atomic_load(&event, __tsan::memory_order_relaxed), 0);
+    atomic_store(&event, (uintptr_t)e, __tsan::memory_order_release);
+    while (atomic_load(&event, __tsan::memory_order_acquire) != 0)
       sched_yield();
   }
 }
 
 ScopedThread::ScopedThread(bool detached, bool main) {
   impl_ = new Impl;
   impl_->main = main;
   impl_->detached = detached;
-  atomic_store(&impl_->event, 0, memory_order_relaxed);
+  atomic_store(&impl_->event, 0, __tsan::memory_order_relaxed);
   if (!main) {
     pthread_attr_t attr;
     pthread_attr_init(&attr);
     pthread_attr_setdetachstate(
         &attr, detached ? PTHREAD_CREATE_DETACHED : PTHREAD_CREATE_JOINABLE);
     pthread_attr_setstacksize(&attr, 64*1024);
     __interceptor_pthread_create(&impl_->thread, &attr,
         ScopedThread::Impl::ScopedThreadCallback, impl_);
void ScopedThread::Detach() {
   __interceptor_pthread_detach(impl_->thread);
 }
 
 void ScopedThread::Access(void *addr, bool is_write,
                           int size, bool expect_race) {
   Event event(is_write ? Event::WRITE : Event::READ, addr, size,
               (uptr)CALLERPC);
   if (expect_race)
-    event.ExpectReport(ReportTypeRace);
+    event.ExpectReport(__tsan::ReportTypeRace);
   impl_->send(&event);
 }
 
 void ScopedThread::VptrUpdate(const MemLoc &vptr,
                               const MemLoc &new_val,
                               bool expect_race) {
   Event event(Event::VPTR_UPDATE, vptr.loc(), (uptr)new_val.loc());
   if (expect_race)
-    event.ExpectReport(ReportTypeRace);
+    event.ExpectReport(__tsan::ReportTypeRace);
   impl_->send(&event);
 }
 
 void ScopedThread::Call(void(*pc)()) {
   Event event(Event::CALL, (void*)((uintptr_t)pc));
   impl_->send(&event);
 }
 
void ScopedThread::ReadUnlock(const UserMutex &m) {
   Event event(Event::MUTEX_READUNLOCK, &m);
   impl_->send(&event);
 }
 
 void ScopedThread::Memcpy(void *dst, const void *src, int size,
                           bool expect_race) {
   Event event(Event::MEMCPY, dst, (uptr)src, size);
   if (expect_race)
-    event.ExpectReport(ReportTypeRace);
+    event.ExpectReport(__tsan::ReportTypeRace);
   impl_->send(&event);
 }
 
 void ScopedThread::Memset(void *dst, int val, int size,
                           bool expect_race) {
   Event event(Event::MEMSET, dst, val, size);
   if (expect_race)
-    event.ExpectReport(ReportTypeRace);
+    event.ExpectReport(__tsan::ReportTypeRace);
   impl_->send(&event);
 }

compiler-rt/lib/tsan/tests/rtl/tsan_thread.cpp

 //===-- tsan_thread.cpp ---------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of ThreadSanitizer (TSan), a race detector.
 //
 //===----------------------------------------------------------------------===//
 #include "tsan_test_util.h"
 #include "gtest/gtest.h"
 
-TEST(ThreadSanitizer, ThreadSync) {
+TEST_F(ThreadSanitizer, ThreadSync) {
   MainThread t0;
   MemLoc l;
   t0.Write1(l);
   {
     ScopedThread t1;
     t1.Write1(l);
   }
   t0.Write1(l);
 }
 
-TEST(ThreadSanitizer, ThreadDetach1) {
+TEST_F(ThreadSanitizer, ThreadDetach1) {
   ScopedThread t1(true);
   MemLoc l;
   t1.Write1(l);
 }
 
-TEST(ThreadSanitizer, ThreadDetach2) {
+TEST_F(ThreadSanitizer, ThreadDetach2) {
   ScopedThread t1;
   MemLoc l;
   t1.Write1(l);
   t1.Detach();
 }
 
 static void *thread_alot_func(void *arg) {
   (void)arg;