tests/test_builder.h

   1 #ifndef TEST_BUILDER_H
   2 #define TEST_BUILDER_H
   3
   4 #include <set>
   5 #include <type_traits>
   6 #include "monster_test_generated.h"
   7 #include "flatbuffers/flatbuffers.h"
   8 #include "test_assert.h"
   9
  10 using MyGame::Example::Color;
  11 using MyGame::Example::Monster;
  12
  13 namespace flatbuffers {
  14 namespace grpc {
  15 class MessageBuilder;
  16 }
  17 }
  18
  19 template <class T, class U>
  20 struct is_same {
  21   static const bool value = false;
  22 };
  23
  24 template <class T>
  25 struct is_same<T, T> {
  26   static const bool value = true;
  27 };
  28
  29 extern const std::string m1_name;
  30 extern const Color m1_color;
  31 extern const std::string m2_name;
  32 extern const Color m2_color;
  33
  34 flatbuffers::Offset<Monster> populate1(flatbuffers::FlatBufferBuilder &builder);
  35 flatbuffers::Offset<Monster> populate2(flatbuffers::FlatBufferBuilder &builder);
  36
  37 uint8_t *release_raw_base(flatbuffers::FlatBufferBuilder &fbb, size_t &size, size_t &offset);
  38
  39 void free_raw(flatbuffers::grpc::MessageBuilder &mbb, uint8_t *buf);
  40 void free_raw(flatbuffers::FlatBufferBuilder &fbb, uint8_t *buf);
  41
  42 bool verify(const flatbuffers::DetachedBuffer &buf, const std::string &expected_name, Color color);
  43 bool verify(const uint8_t *buf, size_t offset, const std::string &expected_name, Color color);
  44
  45 bool release_n_verify(flatbuffers::FlatBufferBuilder &fbb, const std::string &expected_name, Color color);
  46 bool release_n_verify(flatbuffers::grpc::MessageBuilder &mbb, const std::string &expected_name, Color color);
  47
  48 // clang-format off
  49 #if !defined(FLATBUFFERS_CPP98_STL)
  50 // clang-format on
  51 // Invokes this function when testing the following Builder types
  52 // FlatBufferBuilder, TestHeapBuilder, and GrpcLikeMessageBuilder
  53 template <class Builder>
  54 void builder_move_assign_after_releaseraw_test(Builder b1) {
  55   auto root_offset1 = populate1(b1);
  56   b1.Finish(root_offset1);
  57   size_t size, offset;
  58   std::shared_ptr<uint8_t> raw(b1.ReleaseRaw(size, offset), [size](uint8_t *ptr) {
  59     flatbuffers::DefaultAllocator::dealloc(ptr, size);
  60   });
  61   Builder src;
  62   auto root_offset2 = populate2(src);
  63   src.Finish(root_offset2);
  64   auto src_size = src.GetSize();
  65   // Move into a released builder.
  66   b1 = std::move(src);
  67   TEST_EQ_FUNC(b1.GetSize(), src_size);
  68   TEST_ASSERT_FUNC(release_n_verify(b1, m2_name, m2_color));
  69   TEST_EQ_FUNC(src.GetSize(), 0);
  70 }
  71 // clang-format off
  72 #endif  // !defined(FLATBUFFERS_CPP98_STL)
  73 // clang-format on
  74
  75 void builder_move_assign_after_releaseraw_test(flatbuffers::grpc::MessageBuilder b1);
  76
  77 template <class DestBuilder, class SrcBuilder = DestBuilder>
  78 struct BuilderTests {
  79   // clang-format off
  80   #if !defined(FLATBUFFERS_CPP98_STL)
  81   // clang-format on
  82   static void empty_builder_movector_test() {
  83     SrcBuilder src;
  84     size_t src_size = src.GetSize();
  85     DestBuilder dst(std::move(src));
  86     size_t dst_size = dst.GetSize();
  87     TEST_EQ_FUNC(src_size, 0);
  88     TEST_EQ_FUNC(src_size, dst_size);
  89   }
  90
  91   static void nonempty_builder_movector_test() {
  92     SrcBuilder src;
  93     populate1(src);
  94     size_t src_size = src.GetSize();
  95     DestBuilder dst(std::move(src));
  96     TEST_EQ_FUNC(src_size, dst.GetSize());
  97     TEST_EQ_FUNC(src.GetSize(), 0);
  98   }
  99
 100   static void builder_movector_before_finish_test() {
 101     SrcBuilder src;
 102     auto root_offset1 = populate1(src);
 103     DestBuilder dst(std::move(src));
 104     dst.Finish(root_offset1);
 105     TEST_ASSERT_FUNC(release_n_verify(dst, m1_name, m1_color));
 106     TEST_EQ_FUNC(src.GetSize(), 0);
 107   }
 108
 109   static void builder_movector_after_finish_test() {
 110     SrcBuilder src;
 111     auto root_offset1 = populate1(src);
 112     src.Finish(root_offset1);
 113     auto src_size = src.GetSize();
 114     DestBuilder dst(std::move(src));
 115     TEST_EQ_FUNC(dst.GetSize(), src_size);
 116     TEST_ASSERT_FUNC(release_n_verify(dst, m1_name, m1_color));
 117     TEST_EQ_FUNC(src.GetSize(), 0);
 118   }
 119
 120   static void builder_move_assign_before_finish_test() {
 121     SrcBuilder src;
 122     auto root_offset1 = populate1(src);
 123     DestBuilder dst;
 124     populate2(dst);
 125     dst = std::move(src);
 126     dst.Finish(root_offset1);
 127     TEST_ASSERT_FUNC(release_n_verify(dst, m1_name, m1_color));
 128     TEST_EQ_FUNC(src.GetSize(), 0);
 129   }
 130
 131   static void builder_move_assign_after_finish_test() {
 132     SrcBuilder src;
 133     auto root_offset1 = populate1(src);
 134     src.Finish(root_offset1);
 135     auto src_size = src.GetSize();
 136     DestBuilder dst;
 137     auto root_offset2 = populate2(dst);
 138     dst.Finish(root_offset2);
 139     dst = std::move(src);
 140     TEST_EQ_FUNC(dst.GetSize(), src_size);
 141     TEST_ASSERT_FUNC(release_n_verify(dst, m1_name, m1_color));
 142     TEST_EQ_FUNC(src.GetSize(), 0);
 143   }
 144
 145   static void builder_move_assign_after_release_test() {
 146     DestBuilder dst;
 147     auto root_offset1 = populate1(dst);
 148     dst.Finish(root_offset1);
 149     {
 150       flatbuffers::DetachedBuffer dst_detached = dst.Release();
 151       // detached buffer is deleted
 152     }
 153     SrcBuilder src;
 154     auto root_offset2 = populate2(src);
 155     src.Finish(root_offset2);
 156     auto src_size = src.GetSize();
 157     // Move into a released builder.
 158     dst = std::move(src);
 159     TEST_EQ_FUNC(dst.GetSize(), src_size);
 160     TEST_ASSERT_FUNC(release_n_verify(dst, m2_name, m2_color));
 161     TEST_EQ_FUNC(src.GetSize(), 0);
 162   }
 163   // clang-format off
 164   #endif  // !defined(FLATBUFFERS_CPP98_STL)
 165   // clang-format on
 166
 167   static void builder_swap_before_finish_test(bool run = is_same<DestBuilder, SrcBuilder>::value) {
 168     /// Swap is allowed only when lhs and rhs are the same concrete type.
 169     if(run) {
 170       SrcBuilder src;
 171       auto root_offset1 = populate1(src);
 172       auto size1 = src.GetSize();
 173       DestBuilder dst;
 174       auto root_offset2 = populate2(dst);
 175       auto size2 = dst.GetSize();
 176       src.Swap(dst);
 177       src.Finish(root_offset2);
 178       dst.Finish(root_offset1);
 179       TEST_EQ_FUNC(src.GetSize() > size2, true);
 180       TEST_EQ_FUNC(dst.GetSize() > size1, true);
 181       TEST_ASSERT_FUNC(release_n_verify(src, m2_name, m2_color));
 182       TEST_ASSERT_FUNC(release_n_verify(dst, m1_name, m1_color));
 183     }
 184   }
 185
 186   static void builder_swap_after_finish_test(bool run = is_same<DestBuilder, SrcBuilder>::value) {
 187     /// Swap is allowed only when lhs and rhs are the same concrete type.
 188     if(run) {
 189       SrcBuilder src;
 190       auto root_offset1 = populate1(src);
 191       src.Finish(root_offset1);
 192       auto size1 = src.GetSize();
 193       DestBuilder dst;
 194       auto root_offset2 = populate2(dst);
 195       dst.Finish(root_offset2);
 196       auto size2 = dst.GetSize();
 197       src.Swap(dst);
 198       TEST_EQ_FUNC(src.GetSize(), size2);
 199       TEST_EQ_FUNC(dst.GetSize(), size1);
 200       TEST_ASSERT_FUNC(release_n_verify(src, m2_name, m2_color));
 201       TEST_ASSERT_FUNC(release_n_verify(dst, m1_name, m1_color));
 202     }
 203   }
 204
 205   static void all_tests() {
 206     // clang-format off
 207     #if !defined(FLATBUFFERS_CPP98_STL)
 208     // clang-format on
 209     empty_builder_movector_test();
 210     nonempty_builder_movector_test();
 211     builder_movector_before_finish_test();
 212     builder_movector_after_finish_test();
 213     builder_move_assign_before_finish_test();
 214     builder_move_assign_after_finish_test();
 215     builder_move_assign_after_release_test();
 216     builder_move_assign_after_releaseraw_test(DestBuilder());
 217     // clang-format off
 218     #endif   // !defined(FLATBUFFERS_CPP98_STL)
 219     // clang-format on
 220     builder_swap_before_finish_test();
 221     builder_swap_after_finish_test();
 222   }
 223 };
 224
 225 enum BuilderReuseTestSelector {
 226   REUSABLE_AFTER_RELEASE = 1,
 227   REUSABLE_AFTER_RELEASE_RAW = 2,
 228   REUSABLE_AFTER_RELEASE_MESSAGE = 3,
 229   REUSABLE_AFTER_RELEASE_AND_MOVE_ASSIGN = 4,
 230   REUSABLE_AFTER_RELEASE_RAW_AND_MOVE_ASSIGN = 5,
 231   REUSABLE_AFTER_RELEASE_MESSAGE_AND_MOVE_ASSIGN = 6
 232 };
 233
 234 typedef std::set<BuilderReuseTestSelector> TestSelector;
 235
 236 template <class DestBuilder, class SrcBuilder>
 237 struct BuilderReuseTests {
 238   static void builder_reusable_after_release_test(TestSelector selector) {
 239     if (!selector.count(REUSABLE_AFTER_RELEASE)) {
 240       return;
 241     }
 242
 243     DestBuilder fbb;
 244     std::vector<flatbuffers::DetachedBuffer> buffers;
 245     for (int i = 0; i < 5; ++i) {
 246       auto root_offset1 = populate1(fbb);
 247       fbb.Finish(root_offset1);
 248       buffers.push_back(fbb.Release());
 249       TEST_ASSERT_FUNC(verify(buffers[i], m1_name, m1_color));
 250     }
 251   }
 252
 253   static void builder_reusable_after_releaseraw_test(TestSelector selector) {
 254     if (!selector.count(REUSABLE_AFTER_RELEASE_RAW)) {
 255       return;
 256     }
 257
 258     DestBuilder fbb;
 259     for (int i = 0; i < 5; ++i) {
 260       auto root_offset1 = populate1(fbb);
 261       fbb.Finish(root_offset1);
 262       size_t size, offset;
 263       uint8_t *buf = release_raw_base(fbb, size, offset);
 264       TEST_ASSERT_FUNC(verify(buf, offset, m1_name, m1_color));
 265       free_raw(fbb, buf);
 266     }
 267   }
 268
 269   // clang-format off
 270   #if !defined(FLATBUFFERS_CPP98_STL)
 271   // clang-format on
 272   static void builder_reusable_after_release_and_move_assign_test(TestSelector selector) {
 273     if (!selector.count(REUSABLE_AFTER_RELEASE_AND_MOVE_ASSIGN)) {
 274       return;
 275     }
 276
 277     DestBuilder dst;
 278     std::vector<flatbuffers::DetachedBuffer> buffers;
 279     for (int i = 0; i < 5; ++i) {
 280       auto root_offset1 = populate1(dst);
 281       dst.Finish(root_offset1);
 282       buffers.push_back(dst.Release());
 283       TEST_ASSERT_FUNC(verify(buffers[i], m1_name, m1_color));
 284       SrcBuilder src;
 285       dst = std::move(src);
 286       TEST_EQ_FUNC(src.GetSize(), 0);
 287     }
 288   }
 289
 290   static void builder_reusable_after_releaseraw_and_move_assign_test(TestSelector selector) {
 291     if (!selector.count(REUSABLE_AFTER_RELEASE_RAW_AND_MOVE_ASSIGN)) {
 292       return;
 293     }
 294
 295     DestBuilder dst;
 296     for (int i = 0; i < 5; ++i) {
 297       auto root_offset1 = populate1(dst);
 298       dst.Finish(root_offset1);
 299       size_t size, offset;
 300       uint8_t *buf = release_raw_base(dst, size, offset);
 301       TEST_ASSERT_FUNC(verify(buf, offset, m1_name, m1_color));
 302       free_raw(dst, buf);
 303       SrcBuilder src;
 304       dst = std::move(src);
 305       TEST_EQ_FUNC(src.GetSize(), 0);
 306     }
 307   }
 308   // clang-format off
 309   #endif  // !defined(FLATBUFFERS_CPP98_STL)
 310   // clang-format on
 311
 312   static void run_tests(TestSelector selector) {
 313     builder_reusable_after_release_test(selector);
 314     builder_reusable_after_releaseraw_test(selector);
 315     // clang-format off
 316     #if !defined(FLATBUFFERS_CPP98_STL)
 317     // clang-format on
 318     builder_reusable_after_release_and_move_assign_test(selector);
 319     builder_reusable_after_releaseraw_and_move_assign_test(selector);
 320     // clang-format off
 321     #endif  // !defined(FLATBUFFERS_CPP98_STL)
 322     // clang-format on
 323   }
 324 };
 325
 326 #endif // TEST_BUILDER_H