c89fdd716c
PlatformThread's API is using old style function pointers, causes casting, is unintuitive and forces artificial call sequences, and is additionally possible to misuse in release mode. Fix this by an API face lift: 1. The class is turned into a handle, which can be empty. 2. The only way of getting a non-empty PlatformThread is by calling SpawnJoinable or SpawnDetached, clearly conveying the semantics to the code reader. 3. Handles can be Finalized, which works differently for joinable and detached threads: a) Handles for detached threads are simply closed where applicable. b) Joinable threads are joined before handles are closed. 4. The destructor finalizes handles. No explicit call is needed. Fixed: webrtc:12727 Change-Id: Id00a0464edf4fc9e552b6a1fbb5d2e1280e88811 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/215075 Commit-Queue: Markus Handell <handellm@webrtc.org> Reviewed-by: Harald Alvestrand <hta@webrtc.org> Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org> Reviewed-by: Tommi <tommi@webrtc.org> Cr-Commit-Position: refs/heads/master@{#33923}
106 lines
3.2 KiB
C++
106 lines
3.2 KiB
C++
/*
|
|
* Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license
|
|
* that can be found in the LICENSE file in the root of the source
|
|
* tree. An additional intellectual property rights grant can be found
|
|
* in the file PATENTS. All contributing project authors may
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
*/
|
|
|
|
#include "rtc_base/platform_thread.h"
|
|
|
|
#include "absl/types/optional.h"
|
|
#include "rtc_base/event.h"
|
|
#include "system_wrappers/include/sleep.h"
|
|
#include "test/gmock.h"
|
|
|
|
namespace rtc {
|
|
|
|
TEST(PlatformThreadTest, DefaultConstructedIsEmpty) {
|
|
PlatformThread thread;
|
|
EXPECT_EQ(thread.GetHandle(), absl::nullopt);
|
|
EXPECT_TRUE(thread.empty());
|
|
}
|
|
|
|
TEST(PlatformThreadTest, StartFinalize) {
|
|
PlatformThread thread = PlatformThread::SpawnJoinable([] {}, "1");
|
|
EXPECT_NE(thread.GetHandle(), absl::nullopt);
|
|
EXPECT_FALSE(thread.empty());
|
|
thread.Finalize();
|
|
EXPECT_TRUE(thread.empty());
|
|
thread = PlatformThread::SpawnDetached([] {}, "2");
|
|
EXPECT_FALSE(thread.empty());
|
|
thread.Finalize();
|
|
EXPECT_TRUE(thread.empty());
|
|
}
|
|
|
|
TEST(PlatformThreadTest, MovesEmpty) {
|
|
PlatformThread thread1;
|
|
PlatformThread thread2 = std::move(thread1);
|
|
EXPECT_TRUE(thread1.empty());
|
|
EXPECT_TRUE(thread2.empty());
|
|
}
|
|
|
|
TEST(PlatformThreadTest, MovesHandles) {
|
|
PlatformThread thread1 = PlatformThread::SpawnJoinable([] {}, "1");
|
|
PlatformThread thread2 = std::move(thread1);
|
|
EXPECT_TRUE(thread1.empty());
|
|
EXPECT_FALSE(thread2.empty());
|
|
thread1 = PlatformThread::SpawnDetached([] {}, "2");
|
|
thread2 = std::move(thread1);
|
|
EXPECT_TRUE(thread1.empty());
|
|
EXPECT_FALSE(thread2.empty());
|
|
}
|
|
|
|
TEST(PlatformThreadTest,
|
|
TwoThreadHandlesAreDifferentWhenStartedAndEqualWhenJoined) {
|
|
PlatformThread thread1 = PlatformThread();
|
|
PlatformThread thread2 = PlatformThread();
|
|
EXPECT_EQ(thread1.GetHandle(), thread2.GetHandle());
|
|
thread1 = PlatformThread::SpawnJoinable([] {}, "1");
|
|
thread2 = PlatformThread::SpawnJoinable([] {}, "2");
|
|
EXPECT_NE(thread1.GetHandle(), thread2.GetHandle());
|
|
thread1.Finalize();
|
|
EXPECT_NE(thread1.GetHandle(), thread2.GetHandle());
|
|
thread2.Finalize();
|
|
EXPECT_EQ(thread1.GetHandle(), thread2.GetHandle());
|
|
}
|
|
|
|
TEST(PlatformThreadTest, RunFunctionIsCalled) {
|
|
bool flag = false;
|
|
PlatformThread::SpawnJoinable([&] { flag = true; }, "T");
|
|
EXPECT_TRUE(flag);
|
|
}
|
|
|
|
TEST(PlatformThreadTest, JoinsThread) {
|
|
// This test flakes if there are problems with the join implementation.
|
|
rtc::Event event;
|
|
PlatformThread::SpawnJoinable([&] { event.Set(); }, "T");
|
|
EXPECT_TRUE(event.Wait(/*give_up_after_ms=*/0));
|
|
}
|
|
|
|
TEST(PlatformThreadTest, StopsBeforeDetachedThreadExits) {
|
|
// This test flakes if there are problems with the detached thread
|
|
// implementation.
|
|
bool flag = false;
|
|
rtc::Event thread_started;
|
|
rtc::Event thread_continue;
|
|
rtc::Event thread_exiting;
|
|
PlatformThread::SpawnDetached(
|
|
[&] {
|
|
thread_started.Set();
|
|
thread_continue.Wait(Event::kForever);
|
|
flag = true;
|
|
thread_exiting.Set();
|
|
},
|
|
"T");
|
|
thread_started.Wait(Event::kForever);
|
|
EXPECT_FALSE(flag);
|
|
thread_continue.Set();
|
|
thread_exiting.Wait(Event::kForever);
|
|
EXPECT_TRUE(flag);
|
|
}
|
|
|
|
} // namespace rtc
|