| #include "flatbuffers/stl_emulation.h" |
| |
| #include "monster_test_generated.h" |
| #include "test_builder.h" |
| |
| using namespace MyGame::Example; |
| |
| const std::string m1_name = "Cyberdemon"; |
| const Color m1_color = Color_Red; |
| const std::string m2_name = "Imp"; |
| const Color m2_color = Color_Green; |
| |
| struct OwnedAllocator : public flatbuffers::DefaultAllocator {}; |
| |
| class TestHeapBuilder : public flatbuffers::FlatBufferBuilder { |
| private: |
| // clang-format off |
| #if !defined(FLATBUFFERS_CPP98_STL) |
| TestHeapBuilder(const TestHeapBuilder &); |
| TestHeapBuilder &operator=(const TestHeapBuilder &); |
| #endif // !defined(FLATBUFFERS_CPP98_STL) |
| // clang-format on |
| |
| public: |
| TestHeapBuilder() |
| : flatbuffers::FlatBufferBuilder(2048, new OwnedAllocator(), true) {} |
| |
| // clang-format off |
| #if !defined(FLATBUFFERS_CPP98_STL) |
| // clang-format on |
| TestHeapBuilder(TestHeapBuilder &&other) |
| : FlatBufferBuilder(std::move(other)) { } |
| |
| TestHeapBuilder &operator=(TestHeapBuilder &&other) { |
| FlatBufferBuilder::operator=(std::move(other)); |
| return *this; |
| } |
| // clang-format off |
| #endif // !defined(FLATBUFFERS_CPP98_STL) |
| // clang-format on |
| }; |
| |
| // This class simulates flatbuffers::grpc::detail::SliceAllocatorMember |
| struct AllocatorMember { |
| flatbuffers::DefaultAllocator member_allocator_; |
| }; |
| |
| struct GrpcLikeMessageBuilder : private AllocatorMember, |
| public flatbuffers::FlatBufferBuilder { |
| private: |
| GrpcLikeMessageBuilder(const GrpcLikeMessageBuilder &); |
| GrpcLikeMessageBuilder &operator=(const GrpcLikeMessageBuilder &); |
| |
| public: |
| GrpcLikeMessageBuilder() |
| : flatbuffers::FlatBufferBuilder(1024, &member_allocator_, false) {} |
| |
| GrpcLikeMessageBuilder(GrpcLikeMessageBuilder &&other) |
| : FlatBufferBuilder(1024, &member_allocator_, false) { |
| // Default construct and swap idiom. |
| Swap(other); |
| } |
| |
| // clang-format off |
| #if !defined(FLATBUFFERS_CPP98_STL) |
| // clang-format on |
| GrpcLikeMessageBuilder &operator=(GrpcLikeMessageBuilder &&other) { |
| // Construct temporary and swap idiom |
| GrpcLikeMessageBuilder temp(std::move(other)); |
| Swap(temp); |
| return *this; |
| } |
| // clang-format off |
| #endif // !defined(FLATBUFFERS_CPP98_STL) |
| // clang-format on |
| |
| void Swap(GrpcLikeMessageBuilder &other) { |
| // No need to swap member_allocator_ because it's stateless. |
| FlatBufferBuilder::Swap(other); |
| // After swapping the FlatBufferBuilder, we swap back the allocator, which restores |
| // the original allocator back in place. This is necessary because MessageBuilder's |
| // allocator is its own member (SliceAllocatorMember). The allocator passed to |
| // FlatBufferBuilder::vector_downward must point to this member. |
| buf_.swap_allocator(other.buf_); |
| } |
| }; |
| |
| flatbuffers::Offset<Monster> populate1(flatbuffers::FlatBufferBuilder &builder) { |
| auto name_offset = builder.CreateString(m1_name); |
| return CreateMonster(builder, nullptr, 0, 0, name_offset, 0, m1_color); |
| } |
| |
| flatbuffers::Offset<Monster> populate2(flatbuffers::FlatBufferBuilder &builder) { |
| auto name_offset = builder.CreateString(m2_name); |
| return CreateMonster(builder, nullptr, 0, 0, name_offset, 0, m2_color); |
| } |
| |
| uint8_t *release_raw_base(flatbuffers::FlatBufferBuilder &fbb, size_t &size, size_t &offset) { |
| return fbb.ReleaseRaw(size, offset); |
| } |
| |
| void free_raw(flatbuffers::grpc::MessageBuilder &, uint8_t *) { |
| // release_raw_base calls FlatBufferBuilder::ReleaseRaw on the argument MessageBuilder. |
| // It's semantically wrong as MessageBuilder has its own ReleaseRaw member function that |
| // takes three arguments. In such cases though, ~MessageBuilder() invokes |
| // ~SliceAllocator() that takes care of deleting memory as it calls grpc_slice_unref. |
| // Obviously, this behavior is very surprising as the pointer returned by |
| // FlatBufferBuilder::ReleaseRaw is not valid as soon as MessageBuilder goes out of scope. |
| // This problem does not occur with FlatBufferBuilder. |
| } |
| |
| void free_raw(flatbuffers::FlatBufferBuilder &, uint8_t *buf) { |
| flatbuffers::DefaultAllocator().deallocate(buf, 0); |
| } |
| |
| bool verify(const flatbuffers::DetachedBuffer &buf, const std::string &expected_name, Color color) { |
| const Monster *monster = flatbuffers::GetRoot<Monster>(buf.data()); |
| return (monster->name()->str() == expected_name) && (monster->color() == color); |
| } |
| |
| bool verify(const uint8_t *buf, size_t offset, const std::string &expected_name, Color color) { |
| const Monster *monster = flatbuffers::GetRoot<Monster>(buf+offset); |
| return (monster->name()->str() == expected_name) && (monster->color() == color); |
| } |
| |
| bool release_n_verify(flatbuffers::FlatBufferBuilder &fbb, const std::string &expected_name, Color color) { |
| flatbuffers::DetachedBuffer buf = fbb.Release(); |
| return verify(buf, expected_name, color); |
| } |
| |
| void FlatBufferBuilderTest() { |
| using flatbuffers::FlatBufferBuilder; |
| |
| BuilderTests<FlatBufferBuilder>::all_tests(); |
| BuilderTests<TestHeapBuilder>::all_tests(); |
| BuilderTests<GrpcLikeMessageBuilder>::all_tests(); |
| |
| BuilderReuseTestSelector tests[4] = { |
| REUSABLE_AFTER_RELEASE, |
| REUSABLE_AFTER_RELEASE_RAW, |
| REUSABLE_AFTER_RELEASE_AND_MOVE_ASSIGN, |
| REUSABLE_AFTER_RELEASE_RAW_AND_MOVE_ASSIGN |
| }; |
| |
| BuilderReuseTests<FlatBufferBuilder, FlatBufferBuilder>::run_tests(TestSelector(tests, tests+4)); |
| BuilderReuseTests<TestHeapBuilder, TestHeapBuilder>::run_tests(TestSelector(tests, tests+4)); |
| BuilderReuseTests<GrpcLikeMessageBuilder, GrpcLikeMessageBuilder>::run_tests(TestSelector(tests, tests+4)); |
| } |