OLD | NEW |
---|---|
(Empty) | |
1 // Copyright (c) 2012 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 "ppapi/tests/test_file_mapping.h" | |
6 | |
7 #include <string.h> | |
8 | |
9 #include <limits> | |
10 #include <string> | |
11 | |
12 #include "ppapi/c/pp_errors.h" | |
13 #include "ppapi/c/ppb_file_io.h" | |
14 #include "ppapi/c/ppb_file_mapping.h" | |
15 #include "ppapi/cpp/file_io.h" | |
16 #include "ppapi/cpp/file_ref.h" | |
17 #include "ppapi/cpp/file_system.h" | |
18 #include "ppapi/cpp/instance.h" | |
19 #include "ppapi/cpp/module.h" | |
20 #include "ppapi/tests/test_utils.h" | |
21 | |
22 REGISTER_TEST_CASE(FileMapping); | |
23 | |
24 namespace { | |
25 | |
26 // TODO(dmichael): Move these to test_utils so we can share them? | |
27 int32_t ReadEntireFile(PP_Instance instance, | |
28 pp::FileIO* file_io, | |
29 int32_t offset, | |
30 std::string* data, | |
31 CallbackType callback_type) { | |
32 TestCompletionCallback callback(instance, callback_type); | |
33 char buf[256]; | |
34 int32_t read_offset = offset; | |
35 | |
36 for (;;) { | |
37 callback.WaitForResult( | |
38 file_io->Read(read_offset, buf, sizeof(buf), callback.GetCallback())); | |
39 if (callback.result() < 0) | |
40 return callback.result(); | |
41 if (callback.result() == 0) | |
42 break; | |
43 read_offset += callback.result(); | |
44 data->append(buf, callback.result()); | |
45 } | |
46 | |
47 return PP_OK; | |
48 } | |
49 | |
50 int32_t WriteEntireBuffer(PP_Instance instance, | |
51 pp::FileIO* file_io, | |
52 int32_t offset, | |
53 const std::string& data, | |
54 CallbackType callback_type) { | |
55 TestCompletionCallback callback(instance, callback_type); | |
56 int32_t write_offset = offset; | |
57 const char* buf = data.c_str(); | |
58 int32_t size = data.size(); | |
59 | |
60 while (write_offset < offset + size) { | |
61 callback.WaitForResult(file_io->Write(write_offset, | |
62 &buf[write_offset - offset], | |
63 size - write_offset + offset, | |
64 callback.GetCallback())); | |
65 if (callback.result() < 0) | |
66 return callback.result(); | |
67 if (callback.result() == 0) | |
68 return PP_ERROR_FAILED; | |
69 write_offset += callback.result(); | |
70 } | |
71 callback.WaitForResult(file_io->Flush(callback.GetCallback())); | |
72 return callback.result(); | |
73 } | |
74 | |
75 } // namespace | |
76 | |
77 std::string TestFileMapping::MapAndCheckResults(uint32_t prot, | |
78 uint32_t flags) { | |
79 TestCompletionCallback callback(instance_->pp_instance(), callback_type()); | |
80 | |
81 pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY); | |
82 pp::FileRef file_ref(file_system, "/mapped_file"); | |
83 | |
84 callback.WaitForResult(file_system.Open(1024, callback.GetCallback())); | |
85 ASSERT_EQ(PP_OK, callback.result()); | |
86 | |
87 const int64_t page_size = | |
88 file_mapping_if_->GetMapPageSize(instance_->pp_instance()); | |
89 const int64_t kNumPages = 4; | |
90 // Make a string that's big enough that it spans all of the first |n-1| pages, | |
91 // plus a little bit of the |nth| page. | |
92 std::string file_contents((page_size * (kNumPages - 1)) + 128, 'a'); | |
93 | |
94 pp::FileIO file_io(instance_); | |
95 callback.WaitForResult(file_io.Open(file_ref, | |
96 PP_FILEOPENFLAG_CREATE | | |
97 PP_FILEOPENFLAG_TRUNCATE | | |
98 PP_FILEOPENFLAG_READ | | |
99 PP_FILEOPENFLAG_WRITE, | |
100 callback.GetCallback())); | |
101 ASSERT_EQ(PP_OK, callback.result()); | |
102 ASSERT_EQ(PP_OK, WriteEntireBuffer(instance_->pp_instance(), | |
103 &file_io, | |
104 0, | |
105 file_contents, | |
106 callback_type())); | |
107 | |
108 // TODO(dmichael): Use C++ interface. | |
109 void* address = NULL; | |
110 callback.WaitForResult( | |
111 file_mapping_if_->Map( | |
112 instance_->pp_instance(), | |
113 file_io.pp_resource(), | |
114 kNumPages * page_size, | |
115 prot, | |
116 flags, | |
117 0, | |
118 &address, | |
119 callback.GetCallback().pp_completion_callback())); | |
120 CHECK_CALLBACK_BEHAVIOR(callback); | |
121 ASSERT_EQ(PP_OK, callback.result()); | |
122 ASSERT_NE(NULL, address); | |
123 | |
124 if (prot & PP_FILEMAPPROTECTION_READ) { | |
125 // Make sure we can read. | |
126 std::string mapped_data(static_cast<char*>(address), file_contents.size()); | |
127 // The initial data should match. | |
128 ASSERT_EQ(file_contents, mapped_data); | |
129 | |
130 // Now write some data and flush it. | |
131 const std::string file_contents2(file_contents.size(), 'x'); | |
132 ASSERT_EQ(PP_OK, WriteEntireBuffer(instance_->pp_instance(), | |
133 &file_io, | |
134 0, | |
135 file_contents2, | |
136 callback_type())); | |
137 // If the region was mapped SHARED, it should get updated. | |
138 std::string mapped_data2(static_cast<char*>(address), file_contents.size()); | |
139 if (flags & PP_FILEMAPFLAG_SHARED) | |
140 ASSERT_EQ(file_contents2, mapped_data2); | |
141 // In POSIX, it is unspecified in the PRIVATE case whether changes to the | |
142 // file are visible to the mapped region. So we can't really test anything | |
143 // here in that case. | |
144 // FIXME(dmichael): Make sure our Pepper documentation reflects this. | |
bbudge
2014/01/27 18:56:44
// TODO?
dmichael (off chromium)
2014/01/27 19:20:26
Done.
| |
145 } | |
146 if (prot & PP_FILEMAPPROTECTION_WRITE) { | |
147 std::string old_file_contents; | |
148 ASSERT_EQ(PP_OK, ReadEntireFile(instance_->pp_instance(), | |
149 &file_io, | |
150 0, | |
151 &old_file_contents, | |
152 callback_type())); | |
153 // Write something else to the mapped region, then unmap, and see if it | |
154 // gets written to the file. (Note we have to Unmap to make sure that the | |
155 // write is committed). | |
156 memset(address, 'y', file_contents.size()); | |
157 // Note, we might not have read access to the mapped region here, so we | |
158 // make a string with the same contents without actually reading. | |
159 std::string mapped_data3(file_contents.size(), 'y'); | |
160 callback.WaitForResult( | |
161 file_mapping_if_->Unmap( | |
162 instance_->pp_instance(), address, file_contents.size(), | |
163 callback.GetCallback().pp_completion_callback())); | |
164 CHECK_CALLBACK_BEHAVIOR(callback); | |
165 ASSERT_EQ(PP_OK, callback.result()); | |
166 std::string new_file_contents; | |
167 ASSERT_EQ(PP_OK, ReadEntireFile(instance_->pp_instance(), | |
168 &file_io, | |
169 0, | |
170 &new_file_contents, | |
171 callback_type())); | |
172 | |
173 // Sanity-check that the data we wrote isn't the same as what was already | |
174 // there, otherwise our test is invalid. | |
175 ASSERT_NE(mapped_data3, old_file_contents); | |
176 // If it's SHARED, the file should match what we wrote to the mapped region. | |
177 // Otherwise, it should not have changed. | |
178 if (flags & PP_FILEMAPFLAG_SHARED) | |
179 ASSERT_EQ(mapped_data3, new_file_contents); | |
180 else | |
181 ASSERT_EQ(old_file_contents, new_file_contents); | |
182 } else { | |
183 // We didn't do the "WRITE" test, but we still want to Unmap. | |
184 callback.WaitForResult( | |
185 file_mapping_if_->Unmap( | |
186 instance_->pp_instance(), address, file_contents.size(), | |
187 callback.GetCallback().pp_completion_callback())); | |
188 CHECK_CALLBACK_BEHAVIOR(callback); | |
189 ASSERT_EQ(PP_OK, callback.result()); | |
190 } | |
191 PASS(); | |
192 } | |
193 | |
194 bool TestFileMapping::Init() { | |
195 // TODO(dmichael): Use unversioned string when this goes to stable? | |
196 file_mapping_if_ = static_cast<const PPB_FileMapping_0_1*>( | |
197 pp::Module::Get()->GetBrowserInterface(PPB_FILEMAPPING_INTERFACE_0_1)); | |
198 return !!file_mapping_if_ && CheckTestingInterface() && | |
199 EnsureRunningOverHTTP(); | |
200 } | |
201 | |
202 void TestFileMapping::RunTests(const std::string& filter) { | |
203 // TODO(dmichael): Tests to write: | |
204 // - Unmapping partial regions | |
bbudge
2014/01/27 18:56:44
What would you test that isn't already tested in P
dmichael (off chromium)
2014/01/27 19:20:26
Oops, that's an old comment, thanks :)
| |
205 RUN_CALLBACK_TEST(TestFileMapping, BadParameters, filter); | |
206 RUN_CALLBACK_TEST(TestFileMapping, Map, filter); | |
207 RUN_CALLBACK_TEST(TestFileMapping, PartialRegions, filter); | |
208 } | |
209 | |
210 std::string TestFileMapping::TestBadParameters() { | |
211 TestCompletionCallback callback(instance_->pp_instance(), callback_type()); | |
212 | |
213 pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY); | |
214 pp::FileRef file_ref(file_system, "/mapped_file"); | |
215 | |
216 callback.WaitForResult(file_system.Open(1024, callback.GetCallback())); | |
217 ASSERT_EQ(PP_OK, callback.result()); | |
218 | |
219 const int64_t page_size = | |
220 file_mapping_if_->GetMapPageSize(instance_->pp_instance()); | |
221 // const int64_t kNumPages = 4; | |
222 // Make a string that's big enough that it spans 3 pages, plus a little extra. | |
223 //std::string file_contents((page_size * (kNumPages - 1)) + 128, 'a'); | |
224 std::string file_contents(page_size, 'a'); | |
225 | |
226 pp::FileIO file_io(instance_); | |
227 callback.WaitForResult(file_io.Open(file_ref, | |
228 PP_FILEOPENFLAG_CREATE | | |
229 PP_FILEOPENFLAG_TRUNCATE | | |
230 PP_FILEOPENFLAG_READ | | |
231 PP_FILEOPENFLAG_WRITE, | |
232 callback.GetCallback())); | |
233 ASSERT_EQ(PP_OK, callback.result()); | |
234 ASSERT_EQ(PP_OK, WriteEntireBuffer(instance_->pp_instance(), | |
235 &file_io, | |
236 0, | |
237 file_contents, | |
238 callback_type())); | |
239 | |
240 // Bad instance. | |
241 void* address = NULL; | |
242 callback.WaitForResult( | |
243 file_mapping_if_->Map( | |
244 PP_Instance(0xbadbad), | |
245 file_io.pp_resource(), | |
246 page_size, | |
247 PP_FILEMAPPROTECTION_READ, | |
248 PP_FILEMAPFLAG_PRIVATE, | |
249 0, | |
250 &address, | |
251 callback.GetCallback().pp_completion_callback())); | |
252 CHECK_CALLBACK_BEHAVIOR(callback); | |
253 ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result()); | |
254 ASSERT_EQ(NULL, address); | |
255 | |
256 // Bad resource. | |
257 callback.WaitForResult( | |
258 file_mapping_if_->Map( | |
259 instance_->pp_instance(), | |
260 PP_Resource(0xbadbad), | |
261 page_size, | |
262 PP_FILEMAPPROTECTION_READ, | |
263 PP_FILEMAPFLAG_PRIVATE, | |
264 0, | |
265 &address, | |
266 callback.GetCallback().pp_completion_callback())); | |
267 CHECK_CALLBACK_BEHAVIOR(callback); | |
268 ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result()); | |
269 ASSERT_EQ(NULL, address); | |
270 | |
271 // Length too big. | |
272 callback.WaitForResult( | |
273 file_mapping_if_->Map( | |
274 instance_->pp_instance(), | |
275 file_io.pp_resource(), | |
276 std::numeric_limits<int64_t>::max(), | |
277 PP_FILEMAPPROTECTION_READ, | |
278 PP_FILEMAPFLAG_PRIVATE, | |
279 0, | |
280 &address, | |
281 callback.GetCallback().pp_completion_callback())); | |
282 CHECK_CALLBACK_BEHAVIOR(callback); | |
283 ASSERT_EQ(PP_ERROR_NOMEMORY, callback.result()); | |
284 ASSERT_EQ(NULL, address); | |
285 | |
286 // Length too small. | |
287 callback.WaitForResult( | |
288 file_mapping_if_->Map( | |
289 instance_->pp_instance(), | |
290 file_io.pp_resource(), | |
291 -1, | |
292 PP_FILEMAPPROTECTION_READ, | |
293 PP_FILEMAPFLAG_PRIVATE, | |
294 0, | |
295 &address, | |
296 callback.GetCallback().pp_completion_callback())); | |
297 CHECK_CALLBACK_BEHAVIOR(callback); | |
298 ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result()); | |
299 ASSERT_EQ(NULL, address); | |
300 // TODO(dmichael): Check & test length that is not a multiple of page size??? | |
301 | |
302 // Bad protection. | |
303 callback.WaitForResult( | |
304 file_mapping_if_->Map( | |
305 instance_->pp_instance(), | |
306 file_io.pp_resource(), | |
307 page_size, | |
308 ~PP_FILEMAPPROTECTION_READ, | |
309 PP_FILEMAPFLAG_PRIVATE, | |
310 0, | |
311 &address, | |
312 callback.GetCallback().pp_completion_callback())); | |
313 CHECK_CALLBACK_BEHAVIOR(callback); | |
314 ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result()); | |
315 ASSERT_EQ(NULL, address); | |
316 | |
317 // No flags. | |
318 callback.WaitForResult( | |
319 file_mapping_if_->Map( | |
320 instance_->pp_instance(), | |
321 file_io.pp_resource(), | |
322 page_size, | |
323 PP_FILEMAPPROTECTION_READ, | |
324 0, | |
325 0, | |
326 &address, | |
327 callback.GetCallback().pp_completion_callback())); | |
328 CHECK_CALLBACK_BEHAVIOR(callback); | |
329 ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result()); | |
330 ASSERT_EQ(NULL, address); | |
331 | |
332 // Both flags. | |
333 callback.WaitForResult( | |
334 file_mapping_if_->Map( | |
335 instance_->pp_instance(), | |
336 file_io.pp_resource(), | |
337 page_size, | |
338 PP_FILEMAPPROTECTION_READ, | |
339 PP_FILEMAPFLAG_SHARED | PP_FILEMAPFLAG_PRIVATE, | |
340 0, | |
341 &address, | |
342 callback.GetCallback().pp_completion_callback())); | |
343 CHECK_CALLBACK_BEHAVIOR(callback); | |
344 ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result()); | |
345 ASSERT_EQ(NULL, address); | |
346 | |
347 // Bad flags. | |
348 callback.WaitForResult( | |
349 file_mapping_if_->Map( | |
350 instance_->pp_instance(), | |
351 file_io.pp_resource(), | |
352 page_size, | |
353 PP_FILEMAPPROTECTION_READ, | |
354 ~PP_FILEMAPFLAG_SHARED, | |
355 0, | |
356 &address, | |
357 callback.GetCallback().pp_completion_callback())); | |
358 CHECK_CALLBACK_BEHAVIOR(callback); | |
359 ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result()); | |
360 ASSERT_EQ(NULL, address); | |
361 | |
362 // Bad offset; not a multiple of page size. | |
363 callback.WaitForResult( | |
364 file_mapping_if_->Map( | |
365 instance_->pp_instance(), | |
366 file_io.pp_resource(), | |
367 page_size, | |
368 PP_FILEMAPPROTECTION_READ, | |
369 ~PP_FILEMAPFLAG_SHARED, | |
370 1, | |
371 &address, | |
372 callback.GetCallback().pp_completion_callback())); | |
373 CHECK_CALLBACK_BEHAVIOR(callback); | |
374 ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result()); | |
375 ASSERT_EQ(NULL, address); | |
376 | |
377 // Unmap NULL. | |
378 callback.WaitForResult( | |
379 file_mapping_if_->Unmap( | |
380 instance_->pp_instance(), | |
381 NULL, | |
382 page_size, | |
383 callback.GetCallback().pp_completion_callback())); | |
384 CHECK_CALLBACK_BEHAVIOR(callback); | |
385 ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result()); | |
386 | |
387 // Unmap bad address. | |
388 callback.WaitForResult( | |
389 file_mapping_if_->Unmap( | |
390 instance_->pp_instance(), | |
391 reinterpret_cast<const void*>(0xdeadbeef), | |
392 page_size, | |
393 callback.GetCallback().pp_completion_callback())); | |
394 CHECK_CALLBACK_BEHAVIOR(callback); | |
395 ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result()); | |
396 | |
397 PASS(); | |
398 } | |
399 | |
400 std::string TestFileMapping::TestMap() { | |
401 ASSERT_SUBTEST_SUCCESS(MapAndCheckResults(PP_FILEMAPPROTECTION_READ, | |
402 PP_FILEMAPFLAG_SHARED)); | |
403 ASSERT_SUBTEST_SUCCESS(MapAndCheckResults(PP_FILEMAPPROTECTION_WRITE, | |
404 PP_FILEMAPFLAG_SHARED)); | |
405 ASSERT_SUBTEST_SUCCESS( | |
406 MapAndCheckResults(PP_FILEMAPPROTECTION_WRITE | PP_FILEMAPPROTECTION_READ, | |
407 PP_FILEMAPFLAG_SHARED)); | |
408 ASSERT_SUBTEST_SUCCESS(MapAndCheckResults(PP_FILEMAPPROTECTION_READ, | |
409 PP_FILEMAPFLAG_PRIVATE)); | |
410 ASSERT_SUBTEST_SUCCESS(MapAndCheckResults(PP_FILEMAPPROTECTION_WRITE, | |
411 PP_FILEMAPFLAG_PRIVATE)); | |
412 ASSERT_SUBTEST_SUCCESS( | |
413 MapAndCheckResults(PP_FILEMAPPROTECTION_WRITE | PP_FILEMAPPROTECTION_READ, | |
414 PP_FILEMAPFLAG_PRIVATE)); | |
415 // FIXME(dmichael) How to test FIXED?? | |
bbudge
2014/01/27 18:56:44
// TODO?
dmichael (off chromium)
2014/01/27 19:20:26
The PartialRegions test actually does a FIXED mapp
| |
416 PASS(); | |
417 } | |
418 | |
419 std::string TestFileMapping::TestPartialRegions() { | |
420 TestCompletionCallback callback(instance_->pp_instance(), callback_type()); | |
421 | |
422 pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY); | |
423 pp::FileRef file_ref1(file_system, "/mapped_file1"); | |
424 pp::FileRef file_ref2(file_system, "/mapped_file2"); | |
425 | |
426 callback.WaitForResult(file_system.Open(1024, callback.GetCallback())); | |
427 ASSERT_EQ(PP_OK, callback.result()); | |
428 | |
429 const int64_t page_size = | |
430 file_mapping_if_->GetMapPageSize(instance_->pp_instance()); | |
431 const int64_t kNumPages = 3; | |
432 std::string file_contents1(kNumPages * page_size, 'a'); | |
433 | |
434 pp::FileIO file_io1(instance_); | |
435 callback.WaitForResult(file_io1.Open(file_ref1, | |
436 PP_FILEOPENFLAG_CREATE | | |
437 PP_FILEOPENFLAG_TRUNCATE | | |
438 PP_FILEOPENFLAG_READ | | |
439 PP_FILEOPENFLAG_WRITE, | |
440 callback.GetCallback())); | |
441 ASSERT_EQ(PP_OK, callback.result()); | |
442 ASSERT_EQ(PP_OK, WriteEntireBuffer(instance_->pp_instance(), | |
443 &file_io1, | |
444 0, | |
445 file_contents1, | |
446 callback_type())); | |
447 | |
448 // TODO(dmichael): Use C++ interface. | |
449 void* address = NULL; | |
450 callback.WaitForResult( | |
451 file_mapping_if_->Map( | |
452 instance_->pp_instance(), | |
453 file_io1.pp_resource(), | |
454 kNumPages * page_size, | |
455 PP_FILEMAPPROTECTION_WRITE | PP_FILEMAPPROTECTION_READ, | |
456 PP_FILEMAPFLAG_SHARED, | |
457 0, | |
458 &address, | |
459 callback.GetCallback().pp_completion_callback())); | |
460 CHECK_CALLBACK_BEHAVIOR(callback); | |
461 ASSERT_EQ(PP_OK, callback.result()); | |
462 ASSERT_NE(NULL, address); | |
463 | |
464 // Unmap only the middle page. | |
465 void* address_of_middle_page = | |
466 reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(address) + page_size); | |
467 callback.WaitForResult( | |
468 file_mapping_if_->Unmap( | |
469 instance_->pp_instance(), | |
470 address_of_middle_page, | |
471 page_size, | |
472 callback.GetCallback().pp_completion_callback())); | |
473 CHECK_CALLBACK_BEHAVIOR(callback); | |
474 ASSERT_EQ(PP_OK, callback.result()); | |
475 | |
476 // Write another file, map it in to the middle hole that was left above. | |
477 pp::FileIO file_io2(instance_); | |
478 callback.WaitForResult(file_io2.Open(file_ref2, | |
479 PP_FILEOPENFLAG_CREATE | | |
480 PP_FILEOPENFLAG_TRUNCATE | | |
481 PP_FILEOPENFLAG_READ | | |
482 PP_FILEOPENFLAG_WRITE, | |
483 callback.GetCallback())); | |
484 ASSERT_EQ(PP_OK, callback.result()); | |
485 // This second file will have 1 page worth of data. | |
486 std::string file_contents2(page_size, 'b'); | |
487 ASSERT_EQ(PP_OK, WriteEntireBuffer(instance_->pp_instance(), | |
488 &file_io2, | |
489 0, | |
490 file_contents2, | |
491 callback_type())); | |
492 callback.WaitForResult( | |
493 file_mapping_if_->Map( | |
494 instance_->pp_instance(), | |
495 file_io2.pp_resource(), | |
496 page_size, | |
497 PP_FILEMAPPROTECTION_WRITE | PP_FILEMAPPROTECTION_READ, | |
498 PP_FILEMAPFLAG_SHARED | PP_FILEMAPFLAG_FIXED, | |
499 0, | |
500 &address_of_middle_page, | |
501 callback.GetCallback().pp_completion_callback())); | |
502 CHECK_CALLBACK_BEHAVIOR(callback); | |
503 ASSERT_EQ(PP_OK, callback.result()); | |
504 PASS(); | |
505 | |
506 // Write something else to the mapped region, then unmap, and see if it | |
507 // gets written to both files. (Note we have to Unmap to make sure that the | |
508 // write is committed). | |
509 memset(address, 'c', kNumPages * page_size); | |
510 callback.WaitForResult( | |
511 file_mapping_if_->Unmap( | |
512 instance_->pp_instance(), address, kNumPages * page_size, | |
513 callback.GetCallback().pp_completion_callback())); | |
514 CHECK_CALLBACK_BEHAVIOR(callback); | |
515 ASSERT_EQ(PP_OK, callback.result()); | |
516 // The first and third page should have been written with 'c', but the | |
517 // second page should be untouched. | |
518 std::string expected_file_contents1 = std::string(page_size, 'c') + | |
519 std::string(page_size, 'a') + | |
520 std::string(page_size, 'c'); | |
521 std::string new_file_contents1; | |
522 ASSERT_EQ(PP_OK, ReadEntireFile(instance_->pp_instance(), | |
523 &file_io1, | |
524 0, | |
525 &new_file_contents1, | |
526 callback_type())); | |
527 ASSERT_EQ(expected_file_contents1, new_file_contents1); | |
528 | |
529 // The second file should have been entirely over-written. | |
530 std::string expected_file_contents2 = std::string(page_size, 'c'); | |
531 std::string new_file_contents2; | |
532 ASSERT_EQ(PP_OK, ReadEntireFile(instance_->pp_instance(), | |
533 &file_io2, | |
534 0, | |
535 &new_file_contents2, | |
536 callback_type())); | |
537 ASSERT_EQ(expected_file_contents2, new_file_contents2); | |
538 | |
539 // TODO(dmichael): Test non-zero offset | |
540 } | |
541 | |
OLD | NEW |