commit 4aec6d10d8b0d4f00f4588ae07e4f2a75003794a
author William A. Kennington III <wak@google.com> Mon Jan 08 15:28:34 2024 -0800
committer William A. Kennington III <wak@google.com> Wed Jan 10 13:26:05 2024 -0800
tree e14e88495a9dfea259a7baa92e19d62953683cab
parent 4829c9db9df845e3f5b6d1e491f6b16a6c7ab36c

fd/ops: Add readAllExact()

This is a minor shortcut for `readAllFixed` which requires the entire
input to be read exactly.

Change-Id: Ia1208099ef71d2045050eae1483f8ee0b13c7033
Signed-off-by: William A. Kennington III <wak@google.com>

include-fd/stdplus/fd/ops.hpp

diff --git a/include-fd/stdplus/fd/ops.hpp b/include-fd/stdplus/fd/ops.hpp
index 53380d3..20395ab 100644
--- a/include-fd/stdplus/fd/ops.hpp
+++ b/include-fd/stdplus/fd/ops.hpp
@@ -36,6 +36,8 @@
                                        std::span<const std::byte> data,
                                        SendFlags flags);
 
+void verifyExact(size_t expected, size_t actual);
+
 template <typename Fun, typename Container, typename... Args>
 auto alignedOp(Fun&& fun, Fd& fd, Container&& c, Args&&... args)
 {
@@ -126,6 +128,13 @@
 }
 
 template <typename T>
+inline auto readAllExact(Fd& fd, T&& t)
+{
+    auto s = raw::asSpan<std::byte>(t);
+    detail::verifyExact(s.size(), detail::readAllFixed(fd, 1, s).size());
+}
+
+template <typename T>
 inline void recvExact(Fd& fd, T&& t, RecvFlags flags = {})
 {
     detail::recvExact(fd, raw::asSpan<std::byte>(t), flags);

src/fd/ops.cpp

diff --git a/src/fd/ops.cpp b/src/fd/ops.cpp
index d05e9b2..ca549f7 100644
--- a/src/fd/ops.cpp
+++ b/src/fd/ops.cpp
@@ -226,6 +226,14 @@
     }
 }
 
+void verifyExact(size_t expected, size_t actual)
+{
+    if (expected != actual)
+    {
+        throw exception::WouldBlock("verifyExact");
+    }
+}
+
 } // namespace detail
 } // namespace fd
 } // namespace stdplus

test/fd/ops.cpp

diff --git a/test/fd/ops.cpp b/test/fd/ops.cpp
index 708a0ff..3fc511c 100644
--- a/test/fd/ops.cpp
+++ b/test/fd/ops.cpp
@@ -352,4 +352,61 @@
     EXPECT_THROW(readAllFixed(fd, buf), std::system_error);
 }
 
+TEST(ReadAllExact, FailEmpty)
+{
+    testing::StrictMock<FdMock> fd;
+    {
+        testing::InSequence seq;
+        EXPECT_CALL(fd, read(_))
+            .WillRepeatedly(testing::Throw(exception::Eof("test")));
+    }
+    std::array<char, 16> buf;
+    EXPECT_THROW(readAllExact(fd, buf), std::system_error);
+}
+
+TEST(ReadAllExact, FailPartial)
+{
+    testing::StrictMock<FdMock> fd;
+    {
+        testing::InSequence seq;
+        EXPECT_CALL(fd, read(SizeIs(Ge(4)))).WillOnce(readSv("alph"));
+        EXPECT_CALL(fd, read(SizeIs(Ge(2)))).WillOnce(readSv("a "));
+        EXPECT_CALL(fd, read(SizeIs(Ge(3)))).WillOnce(readSv("one"));
+        EXPECT_CALL(fd, read(_))
+            .WillRepeatedly(testing::Throw(exception::Eof("test")));
+    }
+    std::array<char, 16> buf;
+    EXPECT_THROW(readAllExact(fd, buf), std::system_error);
+}
+
+TEST(ReadAllExact, Success)
+{
+    testing::StrictMock<FdMock> fd;
+    {
+        testing::InSequence seq;
+        EXPECT_CALL(fd, read(SizeIs(Ge(4)))).WillOnce(readSv("alph"));
+        EXPECT_CALL(fd, read(SizeIs(Ge(2)))).WillOnce(readSv("a "));
+        EXPECT_CALL(fd, read(SizeIs(Ge(10)))).WillOnce(readSv("one tenner"));
+        EXPECT_CALL(fd, read(_))
+            .WillRepeatedly(testing::Throw(exception::Eof("test")));
+    }
+    std::array<char, 16> buf;
+    readAllExact(fd, buf);
+    EXPECT_EQ(std::string_view(buf.begin(), buf.end()), "alpha one tenner");
+}
+
+TEST(ReadAllExact, TooMuch)
+{
+    testing::StrictMock<FdMock> fd;
+    {
+        testing::InSequence seq;
+        EXPECT_CALL(fd, read(SizeIs(Ge(4)))).WillOnce(readSv("alph"));
+        EXPECT_CALL(fd, read(SizeIs(Ge(2)))).WillOnce(readSv("a "));
+        EXPECT_CALL(fd, read(SizeIs(Ge(10)))).WillOnce(readSv("one tenner"));
+        EXPECT_CALL(fd, read(SizeIs(Ge(1)))).WillOnce(readSv("r"));
+    }
+    std::array<char, 16> buf;
+    EXPECT_THROW(readAllExact(fd, buf), std::system_error);
+}
+
 } // namespace stdplus::fd