Index: base/sync_socket_unittest.cc |
diff --git a/base/sync_socket_unittest.cc b/base/sync_socket_unittest.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..2e0e0d77782eb1f8f0540107302ae883facf2060 |
--- /dev/null |
+++ b/base/sync_socket_unittest.cc |
@@ -0,0 +1,129 @@ |
+// Copyright 2013 The Chromium 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 "base/basictypes.h" |
+#include "base/sync_socket.h" |
+#include "base/threading/simple_thread.h" |
+#include "base/time/time.h" |
+#include "testing/gtest/include/gtest/gtest.h" |
+ |
+namespace { |
+ |
+const int kReceiveTimeoutInSeconds = 5; |
+ |
+class HangingReceiveThread : public base::DelegateSimpleThread::Delegate { |
+ public: |
+ explicit HangingReceiveThread(base::SyncSocket* socket) |
+ : socket_(socket), |
+ thread_(this, "HangingReceiveThread") { |
+ thread_.Start(); |
+ } |
+ |
+ virtual ~HangingReceiveThread() {} |
+ |
+ virtual void Run() OVERRIDE { |
+ int data = 0; |
+ ASSERT_EQ(socket_->Peek(), 0u); |
+ |
+ // Use receive with timeout so we don't hang the test harness indefinitely. |
+ ASSERT_EQ(socket_->ReceiveWithTimeout( |
+ &data, |
+ sizeof(data), |
+ base::TimeDelta::FromSeconds(kReceiveTimeoutInSeconds)), |
+ 0u); |
+ } |
+ |
+ void Stop() { |
+ thread_.Join(); |
+ } |
+ |
+ private: |
+ base::SyncSocket* socket_; |
+ base::DelegateSimpleThread thread_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(HangingReceiveThread); |
+}; |
+ |
+void SendReceivePeek(base::SyncSocket* a, base::SyncSocket* b) { |
+ int received = 0; |
+ const int kSending = 123; |
+ COMPILE_ASSERT(sizeof(kSending) == sizeof(received), Invalid_Data_Size); |
+ |
+ ASSERT_EQ(a->Peek(), 0u); |
awong
2013/09/17 18:57:00
ASSERT_EQ just exists the current function. Is tha
DaleCurtis
2013/09/17 19:36:27
Done.
|
+ ASSERT_EQ(b->Peek(), 0u); |
+ |
+ // Verify |a| can send to |b| and |b| can Receive from |a|. |
+ ASSERT_EQ(a->Send(&kSending, sizeof(kSending)), sizeof(kSending)); |
+ ASSERT_EQ(b->Peek(), sizeof(kSending)); |
+ ASSERT_EQ(b->Receive(&received, sizeof(kSending)), sizeof(kSending)); |
+ ASSERT_EQ(received, kSending); |
+ |
+ ASSERT_EQ(a->Peek(), 0u); |
+ ASSERT_EQ(b->Peek(), 0u); |
+ |
+ // Now verify the reverse. |
+ received = 0; |
+ ASSERT_EQ(b->Send(&kSending, sizeof(kSending)), sizeof(kSending)); |
+ ASSERT_EQ(a->Peek(), sizeof(kSending)); |
+ ASSERT_EQ(a->Receive(&received, sizeof(kSending)), sizeof(kSending)); |
+ ASSERT_EQ(received, kSending); |
+ |
+ ASSERT_EQ(a->Peek(), 0u); |
+ ASSERT_EQ(b->Peek(), 0u); |
+ |
+ ASSERT_TRUE(a->Close()); |
+ ASSERT_TRUE(b->Close()); |
+} |
+ |
+template <class SocketType> |
+void NormalSendReceivePeek() { |
+ SocketType a, b; |
+ ASSERT_TRUE(SocketType::CreatePair(&a, &b)); |
+ SendReceivePeek(&a, &b); |
+} |
+ |
+template <class SocketType> |
+void ClonedSendReceivePeek() { |
+ SocketType a, b; |
+ ASSERT_TRUE(SocketType::CreatePair(&a, &b)); |
+ |
+ // Create new SyncSockets from the paired handles. |
+ SocketType c(a.handle()), d(b.handle()); |
+ SendReceivePeek(&c, &d); |
+} |
+ |
+} // namespace |
+ |
+TEST(SyncSocket, NormalSendReceivePeek) { |
+ NormalSendReceivePeek<base::SyncSocket>(); |
+} |
+ |
+TEST(SyncSocket, ClonedSendReceivePeek) { |
+ ClonedSendReceivePeek<base::SyncSocket>(); |
+} |
+ |
+TEST(CancelableSyncSocket, NormalSendReceivePeek) { |
+ NormalSendReceivePeek<base::CancelableSyncSocket>(); |
+} |
+ |
+TEST(CancelableSyncSocket, ClonedSendReceivePeek) { |
+ ClonedSendReceivePeek<base::CancelableSyncSocket>(); |
+} |
+ |
+TEST(CancelableSyncSocket, CancelReceiveShutdown) { |
+ base::CancelableSyncSocket a, b; |
+ ASSERT_TRUE(base::CancelableSyncSocket::CreatePair(&a, &b)); |
+ |
+ base::TimeTicks start = base::TimeTicks::Now(); |
+ HangingReceiveThread thread(&b); |
+ ASSERT_TRUE(b.Shutdown()); |
+ thread.Stop(); |
+ |
+ // Ensure the receive didn't just timeout. |
+ ASSERT_LT((base::TimeTicks::Now() - start).InSeconds(), |
+ kReceiveTimeoutInSeconds); |
+ |
+ ASSERT_TRUE(a.Close()); |
+ ASSERT_TRUE(b.Close()); |
+} |