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