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

webrtc/base/buffer_unittest.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #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 {
 
 namespace {
 
 // clang-format off
 const uint8_t kTestData[] = {0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7,
                              0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf};
 // clang-format on
 
@@ skipping 268 matching lines @@
 
   for (size_t i = 0; i != 7u; ++i) {
     buf[i] = kTestData[i];
   }
 
   for (size_t i = 0; i != 7u; ++i) {
     EXPECT_EQ(buf[i], kTestData[i]);
   }
 }
 
+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