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

native_client_sdk/src/tests/nacl_io_test/kernel_wrap_test.cc

Index: native_client_sdk/src/tests/nacl_io_test/kernel_wrap_test.cc
diff --git a/native_client_sdk/src/tests/nacl_io_test/kernel_wrap_test.cc b/native_client_sdk/src/tests/nacl_io_test/kernel_wrap_test.cc
index 299592bb903582571259735622bde73cdc95d463..6023cb3277711d41e54fb4059df89f394fddefe1 100644
--- a/native_client_sdk/src/tests/nacl_io_test/kernel_wrap_test.cc
+++ b/native_client_sdk/src/tests/nacl_io_test/kernel_wrap_test.cc
@@ -653,11 +653,15 @@ 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) {
@@ -665,10 +669,13 @@ TEST_F(KernelWrapTest, connect) {
   // 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) {
@@ -682,11 +689,15 @@ TEST_F(KernelWrapTest, getpeername) {
   // 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) {
@@ -694,11 +705,15 @@ TEST_F(KernelWrapTest, getsockname) {
   // 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) {
@@ -707,26 +722,34 @@ TEST_F(KernelWrapTest, getsockopt) {
   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) {
@@ -798,30 +821,40 @@ 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) {
@@ -834,13 +867,15 @@ 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