OLD | NEW |
---|---|
(Empty) | |
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 | |
5 #include "base/basictypes.h" | |
6 #include "base/sync_socket.h" | |
7 #include "base/threading/simple_thread.h" | |
8 #include "base/time/time.h" | |
9 #include "testing/gtest/include/gtest/gtest.h" | |
10 | |
11 namespace { | |
12 | |
13 const int kReceiveTimeoutInSeconds = 5; | |
14 | |
15 class HangingReceiveThread : public base::DelegateSimpleThread::Delegate { | |
16 public: | |
17 explicit HangingReceiveThread(base::SyncSocket* socket) | |
18 : socket_(socket), | |
19 thread_(this, "HangingReceiveThread") { | |
20 thread_.Start(); | |
21 } | |
22 | |
23 virtual ~HangingReceiveThread() {} | |
24 | |
25 virtual void Run() OVERRIDE { | |
26 int data = 0; | |
27 ASSERT_EQ(socket_->Peek(), 0u); | |
28 | |
29 // Use receive with timeout so we don't hang the test harness indefinitely. | |
30 ASSERT_EQ(socket_->ReceiveWithTimeout( | |
31 &data, | |
32 sizeof(data), | |
33 base::TimeDelta::FromSeconds(kReceiveTimeoutInSeconds)), | |
34 0u); | |
35 } | |
36 | |
37 void Stop() { | |
38 thread_.Join(); | |
39 } | |
40 | |
41 private: | |
42 base::SyncSocket* socket_; | |
43 base::DelegateSimpleThread thread_; | |
44 | |
45 DISALLOW_COPY_AND_ASSIGN(HangingReceiveThread); | |
46 }; | |
47 | |
48 void SendReceivePeek(base::SyncSocket* a, base::SyncSocket* b) { | |
49 int received = 0; | |
50 const int kSending = 123; | |
51 COMPILE_ASSERT(sizeof(kSending) == sizeof(received), Invalid_Data_Size); | |
52 | |
53 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.
| |
54 ASSERT_EQ(b->Peek(), 0u); | |
55 | |
56 // Verify |a| can send to |b| and |b| can Receive from |a|. | |
57 ASSERT_EQ(a->Send(&kSending, sizeof(kSending)), sizeof(kSending)); | |
58 ASSERT_EQ(b->Peek(), sizeof(kSending)); | |
59 ASSERT_EQ(b->Receive(&received, sizeof(kSending)), sizeof(kSending)); | |
60 ASSERT_EQ(received, kSending); | |
61 | |
62 ASSERT_EQ(a->Peek(), 0u); | |
63 ASSERT_EQ(b->Peek(), 0u); | |
64 | |
65 // Now verify the reverse. | |
66 received = 0; | |
67 ASSERT_EQ(b->Send(&kSending, sizeof(kSending)), sizeof(kSending)); | |
68 ASSERT_EQ(a->Peek(), sizeof(kSending)); | |
69 ASSERT_EQ(a->Receive(&received, sizeof(kSending)), sizeof(kSending)); | |
70 ASSERT_EQ(received, kSending); | |
71 | |
72 ASSERT_EQ(a->Peek(), 0u); | |
73 ASSERT_EQ(b->Peek(), 0u); | |
74 | |
75 ASSERT_TRUE(a->Close()); | |
76 ASSERT_TRUE(b->Close()); | |
77 } | |
78 | |
79 template <class SocketType> | |
80 void NormalSendReceivePeek() { | |
81 SocketType a, b; | |
82 ASSERT_TRUE(SocketType::CreatePair(&a, &b)); | |
83 SendReceivePeek(&a, &b); | |
84 } | |
85 | |
86 template <class SocketType> | |
87 void ClonedSendReceivePeek() { | |
88 SocketType a, b; | |
89 ASSERT_TRUE(SocketType::CreatePair(&a, &b)); | |
90 | |
91 // Create new SyncSockets from the paired handles. | |
92 SocketType c(a.handle()), d(b.handle()); | |
93 SendReceivePeek(&c, &d); | |
94 } | |
95 | |
96 } // namespace | |
97 | |
98 TEST(SyncSocket, NormalSendReceivePeek) { | |
99 NormalSendReceivePeek<base::SyncSocket>(); | |
100 } | |
101 | |
102 TEST(SyncSocket, ClonedSendReceivePeek) { | |
103 ClonedSendReceivePeek<base::SyncSocket>(); | |
104 } | |
105 | |
106 TEST(CancelableSyncSocket, NormalSendReceivePeek) { | |
107 NormalSendReceivePeek<base::CancelableSyncSocket>(); | |
108 } | |
109 | |
110 TEST(CancelableSyncSocket, ClonedSendReceivePeek) { | |
111 ClonedSendReceivePeek<base::CancelableSyncSocket>(); | |
112 } | |
113 | |
114 TEST(CancelableSyncSocket, CancelReceiveShutdown) { | |
115 base::CancelableSyncSocket a, b; | |
116 ASSERT_TRUE(base::CancelableSyncSocket::CreatePair(&a, &b)); | |
117 | |
118 base::TimeTicks start = base::TimeTicks::Now(); | |
119 HangingReceiveThread thread(&b); | |
120 ASSERT_TRUE(b.Shutdown()); | |
121 thread.Stop(); | |
122 | |
123 // Ensure the receive didn't just timeout. | |
124 ASSERT_LT((base::TimeTicks::Now() - start).InSeconds(), | |
125 kReceiveTimeoutInSeconds); | |
126 | |
127 ASSERT_TRUE(a.Close()); | |
128 ASSERT_TRUE(b.Close()); | |
129 } | |
OLD | NEW |