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); | |
willchan no longer on Chromium
2013/10/04 21:01:35
ASSERT_EQ(expected, actual), you've got them rever
DaleCurtis
2013/10/04 21:08:39
If you're talking about the message format, that i
willchan no longer on Chromium
2013/10/09 20:06:52
Oh, news to me :) But I think we should still make
DaleCurtis
2013/10/09 21:55:40
In media, we decided the "no yoda conditions" styl
| |
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 // Tests sending data between two SyncSockets. Uses ASSERT() and thus will exit | |
49 // early upon failure. Callers should use ASSERT_NO_FATAL_FAILURE() if testing | |
50 // continues after return. | |
51 void SendReceivePeek(base::SyncSocket* a, base::SyncSocket* b) { | |
52 int received = 0; | |
53 const int kSending = 123; | |
54 COMPILE_ASSERT(sizeof(kSending) == sizeof(received), Invalid_Data_Size); | |
55 | |
56 ASSERT_EQ(a->Peek(), 0u); | |
57 ASSERT_EQ(b->Peek(), 0u); | |
58 | |
59 // Verify |a| can send to |b| and |b| can Receive from |a|. | |
60 ASSERT_EQ(a->Send(&kSending, sizeof(kSending)), sizeof(kSending)); | |
61 ASSERT_EQ(b->Peek(), sizeof(kSending)); | |
62 ASSERT_EQ(b->Receive(&received, sizeof(kSending)), sizeof(kSending)); | |
63 ASSERT_EQ(received, kSending); | |
64 | |
65 ASSERT_EQ(a->Peek(), 0u); | |
66 ASSERT_EQ(b->Peek(), 0u); | |
67 | |
68 // Now verify the reverse. | |
69 received = 0; | |
70 ASSERT_EQ(b->Send(&kSending, sizeof(kSending)), sizeof(kSending)); | |
71 ASSERT_EQ(a->Peek(), sizeof(kSending)); | |
72 ASSERT_EQ(a->Receive(&received, sizeof(kSending)), sizeof(kSending)); | |
73 ASSERT_EQ(received, kSending); | |
74 | |
75 ASSERT_EQ(a->Peek(), 0u); | |
76 ASSERT_EQ(b->Peek(), 0u); | |
77 | |
78 ASSERT_TRUE(a->Close()); | |
79 ASSERT_TRUE(b->Close()); | |
80 } | |
81 | |
82 template <class SocketType> | |
83 void NormalSendReceivePeek() { | |
84 SocketType a, b; | |
85 ASSERT_TRUE(SocketType::CreatePair(&a, &b)); | |
86 SendReceivePeek(&a, &b); | |
87 } | |
88 | |
89 template <class SocketType> | |
90 void ClonedSendReceivePeek() { | |
91 SocketType a, b; | |
92 ASSERT_TRUE(SocketType::CreatePair(&a, &b)); | |
93 | |
94 // Create new SyncSockets from the paired handles. | |
95 SocketType c(a.handle()), d(b.handle()); | |
96 SendReceivePeek(&c, &d); | |
97 } | |
98 | |
99 } // namespace | |
100 | |
101 TEST(SyncSocket, NormalSendReceivePeek) { | |
102 NormalSendReceivePeek<base::SyncSocket>(); | |
103 } | |
104 | |
105 TEST(SyncSocket, ClonedSendReceivePeek) { | |
106 ClonedSendReceivePeek<base::SyncSocket>(); | |
107 } | |
108 | |
109 TEST(CancelableSyncSocket, NormalSendReceivePeek) { | |
110 NormalSendReceivePeek<base::CancelableSyncSocket>(); | |
111 } | |
112 | |
113 TEST(CancelableSyncSocket, ClonedSendReceivePeek) { | |
114 ClonedSendReceivePeek<base::CancelableSyncSocket>(); | |
115 } | |
116 | |
117 TEST(CancelableSyncSocket, CancelReceiveShutdown) { | |
118 base::CancelableSyncSocket a, b; | |
119 ASSERT_TRUE(base::CancelableSyncSocket::CreatePair(&a, &b)); | |
120 | |
121 base::TimeTicks start = base::TimeTicks::Now(); | |
122 HangingReceiveThread thread(&b); | |
123 ASSERT_TRUE(b.Shutdown()); | |
124 thread.Stop(); | |
125 | |
126 // Ensure the receive didn't just timeout. | |
127 ASSERT_LT((base::TimeTicks::Now() - start).InSeconds(), | |
128 kReceiveTimeoutInSeconds); | |
129 | |
130 ASSERT_TRUE(a.Close()); | |
131 ASSERT_TRUE(b.Close()); | |
132 } | |
OLD | NEW |