tests/test_builder.cpp

   1 #include "test_builder.h"
   2
   3 #include "flatbuffers/stl_emulation.h"
   4 #include "monster_test_generated.h"
   5
   6 using namespace MyGame::Example;
   7
   8 const std::string m1_name = "Cyberdemon";
   9 const Color m1_color = Color_Red;
  10 const std::string m2_name = "Imp";
  11 const Color m2_color = Color_Green;
  12
  13 struct OwnedAllocator : public flatbuffers::DefaultAllocator {};
  14
  15 class TestHeapBuilder : public flatbuffers::FlatBufferBuilder {
  16  private:
  17   // clang-format off
  18   #if !defined(FLATBUFFERS_CPP98_STL)
  19   TestHeapBuilder(const TestHeapBuilder &);
  20   TestHeapBuilder &operator=(const TestHeapBuilder &);
  21   #endif  // !defined(FLATBUFFERS_CPP98_STL)
  22   // clang-format on
  23
  24  public:
  25   TestHeapBuilder()
  26       : flatbuffers::FlatBufferBuilder(2048, new OwnedAllocator(), true) {}
  27
  28   // clang-format off
  29   #if !defined(FLATBUFFERS_CPP98_STL)
  30   // clang-format on
  31   TestHeapBuilder(TestHeapBuilder &&other)
  32       : FlatBufferBuilder(std::move(other)) {}
  33
  34   TestHeapBuilder &operator=(TestHeapBuilder &&other) {
  35     FlatBufferBuilder::operator=(std::move(other));
  36     return *this;
  37   }
  38   // clang-format off
  39   #endif  // !defined(FLATBUFFERS_CPP98_STL)
  40   // clang-format on
  41 };
  42
  43 // This class simulates flatbuffers::grpc::detail::SliceAllocatorMember
  44 struct AllocatorMember {
  45   flatbuffers::DefaultAllocator member_allocator_;
  46 };
  47
  48 struct GrpcLikeMessageBuilder : private AllocatorMember,
  49                                 public flatbuffers::FlatBufferBuilder {
  50  private:
  51   GrpcLikeMessageBuilder(const GrpcLikeMessageBuilder &);
  52   GrpcLikeMessageBuilder &operator=(const GrpcLikeMessageBuilder &);
  53
  54  public:
  55   GrpcLikeMessageBuilder()
  56       : flatbuffers::FlatBufferBuilder(1024, &member_allocator_, false) {}
  57
  58   GrpcLikeMessageBuilder(GrpcLikeMessageBuilder &&other)
  59       : FlatBufferBuilder(1024, &member_allocator_, false) {
  60     // Default construct and swap idiom.
  61     Swap(other);
  62   }
  63
  64   // clang-format off
  65   #if !defined(FLATBUFFERS_CPP98_STL)
  66   // clang-format on
  67   GrpcLikeMessageBuilder &operator=(GrpcLikeMessageBuilder &&other) {
  68     // Construct temporary and swap idiom
  69     GrpcLikeMessageBuilder temp(std::move(other));
  70     Swap(temp);
  71     return *this;
  72   }
  73   // clang-format off
  74   #endif  // !defined(FLATBUFFERS_CPP98_STL)
  75   // clang-format on
  76
  77   void Swap(GrpcLikeMessageBuilder &other) {
  78     // No need to swap member_allocator_ because it's stateless.
  79     FlatBufferBuilder::Swap(other);
  80     // After swapping the FlatBufferBuilder, we swap back the allocator, which
  81     // restores the original allocator back in place. This is necessary because
  82     // MessageBuilder's allocator is its own member (SliceAllocatorMember). The
  83     // allocator passed to FlatBufferBuilder::vector_downward must point to this
  84     // member.
  85     buf_.swap_allocator(other.buf_);
  86   }
  87 };
  88
  89 flatbuffers::Offset<Monster> populate1(
  90     flatbuffers::FlatBufferBuilder &builder) {
  91   auto name_offset = builder.CreateString(m1_name);
  92   return CreateMonster(builder, nullptr, 0, 0, name_offset, 0, m1_color);
  93 }
  94
  95 flatbuffers::Offset<Monster> populate2(
  96     flatbuffers::FlatBufferBuilder &builder) {
  97   auto name_offset = builder.CreateString(m2_name);
  98   return CreateMonster(builder, nullptr, 0, 0, name_offset, 0, m2_color);
  99 }
 100
 101 uint8_t *release_raw_base(flatbuffers::FlatBufferBuilder &fbb, size_t &size,
 102                           size_t &offset) {
 103   return fbb.ReleaseRaw(size, offset);
 104 }
 105
 106 void free_raw(flatbuffers::grpc::MessageBuilder &, uint8_t *) {
 107   // release_raw_base calls FlatBufferBuilder::ReleaseRaw on the argument
 108   // MessageBuilder. It's semantically wrong as MessageBuilder has its own
 109   // ReleaseRaw member function that takes three arguments. In such cases
 110   // though, ~MessageBuilder() invokes ~SliceAllocator() that takes care of
 111   // deleting memory as it calls grpc_slice_unref. Obviously, this behavior is
 112   // very surprising as the pointer returned by FlatBufferBuilder::ReleaseRaw is
 113   // not valid as soon as MessageBuilder goes out of scope. This problem does
 114   // not occur with FlatBufferBuilder.
 115 }
 116
 117 void free_raw(flatbuffers::FlatBufferBuilder &, uint8_t *buf) {
 118   flatbuffers::DefaultAllocator().deallocate(buf, 0);
 119 }
 120
 121 bool verify(const flatbuffers::DetachedBuffer &buf,
 122             const std::string &expected_name, Color color) {
 123   const Monster *monster = flatbuffers::GetRoot<Monster>(buf.data());
 124   return (monster->name()->str() == expected_name) &&
 125          (monster->color() == color);
 126 }
 127
 128 bool verify(const uint8_t *buf, size_t offset, const std::string &expected_name,
 129             Color color) {
 130   const Monster *monster = flatbuffers::GetRoot<Monster>(buf + offset);
 131   return (monster->name()->str() == expected_name) &&
 132          (monster->color() == color);
 133 }
 134
 135 bool release_n_verify(flatbuffers::FlatBufferBuilder &fbb,
 136                       const std::string &expected_name, Color color) {
 137   flatbuffers::DetachedBuffer buf = fbb.Release();
 138   return verify(buf, expected_name, color);
 139 }
 140
 141 void FlatBufferBuilderTest() {
 142   using flatbuffers::FlatBufferBuilder;
 143
 144   BuilderTests<FlatBufferBuilder>::all_tests();
 145   BuilderTests<TestHeapBuilder>::all_tests();
 146   BuilderTests<GrpcLikeMessageBuilder>::all_tests();
 147
 148   BuilderReuseTestSelector tests[4] = {
 149     REUSABLE_AFTER_RELEASE, REUSABLE_AFTER_RELEASE_RAW,
 150     REUSABLE_AFTER_RELEASE_AND_MOVE_ASSIGN,
 151     REUSABLE_AFTER_RELEASE_RAW_AND_MOVE_ASSIGN
 152   };
 153
 154   BuilderReuseTests<FlatBufferBuilder, FlatBufferBuilder>::run_tests(
 155       TestSelector(tests, tests + 4));
 156   BuilderReuseTests<TestHeapBuilder, TestHeapBuilder>::run_tests(
 157       TestSelector(tests, tests + 4));
 158   BuilderReuseTests<GrpcLikeMessageBuilder, GrpcLikeMessageBuilder>::run_tests(
 159       TestSelector(tests, tests + 4));
 160 }