Define rtc::BufferT, like rtc::Buffer but for any trivial type

webrtc/base/buffer_unittest.cc

Index: webrtc/base/buffer_unittest.cc
diff --git a/webrtc/base/buffer_unittest.cc b/webrtc/base/buffer_unittest.cc
index 2f3bcfd6060ad8afe5c4ed8563badddd82ca3ee4..925ba29a54c405e9ec292daf1ed3f55f266010c7 100644
--- a/webrtc/base/buffer_unittest.cc
+++ b/webrtc/base/buffer_unittest.cc
@@ -11,8 +11,8 @@
 #include "webrtc/base/buffer.h"
 #include "webrtc/base/gunit.h"
 
-#include <algorithm>  // std::swap (pre-C++11)
-#include <utility>  // std::swap (C++11 and later)
+#include <type_traits>
+#include <utility>
 
 namespace rtc {
 
@@ -301,4 +301,60 @@ TEST(BufferTest, TestBracketWrite) {
   }
 }
 
+TEST(BufferTest, TestInt16) {
+  static constexpr int16_t test_data[] = {14, 15, 16, 17, 18};
+  BufferT<int16_t> buf(test_data);
+  EXPECT_EQ(buf.size(), 5u);
+  EXPECT_EQ(buf.capacity(), 5u);
+  EXPECT_NE(buf.data(), nullptr);
+  for (size_t i = 0; i != buf.size(); ++i) {
+    EXPECT_EQ(test_data[i], buf[i]);
+  }
+  BufferT<int16_t> buf2(test_data);
+  EXPECT_EQ(buf, buf2);
+  buf2[0] = 9;
+  EXPECT_NE(buf, buf2);
+}
+
+TEST(BufferTest, TestFloat) {
+  static constexpr float test_data[] = {14, 15, 16, 17, 18};
+  BufferT<float> buf;
+  EXPECT_EQ(buf.size(), 0u);
+  EXPECT_EQ(buf.capacity(), 0u);
+  EXPECT_EQ(buf.data(), nullptr);
+  buf.SetData(test_data);
+  EXPECT_EQ(buf.size(), 5u);
+  EXPECT_EQ(buf.capacity(), 5u);
+  EXPECT_NE(buf.data(), nullptr);
+  float* p1 = buf.data();
+  while (buf.data() == p1) {
+    buf.AppendData(test_data);
+  }
+  EXPECT_EQ(buf.size(), buf.capacity());
+  EXPECT_GT(buf.size(), 5u);
+  EXPECT_EQ(buf.size() % 5, 0u);
+  EXPECT_NE(buf.data(), nullptr);
+  for (size_t i = 0; i != buf.size(); ++i) {
+    EXPECT_EQ(test_data[i % 5], buf[i]);
+  }
+}
+
+TEST(BufferTest, TestStruct) {
+  struct BloodStone {
+    bool blood;
+    const char* stone;
+  };
+  BufferT<BloodStone> buf(4);
+  EXPECT_EQ(buf.size(), 4u);
+  EXPECT_EQ(buf.capacity(), 4u);
+  EXPECT_NE(buf.data(), nullptr);
+  BufferT<BloodStone*> buf2(4);
+  for (size_t i = 0; i < buf2.size(); ++i) {
+    buf2[i] = &buf[i];
+  }
+  static const char* kObsidian = "obsidian";

[tommi, 2016/04/28 22:49:08]

nit: static const char kObsidian[] = "obsidian"

[kwiberg-webrtc, 2016/04/29 00:00:19]

OK, I guess, but why?

[tommi, 2016/04/29 07:46:38]

It doesn't matter much here since it's a unit test. There are couple of reasons
+ consistency.
1)  The space allocated for |*kObsidian = "obsidian"| is sizeof(char*) +
sizeof("obsidian").  The for the [] case, allocating space for the pointer isn't
needed since the constant is the value (and not a pointer to the value).
2) arraysize(kFoo) returns the size of the array, not the pointer.
3) Because of the above, we try to be consistent with doing it the same way all
over.

Since you don't need or care about the first two in this particular test, I
guess only 3 would apply and that's why just mentioned it as a nit.

[kwiberg-webrtc, 2016/04/29 07:51:47]

OK, those are definitely very good reasons. Thanks.

+  buf2[2]->stone = kObsidian;

[tommi, 2016/04/28 22:49:08]

nit: and while this will continue to work, I guess &kObsidian[0] would then be
the technically correct syntax.

[kwiberg-webrtc, 2016/04/29 00:00:19]

The current version works too, because of array-to-pointer decay.

[tommi, 2016/04/29 07:46:38]

yup, that's what I meant by "will continue to work"

+  EXPECT_EQ(kObsidian, buf[2].stone);
+}
+
 }  // namespace rtc