sync_socket_unittest.cc 5.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190
  1. // Copyright 2013 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "base/sync_socket.h"
  5. #include "base/memory/raw_ptr.h"
  6. #include "base/synchronization/waitable_event.h"
  7. #include "base/threading/platform_thread.h"
  8. #include "base/threading/simple_thread.h"
  9. #include "base/time/time.h"
  10. #include "testing/gtest/include/gtest/gtest.h"
  11. namespace base {
  12. namespace {
  13. constexpr TimeDelta kReceiveTimeout = base::Milliseconds(750);
  14. class HangingReceiveThread : public DelegateSimpleThread::Delegate {
  15. public:
  16. explicit HangingReceiveThread(SyncSocket* socket, bool with_timeout)
  17. : socket_(socket),
  18. thread_(this, "HangingReceiveThread"),
  19. with_timeout_(with_timeout),
  20. started_event_(WaitableEvent::ResetPolicy::MANUAL,
  21. WaitableEvent::InitialState::NOT_SIGNALED),
  22. done_event_(WaitableEvent::ResetPolicy::MANUAL,
  23. WaitableEvent::InitialState::NOT_SIGNALED) {
  24. thread_.Start();
  25. }
  26. HangingReceiveThread(const HangingReceiveThread&) = delete;
  27. HangingReceiveThread& operator=(const HangingReceiveThread&) = delete;
  28. ~HangingReceiveThread() override = default;
  29. void Run() override {
  30. int data = 0;
  31. ASSERT_EQ(socket_->Peek(), 0u);
  32. started_event_.Signal();
  33. if (with_timeout_) {
  34. ASSERT_EQ(0u, socket_->ReceiveWithTimeout(&data, sizeof(data),
  35. kReceiveTimeout));
  36. } else {
  37. ASSERT_EQ(0u, socket_->Receive(&data, sizeof(data)));
  38. }
  39. done_event_.Signal();
  40. }
  41. void Stop() {
  42. thread_.Join();
  43. }
  44. WaitableEvent* started_event() { return &started_event_; }
  45. WaitableEvent* done_event() { return &done_event_; }
  46. private:
  47. raw_ptr<SyncSocket> socket_;
  48. DelegateSimpleThread thread_;
  49. bool with_timeout_;
  50. WaitableEvent started_event_;
  51. WaitableEvent done_event_;
  52. };
  53. // Tests sending data between two SyncSockets. Uses ASSERT() and thus will exit
  54. // early upon failure. Callers should use ASSERT_NO_FATAL_FAILURE() if testing
  55. // continues after return.
  56. void SendReceivePeek(SyncSocket* socket_a, SyncSocket* socket_b) {
  57. int received = 0;
  58. const int kSending = 123;
  59. static_assert(sizeof(kSending) == sizeof(received), "invalid data size");
  60. ASSERT_EQ(0u, socket_a->Peek());
  61. ASSERT_EQ(0u, socket_b->Peek());
  62. // Verify |socket_a| can send to |socket_a| and |socket_a| can Receive from
  63. // |socket_a|.
  64. ASSERT_EQ(sizeof(kSending), socket_a->Send(&kSending, sizeof(kSending)));
  65. ASSERT_EQ(sizeof(kSending), socket_b->Peek());
  66. ASSERT_EQ(sizeof(kSending), socket_b->Receive(&received, sizeof(kSending)));
  67. ASSERT_EQ(kSending, received);
  68. ASSERT_EQ(0u, socket_a->Peek());
  69. ASSERT_EQ(0u, socket_b->Peek());
  70. // Now verify the reverse.
  71. received = 0;
  72. ASSERT_EQ(sizeof(kSending), socket_b->Send(&kSending, sizeof(kSending)));
  73. ASSERT_EQ(sizeof(kSending), socket_a->Peek());
  74. ASSERT_EQ(sizeof(kSending), socket_a->Receive(&received, sizeof(kSending)));
  75. ASSERT_EQ(kSending, received);
  76. ASSERT_EQ(0u, socket_a->Peek());
  77. ASSERT_EQ(0u, socket_b->Peek());
  78. socket_a->Close();
  79. socket_b->Close();
  80. }
  81. } // namespace
  82. class SyncSocketTest : public testing::Test {
  83. public:
  84. void SetUp() override {
  85. ASSERT_TRUE(SyncSocket::CreatePair(&socket_a_, &socket_b_));
  86. }
  87. protected:
  88. SyncSocket socket_a_;
  89. SyncSocket socket_b_;
  90. };
  91. TEST_F(SyncSocketTest, NormalSendReceivePeek) {
  92. SendReceivePeek(&socket_a_, &socket_b_);
  93. }
  94. TEST_F(SyncSocketTest, ClonedSendReceivePeek) {
  95. SyncSocket socket_c(socket_a_.Release());
  96. SyncSocket socket_d(socket_b_.Release());
  97. SendReceivePeek(&socket_c, &socket_d);
  98. }
  99. class CancelableSyncSocketTest : public testing::Test {
  100. public:
  101. void SetUp() override {
  102. ASSERT_TRUE(CancelableSyncSocket::CreatePair(&socket_a_, &socket_b_));
  103. }
  104. protected:
  105. CancelableSyncSocket socket_a_;
  106. CancelableSyncSocket socket_b_;
  107. };
  108. TEST_F(CancelableSyncSocketTest, NormalSendReceivePeek) {
  109. SendReceivePeek(&socket_a_, &socket_b_);
  110. }
  111. TEST_F(CancelableSyncSocketTest, ClonedSendReceivePeek) {
  112. CancelableSyncSocket socket_c(socket_a_.Release());
  113. CancelableSyncSocket socket_d(socket_b_.Release());
  114. SendReceivePeek(&socket_c, &socket_d);
  115. }
  116. TEST_F(CancelableSyncSocketTest, ShutdownCancelsReceive) {
  117. HangingReceiveThread thread(&socket_b_, /* with_timeout = */ false);
  118. // Wait for the thread to be started. Note that this doesn't guarantee that
  119. // Receive() is called before Shutdown().
  120. thread.started_event()->Wait();
  121. EXPECT_TRUE(socket_b_.Shutdown());
  122. EXPECT_TRUE(thread.done_event()->TimedWait(kReceiveTimeout));
  123. thread.Stop();
  124. }
  125. TEST_F(CancelableSyncSocketTest, ShutdownCancelsReceiveWithTimeout) {
  126. HangingReceiveThread thread(&socket_b_, /* with_timeout = */ true);
  127. // Wait for the thread to be started. Note that this doesn't guarantee that
  128. // Receive() is called before Shutdown().
  129. thread.started_event()->Wait();
  130. EXPECT_TRUE(socket_b_.Shutdown());
  131. EXPECT_TRUE(thread.done_event()->TimedWait(kReceiveTimeout));
  132. thread.Stop();
  133. }
  134. TEST_F(CancelableSyncSocketTest, ReceiveAfterShutdown) {
  135. socket_a_.Shutdown();
  136. int data = 0;
  137. EXPECT_EQ(0u, socket_a_.Receive(&data, sizeof(data)));
  138. }
  139. TEST_F(CancelableSyncSocketTest, ReceiveWithTimeoutAfterShutdown) {
  140. socket_a_.Shutdown();
  141. TimeTicks start = TimeTicks::Now();
  142. int data = 0;
  143. EXPECT_EQ(0u,
  144. socket_a_.ReceiveWithTimeout(&data, sizeof(data), kReceiveTimeout));
  145. // Ensure the receive didn't just timeout.
  146. EXPECT_LT(TimeTicks::Now() - start, kReceiveTimeout);
  147. }
  148. } // namespace base