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