Fix socket calls in glibc by using new errno return macros.

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 635 matching lines @@
   socklen_t len;
   EXPECT_CALL(mock, accept(kDummyInt, &addr, &len))
       .WillOnce(Return(kDummyInt2));
   EXPECT_EQ(kDummyInt2, accept(kDummyInt, &addr, &len));
 }
 
 TEST_F(KernelWrapTest, bind) {
   // The way we wrap bind does not support returning arbitrary values, so we
   // test 0 and -1.
   struct sockaddr addr;
+
   EXPECT_CALL(mock, bind(kDummyInt, &addr, kDummyInt2))
-      .WillOnce(Return(0))
-      .WillOnce(Return(-1));
+      .WillOnce(Return(0));
   EXPECT_EQ(0, bind(kDummyInt, &addr, kDummyInt2));
+
+  EXPECT_CALL(mock, bind(kDummyInt, &addr, kDummyInt2))

[binji, 2014/05/16 20:19:09]

I think I like it better without the duplication of EXPECT_CALL:

EXPECT_CALL(mock, bind(kDummyInt, &addr, kDummyInt2))
    .WillOnce(Return(0))
    .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));

It seems we're inconsistent in this file, though.

[Sam Clegg, 2014/05/16 20:29:53]

I think that was the conclusion I came to last time I looked that this too.

[bradn, 2014/05/16 20:52:54]

Done.

[bradn, 2014/05/16 20:52:54]

Done.

+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
   EXPECT_EQ(-1, bind(kDummyInt, &addr, kDummyInt2));
+  EXPECT_EQ(kDummyErrno, errno);
 }
 
 TEST_F(KernelWrapTest, connect) {
   // The way we wrap connect does not support returning arbitrary values, so we
   // test 0 and -1.
   struct sockaddr addr;
   EXPECT_CALL(mock, connect(kDummyInt, &addr, kDummyInt2))
-      .WillOnce(Return(0))
-      .WillOnce(Return(-1));
+      .WillOnce(Return(0));
   EXPECT_EQ(0, connect(kDummyInt, &addr, kDummyInt2));
+
+  EXPECT_CALL(mock, connect(kDummyInt, &addr, kDummyInt2))
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
   EXPECT_EQ(-1, connect(kDummyInt, &addr, kDummyInt2));
+  EXPECT_EQ(kDummyErrno, errno);
 }
 
 TEST_F(KernelWrapTest, gethostbyname) {
   struct hostent result;
   EXPECT_CALL(mock, gethostbyname(kDummyConstChar)).WillOnce(Return(&result));
   EXPECT_EQ(&result, gethostbyname(kDummyConstChar));
 }
 
 TEST_F(KernelWrapTest, getpeername) {
   // The way we wrap getpeername does not support returning arbitrary values,
   // so we test 0 and -1.
   struct sockaddr addr;
   socklen_t len;
+
   EXPECT_CALL(mock, getpeername(kDummyInt, &addr, &len))
-      .WillOnce(Return(0))
-      .WillOnce(Return(-1));
+      .WillOnce(Return(0));
   EXPECT_EQ(0, getpeername(kDummyInt, &addr, &len));
+
+  EXPECT_CALL(mock, getpeername(kDummyInt, &addr, &len))
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
   EXPECT_EQ(-1, getpeername(kDummyInt, &addr, &len));
+  EXPECT_EQ(kDummyErrno, errno);
 }
 
 TEST_F(KernelWrapTest, getsockname) {
   // The way we wrap getsockname does not support returning arbitrary values,
   // so we test 0 and -1.
   struct sockaddr addr;
   socklen_t len;
+
   EXPECT_CALL(mock, getsockname(kDummyInt, &addr, &len))
-      .WillOnce(Return(0))
-      .WillOnce(Return(-1));
+      .WillOnce(Return(0));
   EXPECT_EQ(0, getsockname(kDummyInt, &addr, &len));
+
+  EXPECT_CALL(mock, getsockname(kDummyInt, &addr, &len))
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
   EXPECT_EQ(-1, getsockname(kDummyInt, &addr, &len));
+  EXPECT_EQ(kDummyErrno, errno);
 }
 
 TEST_F(KernelWrapTest, getsockopt) {
   // The way we wrap getsockname does not support returning arbitrary values,
   // so we test 0 and -1.
   int dummy_val;
   void* dummy_void_ptr = &dummy_val;
   socklen_t len;
+
   EXPECT_CALL(
       mock, getsockopt(kDummyInt, kDummyInt2, kDummyInt3, dummy_void_ptr, &len))
-      .WillOnce(Return(0))
-      .WillOnce(Return(-1));
+      .WillOnce(Return(0));
   EXPECT_EQ(
       0,
       getsockopt(kDummyInt, kDummyInt2, kDummyInt3, dummy_void_ptr, &len));
+
+  EXPECT_CALL(
+      mock, getsockopt(kDummyInt, kDummyInt2, kDummyInt3, dummy_void_ptr, &len))
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
   EXPECT_EQ(
       -1,
       getsockopt(kDummyInt, kDummyInt2, kDummyInt3, dummy_void_ptr, &len));
+  EXPECT_EQ(kDummyErrno, errno);
 }
 
 TEST_F(KernelWrapTest, listen) {
   // The way we wrap listen does not support returning arbitrary values, so we
   // test 0 and -1.
   EXPECT_CALL(mock, listen(kDummyInt, kDummyInt2))
-      .WillOnce(Return(0))
-      .WillOnce(Return(-1));
+      .WillOnce(Return(0));
   EXPECT_EQ(0, listen(kDummyInt, kDummyInt2));
+
+  EXPECT_CALL(mock, listen(kDummyInt, kDummyInt2))
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
   EXPECT_EQ(-1, listen(kDummyInt, kDummyInt2));
+  EXPECT_EQ(kDummyErrno, errno);
 }
 
 TEST_F(KernelWrapTest, recv) {
   int dummy_val;
   void* dummy_void_ptr = &dummy_val;
   EXPECT_CALL(mock, recv(kDummyInt, dummy_void_ptr, kDummySizeT, kDummyInt2))
       .WillOnce(Return(kDummyInt3));
   EXPECT_EQ(kDummyInt3,
             recv(kDummyInt, dummy_void_ptr, kDummySizeT, kDummyInt2));
 }
@@ skipping 51 matching lines @@
   struct msghdr msg;
   EXPECT_CALL(mock, sendmsg(kDummyInt, &msg, kDummyInt2))
       .WillOnce(Return(kDummyInt3));
   EXPECT_EQ(kDummyInt3, sendmsg(kDummyInt, &msg, kDummyInt2));
 }
 
 TEST_F(KernelWrapTest, setsockopt) {
   // The way we wrap setsockopt does not support returning arbitrary values, so
   // we test 0 and -1.
   const socklen_t kDummySockLen = 0x50cc5;
+
   EXPECT_CALL(
       mock,
       setsockopt(
           kDummyInt, kDummyInt2, kDummyInt3, kDummyVoidPtr, kDummySockLen))
-      .WillOnce(Return(0))
-      .WillOnce(Return(-1));
+      .WillOnce(Return(0));
   EXPECT_EQ(
       0,
       setsockopt(
           kDummyInt, kDummyInt2, kDummyInt3, kDummyVoidPtr, kDummySockLen));
+
+  EXPECT_CALL(
+      mock,
+      setsockopt(
+          kDummyInt, kDummyInt2, kDummyInt3, kDummyVoidPtr, kDummySockLen))
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
   EXPECT_EQ(
       -1,
       setsockopt(
           kDummyInt, kDummyInt2, kDummyInt3, kDummyVoidPtr, kDummySockLen));
+  EXPECT_EQ(kDummyErrno, errno);
 }
 
 TEST_F(KernelWrapTest, shutdown) {
   // The way we wrap shutdown does not support returning arbitrary values, so we
   // test 0 and -1.
   EXPECT_CALL(mock, shutdown(kDummyInt, kDummyInt2))
-      .WillOnce(Return(0))
-      .WillOnce(Return(-1));
+      .WillOnce(Return(0));
   EXPECT_EQ(0, shutdown(kDummyInt, kDummyInt2));
+
+  EXPECT_CALL(mock, shutdown(kDummyInt, kDummyInt2))
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
   EXPECT_EQ(-1, shutdown(kDummyInt, kDummyInt2));
+  EXPECT_EQ(kDummyErrno, errno);
 }
 
 TEST_F(KernelWrapTest, socket) {
   EXPECT_CALL(mock, socket(kDummyInt, kDummyInt2, kDummyInt3))
       .WillOnce(Return(kDummyInt4));
   EXPECT_EQ(kDummyInt4, socket(kDummyInt, kDummyInt2, kDummyInt3));
 }
 
 TEST_F(KernelWrapTest, socketpair) {
   // The way we wrap socketpair does not support returning arbitrary values,
   // so we test 0 and -1.
   int dummy_val;
+
   EXPECT_CALL(mock, socketpair(kDummyInt, kDummyInt2, kDummyInt3, &dummy_val))
-      .WillOnce(Return(0))
-      .WillOnce(Return(-1));
-  EXPECT_EQ(0,
-            socketpair(kDummyInt, kDummyInt2, kDummyInt3, &dummy_val));
-  EXPECT_EQ(-1,
-            socketpair(kDummyInt, kDummyInt2, kDummyInt3, &dummy_val));
+      .WillOnce(Return(0));
+  EXPECT_EQ(0, socketpair(kDummyInt, kDummyInt2, kDummyInt3, &dummy_val));
+
+  EXPECT_CALL(mock, socketpair(kDummyInt, kDummyInt2, kDummyInt3, &dummy_val))
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
+  EXPECT_EQ(-1, socketpair(kDummyInt, kDummyInt2, kDummyInt3, &dummy_val));
+  EXPECT_EQ(kDummyErrno, errno);
 }
 
 #endif  // PROVIDES_SOCKET_API
 
 #endif  // __linux__