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 kReceiveTimeoutInMilliseconds = 750; | |
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(0u, socket_->ReceiveWithTimeout( | |
31 &data, sizeof(data), base::TimeDelta::FromMilliseconds( | |
32 kReceiveTimeoutInMilliseconds))); | |
33 } | |
34 | |
35 void Stop() { | |
36 thread_.Join(); | |
37 } | |
38 | |
39 private: | |
40 base::SyncSocket* socket_; | |
41 base::DelegateSimpleThread thread_; | |
42 | |
43 DISALLOW_COPY_AND_ASSIGN(HangingReceiveThread); | |
44 }; | |
45 | |
46 // Tests sending data between two SyncSockets. Uses ASSERT() and thus will exit | |
47 // early upon failure. Callers should use ASSERT_NO_FATAL_FAILURE() if testing | |
48 // continues after return. | |
49 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.
| |
50 int received = 0; | |
51 const int kSending = 123; | |
52 COMPILE_ASSERT(sizeof(kSending) == sizeof(received), Invalid_Data_Size); | |
53 | |
54 ASSERT_EQ(0u, a->Peek()); | |
55 ASSERT_EQ(0u, b->Peek()); | |
56 | |
57 // Verify |a| can send to |b| and |b| can Receive from |a|. | |
58 ASSERT_EQ(sizeof(kSending), a->Send(&kSending, sizeof(kSending))); | |
59 ASSERT_EQ(sizeof(kSending), b->Peek()); | |
60 ASSERT_EQ(sizeof(kSending), b->Receive(&received, sizeof(kSending))); | |
61 ASSERT_EQ(kSending, received); | |
62 | |
63 ASSERT_EQ(0u, a->Peek()); | |
64 ASSERT_EQ(0u, b->Peek()); | |
65 | |
66 // Now verify the reverse. | |
67 received = 0; | |
68 ASSERT_EQ(sizeof(kSending), b->Send(&kSending, sizeof(kSending))); | |
69 ASSERT_EQ(sizeof(kSending), a->Peek()); | |
70 ASSERT_EQ(sizeof(kSending), a->Receive(&received, sizeof(kSending))); | |
71 ASSERT_EQ(kSending, received); | |
72 | |
73 ASSERT_EQ(0u, a->Peek()); | |
74 ASSERT_EQ(0u, b->Peek()); | |
75 | |
76 ASSERT_TRUE(a->Close()); | |
77 ASSERT_TRUE(b->Close()); | |
78 } | |
79 | |
80 template <class SocketType> | |
81 void NormalSendReceivePeek() { | |
82 SocketType a, b; | |
83 ASSERT_TRUE(SocketType::CreatePair(&a, &b)); | |
84 SendReceivePeek(&a, &b); | |
85 } | |
86 | |
87 template <class SocketType> | |
88 void ClonedSendReceivePeek() { | |
89 SocketType a, b; | |
90 ASSERT_TRUE(SocketType::CreatePair(&a, &b)); | |
91 | |
92 // Create new SyncSockets from the paired handles. | |
93 SocketType c(a.handle()), d(b.handle()); | |
94 SendReceivePeek(&c, &d); | |
95 } | |
96 | |
97 } // namespace | |
98 | |
99 TEST(SyncSocket, NormalSendReceivePeek) { | |
100 NormalSendReceivePeek<base::SyncSocket>(); | |
101 } | |
102 | |
103 TEST(SyncSocket, ClonedSendReceivePeek) { | |
104 ClonedSendReceivePeek<base::SyncSocket>(); | |
105 } | |
106 | |
107 TEST(CancelableSyncSocket, NormalSendReceivePeek) { | |
108 NormalSendReceivePeek<base::CancelableSyncSocket>(); | |
109 } | |
110 | |
111 TEST(CancelableSyncSocket, ClonedSendReceivePeek) { | |
112 ClonedSendReceivePeek<base::CancelableSyncSocket>(); | |
113 } | |
114 | |
115 TEST(CancelableSyncSocket, CancelReceiveShutdown) { | |
116 base::CancelableSyncSocket a, b; | |
117 ASSERT_TRUE(base::CancelableSyncSocket::CreatePair(&a, &b)); | |
118 | |
119 base::TimeTicks start = base::TimeTicks::Now(); | |
120 HangingReceiveThread thread(&b); | |
121 ASSERT_TRUE(b.Shutdown()); | |
122 thread.Stop(); | |
123 | |
124 // Ensure the receive didn't just timeout. | |
125 ASSERT_LT((base::TimeTicks::Now() - start).InMilliseconds(), | |
126 kReceiveTimeoutInMilliseconds); | |
127 | |
128 ASSERT_TRUE(a.Close()); | |
129 ASSERT_TRUE(b.Close()); | |
130 } | |
OLD | NEW |