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