Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(604)

Side by Side Diff: mojo/system/shared_buffer_dispatcher_unittest.cc

Issue 320343002: Mojo: Make default Options directly accessible. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Created 6 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « mojo/system/shared_buffer_dispatcher.cc ('k') | no next file » | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright 2014 The Chromium Authors. All rights reserved. 1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "mojo/system/shared_buffer_dispatcher.h" 5 #include "mojo/system/shared_buffer_dispatcher.h"
6 6
7 #include <limits> 7 #include <limits>
8 8
9 #include "base/macros.h" 9 #include "base/macros.h"
10 #include "base/memory/ref_counted.h" 10 #include "base/memory/ref_counted.h"
(...skipping 82 matching lines...) Expand 10 before | Expand all | Expand 10 after
93 kSizeOfCreateOptions, // |struct_size|. 93 kSizeOfCreateOptions, // |struct_size|.
94 ~0u // |flags|. 94 ~0u // |flags|.
95 }; 95 };
96 MojoCreateSharedBufferOptions unused; 96 MojoCreateSharedBufferOptions unused;
97 EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, 97 EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED,
98 SharedBufferDispatcher::ValidateCreateOptions(&options, &unused)); 98 SharedBufferDispatcher::ValidateCreateOptions(&options, &unused));
99 } 99 }
100 } 100 }
101 101
102 TEST(SharedBufferDispatcherTest, CreateAndMapBuffer) { 102 TEST(SharedBufferDispatcherTest, CreateAndMapBuffer) {
103 MojoCreateSharedBufferOptions validated_options = {};
104 EXPECT_EQ(MOJO_RESULT_OK,
105 SharedBufferDispatcher::ValidateCreateOptions(NULL,
106 &validated_options));
107
108 scoped_refptr<SharedBufferDispatcher> dispatcher; 103 scoped_refptr<SharedBufferDispatcher> dispatcher;
109 EXPECT_EQ(MOJO_RESULT_OK, 104 EXPECT_EQ(MOJO_RESULT_OK,
110 SharedBufferDispatcher::Create(validated_options, 100, 105 SharedBufferDispatcher::Create(
111 &dispatcher)); 106 SharedBufferDispatcher::kDefaultCreateOptions, 100,
107 &dispatcher));
112 ASSERT_TRUE(dispatcher); 108 ASSERT_TRUE(dispatcher);
113 EXPECT_EQ(Dispatcher::kTypeSharedBuffer, dispatcher->GetType()); 109 EXPECT_EQ(Dispatcher::kTypeSharedBuffer, dispatcher->GetType());
114 110
115 // Make a couple of mappings. 111 // Make a couple of mappings.
116 scoped_ptr<RawSharedBufferMapping> mapping1; 112 scoped_ptr<RawSharedBufferMapping> mapping1;
117 EXPECT_EQ(MOJO_RESULT_OK, 113 EXPECT_EQ(MOJO_RESULT_OK,
118 dispatcher->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, 114 dispatcher->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE,
119 &mapping1)); 115 &mapping1));
120 ASSERT_TRUE(mapping1); 116 ASSERT_TRUE(mapping1);
121 ASSERT_TRUE(mapping1->base()); 117 ASSERT_TRUE(mapping1->base());
(...skipping 12 matching lines...) Expand all
134 130
135 EXPECT_EQ(MOJO_RESULT_OK, dispatcher->Close()); 131 EXPECT_EQ(MOJO_RESULT_OK, dispatcher->Close());
136 132
137 // Check that we can still read/write to mappings after the dispatcher has 133 // Check that we can still read/write to mappings after the dispatcher has
138 // gone away. 134 // gone away.
139 static_cast<char*>(mapping2->base())[1] = 'y'; 135 static_cast<char*>(mapping2->base())[1] = 'y';
140 EXPECT_EQ('y', static_cast<char*>(mapping1->base())[51]); 136 EXPECT_EQ('y', static_cast<char*>(mapping1->base())[51]);
141 } 137 }
142 138
143 TEST(SharedBufferDispatcher, DuplicateBufferHandle) { 139 TEST(SharedBufferDispatcher, DuplicateBufferHandle) {
144 MojoCreateSharedBufferOptions validated_options = {};
145 EXPECT_EQ(MOJO_RESULT_OK,
146 SharedBufferDispatcher::ValidateCreateOptions(NULL,
147 &validated_options));
148 scoped_refptr<SharedBufferDispatcher> dispatcher1; 140 scoped_refptr<SharedBufferDispatcher> dispatcher1;
149 EXPECT_EQ(MOJO_RESULT_OK, 141 EXPECT_EQ(MOJO_RESULT_OK,
150 SharedBufferDispatcher::Create(validated_options, 100, 142 SharedBufferDispatcher::Create(
143 SharedBufferDispatcher::kDefaultCreateOptions, 100,
151 &dispatcher1)); 144 &dispatcher1));
152 145
153 // Map and write something. 146 // Map and write something.
154 scoped_ptr<RawSharedBufferMapping> mapping; 147 scoped_ptr<RawSharedBufferMapping> mapping;
155 EXPECT_EQ(MOJO_RESULT_OK, 148 EXPECT_EQ(MOJO_RESULT_OK,
156 dispatcher1->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, 149 dispatcher1->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE,
157 &mapping)); 150 &mapping));
158 static_cast<char*>(mapping->base())[0] = 'x'; 151 static_cast<char*>(mapping->base())[0] = 'x';
159 mapping.reset(); 152 mapping.reset();
160 153
161 // Duplicate |dispatcher1| and then close it. 154 // Duplicate |dispatcher1| and then close it.
162 scoped_refptr<Dispatcher> dispatcher2; 155 scoped_refptr<Dispatcher> dispatcher2;
163 EXPECT_EQ(MOJO_RESULT_OK, 156 EXPECT_EQ(MOJO_RESULT_OK,
164 dispatcher1->DuplicateBufferHandle(NULL, &dispatcher2)); 157 dispatcher1->DuplicateBufferHandle(NULL, &dispatcher2));
165 ASSERT_TRUE(dispatcher2); 158 ASSERT_TRUE(dispatcher2);
166 EXPECT_EQ(Dispatcher::kTypeSharedBuffer, dispatcher2->GetType()); 159 EXPECT_EQ(Dispatcher::kTypeSharedBuffer, dispatcher2->GetType());
167 160
168 EXPECT_EQ(MOJO_RESULT_OK, dispatcher1->Close()); 161 EXPECT_EQ(MOJO_RESULT_OK, dispatcher1->Close());
169 162
170 // Map |dispatcher2| and read something. 163 // Map |dispatcher2| and read something.
171 EXPECT_EQ(MOJO_RESULT_OK, 164 EXPECT_EQ(MOJO_RESULT_OK,
172 dispatcher2->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, 165 dispatcher2->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE,
173 &mapping)); 166 &mapping));
174 EXPECT_EQ('x', static_cast<char*>(mapping->base())[0]); 167 EXPECT_EQ('x', static_cast<char*>(mapping->base())[0]);
175 168
176 EXPECT_EQ(MOJO_RESULT_OK, dispatcher2->Close()); 169 EXPECT_EQ(MOJO_RESULT_OK, dispatcher2->Close());
177 } 170 }
178 171
179 TEST(SharedBufferDispatcherTest, DuplicateBufferHandleOptionsValid) { 172 TEST(SharedBufferDispatcherTest, DuplicateBufferHandleOptionsValid) {
180 MojoCreateSharedBufferOptions validated_options = {};
181 EXPECT_EQ(MOJO_RESULT_OK,
182 SharedBufferDispatcher::ValidateCreateOptions(NULL,
183 &validated_options));
184 scoped_refptr<SharedBufferDispatcher> dispatcher1; 173 scoped_refptr<SharedBufferDispatcher> dispatcher1;
185 EXPECT_EQ(MOJO_RESULT_OK, 174 EXPECT_EQ(MOJO_RESULT_OK,
186 SharedBufferDispatcher::Create(validated_options, 100, 175 SharedBufferDispatcher::Create(
187 &dispatcher1)); 176 SharedBufferDispatcher::kDefaultCreateOptions, 100,
177 &dispatcher1));
188 178
189 MojoDuplicateBufferHandleOptions options[] = { 179 MojoDuplicateBufferHandleOptions options[] = {
190 {sizeof(MojoDuplicateBufferHandleOptions), 180 {sizeof(MojoDuplicateBufferHandleOptions),
191 MOJO_DUPLICATE_BUFFER_HANDLE_OPTIONS_FLAG_NONE}, 181 MOJO_DUPLICATE_BUFFER_HANDLE_OPTIONS_FLAG_NONE},
192 {sizeof(MojoDuplicateBufferHandleOptionsFlags), ~0} 182 {sizeof(MojoDuplicateBufferHandleOptionsFlags), ~0}
193 }; 183 };
194 for (size_t i = 0; i < arraysize(options); i++) { 184 for (size_t i = 0; i < arraysize(options); i++) {
195 scoped_refptr<Dispatcher> dispatcher2; 185 scoped_refptr<Dispatcher> dispatcher2;
196 EXPECT_EQ(MOJO_RESULT_OK, 186 EXPECT_EQ(MOJO_RESULT_OK,
197 dispatcher1->DuplicateBufferHandle(&options[i], &dispatcher2)); 187 dispatcher1->DuplicateBufferHandle(&options[i], &dispatcher2));
198 ASSERT_TRUE(dispatcher2); 188 ASSERT_TRUE(dispatcher2);
199 EXPECT_EQ(Dispatcher::kTypeSharedBuffer, dispatcher2->GetType()); 189 EXPECT_EQ(Dispatcher::kTypeSharedBuffer, dispatcher2->GetType());
200 EXPECT_EQ(MOJO_RESULT_OK, dispatcher2->Close()); 190 EXPECT_EQ(MOJO_RESULT_OK, dispatcher2->Close());
201 } 191 }
202 192
203 EXPECT_EQ(MOJO_RESULT_OK, dispatcher1->Close()); 193 EXPECT_EQ(MOJO_RESULT_OK, dispatcher1->Close());
204 } 194 }
205 195
206 TEST(SharedBufferDispatcherTest, DuplicateBufferHandleOptionsInvalid) { 196 TEST(SharedBufferDispatcherTest, DuplicateBufferHandleOptionsInvalid) {
207 MojoCreateSharedBufferOptions validated_options = {};
208 EXPECT_EQ(MOJO_RESULT_OK,
209 SharedBufferDispatcher::ValidateCreateOptions(NULL,
210 &validated_options));
211 scoped_refptr<SharedBufferDispatcher> dispatcher1; 197 scoped_refptr<SharedBufferDispatcher> dispatcher1;
212 EXPECT_EQ(MOJO_RESULT_OK, 198 EXPECT_EQ(MOJO_RESULT_OK,
213 SharedBufferDispatcher::Create(validated_options, 100, 199 SharedBufferDispatcher::Create(
214 &dispatcher1)); 200 SharedBufferDispatcher::kDefaultCreateOptions, 100,
201 &dispatcher1));
215 202
216 // Invalid |struct_size|. 203 // Invalid |struct_size|.
217 { 204 {
218 MojoDuplicateBufferHandleOptions options = { 205 MojoDuplicateBufferHandleOptions options = {
219 1u, MOJO_DUPLICATE_BUFFER_HANDLE_OPTIONS_FLAG_NONE 206 1u, MOJO_DUPLICATE_BUFFER_HANDLE_OPTIONS_FLAG_NONE
220 }; 207 };
221 scoped_refptr<Dispatcher> dispatcher2; 208 scoped_refptr<Dispatcher> dispatcher2;
222 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, 209 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
223 dispatcher1->DuplicateBufferHandle(&options, &dispatcher2)); 210 dispatcher1->DuplicateBufferHandle(&options, &dispatcher2));
224 EXPECT_FALSE(dispatcher2); 211 EXPECT_FALSE(dispatcher2);
225 } 212 }
226 213
227 // Unknown |flags|. 214 // Unknown |flags|.
228 { 215 {
229 MojoDuplicateBufferHandleOptions options = { 216 MojoDuplicateBufferHandleOptions options = {
230 static_cast<uint32_t>(sizeof(MojoDuplicateBufferHandleOptions)), ~0u 217 static_cast<uint32_t>(sizeof(MojoDuplicateBufferHandleOptions)), ~0u
231 }; 218 };
232 scoped_refptr<Dispatcher> dispatcher2; 219 scoped_refptr<Dispatcher> dispatcher2;
233 EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, 220 EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED,
234 dispatcher1->DuplicateBufferHandle(&options, &dispatcher2)); 221 dispatcher1->DuplicateBufferHandle(&options, &dispatcher2));
235 EXPECT_FALSE(dispatcher2); 222 EXPECT_FALSE(dispatcher2);
236 } 223 }
237 224
238 EXPECT_EQ(MOJO_RESULT_OK, dispatcher1->Close()); 225 EXPECT_EQ(MOJO_RESULT_OK, dispatcher1->Close());
239 } 226 }
240 227
241 TEST(SharedBufferDispatcherTest, CreateInvalidNumBytes) { 228 TEST(SharedBufferDispatcherTest, CreateInvalidNumBytes) {
242 MojoCreateSharedBufferOptions validated_options = {};
243 EXPECT_EQ(MOJO_RESULT_OK,
244 SharedBufferDispatcher::ValidateCreateOptions(NULL,
245 &validated_options));
246
247 // Size too big. 229 // Size too big.
248 scoped_refptr<SharedBufferDispatcher> dispatcher; 230 scoped_refptr<SharedBufferDispatcher> dispatcher;
249 EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, 231 EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
250 SharedBufferDispatcher::Create(validated_options, 232 SharedBufferDispatcher::Create(
251 std::numeric_limits<uint64_t>::max(), 233 SharedBufferDispatcher::kDefaultCreateOptions,
252 &dispatcher)); 234 std::numeric_limits<uint64_t>::max(), &dispatcher));
253 EXPECT_FALSE(dispatcher); 235 EXPECT_FALSE(dispatcher);
254 236
255 // Zero size. 237 // Zero size.
256 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, 238 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
257 SharedBufferDispatcher::Create(validated_options, 0, &dispatcher)); 239 SharedBufferDispatcher::Create(
240 SharedBufferDispatcher::kDefaultCreateOptions, 0, &dispatcher));
258 EXPECT_FALSE(dispatcher); 241 EXPECT_FALSE(dispatcher);
259 } 242 }
260 243
261 TEST(SharedBufferDispatcherTest, MapBufferInvalidArguments) { 244 TEST(SharedBufferDispatcherTest, MapBufferInvalidArguments) {
262 MojoCreateSharedBufferOptions validated_options = {};
263 EXPECT_EQ(MOJO_RESULT_OK,
264 SharedBufferDispatcher::ValidateCreateOptions(NULL,
265 &validated_options));
266
267 scoped_refptr<SharedBufferDispatcher> dispatcher; 245 scoped_refptr<SharedBufferDispatcher> dispatcher;
268 EXPECT_EQ(MOJO_RESULT_OK, 246 EXPECT_EQ(MOJO_RESULT_OK,
269 SharedBufferDispatcher::Create(validated_options, 100, 247 SharedBufferDispatcher::Create(
270 &dispatcher)); 248 SharedBufferDispatcher::kDefaultCreateOptions, 100,
249 &dispatcher));
271 250
272 scoped_ptr<RawSharedBufferMapping> mapping; 251 scoped_ptr<RawSharedBufferMapping> mapping;
273 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, 252 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
274 dispatcher->MapBuffer(0, 101, MOJO_MAP_BUFFER_FLAG_NONE, &mapping)); 253 dispatcher->MapBuffer(0, 101, MOJO_MAP_BUFFER_FLAG_NONE, &mapping));
275 EXPECT_FALSE(mapping); 254 EXPECT_FALSE(mapping);
276 255
277 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, 256 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
278 dispatcher->MapBuffer(1, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping)); 257 dispatcher->MapBuffer(1, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping));
279 EXPECT_FALSE(mapping); 258 EXPECT_FALSE(mapping);
280 259
281 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, 260 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
282 dispatcher->MapBuffer(0, 0, MOJO_MAP_BUFFER_FLAG_NONE, &mapping)); 261 dispatcher->MapBuffer(0, 0, MOJO_MAP_BUFFER_FLAG_NONE, &mapping));
283 EXPECT_FALSE(mapping); 262 EXPECT_FALSE(mapping);
284 263
285 EXPECT_EQ(MOJO_RESULT_OK, dispatcher->Close()); 264 EXPECT_EQ(MOJO_RESULT_OK, dispatcher->Close());
286 } 265 }
287 266
288 } // namespace 267 } // namespace
289 } // namespace system 268 } // namespace system
290 } // namespace mojo 269 } // namespace mojo
OLDNEW
« no previous file with comments | « mojo/system/shared_buffer_dispatcher.cc ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698