Implement BodyReader::read() method and add corresponding tests for content-length reading

Author: yhirose

httplib.h

@@ -7177,11 +7177,34 @@ inline ssize_t Stream::write(const std::string &s) {
   return write(s.data(), s.size());
 }
 
-// BodyReader implementation (stub for Phase 2.2, full impl in Phase 2.3)
+// BodyReader implementation
 inline ssize_t detail::BodyReader::read(char *buf, size_t len) {
-  (void)buf;
-  (void)len;
-  // TODO: Implement in Phase 2.3
+  if (!stream) { return -1; }
+  if (eof) { return 0; }
+
+  if (!chunked) {
+    // Content-Length based reading
+    if (bytes_read >= content_length) {
+      eof = true;
+      return 0;
+    }
+
+    auto remaining = content_length - bytes_read;
+    auto to_read = (std::min)(len, remaining);
+    auto n = stream->read(buf, to_read);
+
+    if (n <= 0) {
+      eof = true;
+      return n;
+    }
+
+    bytes_read += static_cast<size_t>(n);
+    if (bytes_read >= content_length) { eof = true; }
+    return n;
+  }
+
+  // TODO: Chunked transfer encoding (Phase 2.3 extension)
+  // For now, return error for chunked
   return -1;
 }
 

test/test20.cc

@@ -585,3 +585,111 @@ TEST(BodyReaderTest, InitializeAsChunked) {
   EXPECT_TRUE(reader.chunked);
   EXPECT_EQ(0u, reader.content_length);
 }
+
+//------------------------------------------------------------------------------
+// Phase 2.3: BodyReader::read() tests
+//------------------------------------------------------------------------------
+
+// Mock stream for testing BodyReader
+class MockStream : public httplib::Stream {
+public:
+  explicit MockStream(const std::string &data) : data_(data), pos_(0) {}
+
+  bool is_readable() const override { return pos_ < data_.size(); }
+  bool wait_readable() const override { return is_readable(); }
+  bool wait_writable() const override { return true; }
+
+  ssize_t read(char *ptr, size_t size) override {
+    if (pos_ >= data_.size()) return 0;
+    size_t to_read = std::min(size, data_.size() - pos_);
+    std::memcpy(ptr, data_.data() + pos_, to_read);
+    pos_ += to_read;
+    return static_cast<ssize_t>(to_read);
+  }
+
+  ssize_t write(const char *, size_t) override { return -1; }
+
+  void get_remote_ip_and_port(std::string &ip, int &port) const override {
+    ip = "127.0.0.1";
+    port = 0;
+  }
+
+  void get_local_ip_and_port(std::string &ip, int &port) const override {
+    ip = "127.0.0.1";
+    port = 0;
+  }
+
+  socket_t socket() const override { return INVALID_SOCKET; }
+  time_t duration() const override { return 0; }
+
+private:
+  std::string data_;
+  size_t pos_;
+};
+
+TEST(BodyReaderTest, ReadWithContentLength) {
+  std::string body = "Hello, World!";
+  MockStream stream(body);
+
+  httplib::detail::BodyReader reader;
+  reader.stream = &stream;
+  reader.content_length = body.size();
+  reader.chunked = false;
+
+  char buf[32];
+  auto n = reader.read(buf, sizeof(buf));
+
+  EXPECT_EQ(static_cast<ssize_t>(body.size()), n);
+  EXPECT_EQ(body, std::string(buf, static_cast<size_t>(n)));
+  EXPECT_EQ(body.size(), reader.bytes_read);
+}
+
+TEST(BodyReaderTest, ReadWithContentLengthPartial) {
+  std::string body = "Hello, World!";
+  MockStream stream(body);
+
+  httplib::detail::BodyReader reader;
+  reader.stream = &stream;
+  reader.content_length = body.size();
+  reader.chunked = false;
+
+  // Read in small chunks
+  char buf[5];
+  std::string result;
+
+  ssize_t n;
+  while ((n = reader.read(buf, sizeof(buf))) > 0) {
+    result.append(buf, static_cast<size_t>(n));
+  }
+
+  EXPECT_EQ(body, result);
+  EXPECT_TRUE(reader.eof);
+}
+
+TEST(BodyReaderTest, ReadReturnsZeroAtEOF) {
+  std::string body = "Hi";
+  MockStream stream(body);
+
+  httplib::detail::BodyReader reader;
+  reader.stream = &stream;
+  reader.content_length = body.size();
+  reader.chunked = false;
+
+  char buf[32];
+  reader.read(buf, sizeof(buf)); // Read all
+
+  // Next read should return 0
+  auto n = reader.read(buf, sizeof(buf));
+  EXPECT_EQ(0, n);
+  EXPECT_TRUE(reader.eof);
+}
+
+TEST(BodyReaderTest, ReadWithoutStream) {
+  httplib::detail::BodyReader reader;
+  reader.stream = nullptr;
+
+  char buf[32];
+  auto n = reader.read(buf, sizeof(buf));
+
+  EXPECT_EQ(-1, n);
+}