OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 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 | 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/data_pipe.h" | 5 #include "mojo/system/data_pipe.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 | 8 |
9 #include <limits> | 9 #include <limits> |
10 | 10 |
(...skipping 16 matching lines...) Expand all Loading... |
27 EXPECT_EQ(kSizeOfCreateOptions, validated_options.struct_size); | 27 EXPECT_EQ(kSizeOfCreateOptions, validated_options.struct_size); |
28 // Nothing to check for flags. | 28 // Nothing to check for flags. |
29 EXPECT_GT(validated_options.element_num_bytes, 0u); | 29 EXPECT_GT(validated_options.element_num_bytes, 0u); |
30 EXPECT_GT(validated_options.capacity_num_bytes, 0u); | 30 EXPECT_GT(validated_options.capacity_num_bytes, 0u); |
31 EXPECT_EQ(0u, | 31 EXPECT_EQ(0u, |
32 validated_options.capacity_num_bytes % | 32 validated_options.capacity_num_bytes % |
33 validated_options.element_num_bytes); | 33 validated_options.element_num_bytes); |
34 | 34 |
35 MojoCreateDataPipeOptions revalidated_options = {}; | 35 MojoCreateDataPipeOptions revalidated_options = {}; |
36 EXPECT_EQ(MOJO_RESULT_OK, | 36 EXPECT_EQ(MOJO_RESULT_OK, |
37 DataPipe::ValidateCreateOptions(&validated_options, | 37 DataPipe::ValidateCreateOptions(MakeUserPointer(&validated_options), |
38 &revalidated_options)); | 38 &revalidated_options)); |
39 EXPECT_EQ(validated_options.struct_size, revalidated_options.struct_size); | 39 EXPECT_EQ(validated_options.struct_size, revalidated_options.struct_size); |
40 EXPECT_EQ(validated_options.element_num_bytes, | 40 EXPECT_EQ(validated_options.element_num_bytes, |
41 revalidated_options.element_num_bytes); | 41 revalidated_options.element_num_bytes); |
42 EXPECT_EQ(validated_options.capacity_num_bytes, | 42 EXPECT_EQ(validated_options.capacity_num_bytes, |
43 revalidated_options.capacity_num_bytes); | 43 revalidated_options.capacity_num_bytes); |
44 EXPECT_EQ(validated_options.flags, revalidated_options.flags); | 44 EXPECT_EQ(validated_options.flags, revalidated_options.flags); |
45 } | 45 } |
46 | 46 |
47 // Checks that a default-computed capacity is correct. (Does not duplicate the | 47 // Checks that a default-computed capacity is correct. (Does not duplicate the |
48 // checks done by |RevalidateCreateOptions()|.) | 48 // checks done by |RevalidateCreateOptions()|.) |
49 void CheckDefaultCapacity(const MojoCreateDataPipeOptions& validated_options) { | 49 void CheckDefaultCapacity(const MojoCreateDataPipeOptions& validated_options) { |
50 EXPECT_LE(validated_options.capacity_num_bytes, | 50 EXPECT_LE(validated_options.capacity_num_bytes, |
51 kDefaultDataPipeCapacityBytes); | 51 kDefaultDataPipeCapacityBytes); |
52 EXPECT_GT(validated_options.capacity_num_bytes + | 52 EXPECT_GT(validated_options.capacity_num_bytes + |
53 validated_options.element_num_bytes, | 53 validated_options.element_num_bytes, |
54 kDefaultDataPipeCapacityBytes); | 54 kDefaultDataPipeCapacityBytes); |
55 } | 55 } |
56 | 56 |
57 // Tests valid inputs to |ValidateCreateOptions()|. | 57 // Tests valid inputs to |ValidateCreateOptions()|. |
58 TEST(DataPipeTest, ValidateCreateOptionsValid) { | 58 TEST(DataPipeTest, ValidateCreateOptionsValid) { |
59 // Default options. | 59 // Default options. |
60 { | 60 { |
61 MojoCreateDataPipeOptions validated_options = {}; | 61 MojoCreateDataPipeOptions validated_options = {}; |
62 EXPECT_EQ(MOJO_RESULT_OK, | 62 EXPECT_EQ(MOJO_RESULT_OK, |
63 DataPipe::ValidateCreateOptions(NULL, &validated_options)); | 63 DataPipe::ValidateCreateOptions(NullUserPointer(), |
| 64 &validated_options)); |
64 RevalidateCreateOptions(validated_options); | 65 RevalidateCreateOptions(validated_options); |
65 CheckDefaultCapacity(validated_options); | 66 CheckDefaultCapacity(validated_options); |
66 } | 67 } |
67 | 68 |
68 // Size member, but nothing beyond. | 69 // Size member, but nothing beyond. |
69 { | 70 { |
70 MojoCreateDataPipeOptions options = { | 71 MojoCreateDataPipeOptions options = { |
71 offsetof(MojoCreateDataPipeOptions, flags) // |struct_size|. | 72 offsetof(MojoCreateDataPipeOptions, flags) // |struct_size|. |
72 }; | 73 }; |
73 MojoCreateDataPipeOptions validated_options = {}; | 74 MojoCreateDataPipeOptions validated_options = {}; |
74 EXPECT_EQ(MOJO_RESULT_OK, | 75 EXPECT_EQ(MOJO_RESULT_OK, |
75 DataPipe::ValidateCreateOptions(&options, &validated_options)); | 76 DataPipe::ValidateCreateOptions(MakeUserPointer(&options), |
| 77 &validated_options)); |
76 RevalidateCreateOptions(validated_options); | 78 RevalidateCreateOptions(validated_options); |
77 CheckDefaultCapacity(validated_options); | 79 CheckDefaultCapacity(validated_options); |
78 } | 80 } |
79 | 81 |
80 // Different flags. | 82 // Different flags. |
81 MojoCreateDataPipeOptionsFlags flags_values[] = { | 83 MojoCreateDataPipeOptionsFlags flags_values[] = { |
82 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, | 84 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, |
83 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD | 85 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD |
84 }; | 86 }; |
85 for (size_t i = 0; i < arraysize(flags_values); i++) { | 87 for (size_t i = 0; i < arraysize(flags_values); i++) { |
86 const MojoCreateDataPipeOptionsFlags flags = flags_values[i]; | 88 const MojoCreateDataPipeOptionsFlags flags = flags_values[i]; |
87 | 89 |
88 // Flags member, but nothing beyond. | 90 // Flags member, but nothing beyond. |
89 { | 91 { |
90 MojoCreateDataPipeOptions options = { | 92 MojoCreateDataPipeOptions options = { |
91 // |struct_size|. | 93 // |struct_size|. |
92 offsetof(MojoCreateDataPipeOptions, element_num_bytes), | 94 offsetof(MojoCreateDataPipeOptions, element_num_bytes), |
93 flags // |flags|. | 95 flags // |flags|. |
94 }; | 96 }; |
95 MojoCreateDataPipeOptions validated_options = {}; | 97 MojoCreateDataPipeOptions validated_options = {}; |
96 EXPECT_EQ(MOJO_RESULT_OK, | 98 EXPECT_EQ(MOJO_RESULT_OK, |
97 DataPipe::ValidateCreateOptions(&options, &validated_options)); | 99 DataPipe::ValidateCreateOptions(MakeUserPointer(&options), |
| 100 &validated_options)); |
98 RevalidateCreateOptions(validated_options); | 101 RevalidateCreateOptions(validated_options); |
99 EXPECT_EQ(options.flags, validated_options.flags); | 102 EXPECT_EQ(options.flags, validated_options.flags); |
100 CheckDefaultCapacity(validated_options); | 103 CheckDefaultCapacity(validated_options); |
101 } | 104 } |
102 | 105 |
103 // Different capacities (size 1). | 106 // Different capacities (size 1). |
104 for (uint32_t capacity = 1; capacity <= 100 * 1000 * 1000; capacity *= 10) { | 107 for (uint32_t capacity = 1; capacity <= 100 * 1000 * 1000; capacity *= 10) { |
105 MojoCreateDataPipeOptions options = { | 108 MojoCreateDataPipeOptions options = { |
106 kSizeOfCreateOptions, // |struct_size|. | 109 kSizeOfCreateOptions, // |struct_size|. |
107 flags, // |flags|. | 110 flags, // |flags|. |
108 1, // |element_num_bytes|. | 111 1, // |element_num_bytes|. |
109 capacity // |capacity_num_bytes|. | 112 capacity // |capacity_num_bytes|. |
110 }; | 113 }; |
111 MojoCreateDataPipeOptions validated_options = {}; | 114 MojoCreateDataPipeOptions validated_options = {}; |
112 EXPECT_EQ(MOJO_RESULT_OK, | 115 EXPECT_EQ(MOJO_RESULT_OK, |
113 DataPipe::ValidateCreateOptions(&options, &validated_options)) | 116 DataPipe::ValidateCreateOptions(MakeUserPointer(&options), |
| 117 &validated_options)) |
114 << capacity; | 118 << capacity; |
115 RevalidateCreateOptions(validated_options); | 119 RevalidateCreateOptions(validated_options); |
116 EXPECT_EQ(options.flags, validated_options.flags); | 120 EXPECT_EQ(options.flags, validated_options.flags); |
117 EXPECT_EQ(options.element_num_bytes, | 121 EXPECT_EQ(options.element_num_bytes, |
118 validated_options.element_num_bytes); | 122 validated_options.element_num_bytes); |
119 EXPECT_EQ(options.capacity_num_bytes, | 123 EXPECT_EQ(options.capacity_num_bytes, |
120 validated_options.capacity_num_bytes); | 124 validated_options.capacity_num_bytes); |
121 } | 125 } |
122 | 126 |
123 // Small sizes. | 127 // Small sizes. |
124 for (uint32_t size = 1; size < 100; size++) { | 128 for (uint32_t size = 1; size < 100; size++) { |
125 // Different capacities. | 129 // Different capacities. |
126 for (uint32_t elements = 1; elements <= 1000 * 1000; elements *= 10) { | 130 for (uint32_t elements = 1; elements <= 1000 * 1000; elements *= 10) { |
127 MojoCreateDataPipeOptions options = { | 131 MojoCreateDataPipeOptions options = { |
128 kSizeOfCreateOptions, // |struct_size|. | 132 kSizeOfCreateOptions, // |struct_size|. |
129 flags, // |flags|. | 133 flags, // |flags|. |
130 size, // |element_num_bytes|. | 134 size, // |element_num_bytes|. |
131 size * elements // |capacity_num_bytes|. | 135 size * elements // |capacity_num_bytes|. |
132 }; | 136 }; |
133 MojoCreateDataPipeOptions validated_options = {}; | 137 MojoCreateDataPipeOptions validated_options = {}; |
134 EXPECT_EQ(MOJO_RESULT_OK, | 138 EXPECT_EQ(MOJO_RESULT_OK, |
135 DataPipe::ValidateCreateOptions(&options, &validated_options)) | 139 DataPipe::ValidateCreateOptions(MakeUserPointer(&options), |
| 140 &validated_options)) |
136 << size << ", " << elements; | 141 << size << ", " << elements; |
137 RevalidateCreateOptions(validated_options); | 142 RevalidateCreateOptions(validated_options); |
138 EXPECT_EQ(options.flags, validated_options.flags); | 143 EXPECT_EQ(options.flags, validated_options.flags); |
139 EXPECT_EQ(options.element_num_bytes, | 144 EXPECT_EQ(options.element_num_bytes, |
140 validated_options.element_num_bytes); | 145 validated_options.element_num_bytes); |
141 EXPECT_EQ(options.capacity_num_bytes, | 146 EXPECT_EQ(options.capacity_num_bytes, |
142 validated_options.capacity_num_bytes); | 147 validated_options.capacity_num_bytes); |
143 } | 148 } |
144 | 149 |
145 // Default capacity. | 150 // Default capacity. |
146 { | 151 { |
147 MojoCreateDataPipeOptions options = { | 152 MojoCreateDataPipeOptions options = { |
148 kSizeOfCreateOptions, // |struct_size|. | 153 kSizeOfCreateOptions, // |struct_size|. |
149 flags, // |flags|. | 154 flags, // |flags|. |
150 size, // |element_num_bytes|. | 155 size, // |element_num_bytes|. |
151 0 // |capacity_num_bytes|. | 156 0 // |capacity_num_bytes|. |
152 }; | 157 }; |
153 MojoCreateDataPipeOptions validated_options = {}; | 158 MojoCreateDataPipeOptions validated_options = {}; |
154 EXPECT_EQ(MOJO_RESULT_OK, | 159 EXPECT_EQ(MOJO_RESULT_OK, |
155 DataPipe::ValidateCreateOptions(&options, &validated_options)) | 160 DataPipe::ValidateCreateOptions(MakeUserPointer(&options), |
| 161 &validated_options)) |
156 << size; | 162 << size; |
157 RevalidateCreateOptions(validated_options); | 163 RevalidateCreateOptions(validated_options); |
158 EXPECT_EQ(options.flags, validated_options.flags); | 164 EXPECT_EQ(options.flags, validated_options.flags); |
159 EXPECT_EQ(options.element_num_bytes, | 165 EXPECT_EQ(options.element_num_bytes, |
160 validated_options.element_num_bytes); | 166 validated_options.element_num_bytes); |
161 CheckDefaultCapacity(validated_options); | 167 CheckDefaultCapacity(validated_options); |
162 } | 168 } |
163 | 169 |
164 // No capacity field. | 170 // No capacity field. |
165 { | 171 { |
166 MojoCreateDataPipeOptions options = { | 172 MojoCreateDataPipeOptions options = { |
167 // |struct_size|. | 173 // |struct_size|. |
168 offsetof(MojoCreateDataPipeOptions, capacity_num_bytes), | 174 offsetof(MojoCreateDataPipeOptions, capacity_num_bytes), |
169 flags, // |flags|. | 175 flags, // |flags|. |
170 size // |element_num_bytes|. | 176 size // |element_num_bytes|. |
171 }; | 177 }; |
172 MojoCreateDataPipeOptions validated_options = {}; | 178 MojoCreateDataPipeOptions validated_options = {}; |
173 EXPECT_EQ(MOJO_RESULT_OK, | 179 EXPECT_EQ(MOJO_RESULT_OK, |
174 DataPipe::ValidateCreateOptions(&options, &validated_options)) | 180 DataPipe::ValidateCreateOptions(MakeUserPointer(&options), |
| 181 &validated_options)) |
175 << size; | 182 << size; |
176 RevalidateCreateOptions(validated_options); | 183 RevalidateCreateOptions(validated_options); |
177 EXPECT_EQ(options.flags, validated_options.flags); | 184 EXPECT_EQ(options.flags, validated_options.flags); |
178 EXPECT_EQ(options.element_num_bytes, | 185 EXPECT_EQ(options.element_num_bytes, |
179 validated_options.element_num_bytes); | 186 validated_options.element_num_bytes); |
180 CheckDefaultCapacity(validated_options); | 187 CheckDefaultCapacity(validated_options); |
181 } | 188 } |
182 } | 189 } |
183 | 190 |
184 // Larger sizes. | 191 // Larger sizes. |
185 for (uint32_t size = 100; size <= 100 * 1000; size *= 10) { | 192 for (uint32_t size = 100; size <= 100 * 1000; size *= 10) { |
186 // Capacity of 1000 elements. | 193 // Capacity of 1000 elements. |
187 { | 194 { |
188 MojoCreateDataPipeOptions options = { | 195 MojoCreateDataPipeOptions options = { |
189 kSizeOfCreateOptions, // |struct_size|. | 196 kSizeOfCreateOptions, // |struct_size|. |
190 flags, // |flags|. | 197 flags, // |flags|. |
191 size, // |element_num_bytes|. | 198 size, // |element_num_bytes|. |
192 1000 * size // |capacity_num_bytes|. | 199 1000 * size // |capacity_num_bytes|. |
193 }; | 200 }; |
194 MojoCreateDataPipeOptions validated_options = {}; | 201 MojoCreateDataPipeOptions validated_options = {}; |
195 EXPECT_EQ(MOJO_RESULT_OK, | 202 EXPECT_EQ(MOJO_RESULT_OK, |
196 DataPipe::ValidateCreateOptions(&options, &validated_options)) | 203 DataPipe::ValidateCreateOptions(MakeUserPointer(&options), |
| 204 &validated_options)) |
197 << size; | 205 << size; |
198 RevalidateCreateOptions(validated_options); | 206 RevalidateCreateOptions(validated_options); |
199 EXPECT_EQ(options.flags, validated_options.flags); | 207 EXPECT_EQ(options.flags, validated_options.flags); |
200 EXPECT_EQ(options.element_num_bytes, | 208 EXPECT_EQ(options.element_num_bytes, |
201 validated_options.element_num_bytes); | 209 validated_options.element_num_bytes); |
202 EXPECT_EQ(options.capacity_num_bytes, | 210 EXPECT_EQ(options.capacity_num_bytes, |
203 validated_options.capacity_num_bytes); | 211 validated_options.capacity_num_bytes); |
204 } | 212 } |
205 | 213 |
206 // Default capacity. | 214 // Default capacity. |
207 { | 215 { |
208 MojoCreateDataPipeOptions options = { | 216 MojoCreateDataPipeOptions options = { |
209 kSizeOfCreateOptions, // |struct_size|. | 217 kSizeOfCreateOptions, // |struct_size|. |
210 flags, // |flags|. | 218 flags, // |flags|. |
211 size, // |element_num_bytes|. | 219 size, // |element_num_bytes|. |
212 0 // |capacity_num_bytes|. | 220 0 // |capacity_num_bytes|. |
213 }; | 221 }; |
214 MojoCreateDataPipeOptions validated_options = {}; | 222 MojoCreateDataPipeOptions validated_options = {}; |
215 EXPECT_EQ(MOJO_RESULT_OK, | 223 EXPECT_EQ(MOJO_RESULT_OK, |
216 DataPipe::ValidateCreateOptions(&options, &validated_options)) | 224 DataPipe::ValidateCreateOptions(MakeUserPointer(&options), |
| 225 &validated_options)) |
217 << size; | 226 << size; |
218 RevalidateCreateOptions(validated_options); | 227 RevalidateCreateOptions(validated_options); |
219 EXPECT_EQ(options.flags, validated_options.flags); | 228 EXPECT_EQ(options.flags, validated_options.flags); |
220 EXPECT_EQ(options.element_num_bytes, | 229 EXPECT_EQ(options.element_num_bytes, |
221 validated_options.element_num_bytes); | 230 validated_options.element_num_bytes); |
222 CheckDefaultCapacity(validated_options); | 231 CheckDefaultCapacity(validated_options); |
223 } | 232 } |
224 | 233 |
225 // No capacity field. | 234 // No capacity field. |
226 { | 235 { |
227 MojoCreateDataPipeOptions options = { | 236 MojoCreateDataPipeOptions options = { |
228 // |struct_size|. | 237 // |struct_size|. |
229 offsetof(MojoCreateDataPipeOptions, capacity_num_bytes), | 238 offsetof(MojoCreateDataPipeOptions, capacity_num_bytes), |
230 flags, // |flags|. | 239 flags, // |flags|. |
231 size // |element_num_bytes|. | 240 size // |element_num_bytes|. |
232 }; | 241 }; |
233 MojoCreateDataPipeOptions validated_options = {}; | 242 MojoCreateDataPipeOptions validated_options = {}; |
234 EXPECT_EQ(MOJO_RESULT_OK, | 243 EXPECT_EQ(MOJO_RESULT_OK, |
235 DataPipe::ValidateCreateOptions(&options, &validated_options)) | 244 DataPipe::ValidateCreateOptions(MakeUserPointer(&options), |
| 245 &validated_options)) |
236 << size; | 246 << size; |
237 RevalidateCreateOptions(validated_options); | 247 RevalidateCreateOptions(validated_options); |
238 EXPECT_EQ(options.flags, validated_options.flags); | 248 EXPECT_EQ(options.flags, validated_options.flags); |
239 EXPECT_EQ(options.element_num_bytes, | 249 EXPECT_EQ(options.element_num_bytes, |
240 validated_options.element_num_bytes); | 250 validated_options.element_num_bytes); |
241 CheckDefaultCapacity(validated_options); | 251 CheckDefaultCapacity(validated_options); |
242 } | 252 } |
243 } | 253 } |
244 } | 254 } |
245 } | 255 } |
246 | 256 |
247 TEST(DataPipeTest, ValidateCreateOptionsInvalid) { | 257 TEST(DataPipeTest, ValidateCreateOptionsInvalid) { |
248 // Invalid |struct_size|. | 258 // Invalid |struct_size|. |
249 { | 259 { |
250 MojoCreateDataPipeOptions options = { | 260 MojoCreateDataPipeOptions options = { |
251 1, // |struct_size|. | 261 1, // |struct_size|. |
252 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. | 262 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. |
253 1, // |element_num_bytes|. | 263 1, // |element_num_bytes|. |
254 0 // |capacity_num_bytes|. | 264 0 // |capacity_num_bytes|. |
255 }; | 265 }; |
256 MojoCreateDataPipeOptions unused; | 266 MojoCreateDataPipeOptions unused; |
257 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | 267 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
258 DataPipe::ValidateCreateOptions(&options, &unused)); | 268 DataPipe::ValidateCreateOptions(MakeUserPointer(&options), |
| 269 &unused)); |
259 } | 270 } |
260 | 271 |
261 // Unknown |flags|. | 272 // Unknown |flags|. |
262 { | 273 { |
263 MojoCreateDataPipeOptions options = { | 274 MojoCreateDataPipeOptions options = { |
264 kSizeOfCreateOptions, // |struct_size|. | 275 kSizeOfCreateOptions, // |struct_size|. |
265 ~0u, // |flags|. | 276 ~0u, // |flags|. |
266 1, // |element_num_bytes|. | 277 1, // |element_num_bytes|. |
267 0 // |capacity_num_bytes|. | 278 0 // |capacity_num_bytes|. |
268 }; | 279 }; |
269 MojoCreateDataPipeOptions unused; | 280 MojoCreateDataPipeOptions unused; |
270 EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, | 281 EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, |
271 DataPipe::ValidateCreateOptions(&options, &unused)); | 282 DataPipe::ValidateCreateOptions(MakeUserPointer(&options), |
| 283 &unused)); |
272 } | 284 } |
273 | 285 |
274 // Invalid |element_num_bytes|. | 286 // Invalid |element_num_bytes|. |
275 { | 287 { |
276 MojoCreateDataPipeOptions options = { | 288 MojoCreateDataPipeOptions options = { |
277 kSizeOfCreateOptions, // |struct_size|. | 289 kSizeOfCreateOptions, // |struct_size|. |
278 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. | 290 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. |
279 0, // |element_num_bytes|. | 291 0, // |element_num_bytes|. |
280 1000 // |capacity_num_bytes|. | 292 1000 // |capacity_num_bytes|. |
281 }; | 293 }; |
282 MojoCreateDataPipeOptions unused; | 294 MojoCreateDataPipeOptions unused; |
283 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | 295 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
284 DataPipe::ValidateCreateOptions(&options, &unused)); | 296 DataPipe::ValidateCreateOptions(MakeUserPointer(&options), |
| 297 &unused)); |
285 } | 298 } |
286 // |element_num_bytes| too big. | 299 // |element_num_bytes| too big. |
287 { | 300 { |
288 MojoCreateDataPipeOptions options = { | 301 MojoCreateDataPipeOptions options = { |
289 kSizeOfCreateOptions, // |struct_size|. | 302 kSizeOfCreateOptions, // |struct_size|. |
290 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. | 303 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. |
291 std::numeric_limits<uint32_t>::max(), // |element_num_bytes|. | 304 std::numeric_limits<uint32_t>::max(), // |element_num_bytes|. |
292 std::numeric_limits<uint32_t>::max() // |capacity_num_bytes|. | 305 std::numeric_limits<uint32_t>::max() // |capacity_num_bytes|. |
293 }; | 306 }; |
294 MojoCreateDataPipeOptions unused; | 307 MojoCreateDataPipeOptions unused; |
295 EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, | 308 EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, |
296 DataPipe::ValidateCreateOptions(&options, &unused)); | 309 DataPipe::ValidateCreateOptions(MakeUserPointer(&options), |
| 310 &unused)); |
297 } | 311 } |
298 { | 312 { |
299 MojoCreateDataPipeOptions options = { | 313 MojoCreateDataPipeOptions options = { |
300 kSizeOfCreateOptions, // |struct_size|. | 314 kSizeOfCreateOptions, // |struct_size|. |
301 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. | 315 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. |
302 std::numeric_limits<uint32_t>::max() - 1000, // |element_num_bytes|. | 316 std::numeric_limits<uint32_t>::max() - 1000, // |element_num_bytes|. |
303 std::numeric_limits<uint32_t>::max() - 1000 // |capacity_num_bytes|. | 317 std::numeric_limits<uint32_t>::max() - 1000 // |capacity_num_bytes|. |
304 }; | 318 }; |
305 MojoCreateDataPipeOptions unused; | 319 MojoCreateDataPipeOptions unused; |
306 EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, | 320 EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, |
307 DataPipe::ValidateCreateOptions(&options, &unused)); | 321 DataPipe::ValidateCreateOptions(MakeUserPointer(&options), |
| 322 &unused)); |
308 } | 323 } |
309 | 324 |
310 // Invalid |capacity_num_bytes|. | 325 // Invalid |capacity_num_bytes|. |
311 { | 326 { |
312 MojoCreateDataPipeOptions options = { | 327 MojoCreateDataPipeOptions options = { |
313 kSizeOfCreateOptions, // |struct_size|. | 328 kSizeOfCreateOptions, // |struct_size|. |
314 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. | 329 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. |
315 2, // |element_num_bytes|. | 330 2, // |element_num_bytes|. |
316 1 // |capacity_num_bytes|. | 331 1 // |capacity_num_bytes|. |
317 }; | 332 }; |
318 MojoCreateDataPipeOptions unused; | 333 MojoCreateDataPipeOptions unused; |
319 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | 334 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
320 DataPipe::ValidateCreateOptions(&options, &unused)); | 335 DataPipe::ValidateCreateOptions(MakeUserPointer(&options), |
| 336 &unused)); |
321 } | 337 } |
322 { | 338 { |
323 MojoCreateDataPipeOptions options = { | 339 MojoCreateDataPipeOptions options = { |
324 kSizeOfCreateOptions, // |struct_size|. | 340 kSizeOfCreateOptions, // |struct_size|. |
325 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. | 341 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. |
326 2, // |element_num_bytes|. | 342 2, // |element_num_bytes|. |
327 111 // |capacity_num_bytes|. | 343 111 // |capacity_num_bytes|. |
328 }; | 344 }; |
329 MojoCreateDataPipeOptions unused; | 345 MojoCreateDataPipeOptions unused; |
330 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | 346 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
331 DataPipe::ValidateCreateOptions(&options, &unused)); | 347 DataPipe::ValidateCreateOptions(MakeUserPointer(&options), |
| 348 &unused)); |
332 } | 349 } |
333 { | 350 { |
334 MojoCreateDataPipeOptions options = { | 351 MojoCreateDataPipeOptions options = { |
335 kSizeOfCreateOptions, // |struct_size|. | 352 kSizeOfCreateOptions, // |struct_size|. |
336 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. | 353 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. |
337 5, // |element_num_bytes|. | 354 5, // |element_num_bytes|. |
338 104 // |capacity_num_bytes|. | 355 104 // |capacity_num_bytes|. |
339 }; | 356 }; |
340 MojoCreateDataPipeOptions unused; | 357 MojoCreateDataPipeOptions unused; |
341 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | 358 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
342 DataPipe::ValidateCreateOptions(&options, &unused)); | 359 DataPipe::ValidateCreateOptions(MakeUserPointer(&options), |
| 360 &unused)); |
343 } | 361 } |
344 // |capacity_num_bytes| too big. | 362 // |capacity_num_bytes| too big. |
345 { | 363 { |
346 MojoCreateDataPipeOptions options = { | 364 MojoCreateDataPipeOptions options = { |
347 kSizeOfCreateOptions, // |struct_size|. | 365 kSizeOfCreateOptions, // |struct_size|. |
348 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. | 366 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. |
349 8, // |element_num_bytes|. | 367 8, // |element_num_bytes|. |
350 0xffff0000 // |capacity_num_bytes|. | 368 0xffff0000 // |capacity_num_bytes|. |
351 }; | 369 }; |
352 MojoCreateDataPipeOptions unused; | 370 MojoCreateDataPipeOptions unused; |
353 EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, | 371 EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, |
354 DataPipe::ValidateCreateOptions(&options, &unused)); | 372 DataPipe::ValidateCreateOptions(MakeUserPointer(&options), |
| 373 &unused)); |
355 } | 374 } |
356 } | 375 } |
357 | 376 |
358 } // namespace | 377 } // namespace |
359 } // namespace system | 378 } // namespace system |
360 } // namespace mojo | 379 } // namespace mojo |
OLD | NEW |