Wrap test queues in Queue object on creation.

PiperOrigin-RevId: 390245901

1 files changed, 45 insertions, 64 deletions

diff --git a/test/syscalls/linux/msgqueue.cc b/test/syscalls/linux/msgqueue.cc
index 8994b739a..6dd3155c0 100644
--- a/test/syscalls/linux/msgqueue.cc
+++ b/test/syscalls/linux/msgqueue.cc
@@ -40,6 +40,10 @@ constexpr int kInterruptSignal = SIGALRM;
 class Queue {
  public:
   explicit Queue(int id) : id_(id) {}
+  Queue(const Queue&) = delete;
+  Queue& operator=(const Queue&) = delete;
+
+  Queue(Queue&& other) { id_ = other.release(); }
 
   ~Queue() {
     if (id_ >= 0) {
@@ -59,6 +63,14 @@ class Queue {
   int id_ = -1;
 };
 
+PosixErrorOr<Queue> Msgget(key_t key, int flags) {
+  int id = msgget(key, flags);
+  if (id == -1) {
+    return PosixError(errno, absl::StrFormat("msgget(%d, %d)", key, flags));
+  }
+  return Queue(id);
+}
+
 // Default size for messages.
 constexpr size_t msgSize = 50;
 
@@ -90,8 +102,7 @@ TEST(MsgqueueTest, MsgGet) {
   const key_t key = ftok(keyfile.path().c_str(), 1);
   ASSERT_THAT(key, SyscallSucceeds());
 
-  Queue queue(msgget(key, IPC_CREAT));
-  ASSERT_THAT(queue.get(), SyscallSucceeds());
+  Queue queue = ASSERT_NO_ERRNO_AND_VALUE(Msgget(key, IPC_CREAT));
   EXPECT_THAT(msgget(key, 0), SyscallSucceedsWithValue(queue.get()));
 }
 
@@ -103,27 +114,20 @@ TEST(MsgqueueTest, MsgGetFail) {
 
   EXPECT_THAT(msgget(key, 0), SyscallFailsWithErrno(ENOENT));
 
-  Queue queue(msgget(key, IPC_CREAT));
-  ASSERT_THAT(queue.get(), SyscallSucceeds());
-
+  Queue queue = ASSERT_NO_ERRNO_AND_VALUE(Msgget(key, IPC_CREAT));
   EXPECT_THAT(msgget(key, IPC_CREAT | IPC_EXCL), SyscallFailsWithErrno(EEXIST));
 }
 
 // Test using msgget(2) with IPC_PRIVATE option.
 TEST(MsgqueueTest, MsgGetIpcPrivate) {
-  Queue queue1(msgget(IPC_PRIVATE, 0));
-  ASSERT_THAT(queue1.get(), SyscallSucceeds());
-
-  Queue queue2(msgget(IPC_PRIVATE, 0));
-  ASSERT_THAT(queue2.get(), SyscallSucceeds());
-
+  Queue queue1 = ASSERT_NO_ERRNO_AND_VALUE(Msgget(IPC_PRIVATE, 0));
+  Queue queue2 = ASSERT_NO_ERRNO_AND_VALUE(Msgget(IPC_PRIVATE, 0));
   EXPECT_NE(queue1.get(), queue2.get());
 }
 
 // Test simple msgsnd and msgrcv.
 TEST(MsgqueueTest, MsgOpSimple) {
-  Queue queue(msgget(IPC_PRIVATE, 0600));
-  ASSERT_THAT(queue.get(), SyscallSucceeds());
+  Queue queue = ASSERT_NO_ERRNO_AND_VALUE(Msgget(IPC_PRIVATE, 0600));
 
   msgbuf buf{1, "A message."};
   msgbuf rcv;
@@ -138,8 +142,7 @@ TEST(MsgqueueTest, MsgOpSimple) {
 
 // Test msgsnd and msgrcv of an empty message.
 TEST(MsgqueueTest, MsgOpEmpty) {
-  Queue queue(msgget(IPC_PRIVATE, 0600));
-  ASSERT_THAT(queue.get(), SyscallSucceeds());
+  Queue queue = ASSERT_NO_ERRNO_AND_VALUE(Msgget(IPC_PRIVATE, 0600));
 
   msgbuf buf{1, ""};
   msgbuf rcv;
@@ -151,8 +154,7 @@ TEST(MsgqueueTest, MsgOpEmpty) {
 
 // Test truncation of message with MSG_NOERROR flag.
 TEST(MsgqueueTest, MsgOpTruncate) {
-  Queue queue(msgget(IPC_PRIVATE, 0600));
-  ASSERT_THAT(queue.get(), SyscallSucceeds());
+  Queue queue = ASSERT_NO_ERRNO_AND_VALUE(Msgget(IPC_PRIVATE, 0600));
 
   msgbuf buf{1, ""};
   msgbuf rcv;
@@ -166,8 +168,7 @@ TEST(MsgqueueTest, MsgOpTruncate) {
 
 // Test msgsnd and msgrcv using invalid arguments.
 TEST(MsgqueueTest, MsgOpInvalidArgs) {
-  Queue queue(msgget(IPC_PRIVATE, 0600));
-  ASSERT_THAT(queue.get(), SyscallSucceeds());
+  Queue queue = ASSERT_NO_ERRNO_AND_VALUE(Msgget(IPC_PRIVATE, 0600));
 
   msgbuf buf{1, ""};
 
@@ -184,8 +185,7 @@ TEST(MsgqueueTest, MsgOpInvalidArgs) {
 
 // Test non-blocking msgrcv with an empty queue.
 TEST(MsgqueueTest, MsgOpNoMsg) {
-  Queue queue(msgget(IPC_PRIVATE, 0600));
-  ASSERT_THAT(queue.get(), SyscallSucceeds());
+  Queue queue = ASSERT_NO_ERRNO_AND_VALUE(Msgget(IPC_PRIVATE, 0600));
 
   msgbuf rcv;
   EXPECT_THAT(msgrcv(queue.get(), &rcv, sizeof(rcv.mtext) + 1, 0, IPC_NOWAIT),
@@ -195,8 +195,7 @@ TEST(MsgqueueTest, MsgOpNoMsg) {
 // Test non-blocking msgrcv with a non-empty queue, but no messages of wanted
 // type.
 TEST(MsgqueueTest, MsgOpNoMsgType) {
-  Queue queue(msgget(IPC_PRIVATE, 0600));
-  ASSERT_THAT(queue.get(), SyscallSucceeds());
+  Queue queue = ASSERT_NO_ERRNO_AND_VALUE(Msgget(IPC_PRIVATE, 0600));
 
   msgbuf buf{1, ""};
   ASSERT_THAT(msgsnd(queue.get(), &buf, sizeof(buf.mtext), 0),
@@ -208,8 +207,7 @@ TEST(MsgqueueTest, MsgOpNoMsgType) {
 
 // Test msgrcv with a larger size message than wanted, and truncation disabled.
 TEST(MsgqueueTest, MsgOpTooBig) {
-  Queue queue(msgget(IPC_PRIVATE, 0600));
-  ASSERT_THAT(queue.get(), SyscallSucceeds());
+  Queue queue = ASSERT_NO_ERRNO_AND_VALUE(Msgget(IPC_PRIVATE, 0600));
 
   msgbuf buf{1, ""};
   ASSERT_THAT(msgsnd(queue.get(), &buf, sizeof(buf.mtext), 0),
@@ -221,8 +219,7 @@ TEST(MsgqueueTest, MsgOpTooBig) {
 
 // Test receiving messages based on type.
 TEST(MsgqueueTest, MsgRcvType) {
-  Queue queue(msgget(IPC_PRIVATE, 0600));
-  ASSERT_THAT(queue.get(), SyscallSucceeds());
+  Queue queue = ASSERT_NO_ERRNO_AND_VALUE(Msgget(IPC_PRIVATE, 0600));
 
   // Send messages in an order and receive them in reverse, based on type,
   // which shouldn't block.
@@ -248,8 +245,7 @@ TEST(MsgqueueTest, MsgRcvType) {
 
 // Test using MSG_EXCEPT to receive a different-type message.
 TEST(MsgqueueTest, MsgExcept) {
-  Queue queue(msgget(IPC_PRIVATE, 0600));
-  ASSERT_THAT(queue.get(), SyscallSucceeds());
+  Queue queue = ASSERT_NO_ERRNO_AND_VALUE(Msgget(IPC_PRIVATE, 0600));
 
   std::map<int64_t, msgbuf> typeToBuf = {
       {1, msgbuf{1, "Message 1."}},
@@ -274,8 +270,7 @@ TEST(MsgqueueTest, MsgExcept) {
 
 // Test msgrcv with a negative type.
 TEST(MsgqueueTest, MsgRcvTypeNegative) {
-  Queue queue(msgget(IPC_PRIVATE, 0600));
-  ASSERT_THAT(queue.get(), SyscallSucceeds());
+  Queue queue = ASSERT_NO_ERRNO_AND_VALUE(Msgget(IPC_PRIVATE, 0600));
 
   //  When msgtyp is negative, msgrcv returns the first message with mtype less
   //  than or equal to the absolute value.
@@ -298,8 +293,7 @@ TEST(MsgqueueTest, MsgRcvTypeNegative) {
 TEST(MsgqueueTest, MsgOpPermissions) {
   AutoCapability cap(CAP_IPC_OWNER, false);
 
-  Queue queue(msgget(IPC_PRIVATE, 0000));
-  ASSERT_THAT(queue.get(), SyscallSucceeds());
+  Queue queue = ASSERT_NO_ERRNO_AND_VALUE(Msgget(IPC_PRIVATE, 0000));
 
   msgbuf buf{1, ""};
 
@@ -311,8 +305,7 @@ TEST(MsgqueueTest, MsgOpPermissions) {
 
 // Test limits for messages and queues.
 TEST(MsgqueueTest, MsgOpLimits) {
-  Queue queue(msgget(IPC_PRIVATE, 0600));
-  ASSERT_THAT(queue.get(), SyscallSucceeds());
+  Queue queue = ASSERT_NO_ERRNO_AND_VALUE(Msgget(IPC_PRIVATE, 0600));
 
   msgbuf buf{1, "A message."};
 
@@ -340,11 +333,14 @@ bool MsgCopySupported() {
   // test if errno == ENOSYS. This means that the test will always run on
   // gVisor, but may be skipped on native linux.
 
-  Queue queue(msgget(IPC_PRIVATE, 0600));
-
+  auto maybe_id = Msgget(IPC_PRIVATE, 0600);
+  if (!maybe_id.ok()) {
+    return false;
+  }
+  Queue queue(std::move(maybe_id.ValueOrDie()));
   msgbuf buf{1, "Test message."};
-  msgsnd(queue.get(), &buf, sizeof(buf.mtext), 0);
 
+  msgsnd(queue.get(), &buf, sizeof(buf.mtext), 0);
   return !(msgrcv(queue.get(), &buf, sizeof(buf.mtext) + 1, 0,
                   MSG_COPY | IPC_NOWAIT) == -1 &&
            errno == ENOSYS);
@@ -354,9 +350,7 @@ bool MsgCopySupported() {
 TEST(MsgqueueTest, MsgCopy) {
   SKIP_IF(!MsgCopySupported());
 
-  Queue queue(msgget(IPC_PRIVATE, 0600));
-  ASSERT_THAT(queue.get(), SyscallSucceeds());
-
+  Queue queue = ASSERT_NO_ERRNO_AND_VALUE(Msgget(IPC_PRIVATE, 0600));
   msgbuf bufs[5] = {
       msgbuf{1, "Message 1."}, msgbuf{2, "Message 2."}, msgbuf{3, "Message 3."},
       msgbuf{4, "Message 4."}, msgbuf{5, "Message 5."},
@@ -390,9 +384,7 @@ TEST(MsgqueueTest, MsgCopy) {
 TEST(MsgqueueTest, MsgCopyInvalidArgs) {
   SKIP_IF(!MsgCopySupported());
 
-  Queue queue(msgget(IPC_PRIVATE, 0600));
-  ASSERT_THAT(queue.get(), SyscallSucceeds());
-
+  Queue queue = ASSERT_NO_ERRNO_AND_VALUE(Msgget(IPC_PRIVATE, 0600));
   msgbuf rcv;
   EXPECT_THAT(msgrcv(queue.get(), &rcv, msgSize, 1, MSG_COPY),
               SyscallFailsWithErrno(EINVAL));
@@ -406,9 +398,7 @@ TEST(MsgqueueTest, MsgCopyInvalidArgs) {
 TEST(MsgqueueTest, MsgCopyInvalidIndex) {
   SKIP_IF(!MsgCopySupported());
 
-  Queue queue(msgget(IPC_PRIVATE, 0600));
-  ASSERT_THAT(queue.get(), SyscallSucceeds());
-
+  Queue queue = ASSERT_NO_ERRNO_AND_VALUE(Msgget(IPC_PRIVATE, 0600));
   msgbuf rcv;
   EXPECT_THAT(msgrcv(queue.get(), &rcv, msgSize, -3, MSG_COPY | IPC_NOWAIT),
               SyscallFailsWithErrno(ENOMSG));
@@ -419,9 +409,7 @@ TEST(MsgqueueTest, MsgCopyInvalidIndex) {
 
 // Test msgrcv (most probably) blocking on an empty queue.
 TEST(MsgqueueTest, MsgRcvBlocking) {
-  Queue queue(msgget(IPC_PRIVATE, 0600));
-  ASSERT_THAT(queue.get(), SyscallSucceeds());
-
+  Queue queue = ASSERT_NO_ERRNO_AND_VALUE(Msgget(IPC_PRIVATE, 0600));
   msgbuf buf{1, "A message."};
 
   ScopedThread t([&] {
@@ -441,9 +429,7 @@ TEST(MsgqueueTest, MsgRcvBlocking) {
 
 // Test msgrcv (most probably) waiting for a specific-type message.
 TEST(MsgqueueTest, MsgRcvTypeBlocking) {
-  Queue queue(msgget(IPC_PRIVATE, 0600));
-  ASSERT_THAT(queue.get(), SyscallSucceeds());
-
+  Queue queue = ASSERT_NO_ERRNO_AND_VALUE(Msgget(IPC_PRIVATE, 0600));
   msgbuf bufs[5] = {{1, "A message."},
                     {1, "A message."},
                     {1, "A message."},
@@ -471,9 +457,7 @@ TEST(MsgqueueTest, MsgRcvTypeBlocking) {
 
 // Test msgsnd (most probably) blocking on a full queue.
 TEST(MsgqueueTest, MsgSndBlocking) {
-  Queue queue(msgget(IPC_PRIVATE, 0600));
-  ASSERT_THAT(queue.get(), SyscallSucceeds());
-
+  Queue queue = ASSERT_NO_ERRNO_AND_VALUE(Msgget(IPC_PRIVATE, 0600));
   msgmax buf{1, ""};  // Has max amount of bytes.
 
   const size_t msgCount = msgMnb / msgMax;  // Number of messages that can be
@@ -512,8 +496,7 @@ TEST(MsgqueueTest, MsgSndBlocking) {
 
 // Test removing a queue while a blocking msgsnd is executing.
 TEST(MsgqueueTest, MsgSndRmWhileBlocking) {
-  Queue queue(msgget(IPC_PRIVATE, 0600));
-  ASSERT_THAT(queue.get(), SyscallSucceeds());
+  Queue queue = ASSERT_NO_ERRNO_AND_VALUE(Msgget(IPC_PRIVATE, 0600));
 
   // Number of messages that can be sent without blocking.
   const size_t msgCount = msgMnb / msgMax;
@@ -549,8 +532,7 @@ TEST(MsgqueueTest, MsgSndRmWhileBlocking) {
 
 // Test removing a queue while a blocking msgrcv is executing.
 TEST(MsgqueueTest, MsgRcvRmWhileBlocking) {
-  Queue queue(msgget(IPC_PRIVATE, 0600));
-  ASSERT_THAT(queue.get(), SyscallSucceeds());
+  Queue queue = ASSERT_NO_ERRNO_AND_VALUE(Msgget(IPC_PRIVATE, 0600));
 
   ScopedThread t([&] {
     // Because we're repeating on EINTR, msgsnd may race with msgctl(IPC_RMID)
@@ -568,8 +550,7 @@ TEST(MsgqueueTest, MsgRcvRmWhileBlocking) {
 
 // Test a collection of msgsnd/msgrcv operations in different processes.
 TEST(MsgqueueTest, MsgOpGeneral) {
-  Queue queue(msgget(IPC_PRIVATE, 0600));
-  ASSERT_THAT(queue.get(), SyscallSucceeds());
+  Queue queue = ASSERT_NO_ERRNO_AND_VALUE(Msgget(IPC_PRIVATE, 0600));
 
   // Create multiple sending/receiving threads that send messages back and
   // forth. There's a matching recv for each send, so by the end of the test,
@@ -625,7 +606,7 @@ TEST(MsgqueueTest, MsgOpGeneral) {
 void empty_sighandler(int sig, siginfo_t* info, void* context) {}
 
 TEST(MsgqueueTest, InterruptRecv) {
-  Queue queue(msgget(IPC_PRIVATE, 0600));
+  Queue queue = ASSERT_NO_ERRNO_AND_VALUE(Msgget(IPC_PRIVATE, 0600));
   char buf[64];
 
   absl::Notification done, exit;
@@ -663,7 +644,7 @@ TEST(MsgqueueTest, InterruptRecv) {
 }
 
 TEST(MsgqueueTest, InterruptSend) {
-  Queue queue(msgget(IPC_PRIVATE, 0600));
+  Queue queue = ASSERT_NO_ERRNO_AND_VALUE(Msgget(IPC_PRIVATE, 0600));
   msgmax buf{1, ""};
   // Number of messages that can be sent without blocking.
   const size_t msgCount = msgMnb / msgMax;