Travel3: Simple image and video display site

Reads the images and videos from filesystem and builds a site in
memroy.

1 files changed, 282 insertions, 0 deletions

diff --git a/test/test_buffer.cc b/test/test_buffer.cc
new file mode 100644
index 0000000..f1623c6
--- /dev/null
+++ b/test/test_buffer.cc
@@ -0,0 +1,282 @@
+#include "common.hh"
+
+#include <algorithm>
+#include <gtest/gtest.h>
+
+#include "buffer.hh"
+
+TEST(buffer, fixed) {
+  auto buf = Buffer::fixed(10);
+  EXPECT_TRUE(buf->empty());
+  EXPECT_FALSE(buf->full());
+  size_t avail;
+  buf->rbuf(0, avail);
+  EXPECT_EQ(0, avail);
+  buf->wbuf(1, avail);
+  EXPECT_GE(avail, 1);
+  auto* wptr = buf->wbuf(100, avail);
+  EXPECT_EQ(10, avail);
+  avail = std::min(static_cast<size_t>(5), avail);
+  std::fill_n(wptr, avail, 'A');
+  buf->wcommit(avail);
+  EXPECT_FALSE(buf->empty());
+  EXPECT_FALSE(buf->full());
+  auto* rptr = buf->rbuf(0, avail);
+  EXPECT_EQ(5, avail);
+  for (size_t i = 0; i < avail; ++i)
+    EXPECT_EQ('A', rptr[i]) << i;
+  buf->rcommit(2);
+  wptr = buf->wbuf(7, avail);
+  EXPECT_EQ(7, avail);
+  avail = std::min(static_cast<size_t>(7), avail);
+  std::fill_n(wptr, avail, 'B');
+  buf->wcommit(avail);
+  EXPECT_FALSE(buf->empty());
+  EXPECT_TRUE(buf->full());
+  rptr = buf->rbuf(0, avail);
+  EXPECT_EQ(10, avail);
+  for (size_t i = 0; i < avail; ++i)
+    EXPECT_EQ(i < 3 ? 'A' : 'B', rptr[i]) << i;
+  buf->rcommit(5);
+  EXPECT_FALSE(buf->empty());
+  EXPECT_FALSE(buf->full());
+  wptr = buf->wbuf(5, avail);
+  EXPECT_EQ(5, avail);
+  avail = std::min(static_cast<size_t>(5), avail);
+  std::fill_n(wptr, avail, 'C');
+  buf->wcommit(avail);
+  EXPECT_FALSE(buf->empty());
+  EXPECT_TRUE(buf->full());
+  rptr = buf->rbuf(0, avail);
+  if (avail == 10) {
+    for (size_t i = 0; i < avail; ++i)
+      EXPECT_EQ(i < 5 ? 'B' : 'C', rptr[i]) << i;
+    buf->rcommit(10);
+  } else {
+    EXPECT_EQ(5, avail);
+    for (size_t i = 0; i < avail; ++i)
+      EXPECT_EQ('B', rptr[i]) << i;
+    buf->rcommit(5);
+    rptr = buf->rbuf(0, avail);
+    EXPECT_EQ(5, avail);
+    for (size_t i = 0; i < avail; ++i)
+      EXPECT_EQ('C', rptr[i]) << i;
+    buf->rcommit(5);
+  }
+  buf->rcommit(0);
+  EXPECT_TRUE(buf->empty());
+  EXPECT_FALSE(buf->full());
+
+  buf->wbuf(10, avail);
+  EXPECT_EQ(10, avail);
+  buf->wcommit(10);
+  buf->wbuf(10, avail);
+  EXPECT_EQ(0, avail);
+  buf->wcommit(0);
+  buf->clear();
+  buf->wbuf(10, avail);
+  EXPECT_EQ(10, avail);
+}
+
+TEST(buffer, growing) {
+  auto buf = Buffer::growing(5, 50);
+  EXPECT_TRUE(buf->empty());
+  EXPECT_FALSE(buf->full());
+  size_t avail;
+  buf->rbuf(0, avail);
+  EXPECT_EQ(0, avail);
+  buf->wbuf(1, avail);
+  EXPECT_GE(avail, 1);
+  auto* wptr = buf->wbuf(100, avail);
+  EXPECT_EQ(50, avail);
+  avail = std::min(static_cast<size_t>(5), avail);
+  std::fill_n(wptr, avail, 'A');
+  buf->wcommit(avail);
+  EXPECT_FALSE(buf->empty());
+  EXPECT_FALSE(buf->full());
+  auto* rptr = buf->rbuf(0, avail);
+  EXPECT_EQ(5, avail);
+  for (size_t i = 0; i < avail; ++i)
+    EXPECT_EQ('A', rptr[i]) << i;
+  buf->rcommit(2);
+  wptr = buf->wbuf(7, avail);
+  EXPECT_GE(avail, 7);
+  avail = std::min(static_cast<size_t>(7), avail);
+  std::fill_n(wptr, avail, 'B');
+  buf->wcommit(avail);
+  EXPECT_FALSE(buf->empty());
+  EXPECT_FALSE(buf->full());
+  rptr = buf->rbuf(0, avail);
+  EXPECT_EQ(10, avail);
+  for (size_t i = 0; i < avail; ++i)
+    EXPECT_EQ(i < 3 ? 'A' : 'B', rptr[i]) << i;
+  buf->rcommit(5);
+  EXPECT_FALSE(buf->empty());
+  EXPECT_FALSE(buf->full());
+  wptr = buf->wbuf(5, avail);
+  EXPECT_GE(avail, 5);
+  avail = std::min(static_cast<size_t>(5), avail);
+  std::fill_n(wptr, avail, 'C');
+  buf->wcommit(avail);
+  EXPECT_FALSE(buf->empty());
+  EXPECT_FALSE(buf->full());
+  rptr = buf->rbuf(0, avail);
+  EXPECT_EQ(10, avail);
+  for (size_t i = 0; i < avail; ++i)
+    EXPECT_EQ(i < 5 ? 'B' : 'C', rptr[i]) << i;
+  buf->rcommit(10);
+  buf->rcommit(0);
+  EXPECT_TRUE(buf->empty());
+  EXPECT_FALSE(buf->full());
+
+  buf->wbuf(50, avail);
+  EXPECT_EQ(50, avail);
+  buf->wcommit(50);
+  buf->wbuf(50, avail);
+  EXPECT_EQ(0, avail);
+  buf->wcommit(0);
+  buf->clear();
+  buf->wbuf(5, avail);
+  EXPECT_GE(avail, 5);
+  buf->wcommit(5);
+  buf->rbuf(0, avail);
+  EXPECT_EQ(5, avail);
+  buf->rcommit(3);
+  buf->wbuf(3, avail);
+  EXPECT_GE(avail, 3);
+}
+
+TEST(buffer, fixed_want) {
+  auto buf = Buffer::fixed(10);
+
+  size_t avail;
+  auto* wptr = buf->wbuf(10, avail);
+  ASSERT_EQ(10, avail);
+  std::fill_n(wptr, 10, 'a');
+  buf->wcommit(10);
+
+  auto* rptr = buf->rbuf(0, avail);
+  ASSERT_EQ(10, avail);
+  for (size_t i = 0; i < avail; ++i)
+    EXPECT_EQ('a', rptr[i]) << i;
+  buf->rcommit(5);
+
+  wptr = buf->wbuf(5, avail);
+  ASSERT_EQ(5, avail);
+  std::fill_n(wptr, 5, 'b');
+  buf->wcommit(5);
+
+  buf->rbuf(0, avail);
+  ASSERT_EQ(5, avail);
+
+  buf->rbuf(10, avail);
+  ASSERT_EQ(10, avail);
+  for (size_t i = 0; i < avail; ++i)
+    EXPECT_EQ(i < 5 ? 'a' : 'b', rptr[i]) << i;
+  buf->rcommit(10);
+
+  EXPECT_TRUE(buf->empty());
+
+  wptr = buf->wbuf(10, avail);
+  ASSERT_EQ(10, avail);
+  std::fill_n(wptr, 10, 'a');
+  buf->wcommit(10);
+
+  buf->rcommit(5);
+
+  wptr = buf->wbuf(3, avail);
+  ASSERT_EQ(5, avail);
+  std::fill_n(wptr, 3, 'b');
+  buf->wcommit(3);
+
+  buf->rbuf(0, avail);
+  ASSERT_EQ(5, avail);
+
+  buf->rbuf(10, avail);
+  ASSERT_EQ(8, avail);
+  for (size_t i = 0; i < avail; ++i)
+    EXPECT_EQ(i < 5 ? 'a' : 'b', rptr[i]) << i;
+  buf->rcommit(8);
+}
+
+TEST(buffer, read) {
+  auto buf = Buffer::fixed(10);
+  size_t avail;
+  auto* wptr = buf->wbuf(10, avail);
+  ASSERT_EQ(10, avail);
+  std::fill_n(wptr, 5, 'a');
+  std::fill_n(wptr + 5, 5, 'b');
+  buf->wcommit(10);
+
+  char tmp[5];
+  size_t got = Buffer::read(buf.get(), tmp, 0);
+  EXPECT_EQ(0, got);
+  got = Buffer::read(buf.get(), tmp, 5);
+  ASSERT_EQ(5, got);
+  for (size_t i = 0; i < 5; ++i)
+    EXPECT_EQ('a', tmp[i]) << i;
+
+  got = Buffer::read(buf.get(), tmp, 3);
+  ASSERT_EQ(3, got);
+  got = Buffer::read(buf.get(), tmp + 3, 10);
+  ASSERT_EQ(2, got);
+  for (size_t i = 0; i < 5; ++i)
+    EXPECT_EQ('b', tmp[i]) << i;
+
+  got = Buffer::read(buf.get(), tmp, 5);
+  EXPECT_EQ(0, got);
+}
+
+TEST(buffer, write) {
+  char tmp[10];
+  std::fill_n(tmp, 5, 'a');
+  std::fill_n(tmp + 5, 5, 'b');
+
+  auto buf = Buffer::growing(5, 10);
+  auto got = Buffer::write(buf.get(), tmp, 0);
+  EXPECT_EQ(0, got);
+  got = Buffer::write(buf.get(), tmp, 2);
+  EXPECT_EQ(2, got);
+  got = Buffer::write(buf.get(), tmp + 2, 5);
+  EXPECT_EQ(5, got);
+  got = Buffer::write(buf.get(), tmp + 7, 10);
+  EXPECT_EQ(3, got);
+
+  char tmp2[10];
+  got = Buffer::read(buf.get(), tmp2, 10);
+  EXPECT_EQ(10, got);
+
+  for (size_t i = 0; i < 10; ++i)
+    EXPECT_EQ(tmp[i], tmp2[i]) << i;
+}
+
+TEST(buffer, growing_full) {
+  char tmp[10];
+  std::fill_n(tmp, 10, 'x');
+  auto buf = Buffer::growing(5, 10);
+  Buffer::write(buf.get(), tmp, 10);
+  EXPECT_TRUE(buf->full());
+  char tmp2[1];
+  auto got = Buffer::read(buf.get(), tmp2, 1);
+  EXPECT_EQ('x', tmp2[0]);
+  EXPECT_EQ(1, got);
+  EXPECT_FALSE(buf->full());
+}
+
+TEST(buffer, null) {
+  auto buf = Buffer::null();
+  EXPECT_FALSE(buf->full());
+  EXPECT_TRUE(buf->empty());
+  size_t avail;
+  buf->rbuf(1, avail);
+  EXPECT_EQ(0, avail);
+  auto* ptr = buf->wbuf(65536, avail);
+  ASSERT_GE(avail, 1);
+  ptr[0] = 'x';
+  buf->wcommit(1);
+  EXPECT_TRUE(buf->empty());
+  buf->rbuf(1, avail);
+  EXPECT_EQ(0, avail);
+  buf->rcommit(0);
+  buf->clear();
+}