Plumbing though mode parameter to open, since fusefs can make use of it.

native_client_sdk/src/tests/nacl_io_test/kernel_wrap_test.cc

 // Copyright (c) 2013 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.
 
 // The linux host build of nacl_io can't do wrapping of syscalls so all
 // these tests must be disabled.
 #if !defined(__linux__)
 
 #include <unistd.h>
 
@@ skipping 109 matching lines @@
 class KernelWrapTest : public ::testing::Test {
  public:
   KernelWrapTest() {}
 
   virtual void SetUp() {
     // Initialize the global errno value to a consistent value rather than
     // relying on its value from previous test runs.
     errno = 0;
 
     // Initializing the KernelProxy opens stdin/stdout/stderr.
-    EXPECT_CALL(mock, open(_, _))
+    EXPECT_CALL(mock, open(_, _, _))
         .WillOnce(Return(0))
         .WillOnce(Return(1))
         .WillOnce(Return(2));
 
     ASSERT_EQ(0, ki_push_state_for_testing());
     ASSERT_EQ(0, ki_init(&mock));
 
     // We allow write to be called any number of times, and it forwards to
     // _real_write. This prevents an infinite loop writing output if there is a
     // failure.
@@ skipping 302 matching lines @@
   // one. The result returned is from the "real" mmap.
   int dummy1 = 123;
   void* kDummyVoidPtr = &dummy1;
   size_t kDummySizeT = sizeof(kDummyVoidPtr);
   EXPECT_CALL(mock, munmap(kDummyVoidPtr, kDummySizeT));
   munmap(kDummyVoidPtr, kDummySizeT);
 }
 
 TEST_F(KernelWrapTest, open) {
   // We pass O_RDONLY because we do not want an error in flags translation
-  EXPECT_CALL(mock, open(kDummyConstChar, 0))
+  EXPECT_CALL(mock, open(kDummyConstChar, 0, 0))
       .WillOnce(Return(kDummyInt2))
       .WillOnce(Return(kDummyInt2));
 
-  EXPECT_EQ(kDummyInt2, open(kDummyConstChar, 0));
-  EXPECT_EQ(kDummyInt2, open(kDummyConstChar, 0));
+  EXPECT_EQ(kDummyInt2, open(kDummyConstChar, 0, 0));
+  EXPECT_EQ(kDummyInt2, open(kDummyConstChar, 0, 0));
 }
 
 TEST_F(KernelWrapTest, pipe) {
   int fds[] = {1, 2};
   EXPECT_CALL(mock, pipe(fds)).WillOnce(Return(kDummyInt));
   EXPECT_EQ(kDummyInt, pipe(fds));
 }
 
 TEST_F(KernelWrapTest, read) {
   int dummy_value;
@@ skipping 424 matching lines @@
       .WillOnce(Return(0))
       .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
   EXPECT_EQ(0, socketpair(kDummyInt, kDummyInt2, kDummyInt3, &dummy_val));
   EXPECT_EQ(-1, socketpair(kDummyInt, kDummyInt2, kDummyInt3, &dummy_val));
   EXPECT_EQ(kDummyErrno, errno);
 }
 
 #endif  // PROVIDES_SOCKET_API
 
 #endif  // __linux__