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
327