kernel_wrap_test.cc revision c5cede9ae108bb15f6b7a8aea21c7e1fefa2834c 
1// Copyright (c) 2013 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// The linux host build of nacl_io can't do wrapping of syscalls so all
6// these tests must be disabled.
7#if !defined(__linux__)
8
9#include <unistd.h>
10
11#include <string>
12#include <vector>
13
14#include "gtest/gtest.h"
15#include "mock_kernel_proxy.h"
16#include "nacl_io/kernel_intercept.h"
17#include "nacl_io/kernel_wrap.h"
18#include "nacl_io/osmman.h"
19#include "nacl_io/ossocket.h"
20#include "nacl_io/ostermios.h"
21
22#if defined(__native_client__) && !defined(__GLIBC__)
23extern "C" {
24// TODO(sbc): remove once these get added to the newlib toolchain headers.
25int fchdir(int fd);
26int utimes(const char *filename, const struct timeval times[2]);
27}
28#endif
29
30using namespace nacl_io;
31
32using ::testing::_;
33using ::testing::DoAll;
34using ::testing::Return;
35using ::testing::StrEq;
36
37namespace {
38
39#define COMPARE_FIELD(f)                                                     \
40  if (arg->f != statbuf->f) {                                                \
41    *result_listener << "mismatch of field \"" #f                            \
42                        "\". "                                               \
43                        "expected: " << statbuf->f << " actual: " << arg->f; \
44    return false;                                                            \
45  }
46
47MATCHER_P(IsEqualToStatbuf, statbuf, "") {
48  COMPARE_FIELD(st_dev);
49  COMPARE_FIELD(st_ino);
50  COMPARE_FIELD(st_mode);
51  COMPARE_FIELD(st_nlink);
52  COMPARE_FIELD(st_uid);
53  COMPARE_FIELD(st_gid);
54  COMPARE_FIELD(st_rdev);
55  COMPARE_FIELD(st_size);
56  COMPARE_FIELD(st_atime);
57  COMPARE_FIELD(st_mtime);
58  COMPARE_FIELD(st_ctime);
59  return true;
60}
61
62#undef COMPARE_FIELD
63
64ACTION_P(SetStat, statbuf) {
65  memset(arg1, 0, sizeof(struct stat));
66  arg1->st_dev = statbuf->st_dev;
67  arg1->st_ino = statbuf->st_ino;
68  arg1->st_mode = statbuf->st_mode;
69  arg1->st_nlink = statbuf->st_nlink;
70  arg1->st_uid = statbuf->st_uid;
71  arg1->st_gid = statbuf->st_gid;
72  arg1->st_rdev = statbuf->st_rdev;
73  arg1->st_size = statbuf->st_size;
74  arg1->st_atime = statbuf->st_atime;
75  arg1->st_mtime = statbuf->st_mtime;
76  arg1->st_ctime = statbuf->st_ctime;
77}
78
79void MakeDummyStatbuf(struct stat* statbuf) {
80  memset(&statbuf[0], 0, sizeof(struct stat));
81  statbuf->st_dev = 1;
82  statbuf->st_ino = 2;
83  statbuf->st_mode = 3;
84  statbuf->st_nlink = 4;
85  statbuf->st_uid = 5;
86  statbuf->st_gid = 6;
87  statbuf->st_rdev = 7;
88  statbuf->st_size = 8;
89  statbuf->st_atime = 9;
90  statbuf->st_mtime = 10;
91  statbuf->st_ctime = 11;
92}
93
94const mode_t kDummyMode = 0xbeef;
95const int kDummyInt = 0xdedbeef;
96const int kDummyInt2 = 0xcabba6e;
97const int kDummyInt3 = 0xf00ba4;
98const int kDummyInt4 = 0xabacdba;
99const size_t kDummySizeT = 0x60067e;
100const char* kDummyConstChar = "foobar";
101const char* kDummyConstChar2 = "g00gl3";
102const char* kDummyConstChar3 = "fr00gl3";
103const void* kDummyVoidPtr = "blahblah";
104const uid_t kDummyUid = 1001;
105const gid_t kDummyGid = 1002;
106
107class KernelWrapTest : public ::testing::Test {
108 public:
109  KernelWrapTest() {}
110
111  virtual void SetUp() {
112    // Initializing the KernelProxy opens stdin/stdout/stderr.
113    EXPECT_CALL(mock, open(_, _))
114        .WillOnce(Return(0))
115        .WillOnce(Return(1))
116        .WillOnce(Return(2));
117    // And will call mount / and /dev.
118    EXPECT_CALL(mock, mount(_, _, _, _, _))
119        .WillOnce(Return(0))
120        .WillOnce(Return(0));
121
122    ASSERT_EQ(0, ki_push_state_for_testing());
123    ASSERT_EQ(0, ki_init(&mock));
124  }
125
126  void TearDown() {
127    // Uninitialize the kernel proxy so wrapped functions passthrough to their
128    // unwrapped versions.
129    ki_uninit();
130  }
131
132
133  MockKernelProxy mock;
134};
135
136}  // namespace
137
138TEST_F(KernelWrapTest, access) {
139  EXPECT_CALL(mock, access(kDummyConstChar, kDummyInt)) .WillOnce(Return(-1));
140  EXPECT_EQ(-1, access(kDummyConstChar, kDummyInt));
141
142  EXPECT_CALL(mock, access(kDummyConstChar, kDummyInt)) .WillOnce(Return(0));
143  EXPECT_EQ(0, access(kDummyConstChar, kDummyInt));
144}
145
146TEST_F(KernelWrapTest, chdir) {
147  EXPECT_CALL(mock, chdir(kDummyConstChar)).WillOnce(Return(-1));
148  EXPECT_EQ(-1, chdir(kDummyConstChar));
149
150  EXPECT_CALL(mock, chdir(kDummyConstChar)).WillOnce(Return(0));
151  EXPECT_EQ(0, chdir(kDummyConstChar));
152}
153
154TEST_F(KernelWrapTest, chmod) {
155  EXPECT_CALL(mock, chmod(kDummyConstChar, kDummyMode))
156      .WillOnce(Return(kDummyInt2));
157  EXPECT_EQ(kDummyInt2,chmod(kDummyConstChar, kDummyMode));
158}
159
160TEST_F(KernelWrapTest, chown) {
161  EXPECT_CALL(mock, chown(kDummyConstChar, kDummyUid, kDummyGid))
162      .WillOnce(Return(kDummyInt));
163  EXPECT_EQ(kDummyInt, chown(kDummyConstChar, kDummyUid, kDummyGid));
164}
165
166TEST_F(KernelWrapTest, close) {
167  // The way we wrap close does not support returning arbitrary values, so we
168  // test 0 and -1.
169  EXPECT_CALL(mock, close(kDummyInt))
170      .WillOnce(Return(0))
171      .WillOnce(Return(-1));
172
173  EXPECT_EQ(0, close(kDummyInt));
174  EXPECT_EQ(-1, close(kDummyInt));
175}
176
177TEST_F(KernelWrapTest, dup) {
178  EXPECT_CALL(mock, dup(kDummyInt)).WillOnce(Return(kDummyInt2));
179  EXPECT_EQ(kDummyInt2, dup(kDummyInt));
180}
181
182TEST_F(KernelWrapTest, dup2) {
183  // The way we wrap dup2 does not support returning aribtrary values, only -1
184  // or the value of the new fd.
185  EXPECT_CALL(mock, dup2(kDummyInt, kDummyInt2))
186      .WillOnce(Return(kDummyInt2))
187      .WillOnce(Return(-1));
188  EXPECT_EQ(kDummyInt2, dup2(kDummyInt, kDummyInt2));
189  EXPECT_EQ(-1, dup2(kDummyInt, kDummyInt2));
190}
191
192TEST_F(KernelWrapTest, fchdir) {
193  EXPECT_CALL(mock, fchdir(kDummyInt))
194      .WillOnce(Return(-1));
195  EXPECT_EQ(-1, fchdir(kDummyInt));
196}
197
198TEST_F(KernelWrapTest, fchmod) {
199  EXPECT_CALL(mock, fchmod(kDummyInt, kDummyMode))
200      .WillOnce(Return(-1));
201  EXPECT_EQ(-1, fchmod(kDummyInt, kDummyMode));
202
203  EXPECT_CALL(mock, fchmod(kDummyInt, kDummyMode)) .WillOnce(Return(0));
204  EXPECT_EQ(0, fchmod(kDummyInt, kDummyMode));
205}
206
207TEST_F(KernelWrapTest, fchown) {
208  EXPECT_CALL(mock, fchown(kDummyInt, kDummyUid, kDummyGid))
209      .WillOnce(Return(kDummyInt));
210  EXPECT_EQ(kDummyInt, fchown(kDummyInt, kDummyUid, kDummyGid));
211}
212
213TEST_F(KernelWrapTest, fcntl) {
214  char buffer[] = "fcntl";
215  EXPECT_CALL(mock, fcntl(kDummyInt, kDummyInt2, _))
216      .WillOnce(Return(kDummyInt3));
217  EXPECT_EQ(kDummyInt3, fcntl(kDummyInt, kDummyInt2, buffer));
218}
219
220TEST_F(KernelWrapTest, fdatasync) {
221  EXPECT_CALL(mock, fdatasync(kDummyInt)).WillOnce(Return(-1));
222  EXPECT_EQ(-1, fdatasync(kDummyInt));
223
224  EXPECT_CALL(mock, fdatasync(kDummyInt)).WillOnce(Return(0));
225  EXPECT_EQ(0, fdatasync(kDummyInt));
226}
227
228TEST_F(KernelWrapTest, fstat) {
229  // The way we wrap fstat does not support returning aribtrary values, only 0
230  // or -1.
231  struct stat in_statbuf;
232  MakeDummyStatbuf(&in_statbuf);
233  EXPECT_CALL(mock, fstat(kDummyInt, _))
234      .WillOnce(DoAll(SetStat(&in_statbuf), Return(0)))
235      .WillOnce(Return(-1));
236  struct stat out_statbuf;
237  EXPECT_EQ(0, fstat(kDummyInt, &out_statbuf));
238  EXPECT_THAT(&in_statbuf, IsEqualToStatbuf(&out_statbuf));
239  EXPECT_EQ(-1, fstat(kDummyInt, &out_statbuf));
240}
241
242TEST_F(KernelWrapTest, ftruncate) {
243  EXPECT_CALL(mock, ftruncate(kDummyInt, kDummyInt2))
244      .WillOnce(Return(kDummyInt3));
245  EXPECT_EQ(kDummyInt3, ftruncate(kDummyInt, kDummyInt2));
246}
247
248TEST_F(KernelWrapTest, fsync) {
249  EXPECT_CALL(mock, fsync(kDummyInt)).WillOnce(Return(-1));
250  EXPECT_EQ(-1, fsync(kDummyInt));
251}
252
253TEST_F(KernelWrapTest, getcwd) {
254  char result[] = "getcwd_result";
255  char buffer[] = "getcwd";
256  EXPECT_CALL(mock, getcwd(buffer, kDummySizeT)).WillOnce(Return(result));
257  EXPECT_EQ(result, getcwd(buffer, kDummySizeT));
258}
259
260TEST_F(KernelWrapTest, getdents) {
261#if !defined( __GLIBC__) && !defined(__BIONIC__)
262  // TODO(sbc): Find a way to test the getdents wrapper under glibc.
263  // It looks like the only way to exercise it is to call readdir(2).
264  // There is an internal glibc function __getdents that will call the
265  // IRT but that cannot be accessed from here as glibc does not export it.
266  int dummy_val;
267  void* void_ptr = &dummy_val;
268  EXPECT_CALL(mock, getdents(kDummyInt, void_ptr, kDummyInt2))
269      .WillOnce(Return(kDummyInt2));
270  EXPECT_EQ(kDummyInt2, getdents(kDummyInt, void_ptr, kDummyInt2));
271#endif
272}
273
274// gcc gives error: getwd is deprecated.
275#if defined(__GNUC__)
276#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
277#endif
278TEST_F(KernelWrapTest, getwd) {
279  char result[] = "getwd_result";
280  char buffer[] = "getwd";
281  EXPECT_CALL(mock, getwd(buffer)).WillOnce(Return(result));
282  EXPECT_EQ(result, getwd(buffer));
283}
284#if defined(__GNUC__)
285#pragma GCC diagnostic warning "-Wdeprecated-declarations"
286#endif
287
288TEST_F(KernelWrapTest, ioctl) {
289  char buffer[] = "ioctl";
290  EXPECT_CALL(mock, ioctl(kDummyInt, kDummyInt2, _))
291      .WillOnce(Return(kDummyInt3));
292  EXPECT_EQ(kDummyInt3, ioctl(kDummyInt, kDummyInt2, buffer));
293}
294
295#if !defined(__BIONIC__)
296TEST_F(KernelWrapTest, isatty) {
297  EXPECT_CALL(mock, isatty(kDummyInt)).WillOnce(Return(kDummyInt2));
298  EXPECT_EQ(kDummyInt2, isatty(kDummyInt));
299
300  // This test verifies that the IRT interception wrapper for isatty
301  // ignores the value of errno when isatty() returns 1.  We had a bug
302  // where returning 1 from ki_isatty resulted in errno being returned
303  // by the IRT interface.
304  errno = kDummyInt3;
305  EXPECT_CALL(mock, isatty(kDummyInt)).WillOnce(Return(1));
306  EXPECT_EQ(1, isatty(kDummyInt));
307}
308#endif
309
310TEST_F(KernelWrapTest, kill) {
311  EXPECT_CALL(mock, kill(kDummyInt, kDummyInt2)).WillOnce(Return(kDummyInt3));
312  EXPECT_EQ(kDummyInt3, kill(kDummyInt, kDummyInt2));
313}
314
315TEST_F(KernelWrapTest, lchown) {
316  EXPECT_CALL(mock, lchown(kDummyConstChar, kDummyUid, kDummyGid))
317      .WillOnce(Return(kDummyInt));
318  EXPECT_EQ(kDummyInt, lchown(kDummyConstChar, kDummyUid, kDummyGid));
319}
320
321TEST_F(KernelWrapTest, link) {
322  EXPECT_CALL(mock, link(kDummyConstChar, kDummyConstChar2))
323      .WillOnce(Return(kDummyInt));
324  EXPECT_EQ(kDummyInt, link(kDummyConstChar, kDummyConstChar2));
325}
326
327TEST_F(KernelWrapTest, lseek) {
328  EXPECT_CALL(mock, lseek(kDummyInt, kDummyInt2, kDummyInt3))
329      .WillOnce(Return(kDummyInt4));
330  EXPECT_EQ(kDummyInt4, lseek(kDummyInt, kDummyInt2, kDummyInt3));
331}
332
333TEST_F(KernelWrapTest, mkdir) {
334#if defined(WIN32)
335  EXPECT_CALL(mock, mkdir(kDummyConstChar, 0777)).WillOnce(Return(kDummyInt2));
336  EXPECT_EQ(kDummyInt2, mkdir(kDummyConstChar));
337#else
338  EXPECT_CALL(mock, mkdir(kDummyConstChar, kDummyMode))
339      .WillOnce(Return(kDummyInt2));
340  EXPECT_EQ(kDummyInt2, mkdir(kDummyConstChar, kDummyMode));
341#endif
342}
343
344TEST_F(KernelWrapTest, mmap) {
345  // We only wrap mmap if |flags| has the MAP_ANONYMOUS bit unset.
346  int flags = kDummyInt2 & ~MAP_ANONYMOUS;
347
348  const size_t kDummySizeT2 = 0xbadf00d;
349  int dummy1 = 123;
350  int dummy2 = 456;
351  void* kDummyVoidPtr1 = &dummy1;
352  void* kDummyVoidPtr2 = &dummy2;
353  EXPECT_CALL(mock,
354              mmap(kDummyVoidPtr1,
355                   kDummySizeT,
356                   kDummyInt,
357                   flags,
358                   kDummyInt3,
359                   kDummySizeT2)).WillOnce(Return(kDummyVoidPtr2));
360  EXPECT_EQ(kDummyVoidPtr2,
361            mmap(kDummyVoidPtr1,
362                 kDummySizeT,
363                 kDummyInt,
364                 flags,
365                 kDummyInt3,
366                 kDummySizeT2));
367}
368
369TEST_F(KernelWrapTest, mount) {
370  EXPECT_CALL(mock,
371              mount(kDummyConstChar,
372                    kDummyConstChar2,
373                    kDummyConstChar3,
374                    kDummyInt,
375                    kDummyVoidPtr)).WillOnce(Return(kDummyInt2));
376  EXPECT_EQ(kDummyInt2,
377            mount(kDummyConstChar,
378                  kDummyConstChar2,
379                  kDummyConstChar3,
380                  kDummyInt,
381                  kDummyVoidPtr));
382}
383
384TEST_F(KernelWrapTest, munmap) {
385  // The way we wrap munmap, calls the "real" mmap as well as the intercepted
386  // one. The result returned is from the "real" mmap.
387  int dummy1 = 123;
388  void* kDummyVoidPtr = &dummy1;
389  size_t kDummySizeT = sizeof(kDummyVoidPtr);
390  EXPECT_CALL(mock, munmap(kDummyVoidPtr, kDummySizeT));
391  munmap(kDummyVoidPtr, kDummySizeT);
392}
393
394
395TEST_F(KernelWrapTest, open) {
396  // We pass O_RDONLY because we do not want an error in flags translation
397  EXPECT_CALL(mock, open(kDummyConstChar, 0))
398      .WillOnce(Return(kDummyInt2));
399  EXPECT_EQ(kDummyInt2, open(kDummyConstChar, 0));
400
401  EXPECT_CALL(mock, open(kDummyConstChar, 0))
402      .WillOnce(Return(kDummyInt2));
403  EXPECT_EQ(kDummyInt2, open(kDummyConstChar, 0));
404}
405
406TEST_F(KernelWrapTest, pipe) {
407  int fds[] = {1, 2};
408  EXPECT_CALL(mock, pipe(fds)).WillOnce(Return(kDummyInt));
409  EXPECT_EQ(kDummyInt, pipe(fds));
410}
411
412TEST_F(KernelWrapTest, read) {
413  int dummy_value;
414  void* dummy_void_ptr = &dummy_value;
415  EXPECT_CALL(mock, read(kDummyInt, dummy_void_ptr, kDummyInt2))
416      .WillOnce(Return(kDummyInt3));
417  EXPECT_EQ(kDummyInt3, read(kDummyInt, dummy_void_ptr, kDummyInt2));
418}
419
420TEST_F(KernelWrapTest, readlink) {
421  char buf[10];
422
423  EXPECT_CALL(mock, readlink(kDummyConstChar, buf, 10))
424      .WillOnce(Return(-1));
425  EXPECT_EQ(-1, readlink(kDummyConstChar, buf, 10));
426
427  EXPECT_CALL(mock, readlink(kDummyConstChar, buf, 10))
428      .WillOnce(Return(kDummyInt));
429  EXPECT_EQ(kDummyInt, readlink(kDummyConstChar, buf, 10));
430}
431
432#ifdef __GLIBC__
433// Under newlib there is no remove syscall.  Instead it is implemented
434// in terms of unlink()/rmdir().
435TEST_F(KernelWrapTest, remove) {
436  EXPECT_CALL(mock, remove(kDummyConstChar)).WillOnce(Return(-1));
437  EXPECT_EQ(-1, remove(kDummyConstChar));
438}
439#endif
440
441TEST_F(KernelWrapTest, rename) {
442  EXPECT_CALL(mock, rename(kDummyConstChar, kDummyConstChar2))
443      .WillOnce(Return(-1));
444  EXPECT_EQ(-1, rename(kDummyConstChar, kDummyConstChar2));
445
446  EXPECT_CALL(mock, rename(kDummyConstChar, kDummyConstChar2))
447      .WillOnce(Return(0));
448  EXPECT_EQ(0, rename(kDummyConstChar, kDummyConstChar2));
449}
450
451TEST_F(KernelWrapTest, rmdir) {
452  EXPECT_CALL(mock, rmdir(kDummyConstChar)).WillOnce(Return(kDummyInt));
453  EXPECT_EQ(kDummyInt, rmdir(kDummyConstChar));
454}
455
456static void new_handler(int) {}
457
458TEST_F(KernelWrapTest, sigaction) {
459  struct sigaction action;
460  struct sigaction oaction;
461  EXPECT_CALL(mock, sigaction(kDummyInt, &action, &oaction))
462      .WillOnce(Return(0));
463  EXPECT_EQ(0, sigaction(kDummyInt, &action, &oaction));
464}
465
466TEST_F(KernelWrapTest, sigset) {
467  EXPECT_CALL(mock, sigaction(kDummyInt, _, _))
468      .WillOnce(Return(0));
469  EXPECT_EQ(NULL, sigset(kDummyInt, new_handler));
470}
471
472TEST_F(KernelWrapTest, signal) {
473  // KernelIntercept forwards calls to signal to KernelProxy::sigset.
474  EXPECT_CALL(mock, sigaction(kDummyInt, _, _))
475      .WillOnce(Return(0));
476  EXPECT_EQ(NULL, signal(kDummyInt, new_handler));
477}
478
479TEST_F(KernelWrapTest, stat) {
480  // The way we wrap stat does not support returning aribtrary values, only 0
481  // or -1.
482  struct stat in_statbuf;
483  MakeDummyStatbuf(&in_statbuf);
484  EXPECT_CALL(mock, stat(StrEq(kDummyConstChar), _))
485      .WillOnce(DoAll(SetStat(&in_statbuf), Return(0)))
486      .WillOnce(Return(-1));
487  struct stat out_statbuf;
488  EXPECT_EQ(0, stat(kDummyConstChar, &out_statbuf));
489  EXPECT_THAT(&in_statbuf, IsEqualToStatbuf(&out_statbuf));
490  EXPECT_EQ(-1, stat(kDummyConstChar, &out_statbuf));
491}
492
493TEST_F(KernelWrapTest, symlink) {
494  EXPECT_CALL(mock, symlink(kDummyConstChar, kDummyConstChar2))
495      .WillOnce(Return(kDummyInt));
496  EXPECT_EQ(kDummyInt, symlink(kDummyConstChar, kDummyConstChar2));
497}
498
499#ifndef __BIONIC__
500TEST_F(KernelWrapTest, tcflush) {
501  EXPECT_CALL(mock, tcflush(kDummyInt, kDummyInt2))
502      .WillOnce(Return(kDummyInt3));
503  EXPECT_EQ(kDummyInt3, tcflush(kDummyInt, kDummyInt2));
504}
505
506TEST_F(KernelWrapTest, tcgetattr) {
507  struct termios term;
508  EXPECT_CALL(mock, tcgetattr(kDummyInt, &term)).WillOnce(Return(kDummyInt2));
509  EXPECT_EQ(kDummyInt2, tcgetattr(kDummyInt, &term));
510}
511
512TEST_F(KernelWrapTest, tcsetattr) {
513  struct termios term;
514  EXPECT_CALL(mock, tcsetattr(kDummyInt, kDummyInt2, &term))
515      .WillOnce(Return(kDummyInt3));
516  EXPECT_EQ(kDummyInt3, tcsetattr(kDummyInt, kDummyInt2, &term));
517}
518#endif
519
520TEST_F(KernelWrapTest, umount) {
521  EXPECT_CALL(mock, umount(kDummyConstChar)).WillOnce(Return(kDummyInt));
522  EXPECT_EQ(kDummyInt, umount(kDummyConstChar));
523}
524
525TEST_F(KernelWrapTest, truncate) {
526  EXPECT_CALL(mock, truncate(kDummyConstChar, kDummyInt3)).WillOnce(Return(-1));
527  EXPECT_EQ(-1, truncate(kDummyConstChar, kDummyInt3));
528
529  EXPECT_CALL(mock, truncate(kDummyConstChar, kDummyInt3)).WillOnce(Return(0));
530  EXPECT_EQ(0, truncate(kDummyConstChar, kDummyInt3));
531}
532
533#ifndef __BIONIC__
534TEST_F(KernelWrapTest, lstat) {
535  struct stat buf;
536  EXPECT_CALL(mock, lstat(kDummyConstChar, &buf)).WillOnce(Return(-1));
537  EXPECT_EQ(-1, lstat(kDummyConstChar, &buf));
538
539  EXPECT_CALL(mock, lstat(kDummyConstChar, &buf)).WillOnce(Return(0));
540  EXPECT_EQ(0, lstat(kDummyConstChar, &buf));
541}
542#endif
543
544TEST_F(KernelWrapTest, unlink) {
545  EXPECT_CALL(mock, unlink(kDummyConstChar)).WillOnce(Return(kDummyInt));
546  EXPECT_EQ(kDummyInt, unlink(kDummyConstChar));
547}
548
549TEST_F(KernelWrapTest, utime) {
550  const struct utimbuf* times = NULL;
551  EXPECT_CALL(mock, utime(kDummyConstChar, times)).WillOnce(Return(kDummyInt));
552  EXPECT_EQ(kDummyInt, utime(kDummyConstChar, times));
553}
554
555TEST_F(KernelWrapTest, utimes) {
556  struct timeval* times = NULL;
557  EXPECT_CALL(mock, utimes(kDummyConstChar, times)).WillOnce(Return(-1));
558  EXPECT_EQ(-1, utimes(kDummyConstChar, times));
559}
560
561TEST_F(KernelWrapTest, write) {
562  EXPECT_CALL(mock, write(kDummyInt, kDummyVoidPtr, kDummyInt2))
563      .WillOnce(Return(kDummyInt3));
564  EXPECT_EQ(kDummyInt3, write(kDummyInt, kDummyVoidPtr, kDummyInt2));
565}
566
567#if defined(PROVIDES_SOCKET_API) and !defined(__BIONIC__)
568TEST_F(KernelWrapTest, poll) {
569  struct pollfd fds;
570  EXPECT_CALL(mock, poll(&fds, kDummyInt, kDummyInt2))
571      .WillOnce(Return(kDummyInt3));
572  EXPECT_EQ(kDummyInt3, poll(&fds, kDummyInt, kDummyInt2));
573}
574
575TEST_F(KernelWrapTest, select) {
576  fd_set readfds;
577  fd_set writefds;
578  fd_set exceptfds;
579  EXPECT_CALL(mock, select(kDummyInt, &readfds, &writefds, &exceptfds, NULL))
580      .WillOnce(Return(kDummyInt2));
581  EXPECT_EQ(kDummyInt2,
582            select(kDummyInt, &readfds, &writefds, &exceptfds, NULL));
583}
584
585// Socket Functions
586TEST_F(KernelWrapTest, accept) {
587  struct sockaddr addr;
588  socklen_t len;
589  EXPECT_CALL(mock, accept(kDummyInt, &addr, &len))
590      .WillOnce(Return(kDummyInt2));
591  EXPECT_EQ(kDummyInt2, accept(kDummyInt, &addr, &len));
592}
593
594TEST_F(KernelWrapTest, bind) {
595  struct sockaddr addr;
596  EXPECT_CALL(mock, bind(kDummyInt, &addr, kDummyInt2))
597      .WillOnce(Return(kDummyInt2));
598  EXPECT_EQ(kDummyInt2, bind(kDummyInt, &addr, kDummyInt2));
599}
600
601TEST_F(KernelWrapTest, connect) {
602  struct sockaddr addr;
603  EXPECT_CALL(mock, connect(kDummyInt, &addr, kDummyInt2))
604      .WillOnce(Return(kDummyInt2));
605  EXPECT_EQ(kDummyInt2, connect(kDummyInt, &addr, kDummyInt2));
606}
607
608TEST_F(KernelWrapTest, gethostbyname) {
609  struct hostent result;
610  EXPECT_CALL(mock, gethostbyname(kDummyConstChar)).WillOnce(Return(&result));
611  EXPECT_EQ(&result, gethostbyname(kDummyConstChar));
612}
613
614TEST_F(KernelWrapTest, getpeername) {
615  struct sockaddr addr;
616  socklen_t len;
617  EXPECT_CALL(mock, getpeername(kDummyInt, &addr, &len))
618      .WillOnce(Return(kDummyInt2));
619  EXPECT_EQ(kDummyInt2, getpeername(kDummyInt, &addr, &len));
620}
621
622TEST_F(KernelWrapTest, getsockname) {
623  struct sockaddr addr;
624  socklen_t len;
625  EXPECT_CALL(mock, getsockname(kDummyInt, &addr, &len))
626      .WillOnce(Return(kDummyInt2));
627  EXPECT_EQ(kDummyInt2, getsockname(kDummyInt, &addr, &len));
628}
629
630TEST_F(KernelWrapTest, getsockopt) {
631  int dummy_val;
632  void* dummy_void_ptr = &dummy_val;
633  socklen_t len;
634  EXPECT_CALL(
635      mock, getsockopt(kDummyInt, kDummyInt2, kDummyInt3, dummy_void_ptr, &len))
636      .WillOnce(Return(kDummyInt4));
637  EXPECT_EQ(
638      kDummyInt4,
639      getsockopt(kDummyInt, kDummyInt2, kDummyInt3, dummy_void_ptr, &len));
640}
641
642TEST_F(KernelWrapTest, listen) {
643  EXPECT_CALL(mock, listen(kDummyInt, kDummyInt2)).WillOnce(Return(kDummyInt3));
644  EXPECT_EQ(kDummyInt3, listen(kDummyInt, kDummyInt2));
645}
646
647TEST_F(KernelWrapTest, recv) {
648  int dummy_val;
649  void* dummy_void_ptr = &dummy_val;
650  EXPECT_CALL(mock, recv(kDummyInt, dummy_void_ptr, kDummySizeT, kDummyInt2))
651      .WillOnce(Return(kDummyInt3));
652  EXPECT_EQ(kDummyInt3,
653            recv(kDummyInt, dummy_void_ptr, kDummySizeT, kDummyInt2));
654}
655
656TEST_F(KernelWrapTest, recvfrom) {
657  int dummy_val;
658  void* dummy_void_ptr = &dummy_val;
659  struct sockaddr addr;
660  socklen_t len;
661  EXPECT_CALL(
662      mock,
663      recvfrom(kDummyInt, dummy_void_ptr, kDummyInt2, kDummyInt3, &addr, &len))
664      .WillOnce(Return(kDummyInt4));
665  EXPECT_EQ(
666      kDummyInt4,
667      recvfrom(kDummyInt, dummy_void_ptr, kDummyInt2, kDummyInt3, &addr, &len));
668}
669
670#ifndef __BIONIC__
671TEST_F(KernelWrapTest, recvmsg) {
672  struct msghdr msg;
673  EXPECT_CALL(mock, recvmsg(kDummyInt, &msg, kDummyInt2))
674      .WillOnce(Return(kDummyInt3));
675  EXPECT_EQ(kDummyInt3, recvmsg(kDummyInt, &msg, kDummyInt2));
676}
677#endif
678
679TEST_F(KernelWrapTest, send) {
680  EXPECT_CALL(mock, send(kDummyInt, kDummyVoidPtr, kDummySizeT, kDummyInt2))
681      .WillOnce(Return(kDummyInt3));
682  EXPECT_EQ(kDummyInt3,
683            send(kDummyInt, kDummyVoidPtr, kDummySizeT, kDummyInt2));
684}
685
686TEST_F(KernelWrapTest, sendto) {
687  const socklen_t kDummySockLen = 0x50cc5;
688  struct sockaddr addr;
689  EXPECT_CALL(mock,
690              sendto(kDummyInt,
691                     kDummyVoidPtr,
692                     kDummyInt2,
693                     kDummyInt3,
694                     &addr,
695                     kDummySockLen)).WillOnce(Return(kDummyInt4));
696  EXPECT_EQ(kDummyInt4,
697            sendto(kDummyInt,
698                   kDummyVoidPtr,
699                   kDummyInt2,
700                   kDummyInt3,
701                   &addr,
702                   kDummySockLen));
703}
704
705TEST_F(KernelWrapTest, sendmsg) {
706  struct msghdr msg;
707  EXPECT_CALL(mock, sendmsg(kDummyInt, &msg, kDummyInt2))
708      .WillOnce(Return(kDummyInt3));
709  EXPECT_EQ(kDummyInt3, sendmsg(kDummyInt, &msg, kDummyInt2));
710}
711
712TEST_F(KernelWrapTest, setsockopt) {
713  const socklen_t kDummySockLen = 0x50cc5;
714  EXPECT_CALL(
715      mock,
716      setsockopt(
717          kDummyInt, kDummyInt2, kDummyInt3, kDummyVoidPtr, kDummySockLen))
718      .WillOnce(Return(kDummyInt4));
719  EXPECT_EQ(
720      kDummyInt4,
721      setsockopt(
722          kDummyInt, kDummyInt2, kDummyInt3, kDummyVoidPtr, kDummySockLen));
723}
724
725TEST_F(KernelWrapTest, shutdown) {
726  EXPECT_CALL(mock, shutdown(kDummyInt, kDummyInt2))
727      .WillOnce(Return(kDummyInt3));
728  EXPECT_EQ(kDummyInt3, shutdown(kDummyInt, kDummyInt2));
729}
730
731TEST_F(KernelWrapTest, socket) {
732  EXPECT_CALL(mock, socket(kDummyInt, kDummyInt2, kDummyInt3))
733      .WillOnce(Return(kDummyInt4));
734  EXPECT_EQ(kDummyInt4, socket(kDummyInt, kDummyInt2, kDummyInt3));
735}
736
737TEST_F(KernelWrapTest, socketpair) {
738  int dummy_val;
739  EXPECT_CALL(mock, socketpair(kDummyInt, kDummyInt2, kDummyInt3, &dummy_val))
740      .WillOnce(Return(kDummyInt4));
741  EXPECT_EQ(kDummyInt4,
742            socketpair(kDummyInt, kDummyInt2, kDummyInt3, &dummy_val));
743}
744
745#endif  // PROVIDES_SOCKET_API
746
747#endif  // __linux__
748