[NaCl SDK] nacl_io: Added support for access() syscall.

native_client_sdk/src/libraries/nacl_io_test/mount_http_test.cc

 /* Copyright (c) 2012 The Chromium Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <fcntl.h>
 #include <gmock/gmock.h>
 #include <ppapi/c/ppb_file_io.h>
 #include <ppapi/c/pp_errors.h>
 #include <ppapi/c/pp_instance.h>
@@ skipping 158 matching lines @@
 class MountHttpNodeTest : public MountHttpTest {
  public:
   MountHttpNodeTest();
   virtual void TearDown();
 
   void SetMountArgs(const StringMap_t& args);
   void ExpectOpen(const char* method);
   void ExpectHeaders(const char* headers);
   void OpenNode();
   void SetResponse(int status_code, const char* headers);
+  // Set a response code, but expect the request to fail. Certain function calls
+  // expected by SetResponse are not expected here.
+  void SetResponseExpectFail(int status_code, const char* headers);

[Matt Giuca, 2013/06/19 10:41:42]

Note: I borrowed this code from my other CL
https://codereview.chromium.org/16959007/.

I'm hoping I'll just submit that one before this.

[binji, 2013/06/19 16:46:28]

In the future, you can use "git cl upload <branch name>" to upload a patch that
assumes branch is upstream so it won't show up in the diff.

(Though I guess this is nice in a way, because it gives more context to the
CL...)

[Matt Giuca, 2013/06/20 01:43:14]

Yeah I wasn't sure whether to do that in this case.

   void SetResponseBody(const char* body);
   void ResetMocks();
 
  protected:
   MountHttpMock* mnt_;
   MountNode* node_;
 
   VarInterfaceMock* var_;
   URLLoaderInterfaceMock* loader_;
   URLRequestInfoInterfaceMock* request_;
@@ skipping 87 matching lines @@
                           PP_URLRESPONSEPROPERTY_STATUSCODE))
       .WillOnce(Return(PP_MakeInt32(status_code)));
   EXPECT_CALL(*response_,
               GetProperty(response_resource_, PP_URLRESPONSEPROPERTY_HEADERS))
       .WillOnce(Return(var_headers));
   EXPECT_CALL(*var_, VarToUtf8(IsEqualToVar(var_headers), _))
       .WillOnce(DoAll(SetArgPointee<1>(strlen(headers)),
                       Return(headers)));
 }
 
+void MountHttpNodeTest::SetResponseExpectFail(int status_code,
+                                              const char* headers) {
+  ON_CALL(*response_, GetProperty(response_resource_, _))
+      .WillByDefault(Return(PP_MakeUndefined()));
+
+  PP_Var var_headers = MakeString(348);
+  EXPECT_CALL(*response_,
+              GetProperty(response_resource_,
+                          PP_URLRESPONSEPROPERTY_STATUSCODE))
+      .WillOnce(Return(PP_MakeInt32(status_code)));
+}
+
 ACTION_P3(ReadResponseBodyAction, offset, body, body_length) {
   char* buf = static_cast<char*>(arg1);
   size_t read_length = arg2;
   PP_CompletionCallback callback = arg3;
   if (*offset >= body_length)
     return 0;
 
   read_length = std::min(read_length, body_length - *offset);
   memcpy(buf, body + *offset, read_length);
   *offset += read_length;
@@ skipping 34 matching lines @@
 TEST_F(MountHttpNodeTest, OpenAndCloseNoCache) {
   StringMap_t smap;
   smap["cache_content"] = "false";
   SetMountArgs(StringMap_t());
   ExpectOpen("HEAD");
   ExpectHeaders("");
   SetResponse(200, "");
   OpenNode();
 }
 
+TEST_F(MountHttpNodeTest, Access) {

[Matt Giuca, 2013/06/19 10:41:42]

Note: Access and AccessWrite suffer from the same mysterious problem as
OpenAndCloseNoCache and ReadCachedNoContentLength (http://crbug.com/244313), so
they currently fail. But I figure that we already have failing cases, so this
doesn't hurt.

+  StringMap_t smap;
+  smap["cache_content"] = "false";
+  SetMountArgs(StringMap_t());
+  ExpectOpen("HEAD");
+  ExpectHeaders("");
+  SetResponse(200, "");
+  ASSERT_EQ(0, mnt_->Access(Path(path_), R_OK));
+}
+
+TEST_F(MountHttpNodeTest, AccessWrite) {
+  StringMap_t smap;
+  smap["cache_content"] = "false";
+  SetMountArgs(StringMap_t());
+  ExpectOpen("HEAD");
+  ExpectHeaders("");
+  SetResponse(200, "");
+  ASSERT_EQ(EACCES, mnt_->Access(Path(path_), W_OK));
+}
+
+TEST_F(MountHttpNodeTest, AccessNotFound) {
+  StringMap_t smap;
+  smap["cache_content"] = "false";
+  SetMountArgs(StringMap_t());
+  ExpectOpen("HEAD");
+  ExpectHeaders("");
+  SetResponseExpectFail(404, "");
+  // TODO(mgiuca): Expect ENOENT instead. http://crbug.com/251662.
+  ASSERT_EQ(EINVAL, mnt_->Access(Path(path_), R_OK));
+}
+
 TEST_F(MountHttpNodeTest, ReadCached) {
   size_t result_size = 0;
   int result_bytes = 0;
 
   SetMountArgs(StringMap_t());
   ExpectOpen("HEAD");
   ExpectHeaders("");
   SetResponse(200, "Content-Length: 42\n");
   OpenNode();
   ResetMocks();
@@ skipping 170 matching lines @@
   memset(&buf[0], 0, sizeof(buf));
 
   ExpectOpen("GET");
   ExpectHeaders("Range: bytes=10-18\n");
   SetResponse(200, "Content-Length: 20\n");
   SetResponseBody("0123456789abcdefghij");
   EXPECT_EQ(0, node_->Read(10, buf, sizeof(buf) - 1, &result_bytes));
   EXPECT_EQ(sizeof(buf) - 1, result_bytes);
   EXPECT_STREQ("abcdefghi", &buf[0]);
 }