OLD | NEW |
| (Empty) |
1 // Copyright 2016 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 // This file tests the C message pipe API (the functions declared in | |
6 // mojo/public/c/include/mojo/system/message_pipe.h). | |
7 | |
8 #include <mojo/system/message_pipe.h> | |
9 | |
10 #include <mojo/result.h> | |
11 #include <mojo/system/buffer.h> | |
12 #include <mojo/system/handle.h> | |
13 #include <mojo/system/wait.h> | |
14 | |
15 #include "gtest/gtest.h" | |
16 | |
17 namespace { | |
18 | |
19 const MojoHandleRights kDefaultMessagePipeHandleRights = | |
20 MOJO_HANDLE_RIGHT_TRANSFER | MOJO_HANDLE_RIGHT_READ | | |
21 MOJO_HANDLE_RIGHT_WRITE | MOJO_HANDLE_RIGHT_GET_OPTIONS | | |
22 MOJO_HANDLE_RIGHT_SET_OPTIONS; | |
23 | |
24 TEST(MessagePipeTest, InvalidHandle) { | |
25 char buffer[10] = {}; | |
26 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | |
27 MojoWriteMessage(MOJO_HANDLE_INVALID, buffer, 0u, nullptr, 0u, | |
28 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
29 uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer)); | |
30 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | |
31 MojoReadMessage(MOJO_HANDLE_INVALID, buffer, &buffer_size, nullptr, | |
32 nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); | |
33 } | |
34 | |
35 TEST(MessagePipeTest, Basic) { | |
36 MojoHandle h0 = MOJO_HANDLE_INVALID; | |
37 MojoHandle h1 = MOJO_HANDLE_INVALID; | |
38 EXPECT_EQ(MOJO_RESULT_OK, MojoCreateMessagePipe(nullptr, &h0, &h1)); | |
39 EXPECT_NE(h0, MOJO_HANDLE_INVALID); | |
40 EXPECT_NE(h1, MOJO_HANDLE_INVALID); | |
41 EXPECT_NE(h0, h1); | |
42 | |
43 // Both handles should have the correct rights. | |
44 MojoHandleRights rights = MOJO_HANDLE_RIGHT_NONE; | |
45 EXPECT_EQ(MOJO_RESULT_OK, MojoGetRights(h0, &rights)); | |
46 EXPECT_EQ(kDefaultMessagePipeHandleRights, rights); | |
47 rights = MOJO_HANDLE_RIGHT_NONE; | |
48 EXPECT_EQ(MOJO_RESULT_OK, MojoGetRights(h1, &rights)); | |
49 EXPECT_EQ(kDefaultMessagePipeHandleRights, rights); | |
50 | |
51 // Shouldn't be able to duplicate either handle (just test "with reduced | |
52 // rights" on one, and without on the other). | |
53 MojoHandle handle_denied = MOJO_HANDLE_INVALID; | |
54 EXPECT_EQ(MOJO_RESULT_PERMISSION_DENIED, | |
55 MojoDuplicateHandleWithReducedRights( | |
56 h0, MOJO_HANDLE_RIGHT_DUPLICATE, &handle_denied)); | |
57 EXPECT_EQ(MOJO_HANDLE_INVALID, handle_denied); | |
58 handle_denied = MOJO_HANDLE_INVALID; | |
59 EXPECT_EQ(MOJO_RESULT_PERMISSION_DENIED, | |
60 MojoDuplicateHandle(h1, &handle_denied)); | |
61 EXPECT_EQ(MOJO_HANDLE_INVALID, handle_denied); | |
62 | |
63 // Shouldn't be readable, we haven't written anything. | |
64 MojoHandleSignalsState state; | |
65 EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, | |
66 MojoWait(h0, MOJO_HANDLE_SIGNAL_READABLE, 0, &state)); | |
67 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, state.satisfied_signals); | |
68 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE | | |
69 MOJO_HANDLE_SIGNAL_PEER_CLOSED, | |
70 state.satisfiable_signals); | |
71 | |
72 // Should be writable. | |
73 EXPECT_EQ(MOJO_RESULT_OK, | |
74 MojoWait(h0, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &state)); | |
75 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, state.satisfied_signals); | |
76 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE | | |
77 MOJO_HANDLE_SIGNAL_PEER_CLOSED, | |
78 state.satisfiable_signals); | |
79 | |
80 // Last parameter is optional. | |
81 EXPECT_EQ(MOJO_RESULT_OK, | |
82 MojoWait(h0, MOJO_HANDLE_SIGNAL_WRITABLE, 0, nullptr)); | |
83 | |
84 // Try to read. | |
85 char buffer[10] = {}; | |
86 uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer)); | |
87 EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, | |
88 MojoReadMessage(h0, buffer, &buffer_size, nullptr, nullptr, | |
89 MOJO_READ_MESSAGE_FLAG_NONE)); | |
90 | |
91 // Write to |h1|. | |
92 static const char kHello[] = "hello"; | |
93 buffer_size = static_cast<uint32_t>(sizeof(kHello)); | |
94 EXPECT_EQ(MOJO_RESULT_OK, MojoWriteMessage(h1, kHello, buffer_size, nullptr, | |
95 0, MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
96 | |
97 // |h0| should be readable. | |
98 MojoHandleSignals sig = MOJO_HANDLE_SIGNAL_READABLE; | |
99 MojoHandleSignalsState states[1] = {}; | |
100 uint32_t result_index = 1; | |
101 EXPECT_EQ(MOJO_RESULT_OK, MojoWaitMany(&h0, &sig, 1, MOJO_DEADLINE_INDEFINITE, | |
102 &result_index, states)); | |
103 EXPECT_EQ(0u, result_index); | |
104 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, | |
105 states[0].satisfied_signals); | |
106 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE | | |
107 MOJO_HANDLE_SIGNAL_PEER_CLOSED, | |
108 states[0].satisfiable_signals); | |
109 | |
110 // Read from |h0|. | |
111 buffer_size = static_cast<uint32_t>(sizeof(buffer)); | |
112 EXPECT_EQ(MOJO_RESULT_OK, | |
113 MojoReadMessage(h0, buffer, &buffer_size, nullptr, nullptr, | |
114 MOJO_READ_MESSAGE_FLAG_NONE)); | |
115 EXPECT_EQ(static_cast<uint32_t>(sizeof(kHello)), buffer_size); | |
116 EXPECT_STREQ(kHello, buffer); | |
117 | |
118 // |h0| should no longer be readable. | |
119 EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, | |
120 MojoWait(h0, MOJO_HANDLE_SIGNAL_READABLE, 10, &state)); | |
121 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, state.satisfied_signals); | |
122 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE | | |
123 MOJO_HANDLE_SIGNAL_PEER_CLOSED, | |
124 state.satisfiable_signals); | |
125 | |
126 // Close |h0|. | |
127 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h0)); | |
128 | |
129 // |h1| should no longer be readable or writable. | |
130 EXPECT_EQ( | |
131 MOJO_RESULT_FAILED_PRECONDITION, | |
132 MojoWait(h1, MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, | |
133 1000, &state)); | |
134 EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfied_signals); | |
135 EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfiable_signals); | |
136 | |
137 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h1)); | |
138 } | |
139 | |
140 TEST(MessagePipeTest, ChecksTransferRight) { | |
141 MojoHandle h0 = MOJO_HANDLE_INVALID; | |
142 MojoHandle h1 = MOJO_HANDLE_INVALID; | |
143 EXPECT_EQ(MOJO_RESULT_OK, MojoCreateMessagePipe(nullptr, &h0, &h1)); | |
144 | |
145 // Create a shared buffer (which is transferrable and duplicatable). | |
146 MojoHandle h_transferrable = MOJO_HANDLE_INVALID; | |
147 EXPECT_EQ(MOJO_RESULT_OK, | |
148 MojoCreateSharedBuffer(nullptr, 100, &h_transferrable)); | |
149 | |
150 // Make a non-transferrable duplicate handle. | |
151 MojoHandle h_not_transferrable = MOJO_HANDLE_INVALID; | |
152 EXPECT_EQ(MOJO_RESULT_OK, MojoDuplicateHandleWithReducedRights( | |
153 h_transferrable, MOJO_HANDLE_RIGHT_TRANSFER, | |
154 &h_not_transferrable)); | |
155 | |
156 // |h_transferrable| can be transferred. | |
157 EXPECT_EQ(MOJO_RESULT_OK, MojoWriteMessage(h0, nullptr, 0u, &h_transferrable, | |
158 1u, MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
159 | |
160 // |h_not_transferrable| can be transferred. | |
161 EXPECT_EQ(MOJO_RESULT_PERMISSION_DENIED, | |
162 MojoWriteMessage(h0, nullptr, 0u, &h_not_transferrable, 1u, | |
163 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
164 | |
165 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h0)); | |
166 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h1)); | |
167 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h_not_transferrable)); | |
168 } | |
169 | |
170 // TODO(vtl): Add multi-threaded tests. | |
171 | |
172 } // namespace | |
OLD | NEW |