ppapi/tests/test_file_io.cc

   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_io.h"
   6
   7 #include <errno.h>
   8 #include <fcntl.h>
   9 #include <stdio.h>
  10 #include <string.h>
  11 #include <sys/stat.h>
  12 #include <sys/types.h>
  13
  14 #include <algorithm>
  15 #include <vector>
  16
  17 #include "ppapi/c/pp_errors.h"
  18 #include "ppapi/c/ppb_file_io.h"
  19 #include "ppapi/c/private/pp_file_handle.h"
  20 #include "ppapi/c/private/ppb_testing_private.h"
  21 #include "ppapi/cpp/file_io.h"
  22 #include "ppapi/cpp/file_ref.h"
  23 #include "ppapi/cpp/file_system.h"
  24 #include "ppapi/cpp/instance.h"
  25 #include "ppapi/cpp/module.h"
  26 #include "ppapi/cpp/private/file_io_private.h"
  27 #include "ppapi/cpp/private/pass_file_handle.h"
  28 #include "ppapi/tests/test_utils.h"
  29 #include "ppapi/tests/testing_instance.h"
  30
  31 #if defined(PPAPI_OS_WIN)
  32 # include <io.h>
  33 # include <windows.h>
  34 // TODO(hamaji): Use standard windows APIs instead of compatibility layer?
  35 # define lseek _lseek
  36 # define read _read
  37 # define write _write
  38 # define ssize_t int
  39 #else
  40 # include <sys/mman.h>
  41 # include <unistd.h>
  42 #endif
  43
  44 REGISTER_TEST_CASE(FileIO);
  45
  46 namespace {
  47
  48 std::string ReportMismatch(const std::string& method_name,
  49                            const std::string& returned_result,
  50                            const std::string& expected_result) {
  51   return method_name + " returned '" + returned_result + "'; '" +
  52       expected_result + "' expected.";
  53 }
  54
  55 std::string ReportOpenError(int32_t open_flags) {
  56   static const char* kFlagNames[] = {
  57     "PP_FILEOPENFLAG_READ",
  58     "PP_FILEOPENFLAG_WRITE",
  59     "PP_FILEOPENFLAG_CREATE",
  60     "PP_FILEOPENFLAG_TRUNCATE",
  61     "PP_FILEOPENFLAG_EXCLUSIVE"
  62   };
  63
  64   std::string result = "FileIO:Open had unexpected behavior with flags: ";
  65   bool first_flag = true;
  66   for (int32_t mask = 1, index = 0; mask <= PP_FILEOPENFLAG_EXCLUSIVE;
  67        mask <<= 1, ++index) {
  68     if (mask & open_flags) {
  69       if (first_flag) {
  70         first_flag = false;
  71       } else {
  72         result += " | ";
  73       }
  74       result += kFlagNames[index];
  75     }
  76   }
  77   if (first_flag)
  78     result += "[None]";
  79
  80   return result;
  81 }
  82
  83 int32_t ReadEntireFile(PP_Instance instance,
  84                        pp::FileIO* file_io,
  85                        int32_t offset,
  86                        std::string* data,
  87                        CallbackType callback_type) {
  88   TestCompletionCallback callback(instance, callback_type);
  89   char buf[256];
  90   int32_t read_offset = offset;
  91
  92   for (;;) {
  93     callback.WaitForResult(
  94         file_io->Read(read_offset, buf, sizeof(buf), callback.GetCallback()));
  95     if (callback.result() < 0)
  96       return callback.result();
  97     if (callback.result() == 0)
  98       break;
  99     read_offset += callback.result();
 100     data->append(buf, callback.result());
 101   }
 102
 103   return PP_OK;
 104 }
 105
 106 int32_t ReadToArrayEntireFile(PP_Instance instance,
 107                               pp::FileIO* file_io,
 108                               int32_t offset,
 109                               std::string* data,
 110                               CallbackType callback_type) {
 111   TestCompletionCallbackWithOutput< std::vector<char> > callback(
 112       instance, callback_type);
 113
 114   for (;;) {
 115     callback.WaitForResult(file_io->Read(offset, 256, callback.GetCallback()));
 116     int32_t rv = callback.result();
 117     if (rv < 0)
 118       return rv;
 119     if (rv == 0)
 120       break;
 121     const std::vector<char>& output = callback.output();
 122     assert(rv == static_cast<int32_t>(output.size()));
 123     offset += rv;
 124     data->append(output.begin(), output.end());
 125   }
 126
 127   return PP_OK;
 128 }
 129
 130 bool ReadEntireFileFromFileHandle(int fd, std::string* data) {
 131   if (lseek(fd, 0, SEEK_SET) < 0)
 132     return false;
 133   data->clear();
 134
 135   int ret;
 136   do {
 137     char buf[8192];
 138     ret = read(fd, buf, sizeof(buf));
 139     if (ret > 0)
 140       data->append(buf, ret);
 141   } while (ret > 0);
 142   return ret == 0;
 143 }
 144
 145 int32_t WriteEntireBuffer(PP_Instance instance,
 146                           pp::FileIO* file_io,
 147                           int32_t offset,
 148                           const std::string& data,
 149                           CallbackType callback_type) {
 150   TestCompletionCallback callback(instance, callback_type);
 151   int32_t write_offset = offset;
 152   const char* buf = data.c_str();
 153   int32_t size = data.size();
 154
 155   while (write_offset < offset + size) {
 156     callback.WaitForResult(file_io->Write(write_offset,
 157                                           &buf[write_offset - offset],
 158                                           size - write_offset + offset,
 159                                           callback.GetCallback()));
 160     if (callback.result() < 0)
 161       return callback.result();
 162     if (callback.result() == 0)
 163       return PP_ERROR_FAILED;
 164     write_offset += callback.result();
 165   }
 166
 167   return PP_OK;
 168 }
 169
 170 }  // namespace
 171
 172 bool TestFileIO::Init() {
 173   return CheckTestingInterface() && EnsureRunningOverHTTP();
 174 }
 175
 176 void TestFileIO::RunTests(const std::string& filter) {
 177   RUN_CALLBACK_TEST(TestFileIO, Open, filter);
 178   RUN_CALLBACK_TEST(TestFileIO, OpenDirectory, filter);
 179   RUN_CALLBACK_TEST(TestFileIO, ReadWriteSetLength, filter);
 180   RUN_CALLBACK_TEST(TestFileIO, ReadToArrayWriteSetLength, filter);
 181   RUN_CALLBACK_TEST(TestFileIO, TouchQuery, filter);
 182   RUN_CALLBACK_TEST(TestFileIO, AbortCalls, filter);
 183   RUN_CALLBACK_TEST(TestFileIO, ParallelReads, filter);
 184   RUN_CALLBACK_TEST(TestFileIO, ParallelWrites, filter);
 185   RUN_CALLBACK_TEST(TestFileIO, NotAllowMixedReadWrite, filter);
 186   RUN_CALLBACK_TEST(TestFileIO, RequestOSFileHandle, filter);
 187   RUN_CALLBACK_TEST(TestFileIO, RequestOSFileHandleWithOpenExclusive, filter);
 188   RUN_CALLBACK_TEST(TestFileIO, Mmap, filter);
 189
 190   // TODO(viettrungluu): add tests:
 191   //  - that PP_ERROR_PENDING is correctly returned
 192   //  - that operations respect the file open modes (flags)
 193 }
 194
 195 std::string TestFileIO::TestOpen() {
 196   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 197
 198   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
 199   pp::FileRef file_ref(file_system, "/file_open");
 200
 201   callback.WaitForResult(file_system.Open(1024, callback.GetCallback()));
 202   CHECK_CALLBACK_BEHAVIOR(callback);
 203   ASSERT_EQ(PP_OK, callback.result());
 204
 205   std::string result;
 206   result = MatchOpenExpectations(
 207       &file_system,
 208       PP_FILEOPENFLAG_READ,
 209       DONT_CREATE_IF_DOESNT_EXIST | OPEN_IF_EXISTS | DONT_TRUNCATE_IF_EXISTS);
 210   if (!result.empty())
 211     return result;
 212
 213   // Test the behavior of the power set of
 214   //   { PP_FILEOPENFLAG_CREATE,
 215   //     PP_FILEOPENFLAG_TRUNCATE,
 216   //     PP_FILEOPENFLAG_EXCLUSIVE }.
 217
 218   // First of all, none of them are specified.
 219   result = MatchOpenExpectations(
 220       &file_system,
 221       PP_FILEOPENFLAG_WRITE,
 222       DONT_CREATE_IF_DOESNT_EXIST | OPEN_IF_EXISTS | DONT_TRUNCATE_IF_EXISTS);
 223   if (!result.empty())
 224     return result;
 225
 226   result = MatchOpenExpectations(
 227       &file_system,
 228       PP_FILEOPENFLAG_WRITE | PP_FILEOPENFLAG_CREATE,
 229       CREATE_IF_DOESNT_EXIST | OPEN_IF_EXISTS | DONT_TRUNCATE_IF_EXISTS);
 230   if (!result.empty())
 231     return result;
 232
 233   result = MatchOpenExpectations(
 234       &file_system,
 235       PP_FILEOPENFLAG_WRITE | PP_FILEOPENFLAG_EXCLUSIVE,
 236       DONT_CREATE_IF_DOESNT_EXIST | OPEN_IF_EXISTS | DONT_TRUNCATE_IF_EXISTS);
 237   if (!result.empty())
 238     return result;
 239
 240   result = MatchOpenExpectations(
 241       &file_system,
 242       PP_FILEOPENFLAG_WRITE | PP_FILEOPENFLAG_TRUNCATE,
 243       DONT_CREATE_IF_DOESNT_EXIST | OPEN_IF_EXISTS | TRUNCATE_IF_EXISTS);
 244   if (!result.empty())
 245     return result;
 246
 247   result = MatchOpenExpectations(
 248       &file_system,
 249       PP_FILEOPENFLAG_WRITE | PP_FILEOPENFLAG_CREATE |
 250       PP_FILEOPENFLAG_EXCLUSIVE,
 251       CREATE_IF_DOESNT_EXIST | DONT_OPEN_IF_EXISTS | DONT_TRUNCATE_IF_EXISTS);
 252   if (!result.empty())
 253     return result;
 254
 255   result = MatchOpenExpectations(
 256       &file_system,
 257       PP_FILEOPENFLAG_WRITE | PP_FILEOPENFLAG_CREATE | PP_FILEOPENFLAG_TRUNCATE,
 258       CREATE_IF_DOESNT_EXIST | OPEN_IF_EXISTS | TRUNCATE_IF_EXISTS);
 259   if (!result.empty())
 260     return result;
 261
 262   result = MatchOpenExpectations(
 263       &file_system,
 264       PP_FILEOPENFLAG_WRITE | PP_FILEOPENFLAG_EXCLUSIVE |
 265       PP_FILEOPENFLAG_TRUNCATE,
 266       DONT_CREATE_IF_DOESNT_EXIST | OPEN_IF_EXISTS | TRUNCATE_IF_EXISTS);
 267   if (!result.empty())
 268     return result;
 269
 270   result = MatchOpenExpectations(
 271       &file_system,
 272       PP_FILEOPENFLAG_WRITE | PP_FILEOPENFLAG_CREATE |
 273       PP_FILEOPENFLAG_EXCLUSIVE | PP_FILEOPENFLAG_TRUNCATE,
 274       CREATE_IF_DOESNT_EXIST | DONT_OPEN_IF_EXISTS | DONT_TRUNCATE_IF_EXISTS);
 275   if (!result.empty())
 276     return result;
 277
 278   // Invalid combination: PP_FILEOPENFLAG_TRUNCATE without
 279   // PP_FILEOPENFLAG_WRITE.
 280   result = MatchOpenExpectations(
 281       &file_system,
 282       PP_FILEOPENFLAG_READ | PP_FILEOPENFLAG_TRUNCATE,
 283       INVALID_FLAG_COMBINATION);
 284   if (!result.empty())
 285     return result;
 286
 287   PASS();
 288 }
 289
 290 std::string TestFileIO::TestOpenDirectory() {
 291   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 292
 293   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
 294   callback.WaitForResult(file_system.Open(1024, callback.GetCallback()));
 295   CHECK_CALLBACK_BEHAVIOR(callback);
 296   ASSERT_EQ(PP_OK, callback.result());
 297
 298   // Make a directory.
 299   pp::FileRef dir_ref(file_system, "/test_dir_open_directory");
 300   callback.WaitForResult(dir_ref.MakeDirectory(
 301       PP_MAKEDIRECTORYFLAG_NONE, callback.GetCallback()));
 302   CHECK_CALLBACK_BEHAVIOR(callback);
 303   ASSERT_EQ(PP_OK, callback.result());
 304
 305   // Open the directory. This is expected to fail since directories cannot be
 306   // opened.
 307   pp::FileIO file_io(instance_);
 308   callback.WaitForResult(file_io.Open(dir_ref, PP_FILEOPENFLAG_READ,
 309                                       callback.GetCallback()));
 310   CHECK_CALLBACK_BEHAVIOR(callback);
 311   ASSERT_EQ(PP_ERROR_NOTAFILE, callback.result());
 312
 313   PASS();
 314 }
 315
 316 std::string TestFileIO::TestReadWriteSetLength() {
 317   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 318
 319   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
 320   pp::FileRef file_ref(file_system, "/file_read_write_setlength");
 321   callback.WaitForResult(file_system.Open(1024, callback.GetCallback()));
 322   CHECK_CALLBACK_BEHAVIOR(callback);
 323   ASSERT_EQ(PP_OK, callback.result());
 324
 325   pp::FileIO file_io(instance_);
 326   callback.WaitForResult(file_io.Open(file_ref,
 327                                       PP_FILEOPENFLAG_CREATE |
 328                                       PP_FILEOPENFLAG_TRUNCATE |
 329                                       PP_FILEOPENFLAG_READ |
 330                                       PP_FILEOPENFLAG_WRITE,
 331                                       callback.GetCallback()));
 332   CHECK_CALLBACK_BEHAVIOR(callback);
 333   ASSERT_EQ(PP_OK, callback.result());
 334
 335   // Write something to the file.
 336   int32_t rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 0,
 337                                  "test_test", callback_type());
 338   ASSERT_EQ(PP_OK, rv);
 339
 340   // Attempt to read a negative number of bytes; it should fail.
 341   char buf[256];
 342   callback.WaitForResult(file_io.Read(0,
 343                                       buf,
 344                                       -1,
 345                                       callback.GetCallback()));
 346   CHECK_CALLBACK_BEHAVIOR(callback);
 347   ASSERT_EQ(PP_ERROR_FAILED, callback.result());
 348
 349   // Read the entire file.
 350   std::string read_buffer;
 351   rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer,
 352                       callback_type());
 353   ASSERT_EQ(PP_OK, rv);
 354   ASSERT_EQ(std::string("test_test"), read_buffer);
 355
 356   // Truncate the file.
 357   callback.WaitForResult(file_io.SetLength(4, callback.GetCallback()));
 358   CHECK_CALLBACK_BEHAVIOR(callback);
 359   ASSERT_EQ(PP_OK, callback.result());
 360
 361   // Check the file contents.
 362   read_buffer.clear();
 363   rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer,
 364                       callback_type());
 365   ASSERT_EQ(PP_OK, rv);
 366   ASSERT_EQ(std::string("test"), read_buffer);
 367
 368   // Try to read past the end of the file.
 369   read_buffer.clear();
 370   rv = ReadEntireFile(instance_->pp_instance(), &file_io, 100, &read_buffer,
 371                       callback_type());
 372   ASSERT_EQ(PP_OK, rv);
 373   ASSERT_TRUE(read_buffer.empty());
 374
 375   // Write past the end of the file. The file should be zero-padded.
 376   rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 8, "test",
 377                          callback_type());
 378   ASSERT_EQ(PP_OK, rv);
 379
 380   // Check the contents of the file.
 381   read_buffer.clear();
 382   rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer,
 383                       callback_type());
 384   ASSERT_EQ(PP_OK, rv);
 385   ASSERT_EQ(std::string("test\0\0\0\0test", 12), read_buffer);
 386
 387   // Extend the file.
 388   callback.WaitForResult(file_io.SetLength(16, callback.GetCallback()));
 389   CHECK_CALLBACK_BEHAVIOR(callback);
 390   ASSERT_EQ(PP_OK, callback.result());
 391
 392   // Check the contents of the file.
 393   read_buffer.clear();
 394   rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer,
 395                       callback_type());
 396   ASSERT_EQ(PP_OK, rv);
 397   ASSERT_EQ(std::string("test\0\0\0\0test\0\0\0\0", 16), read_buffer);
 398
 399   // Write in the middle of the file.
 400   rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 4, "test",
 401                          callback_type());
 402   ASSERT_EQ(PP_OK, rv);
 403
 404   // Check the contents of the file.
 405   read_buffer.clear();
 406   rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer,
 407                       callback_type());
 408   ASSERT_EQ(PP_OK, rv);
 409   ASSERT_EQ(std::string("testtesttest\0\0\0\0", 16), read_buffer);
 410
 411   // Read from the middle of the file.
 412   read_buffer.clear();
 413   rv = ReadEntireFile(instance_->pp_instance(), &file_io, 4, &read_buffer,
 414                       callback_type());
 415   ASSERT_EQ(PP_OK, rv);
 416   ASSERT_EQ(std::string("testtest\0\0\0\0", 12), read_buffer);
 417
 418   // Append to the end of the file.
 419   pp::FileIO file_io2(instance_);
 420   callback.WaitForResult(file_io2.Open(file_ref,
 421                                        PP_FILEOPENFLAG_CREATE |
 422                                        PP_FILEOPENFLAG_READ |
 423                                        PP_FILEOPENFLAG_APPEND,
 424                                        callback.GetCallback()));
 425   rv = WriteEntireBuffer(instance_->pp_instance(), &file_io2, 0, "appended",
 426                          callback_type());
 427   ASSERT_EQ(PP_OK, rv);
 428   read_buffer.clear();
 429   rv = ReadEntireFile(instance_->pp_instance(), &file_io2, 0, &read_buffer,
 430                       callback_type());
 431   ASSERT_EQ(PP_OK, rv);
 432   ASSERT_EQ(std::string("testtesttest\0\0\0\0appended", 24), read_buffer);
 433
 434   PASS();
 435 }
 436
 437 // This is basically a copy of TestReadWriteSetLength, but with the new Read
 438 // API.  With this test case, we can make sure the two Read's have the same
 439 // behavior.
 440 std::string TestFileIO::TestReadToArrayWriteSetLength() {
 441   if (callback_type() == PP_BLOCKING) {
 442     // This test does not make sense for blocking callbacks.
 443     PASS();
 444   }
 445   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 446
 447   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
 448   pp::FileRef file_ref(file_system, "/file_read_write_setlength");
 449   callback.WaitForResult(file_system.Open(1024, callback.GetCallback()));
 450   CHECK_CALLBACK_BEHAVIOR(callback);
 451   ASSERT_EQ(PP_OK, callback.result());
 452
 453   pp::FileIO file_io(instance_);
 454   callback.WaitForResult(file_io.Open(file_ref,
 455                                       PP_FILEOPENFLAG_CREATE |
 456                                       PP_FILEOPENFLAG_TRUNCATE |
 457                                       PP_FILEOPENFLAG_READ |
 458                                       PP_FILEOPENFLAG_WRITE,
 459                                       callback.GetCallback()));
 460   CHECK_CALLBACK_BEHAVIOR(callback);
 461   ASSERT_EQ(PP_OK, callback.result());
 462
 463   // Write something to the file.
 464   int32_t rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 0,
 465                                  "test_test", callback_type());
 466   ASSERT_EQ(PP_OK, rv);
 467
 468   TestCompletionCallbackWithOutput< std::vector<char> > callback2(
 469       instance_->pp_instance(), callback_type());
 470   // Attempt to read a negative number of bytes; it should fail.
 471   callback2.WaitForResult(file_io.Read(0, -1, callback2.GetCallback()));
 472   CHECK_CALLBACK_BEHAVIOR(callback2);
 473   ASSERT_EQ(PP_ERROR_FAILED, callback2.result());
 474
 475   // Read the entire file.
 476   std::string read_buffer;
 477   read_buffer.reserve(10);
 478   rv = ReadToArrayEntireFile(instance_->pp_instance(), &file_io, 0,
 479                              &read_buffer, callback_type());
 480   ASSERT_EQ(PP_OK, rv);
 481   ASSERT_EQ(std::string("test_test"), read_buffer);
 482
 483   // Truncate the file.
 484   callback.WaitForResult(file_io.SetLength(4, callback.GetCallback()));
 485   CHECK_CALLBACK_BEHAVIOR(callback);
 486   ASSERT_EQ(PP_OK, rv);
 487
 488   // Check the file contents.
 489   read_buffer.clear();
 490   rv = ReadToArrayEntireFile(instance_->pp_instance(), &file_io, 0,
 491                              &read_buffer, callback_type());
 492   ASSERT_EQ(PP_OK, rv);
 493   ASSERT_EQ(std::string("test"), read_buffer);
 494
 495   // Try to read past the end of the file.
 496   read_buffer.clear();
 497   rv = ReadToArrayEntireFile(instance_->pp_instance(), &file_io, 100,
 498                              &read_buffer, callback_type());
 499   ASSERT_EQ(PP_OK, rv);
 500   ASSERT_TRUE(read_buffer.empty());
 501
 502   // Write past the end of the file. The file should be zero-padded.
 503   rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 8, "test",
 504                          callback_type());
 505   ASSERT_EQ(PP_OK, rv);
 506
 507   // Check the contents of the file.
 508   read_buffer.clear();
 509   rv = ReadToArrayEntireFile(instance_->pp_instance(), &file_io, 0,
 510                              &read_buffer, callback_type());
 511   ASSERT_EQ(PP_OK, rv);
 512   ASSERT_EQ(std::string("test\0\0\0\0test", 12), read_buffer);
 513
 514   // Extend the file.
 515   callback.WaitForResult(file_io.SetLength(16, callback.GetCallback()));
 516   CHECK_CALLBACK_BEHAVIOR(callback);
 517   ASSERT_EQ(PP_OK, callback.result());
 518
 519   // Check the contents of the file.
 520   read_buffer.clear();
 521   rv = ReadToArrayEntireFile(instance_->pp_instance(), &file_io, 0,
 522                              &read_buffer, callback_type());
 523   ASSERT_EQ(PP_OK, rv);
 524   ASSERT_EQ(std::string("test\0\0\0\0test\0\0\0\0", 16), read_buffer);
 525
 526   // Write in the middle of the file.
 527   rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 4, "test",
 528                          callback_type());
 529   ASSERT_EQ(PP_OK, rv);
 530
 531   // Check the contents of the file.
 532   read_buffer.clear();
 533   rv = ReadToArrayEntireFile(instance_->pp_instance(), &file_io, 0,
 534                              &read_buffer, callback_type());
 535   ASSERT_EQ(PP_OK, rv);
 536   ASSERT_EQ(std::string("testtesttest\0\0\0\0", 16), read_buffer);
 537
 538   // Read from the middle of the file.
 539   read_buffer.clear();
 540   rv = ReadToArrayEntireFile(instance_->pp_instance(), &file_io, 4,
 541                              &read_buffer, callback_type());
 542   ASSERT_EQ(PP_OK, rv);
 543   ASSERT_EQ(std::string("testtest\0\0\0\0", 12), read_buffer);
 544
 545   PASS();
 546 }
 547
 548 std::string TestFileIO::TestTouchQuery() {
 549   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 550
 551   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
 552   callback.WaitForResult(file_system.Open(1024, callback.GetCallback()));
 553   CHECK_CALLBACK_BEHAVIOR(callback);
 554   ASSERT_EQ(PP_OK, callback.result());
 555
 556   pp::FileRef file_ref(file_system, "/file_touch");
 557   pp::FileIO file_io(instance_);
 558   callback.WaitForResult(file_io.Open(file_ref,
 559                                       PP_FILEOPENFLAG_CREATE |
 560                                       PP_FILEOPENFLAG_TRUNCATE |
 561                                       PP_FILEOPENFLAG_WRITE,
 562                                       callback.GetCallback()));
 563   CHECK_CALLBACK_BEHAVIOR(callback);
 564   ASSERT_EQ(PP_OK, callback.result());
 565
 566   // Write some data to have a non-zero file size.
 567   callback.WaitForResult(file_io.Write(0, "test", 4, callback.GetCallback()));
 568   CHECK_CALLBACK_BEHAVIOR(callback);
 569   ASSERT_EQ(4, callback.result());
 570
 571   const PP_Time last_access_time = 123 * 24 * 3600.0;
 572   // last_modified_time's granularity is 2 seconds
 573   // NOTE: In NaCl on Windows, NaClDescIO uses _fstat64 to retrieve file info.
 574   // This function returns strange values for very small time values (near the
 575   // Unix Epoch). For a value like 246.0, it returns -1. For larger values, it
 576   // returns values that are exactly an hour less. The value below is handled
 577   // correctly, and is only 100 days after the start of Unix time.
 578   const PP_Time last_modified_time = 100 * 24 * 3600.0;
 579   callback.WaitForResult(file_io.Touch(last_access_time, last_modified_time,
 580                                        callback.GetCallback()));
 581   CHECK_CALLBACK_BEHAVIOR(callback);
 582   ASSERT_EQ(PP_OK, callback.result());
 583
 584   PP_FileInfo info;
 585   callback.WaitForResult(file_io.Query(&info, callback.GetCallback()));
 586   CHECK_CALLBACK_BEHAVIOR(callback);
 587   ASSERT_EQ(PP_OK, callback.result());
 588
 589   if ((info.size != 4) ||
 590       (info.type != PP_FILETYPE_REGULAR) ||
 591       (info.system_type != PP_FILESYSTEMTYPE_LOCALTEMPORARY))
 592       // Disabled due to DST-related failure: crbug.com/314579
 593       //(info.last_access_time != last_access_time) ||
 594       //(info.last_modified_time != last_modified_time))
 595     return "FileIO::Query() has returned bad data.";
 596
 597   // Call |Query()| again, to make sure it works a second time.
 598   callback.WaitForResult(file_io.Query(&info, callback.GetCallback()));
 599   CHECK_CALLBACK_BEHAVIOR(callback);
 600   ASSERT_EQ(PP_OK, callback.result());
 601
 602   PASS();
 603 }
 604
 605 std::string TestFileIO::TestAbortCalls() {
 606   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 607
 608   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
 609   pp::FileRef file_ref(file_system, "/file_abort_calls");
 610   callback.WaitForResult(file_system.Open(1024, callback.GetCallback()));
 611   CHECK_CALLBACK_BEHAVIOR(callback);
 612   ASSERT_EQ(PP_OK, callback.result());
 613
 614   int32_t rv = PP_ERROR_FAILED;
 615   // First, create a file on which to do ops.
 616   {
 617     pp::FileIO file_io(instance_);
 618     callback.WaitForResult(
 619         file_io.Open(file_ref,
 620                      PP_FILEOPENFLAG_CREATE | PP_FILEOPENFLAG_WRITE,
 621                      callback.GetCallback()));
 622     CHECK_CALLBACK_BEHAVIOR(callback);
 623     ASSERT_EQ(PP_OK, callback.result());
 624
 625     // N.B.: Should write at least 3 bytes.
 626     rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 0,
 627                            "foobarbazquux", callback_type());
 628     ASSERT_EQ(PP_OK, rv);
 629   }
 630
 631   // Abort |Open()|.
 632   {
 633     rv = pp::FileIO(instance_)
 634         .Open(file_ref, PP_FILEOPENFLAG_READ, callback.GetCallback());
 635   }
 636   callback.WaitForAbortResult(rv);
 637   CHECK_CALLBACK_BEHAVIOR(callback);
 638
 639   // Abort |Query()|.
 640   {
 641     PP_FileInfo info = { 0 };
 642     // Save a copy and make sure |info| doesn't get written to if it is aborted.
 643     PP_FileInfo info_copy;
 644     memcpy(&info_copy, &info, sizeof(info));
 645     {
 646       pp::FileIO file_io(instance_);
 647       callback.WaitForResult(file_io.Open(file_ref, PP_FILEOPENFLAG_READ,
 648                                           callback.GetCallback()));
 649       CHECK_CALLBACK_BEHAVIOR(callback);
 650       ASSERT_EQ(PP_OK, callback.result());
 651
 652       rv = file_io.Query(&info, callback.GetCallback());
 653     }  // Destroy |file_io|.
 654     callback.WaitForResult(rv);
 655     CHECK_CALLBACK_BEHAVIOR(callback);
 656     if (callback_type() == PP_BLOCKING) {
 657       ASSERT_EQ(PP_OK, callback.result());
 658       // The operation completed synchronously, so |info| should have changed.
 659       ASSERT_NE(0, memcmp(&info_copy, &info, sizeof(info)));
 660     } else {
 661       ASSERT_EQ(PP_ERROR_ABORTED, callback.result());
 662       ASSERT_EQ(0, memcmp(&info_copy, &info, sizeof(info)));
 663     }
 664   }
 665
 666   // Abort |Touch()|.
 667   {
 668     {
 669       pp::FileIO file_io(instance_);
 670       callback.WaitForResult(file_io.Open(file_ref, PP_FILEOPENFLAG_WRITE,
 671                                           callback.GetCallback()));
 672       CHECK_CALLBACK_BEHAVIOR(callback);
 673       ASSERT_EQ(PP_OK, callback.result());
 674
 675       rv = file_io.Touch(0, 0, callback.GetCallback());
 676     }  // Destroy |file_io|.
 677     callback.WaitForAbortResult(rv);
 678     CHECK_CALLBACK_BEHAVIOR(callback);
 679   }
 680
 681   // Abort |Read()|.
 682   {
 683     char buf[3] = { 0 };
 684     {
 685       pp::FileIO file_io(instance_);
 686       callback.WaitForResult(file_io.Open(file_ref, PP_FILEOPENFLAG_READ,
 687                                           callback.GetCallback()));
 688       CHECK_CALLBACK_BEHAVIOR(callback);
 689       ASSERT_EQ(PP_OK, callback.result());
 690
 691       rv = file_io.Read(0, buf, sizeof(buf), callback.GetCallback());
 692     }  // Destroy |file_io|.
 693     // Save a copy to make sure buf isn't written to in the async case.
 694     char buf_copy[3];
 695     memcpy(&buf_copy, &buf, sizeof(buf));
 696     callback.WaitForResult(rv);
 697     CHECK_CALLBACK_BEHAVIOR(callback);
 698     if (callback_type() == PP_BLOCKING) {
 699       ASSERT_EQ(callback.result(), sizeof(buf));
 700     } else {
 701       ASSERT_EQ(PP_ERROR_ABORTED, callback.result());
 702       ASSERT_EQ(0, memcmp(&buf_copy, &buf, sizeof(buf)));
 703     }
 704   }
 705
 706   // Abort |Write()|.
 707   {
 708     char buf[3] = { 0 };
 709     {
 710       pp::FileIO file_io(instance_);
 711       callback.WaitForResult(file_io.Open(file_ref, PP_FILEOPENFLAG_WRITE,
 712                                           callback.GetCallback()));
 713       CHECK_CALLBACK_BEHAVIOR(callback);
 714       ASSERT_EQ(PP_OK, callback.result());
 715
 716       rv = file_io.Write(0, buf, sizeof(buf), callback.GetCallback());
 717     }  // Destroy |file_io|.
 718     callback.WaitForResult(rv);
 719     CHECK_CALLBACK_BEHAVIOR(callback);
 720     if (callback_type() == PP_BLOCKING)
 721       ASSERT_EQ(callback.result(), sizeof(buf));
 722     else
 723       ASSERT_EQ(PP_ERROR_ABORTED, callback.result());
 724   }
 725
 726   // Abort |SetLength()|.
 727   {
 728     {
 729       pp::FileIO file_io(instance_);
 730       callback.WaitForResult(file_io.Open(file_ref, PP_FILEOPENFLAG_WRITE,
 731                                           callback.GetCallback()));
 732       CHECK_CALLBACK_BEHAVIOR(callback);
 733       ASSERT_EQ(PP_OK, callback.result());
 734
 735       rv = file_io.SetLength(3, callback.GetCallback());
 736     }  // Destroy |file_io|.
 737     callback.WaitForAbortResult(rv);
 738     CHECK_CALLBACK_BEHAVIOR(callback);
 739   }
 740
 741   // Abort |Flush|.
 742   {
 743     {
 744       pp::FileIO file_io(instance_);
 745       callback.WaitForResult(file_io.Open(file_ref, PP_FILEOPENFLAG_WRITE,
 746                                           callback.GetCallback()));
 747       CHECK_CALLBACK_BEHAVIOR(callback);
 748       ASSERT_EQ(PP_OK, callback.result());
 749
 750       rv = file_io.Flush(callback.GetCallback());
 751     }  // Destroy |file_io|.
 752     callback.WaitForAbortResult(rv);
 753     CHECK_CALLBACK_BEHAVIOR(callback);
 754   }
 755
 756   PASS();
 757 }
 758
 759 std::string TestFileIO::TestParallelReads() {
 760   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 761   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
 762   pp::FileRef file_ref(file_system, "/file_parallel_reads");
 763   callback.WaitForResult(file_system.Open(1024, callback.GetCallback()));
 764   CHECK_CALLBACK_BEHAVIOR(callback);
 765   ASSERT_EQ(PP_OK, callback.result());
 766
 767   pp::FileIO file_io(instance_);
 768   callback.WaitForResult(file_io.Open(file_ref,
 769                                       PP_FILEOPENFLAG_CREATE |
 770                                       PP_FILEOPENFLAG_TRUNCATE |
 771                                       PP_FILEOPENFLAG_READ |
 772                                       PP_FILEOPENFLAG_WRITE,
 773                                       callback.GetCallback()));
 774   CHECK_CALLBACK_BEHAVIOR(callback);
 775   ASSERT_EQ(PP_OK, callback.result());
 776
 777   // Set up testing contents.
 778   int32_t rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 0,
 779                                  "abcdefghijkl", callback_type());
 780   ASSERT_EQ(PP_OK, rv);
 781
 782   // Parallel read operations.
 783   const char* border = "__border__";
 784   const int32_t border_size = strlen(border);
 785
 786   TestCompletionCallback callback_1(instance_->pp_instance(), callback_type());
 787   int32_t read_offset_1 = 0;
 788   int32_t size_1 = 3;
 789   std::vector<char> extended_buf_1(border_size * 2 + size_1);
 790   char* buf_1 = &extended_buf_1[border_size];
 791   memcpy(&extended_buf_1[0], border, border_size);
 792   memcpy(buf_1 + size_1, border, border_size);
 793
 794   TestCompletionCallback callback_2(instance_->pp_instance(), callback_type());
 795   int32_t read_offset_2 = size_1;
 796   int32_t size_2 = 9;
 797   std::vector<char> extended_buf_2(border_size * 2 + size_2);
 798   char* buf_2 = &extended_buf_2[border_size];
 799   memcpy(&extended_buf_2[0], border, border_size);
 800   memcpy(buf_2 + size_2, border, border_size);
 801
 802   int32_t rv_1 = PP_OK;
 803   int32_t rv_2 = PP_OK;
 804   while (size_1 >= 0 && size_2 >= 0 && size_1 + size_2 > 0) {
 805     if (size_1 > 0) {
 806       rv_1 = file_io.Read(read_offset_1, buf_1, size_1,
 807                           callback_1.GetCallback());
 808     }
 809     if (size_2 > 0) {
 810       rv_2 = file_io.Read(read_offset_2, buf_2, size_2,
 811                           callback_2.GetCallback());
 812     }
 813     if (size_1 > 0) {
 814       callback_1.WaitForResult(rv_1);
 815       CHECK_CALLBACK_BEHAVIOR(callback_1);
 816       ASSERT_TRUE(callback_1.result() > 0);
 817       read_offset_1 += callback_1.result();
 818       buf_1 += callback_1.result();
 819       size_1 -= callback_1.result();
 820     }
 821
 822     if (size_2 > 0) {
 823       callback_2.WaitForResult(rv_2);
 824       CHECK_CALLBACK_BEHAVIOR(callback_2);
 825       ASSERT_TRUE(callback_2.result() > 0);
 826       read_offset_2 += callback_2.result();
 827       buf_2 += callback_2.result();
 828       size_2 -= callback_2.result();
 829     }
 830   }
 831
 832   // If |size_1| or |size_2| is not 0, we have invoked wrong callback(s).
 833   ASSERT_EQ(0, size_1);
 834   ASSERT_EQ(0, size_2);
 835
 836   // Make sure every read operation writes into the correct buffer.
 837   const char expected_result_1[] = "__border__abc__border__";
 838   const char expected_result_2[] = "__border__defghijkl__border__";
 839   ASSERT_TRUE(strncmp(&extended_buf_1[0], expected_result_1,
 840                       strlen(expected_result_1)) == 0);
 841   ASSERT_TRUE(strncmp(&extended_buf_2[0], expected_result_2,
 842                       strlen(expected_result_2)) == 0);
 843   PASS();
 844 }
 845
 846 std::string TestFileIO::TestParallelWrites() {
 847   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 848   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
 849   pp::FileRef file_ref(file_system, "/file_parallel_writes");
 850   callback.WaitForResult(file_system.Open(1024, callback.GetCallback()));
 851   CHECK_CALLBACK_BEHAVIOR(callback);
 852   ASSERT_EQ(PP_OK, callback.result());
 853
 854   pp::FileIO file_io(instance_);
 855   callback.WaitForResult(file_io.Open(file_ref,
 856                                       PP_FILEOPENFLAG_CREATE |
 857                                       PP_FILEOPENFLAG_TRUNCATE |
 858                                       PP_FILEOPENFLAG_READ |
 859                                       PP_FILEOPENFLAG_WRITE,
 860                                       callback.GetCallback()));
 861   CHECK_CALLBACK_BEHAVIOR(callback);
 862   ASSERT_EQ(PP_OK, callback.result());
 863
 864   // Parallel write operations.
 865   TestCompletionCallback callback_1(instance_->pp_instance(), callback_type());
 866   int32_t write_offset_1 = 0;
 867   const char* buf_1 = "abc";
 868   int32_t size_1 = strlen(buf_1);
 869
 870   TestCompletionCallback callback_2(instance_->pp_instance(), callback_type());
 871   int32_t write_offset_2 = size_1;
 872   const char* buf_2 = "defghijkl";
 873   int32_t size_2 = strlen(buf_2);
 874
 875   int32_t rv_1 = PP_OK;
 876   int32_t rv_2 = PP_OK;
 877   while (size_1 >= 0 && size_2 >= 0 && size_1 + size_2 > 0) {
 878     if (size_1 > 0) {
 879       // Copy the buffer so we can erase it below.
 880       std::string str_1(buf_1);
 881       rv_1 = file_io.Write(
 882           write_offset_1, &str_1[0], str_1.size(), callback_1.GetCallback());
 883       // Erase the buffer to test that async writes copy it.
 884       std::fill(str_1.begin(), str_1.end(), 0);
 885     }
 886     if (size_2 > 0) {
 887       // Copy the buffer so we can erase it below.
 888       std::string str_2(buf_2);
 889       rv_2 = file_io.Write(
 890           write_offset_2, &str_2[0], str_2.size(), callback_2.GetCallback());
 891       // Erase the buffer to test that async writes copy it.
 892       std::fill(str_2.begin(), str_2.end(), 0);
 893     }
 894
 895     if (size_1 > 0) {
 896       callback_1.WaitForResult(rv_1);
 897       CHECK_CALLBACK_BEHAVIOR(callback_1);
 898       ASSERT_TRUE(callback_1.result() > 0);
 899       write_offset_1 += callback_1.result();
 900       buf_1 += callback_1.result();
 901       size_1 -= callback_1.result();
 902     }
 903
 904     if (size_2 > 0) {
 905       callback_2.WaitForResult(rv_2);
 906       CHECK_CALLBACK_BEHAVIOR(callback_2);
 907       ASSERT_TRUE(callback_2.result() > 0);
 908       write_offset_2 += callback_2.result();
 909       buf_2 += callback_2.result();
 910       size_2 -= callback_2.result();
 911     }
 912   }
 913
 914   // If |size_1| or |size_2| is not 0, we have invoked wrong callback(s).
 915   ASSERT_EQ(0, size_1);
 916   ASSERT_EQ(0, size_2);
 917
 918   // Check the file contents.
 919   std::string read_buffer;
 920   int32_t rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0,
 921                               &read_buffer, callback_type());
 922   ASSERT_EQ(PP_OK, rv);
 923   ASSERT_EQ(std::string("abcdefghijkl"), read_buffer);
 924
 925   PASS();
 926 }
 927
 928 std::string TestFileIO::TestNotAllowMixedReadWrite() {
 929   if (callback_type() == PP_BLOCKING) {
 930     // This test does not make sense for blocking callbacks.
 931     PASS();
 932   }
 933   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 934
 935   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
 936   pp::FileRef file_ref(file_system, "/file_not_allow_mixed_read_write");
 937   callback.WaitForResult(file_system.Open(1024, callback.GetCallback()));
 938   CHECK_CALLBACK_BEHAVIOR(callback);
 939   ASSERT_EQ(PP_OK, callback.result());
 940
 941   pp::FileIO file_io(instance_);
 942   callback.WaitForResult(file_io.Open(file_ref,
 943                                       PP_FILEOPENFLAG_CREATE |
 944                                       PP_FILEOPENFLAG_TRUNCATE |
 945                                       PP_FILEOPENFLAG_READ |
 946                                       PP_FILEOPENFLAG_WRITE,
 947                                       callback.GetCallback()));
 948   CHECK_CALLBACK_BEHAVIOR(callback);
 949   ASSERT_EQ(PP_OK, callback.result());
 950
 951   TestCompletionCallback callback_1(instance_->pp_instance(), PP_REQUIRED);
 952   int32_t write_offset_1 = 0;
 953   const char* buf_1 = "mnopqrstuvw";
 954   int32_t rv_1 = file_io.Write(write_offset_1, buf_1, strlen(buf_1),
 955                                callback_1.GetCallback());
 956   ASSERT_EQ(PP_OK_COMPLETIONPENDING, rv_1);
 957
 958   TestCompletionCallback callback_2(instance_->pp_instance(), callback_type());
 959   int32_t read_offset_2 = 4;
 960   char buf_2[3];
 961   callback_2.WaitForResult(file_io.Read(read_offset_2, buf_2, sizeof(buf_2),
 962                                         callback_2.GetCallback()));
 963   CHECK_CALLBACK_BEHAVIOR(callback_2);
 964   ASSERT_EQ(PP_ERROR_INPROGRESS, callback_2.result());
 965   callback_1.WaitForResult(rv_1);
 966   CHECK_CALLBACK_BEHAVIOR(callback_1);
 967
 968   // Cannot query while a write is pending.
 969   rv_1 = file_io.Write(write_offset_1, buf_1, strlen(buf_1),
 970                        callback_1.GetCallback());
 971   ASSERT_EQ(PP_OK_COMPLETIONPENDING, rv_1);
 972   PP_FileInfo info;
 973   callback_2.WaitForResult(file_io.Query(&info, callback_2.GetCallback()));
 974   CHECK_CALLBACK_BEHAVIOR(callback_2);
 975   ASSERT_EQ(PP_ERROR_INPROGRESS, callback_2.result());
 976   callback_1.WaitForResult(rv_1);
 977   CHECK_CALLBACK_BEHAVIOR(callback_1);
 978
 979   // Cannot touch while a write is pending.
 980   rv_1 = file_io.Write(write_offset_1, buf_1, strlen(buf_1),
 981                        callback_1.GetCallback());
 982   ASSERT_EQ(PP_OK_COMPLETIONPENDING, rv_1);
 983   callback_2.WaitForResult(file_io.Touch(1234.0, 5678.0,
 984                            callback_2.GetCallback()));
 985   CHECK_CALLBACK_BEHAVIOR(callback_2);
 986   ASSERT_EQ(PP_ERROR_INPROGRESS, callback_2.result());
 987   callback_1.WaitForResult(rv_1);
 988   CHECK_CALLBACK_BEHAVIOR(callback_1);
 989
 990   // Cannot set length while a write is pending.
 991   rv_1 = file_io.Write(write_offset_1, buf_1, strlen(buf_1),
 992                        callback_1.GetCallback());
 993   ASSERT_EQ(PP_OK_COMPLETIONPENDING, rv_1);
 994   callback_2.WaitForResult(file_io.SetLength(123, callback_2.GetCallback()));
 995   CHECK_CALLBACK_BEHAVIOR(callback_2);
 996   ASSERT_EQ(PP_ERROR_INPROGRESS, callback_2.result());
 997   callback_1.WaitForResult(rv_1);
 998   CHECK_CALLBACK_BEHAVIOR(callback_1);
 999
1000   PASS();
1001 }
1002
1003 std::string TestFileIO::TestRequestOSFileHandle() {
1004   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
1005
1006   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
1007   pp::FileRef file_ref(file_system, "/file_os_fd");
1008
1009   callback.WaitForResult(file_system.Open(1024, callback.GetCallback()));
1010   ASSERT_EQ(PP_OK, callback.result());
1011
1012   pp::FileIO_Private file_io(instance_);
1013   callback.WaitForResult(file_io.Open(file_ref,
1014                                       PP_FILEOPENFLAG_CREATE |
1015                                       PP_FILEOPENFLAG_TRUNCATE |
1016                                       PP_FILEOPENFLAG_READ |
1017                                       PP_FILEOPENFLAG_WRITE,
1018                                       callback.GetCallback()));
1019   ASSERT_EQ(PP_OK, callback.result());
1020
1021   TestCompletionCallbackWithOutput<pp::PassFileHandle> output_callback(
1022       instance_->pp_instance(), callback_type());
1023   output_callback.WaitForResult(
1024       file_io.RequestOSFileHandle(output_callback.GetCallback()));
1025   PP_FileHandle handle = output_callback.output().Release();
1026   ASSERT_EQ(PP_OK, output_callback.result());
1027
1028   if (handle == PP_kInvalidFileHandle)
1029     return "FileIO::RequestOSFileHandle() returned a bad file handle.";
1030 #if defined(PPAPI_OS_WIN)
1031   int fd = _open_osfhandle(reinterpret_cast<intptr_t>(handle),
1032                            _O_RDWR | _O_BINARY);
1033 #else
1034   int fd = handle;
1035 #endif
1036   if (fd < 0)
1037     return "FileIO::RequestOSFileHandle() returned a bad file descriptor.";
1038
1039   // Check write(2) for the native FD.
1040   const std::string msg = "foobar";
1041   ssize_t cnt = write(fd, msg.data(), msg.size());
1042   if (cnt < 0)
1043     return ReportError("write for native FD returned error", errno);
1044   if (cnt != static_cast<ssize_t>(msg.size()))
1045     return ReportError("write for native FD count mismatch", cnt);
1046
1047   // Check lseek(2) for the native FD.
1048   off_t off = lseek(fd, 0, SEEK_CUR);
1049   if (off == static_cast<off_t>(-1))
1050     return ReportError("lseek for native FD returned error", errno);
1051   if (off != static_cast<off_t>(msg.size()))
1052     return ReportError("lseek for native FD offset mismatch", off);
1053
1054   off = lseek(fd, 0, SEEK_SET);
1055   if (off == static_cast<off_t>(-1))
1056     return ReportError("lseek for native FD returned error", errno);
1057   if (off != 0)
1058     return ReportError("lseek for native FD offset mismatch", off);
1059
1060   // Check read(2) for the native FD.
1061   std::string buf(msg.size(), '\0');
1062   cnt = read(fd, &buf[0], msg.size());
1063   if (cnt < 0)
1064     return ReportError("read for native FD returned error", errno);
1065   if (cnt != static_cast<ssize_t>(msg.size()))
1066     return ReportError("read for native FD count mismatch", cnt);
1067   if (msg != buf)
1068     return ReportMismatch("read for native FD", buf, msg);
1069   PASS();
1070 }
1071
1072 // Calling RequestOSFileHandle with the FileIO that is opened with
1073 // PP_FILEOPENFLAG_EXCLUSIVE used to cause NaCl module to crash while loading.
1074 // This is a regression test for crbug.com/243241.
1075 std::string TestFileIO::TestRequestOSFileHandleWithOpenExclusive() {
1076   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
1077
1078   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
1079   pp::FileRef file_ref(file_system, "/file_os_fd2");
1080
1081   callback.WaitForResult(file_system.Open(1024, callback.GetCallback()));
1082   ASSERT_EQ(PP_OK, callback.result());
1083
1084   // Open with PP_FILEOPENFLAG_CREATE and PP_FILEOPENFLAG_EXCLUSIVE will fail
1085   // if the file already exists. Delete it here to make sure it does not.
1086   callback.WaitForResult(file_ref.Delete(callback.GetCallback()));
1087
1088   pp::FileIO_Private file_io(instance_);
1089   callback.WaitForResult(file_io.Open(file_ref,
1090                                       PP_FILEOPENFLAG_CREATE |
1091                                       PP_FILEOPENFLAG_READ |
1092                                       PP_FILEOPENFLAG_WRITE |
1093                                       PP_FILEOPENFLAG_EXCLUSIVE,
1094                                       callback.GetCallback()));
1095   ASSERT_EQ(PP_OK, callback.result());
1096
1097   TestCompletionCallbackWithOutput<pp::PassFileHandle> output_callback(
1098       instance_->pp_instance(), callback_type());
1099   output_callback.WaitForResult(
1100       file_io.RequestOSFileHandle(output_callback.GetCallback()));
1101   PP_FileHandle handle = output_callback.output().Release();
1102   if (handle == PP_kInvalidFileHandle)
1103     return "FileIO::RequestOSFileHandle() returned a bad file handle.";
1104   ASSERT_EQ(PP_OK, output_callback.result());
1105
1106   PASS();
1107 }
1108
1109 std::string TestFileIO::TestMmap() {
1110 #if !defined(PPAPI_OS_WIN)
1111   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
1112
1113   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
1114   pp::FileRef file_ref(file_system, "/file_os_fd");
1115
1116   callback.WaitForResult(file_system.Open(1024, callback.GetCallback()));
1117   ASSERT_EQ(PP_OK, callback.result());
1118
1119   pp::FileIO_Private file_io(instance_);
1120   callback.WaitForResult(file_io.Open(file_ref,
1121                                       PP_FILEOPENFLAG_CREATE |
1122                                       PP_FILEOPENFLAG_TRUNCATE |
1123                                       PP_FILEOPENFLAG_READ |
1124                                       PP_FILEOPENFLAG_WRITE,
1125                                       callback.GetCallback()));
1126   ASSERT_EQ(PP_OK, callback.result());
1127
1128   TestCompletionCallbackWithOutput<pp::PassFileHandle> output_callback(
1129       instance_->pp_instance(), callback_type());
1130   output_callback.WaitForResult(
1131       file_io.RequestOSFileHandle(output_callback.GetCallback()));
1132   PP_FileHandle handle = output_callback.output().Release();
1133   ASSERT_EQ(PP_OK, output_callback.result());
1134
1135   if (handle == PP_kInvalidFileHandle)
1136     return "FileIO::RequestOSFileHandle() returned a bad file handle.";
1137   int fd = handle;
1138   if (fd < 0)
1139     return "FileIO::RequestOSFileHandle() returned a bad file descriptor.";
1140
1141   // Check write(2) for the native FD.
1142   const std::string msg = "foobar";
1143   ssize_t cnt = write(fd, msg.data(), msg.size());
1144   if (cnt < 0)
1145     return ReportError("write for native FD returned error", errno);
1146   if (cnt != static_cast<ssize_t>(msg.size()))
1147     return ReportError("write for native FD count mismatch", cnt);
1148
1149   // BEGIN mmap(2) test with a file handle opened in READ-WRITE mode.
1150   // Check mmap(2) for read.
1151   {
1152     char* mapped = reinterpret_cast<char*>(
1153         mmap(NULL, msg.size(), PROT_READ, MAP_PRIVATE, fd, 0));
1154     if (mapped == MAP_FAILED)
1155       return ReportError("mmap(r) for native FD returned errno", errno);
1156     // Make sure the buffer is cleared.
1157     std::string buf = std::string(msg.size(), '\0');
1158     memcpy(&buf[0], mapped, msg.size());
1159     if (msg != buf)
1160       return ReportMismatch("mmap(r) for native FD", buf, msg);
1161     int r = munmap(mapped, msg.size());
1162     if (r < 0)
1163       return ReportError("munmap for native FD returned error", errno);
1164   }
1165
1166   // Check mmap(2) for write with MAP_PRIVATE
1167   {
1168     char* mapped = reinterpret_cast<char*>(
1169         mmap(NULL, msg.size(), PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0));
1170     if (mapped == MAP_FAILED)
1171       return ReportError("mmap(r) for native FD returned errno", errno);
1172     // Make sure the file is not polluted by writing to privage mmap.
1173     strncpy(mapped, "baz", 3);
1174     std::string read_buffer;
1175     ASSERT_TRUE(ReadEntireFileFromFileHandle(fd, &read_buffer));
1176     if (msg != read_buffer)
1177       return ReportMismatch("file content != msg", read_buffer, msg);
1178     int r = munmap(mapped, msg.size());
1179     if (r < 0)
1180       return ReportError("munmap for native FD returned error", errno);
1181   }
1182
1183   // Check mmap(2) for write with MAP_SHARED.
1184   {
1185     char* mapped = reinterpret_cast<char*>(
1186         mmap(NULL, msg.size(), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0));
1187     if (mapped == MAP_FAILED)
1188       return ReportError("mmap(w) for native FD returned errno", errno);
1189     // s/foo/baz/
1190     strncpy(mapped, "baz", 3);
1191     std::string read_buffer;
1192     ASSERT_TRUE(ReadEntireFileFromFileHandle(fd, &read_buffer));
1193     if (read_buffer != "bazbar")
1194       return ReportMismatch("file content != msg", read_buffer, "bazbar");
1195     int r = munmap(mapped, msg.size());
1196     if (r < 0)
1197       return ReportError("munmap for native FD returned error", errno);
1198   }
1199   // END mmap(2) test with a file handle opened in READ-WRITE mode.
1200
1201   if (close(fd) < 0)
1202     return ReportError("close for native FD returned error", errno);
1203
1204   // BEGIN mmap(2) test with a file handle opened in READONLY mode.
1205   file_io = pp::FileIO_Private(instance_);
1206   callback.WaitForResult(file_io.Open(file_ref,
1207                                       PP_FILEOPENFLAG_READ,
1208                                       callback.GetCallback()));
1209   ASSERT_EQ(PP_OK, callback.result());
1210
1211   output_callback = TestCompletionCallbackWithOutput<pp::PassFileHandle>(
1212       instance_->pp_instance(), callback_type());
1213   output_callback.WaitForResult(
1214       file_io.RequestOSFileHandle(output_callback.GetCallback()));
1215   handle = output_callback.output().Release();
1216   ASSERT_EQ(PP_OK, output_callback.result());
1217
1218   if (handle == PP_kInvalidFileHandle)
1219     return "FileIO::RequestOSFileHandle() returned a bad file handle.";
1220   fd = handle;
1221   if (fd < 0)
1222     return "FileIO::RequestOSFileHandle() returned a bad file descriptor.";
1223
1224   const std::string msg2 = "bazbar";
1225
1226   // Check mmap(2) for read.
1227   {
1228     char* mapped = reinterpret_cast<char*>(
1229         mmap(NULL, msg2.size(), PROT_READ, MAP_PRIVATE, fd, 0));
1230     if (mapped == MAP_FAILED)
1231       return ReportError("mmap(r) for native FD returned errno", errno);
1232     // Make sure the buffer is cleared.
1233     std::string buf = std::string(msg2.size(), '\0');
1234     memcpy(&buf[0], mapped, msg2.size());
1235     if (msg2 != buf)
1236       return ReportMismatch("mmap(r) for native FD", buf, msg2);
1237     int r = munmap(mapped, msg2.size());
1238     if (r < 0)
1239       return ReportError("munmap for native FD returned error", errno);
1240   }
1241
1242   // Check mmap(2) for write with MAP_PRIVATE
1243   {
1244     char* mapped = reinterpret_cast<char*>(
1245         mmap(NULL, msg2.size(), PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0));
1246     if (mapped == MAP_FAILED)
1247       return ReportError("mmap(r) for native FD returned errno", errno);
1248     // Make sure the file is not polluted by writing to privage mmap.
1249     strncpy(mapped, "baz", 3);
1250     std::string read_buffer;
1251     ASSERT_TRUE(ReadEntireFileFromFileHandle(fd, &read_buffer));
1252     if (msg2 != read_buffer)
1253       return ReportMismatch("file content != msg2", read_buffer, msg2);
1254     int r = munmap(mapped, msg2.size());
1255     if (r < 0)
1256       return ReportError("munmap for native FD returned error", errno);
1257   }
1258
1259   // Check mmap(2) for write with MAP_SHARED.
1260   {
1261     char* mapped = reinterpret_cast<char*>(
1262         mmap(NULL, msg2.size(), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0));
1263     if (mapped != MAP_FAILED)
1264       return ReportError("mmap(w) for native FD must fail when opened readonly",
1265                          -1);
1266   }
1267   // END mmap(2) test with a file handle opened in READONLY mode.
1268
1269   if (close(fd) < 0)
1270     return ReportError("close for native FD returned error", errno);
1271 #endif  // !defined(PPAPI_OS_WIN)
1272
1273   PASS();
1274 }
1275
1276 std::string TestFileIO::MatchOpenExpectations(pp::FileSystem* file_system,
1277                                               size_t open_flags,
1278                                               size_t expectations) {
1279   std::string bad_argument =
1280       "TestFileIO::MatchOpenExpectations has invalid input arguments.";
1281   bool invalid_combination = !!(expectations & INVALID_FLAG_COMBINATION);
1282   if (invalid_combination) {
1283     if (expectations != INVALID_FLAG_COMBINATION)
1284       return bad_argument;
1285   } else {
1286     // Validate that one and only one of <some_expectation> and
1287     // DONT_<some_expectation> is specified.
1288     for (size_t remains = expectations, end = END_OF_OPEN_EXPECATION_PAIRS;
1289          end != 0; remains >>= 2, end >>= 2) {
1290       if (!!(remains & 1) == !!(remains & 2))
1291         return bad_argument;
1292     }
1293   }
1294   bool create_if_doesnt_exist = !!(expectations & CREATE_IF_DOESNT_EXIST);
1295   bool open_if_exists = !!(expectations & OPEN_IF_EXISTS);
1296   bool truncate_if_exists = !!(expectations & TRUNCATE_IF_EXISTS);
1297
1298   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
1299   pp::FileRef existent_file_ref(
1300       *file_system, "/match_open_expectation_existent_non_empty_file");
1301   pp::FileRef nonexistent_file_ref(
1302       *file_system, "/match_open_expectation_nonexistent_file");
1303
1304   // Setup files for test.
1305   {
1306     callback.WaitForResult(existent_file_ref.Delete(callback.GetCallback()));
1307     CHECK_CALLBACK_BEHAVIOR(callback);
1308     ASSERT_TRUE(callback.result() == PP_OK ||
1309                 callback.result() == PP_ERROR_FILENOTFOUND);
1310     callback.WaitForResult(nonexistent_file_ref.Delete(callback.GetCallback()));
1311     CHECK_CALLBACK_BEHAVIOR(callback);
1312     ASSERT_TRUE(callback.result() == PP_OK ||
1313                 callback.result() == PP_ERROR_FILENOTFOUND);
1314
1315     pp::FileIO existent_file_io(instance_);
1316     callback.WaitForResult(existent_file_io.Open(
1317         existent_file_ref,
1318         PP_FILEOPENFLAG_CREATE | PP_FILEOPENFLAG_WRITE,
1319         callback.GetCallback()));
1320     CHECK_CALLBACK_BEHAVIOR(callback);
1321     ASSERT_EQ(PP_OK, callback.result());
1322     int32_t rv = WriteEntireBuffer(instance_->pp_instance(), &existent_file_io,
1323                                    0, "foobar", callback_type());
1324     ASSERT_EQ(PP_OK, rv);
1325   }
1326
1327   pp::FileIO existent_file_io(instance_);
1328   callback.WaitForResult(existent_file_io.Open(existent_file_ref, open_flags,
1329                                                callback.GetCallback()));
1330   CHECK_CALLBACK_BEHAVIOR(callback);
1331   if ((invalid_combination && callback.result() == PP_OK) ||
1332       (!invalid_combination &&
1333        ((callback.result() == PP_OK) != open_if_exists))) {
1334     return ReportOpenError(open_flags);
1335   }
1336
1337   if (!invalid_combination && open_if_exists) {
1338     PP_FileInfo info;
1339     callback.WaitForResult(existent_file_io.Query(&info,
1340                                                   callback.GetCallback()));
1341     CHECK_CALLBACK_BEHAVIOR(callback);
1342     ASSERT_EQ(PP_OK, callback.result());
1343     if (truncate_if_exists != (info.size == 0))
1344       return ReportOpenError(open_flags);
1345   }
1346
1347   pp::FileIO nonexistent_file_io(instance_);
1348   callback.WaitForResult(nonexistent_file_io.Open(nonexistent_file_ref,
1349                                                   open_flags,
1350                                                   callback.GetCallback()));
1351   CHECK_CALLBACK_BEHAVIOR(callback);
1352   if ((invalid_combination && callback.result() == PP_OK) ||
1353       (!invalid_combination &&
1354        ((callback.result() == PP_OK) != create_if_doesnt_exist))) {
1355     return ReportOpenError(open_flags);
1356   }
1357
1358   return std::string();
1359 }
1360
1361 // TODO(viettrungluu): Test Close(). crbug.com/69457