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..4e82ce366c326970c26cd79b79a31fd29cf20c0a |
--- /dev/null |
+++ b/base/sync_socket_unittest.cc |
@@ -0,0 +1,130 @@ |
+// 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 kReceiveTimeoutInMilliseconds = 750; |
+ |
+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(0u, socket_->ReceiveWithTimeout( |
+ &data, sizeof(data), base::TimeDelta::FromMilliseconds( |
+ kReceiveTimeoutInMilliseconds))); |
+ } |
+ |
+ void Stop() { |
+ thread_.Join(); |
+ } |
+ |
+ private: |
+ base::SyncSocket* socket_; |
+ base::DelegateSimpleThread thread_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(HangingReceiveThread); |
+}; |
+ |
+// Tests sending data between two SyncSockets. Uses ASSERT() and thus will exit |
+// early upon failure. Callers should use ASSERT_NO_FATAL_FAILURE() if testing |
+// continues after return. |
+void SendReceivePeek(base::SyncSocket* a, base::SyncSocket* b) { |
jar (doing other things)
2013/10/10 02:01:28
nit: avoid one letter variable names througout fil
DaleCurtis
2013/10/11 22:48:24
Done.
|
+ int received = 0; |
+ const int kSending = 123; |
+ COMPILE_ASSERT(sizeof(kSending) == sizeof(received), Invalid_Data_Size); |
+ |
+ ASSERT_EQ(0u, a->Peek()); |
+ ASSERT_EQ(0u, b->Peek()); |
+ |
+ // Verify |a| can send to |b| and |b| can Receive from |a|. |
+ ASSERT_EQ(sizeof(kSending), a->Send(&kSending, sizeof(kSending))); |
+ ASSERT_EQ(sizeof(kSending), b->Peek()); |
+ ASSERT_EQ(sizeof(kSending), b->Receive(&received, sizeof(kSending))); |
+ ASSERT_EQ(kSending, received); |
+ |
+ ASSERT_EQ(0u, a->Peek()); |
+ ASSERT_EQ(0u, b->Peek()); |
+ |
+ // Now verify the reverse. |
+ received = 0; |
+ ASSERT_EQ(sizeof(kSending), b->Send(&kSending, sizeof(kSending))); |
+ ASSERT_EQ(sizeof(kSending), a->Peek()); |
+ ASSERT_EQ(sizeof(kSending), a->Receive(&received, sizeof(kSending))); |
+ ASSERT_EQ(kSending, received); |
+ |
+ ASSERT_EQ(0u, a->Peek()); |
+ ASSERT_EQ(0u, b->Peek()); |
+ |
+ 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).InMilliseconds(), |
+ kReceiveTimeoutInMilliseconds); |
+ |
+ ASSERT_TRUE(a.Close()); |
+ ASSERT_TRUE(b.Close()); |
+} |