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