diff options
Diffstat (limited to 'tests')
| -rw-r--r-- | tests/BUILD.bazel | 10 | ||||
| -rw-r--r-- | tests/alignment_test.cpp | 31 | ||||
| -rw-r--r-- | tests/alignment_test.fbs | 24 | ||||
| -rw-r--r-- | tests/alignment_test.h | 12 | ||||
| -rw-r--r-- | tests/alignment_test_generated.h | 497 | ||||
| -rw-r--r-- | tests/test.cpp | 3 |
6 files changed, 577 insertions, 0 deletions
diff --git a/tests/BUILD.bazel b/tests/BUILD.bazel index 3330bfc5..d9048ea2 100644 --- a/tests/BUILD.bazel +++ b/tests/BUILD.bazel @@ -8,6 +8,9 @@ cc_test( name = "flatbuffers_test", testonly = 1, srcs = [ + "alignment_test.cpp", + "alignment_test.h", + "alignment_test_generated.h", "evolution_test.cpp", "evolution_test.h", "evolution_test/evolution_v1_generated.h", @@ -50,6 +53,7 @@ cc_test( "-DBAZEL_TEST_DATA_PATH", ], data = [ + ":alignment_test.fbs", ":arrays_test.bfbs", ":arrays_test.fbs", ":arrays_test.golden", @@ -90,6 +94,7 @@ cc_test( "include/", ], deps = [ + ":alignment_test_cc_fbs", ":arrays_test_cc_fbs", ":monster_extra_cc_fbs", ":monster_test_cc_fbs", @@ -214,3 +219,8 @@ flatbuffer_cc_library( "--cpp-ptr-type flatbuffers::unique_ptr", ], ) + +flatbuffer_cc_library( + name = "alignment_test_cc_fbs", + srcs = ["alignment_test.fbs"], +) diff --git a/tests/alignment_test.cpp b/tests/alignment_test.cpp new file mode 100644 index 00000000..1026fc33 --- /dev/null +++ b/tests/alignment_test.cpp @@ -0,0 +1,31 @@ +#include "alignment_test.h" + +#include "flatbuffers/flatbuffer_builder.h" +#include "alignment_test_generated.h" +#include "test_assert.h" + +namespace flatbuffers { +namespace tests { + +void AlignmentTest() { + FlatBufferBuilder builder; + + BadAlignmentLarge large; + Offset<OuterLarge> outer_large = CreateOuterLarge(builder, &large); + + BadAlignmentSmall *small; + Offset<Vector<const BadAlignmentSmall *>> small_offset = + builder.CreateUninitializedVectorOfStructs(9, &small); + (void)small; // We do not have to write data to trigger the test failure + + Offset<BadAlignmentRoot> root = + CreateBadAlignmentRoot(builder, outer_large, small_offset); + + builder.Finish(root); + + Verifier verifier(builder.GetBufferPointer(), builder.GetSize()); + TEST_ASSERT(VerifyBadAlignmentRootBuffer(verifier)); +} + +} // namespace tests +} // namespace flatbuffers diff --git a/tests/alignment_test.fbs b/tests/alignment_test.fbs new file mode 100644 index 00000000..3fc08bd7 --- /dev/null +++ b/tests/alignment_test.fbs @@ -0,0 +1,24 @@ +// sizeof(BadAlignmentSmall) == 12 +// alignof(BadAlignmentSmall) == 4 +struct BadAlignmentSmall { + var_0: uint; + var_1: uint; + var_2: uint; +} + +// sizeof(BadAlignmentLarge) == 8 +// alignof(BadAlignmentLarge) == 8 +struct BadAlignmentLarge { + var_0: ulong; +} + +table OuterLarge { + large: BadAlignmentLarge; +} + +table BadAlignmentRoot { + large: OuterLarge; + small: [BadAlignmentSmall]; +} + +root_type BadAlignmentRoot; diff --git a/tests/alignment_test.h b/tests/alignment_test.h new file mode 100644 index 00000000..68cdf0bd --- /dev/null +++ b/tests/alignment_test.h @@ -0,0 +1,12 @@ +#ifndef TESTS_ALIGNMENT_TEST_H +#define TESTS_ALIGNMENT_TEST_H + +namespace flatbuffers { +namespace tests { + +void AlignmentTest(); + +} // namespace tests +} // namespace flatbuffers + +#endif diff --git a/tests/alignment_test_generated.h b/tests/alignment_test_generated.h new file mode 100644 index 00000000..416152b7 --- /dev/null +++ b/tests/alignment_test_generated.h @@ -0,0 +1,497 @@ +// automatically generated by the FlatBuffers compiler, do not modify + + +#ifndef FLATBUFFERS_GENERATED_ALIGNMENTTEST_H_ +#define FLATBUFFERS_GENERATED_ALIGNMENTTEST_H_ + +#include "flatbuffers/flatbuffers.h" + +// Ensure the included flatbuffers.h is the same version as when this file was +// generated, otherwise it may not be compatible. +static_assert(FLATBUFFERS_VERSION_MAJOR == 2 && + FLATBUFFERS_VERSION_MINOR == 0 && + FLATBUFFERS_VERSION_REVISION == 8, + "Non-compatible flatbuffers version included"); + +struct BadAlignmentSmall; + +struct BadAlignmentLarge; + +struct OuterLarge; +struct OuterLargeBuilder; +struct OuterLargeT; + +struct BadAlignmentRoot; +struct BadAlignmentRootBuilder; +struct BadAlignmentRootT; + +bool operator==(const BadAlignmentSmall &lhs, const BadAlignmentSmall &rhs); +bool operator!=(const BadAlignmentSmall &lhs, const BadAlignmentSmall &rhs); +bool operator==(const BadAlignmentLarge &lhs, const BadAlignmentLarge &rhs); +bool operator!=(const BadAlignmentLarge &lhs, const BadAlignmentLarge &rhs); +bool operator==(const OuterLargeT &lhs, const OuterLargeT &rhs); +bool operator!=(const OuterLargeT &lhs, const OuterLargeT &rhs); +bool operator==(const BadAlignmentRootT &lhs, const BadAlignmentRootT &rhs); +bool operator!=(const BadAlignmentRootT &lhs, const BadAlignmentRootT &rhs); + +inline const flatbuffers::TypeTable *BadAlignmentSmallTypeTable(); + +inline const flatbuffers::TypeTable *BadAlignmentLargeTypeTable(); + +inline const flatbuffers::TypeTable *OuterLargeTypeTable(); + +inline const flatbuffers::TypeTable *BadAlignmentRootTypeTable(); + +FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) BadAlignmentSmall FLATBUFFERS_FINAL_CLASS { + private: + uint32_t var_0_; + uint32_t var_1_; + uint32_t var_2_; + + public: + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return BadAlignmentSmallTypeTable(); + } + BadAlignmentSmall() + : var_0_(0), + var_1_(0), + var_2_(0) { + } + BadAlignmentSmall(uint32_t _var_0, uint32_t _var_1, uint32_t _var_2) + : var_0_(flatbuffers::EndianScalar(_var_0)), + var_1_(flatbuffers::EndianScalar(_var_1)), + var_2_(flatbuffers::EndianScalar(_var_2)) { + } + uint32_t var_0() const { + return flatbuffers::EndianScalar(var_0_); + } + void mutate_var_0(uint32_t _var_0) { + flatbuffers::WriteScalar(&var_0_, _var_0); + } + uint32_t var_1() const { + return flatbuffers::EndianScalar(var_1_); + } + void mutate_var_1(uint32_t _var_1) { + flatbuffers::WriteScalar(&var_1_, _var_1); + } + uint32_t var_2() const { + return flatbuffers::EndianScalar(var_2_); + } + void mutate_var_2(uint32_t _var_2) { + flatbuffers::WriteScalar(&var_2_, _var_2); + } +}; +FLATBUFFERS_STRUCT_END(BadAlignmentSmall, 12); + +inline bool operator==(const BadAlignmentSmall &lhs, const BadAlignmentSmall &rhs) { + return + (lhs.var_0() == rhs.var_0()) && + (lhs.var_1() == rhs.var_1()) && + (lhs.var_2() == rhs.var_2()); +} + +inline bool operator!=(const BadAlignmentSmall &lhs, const BadAlignmentSmall &rhs) { + return !(lhs == rhs); +} + + +FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) BadAlignmentLarge FLATBUFFERS_FINAL_CLASS { + private: + uint64_t var_0_; + + public: + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return BadAlignmentLargeTypeTable(); + } + BadAlignmentLarge() + : var_0_(0) { + } + BadAlignmentLarge(uint64_t _var_0) + : var_0_(flatbuffers::EndianScalar(_var_0)) { + } + uint64_t var_0() const { + return flatbuffers::EndianScalar(var_0_); + } + void mutate_var_0(uint64_t _var_0) { + flatbuffers::WriteScalar(&var_0_, _var_0); + } +}; +FLATBUFFERS_STRUCT_END(BadAlignmentLarge, 8); + +inline bool operator==(const BadAlignmentLarge &lhs, const BadAlignmentLarge &rhs) { + return + (lhs.var_0() == rhs.var_0()); +} + +inline bool operator!=(const BadAlignmentLarge &lhs, const BadAlignmentLarge &rhs) { + return !(lhs == rhs); +} + + +struct OuterLargeT : public flatbuffers::NativeTable { + typedef OuterLarge TableType; + flatbuffers::unique_ptr<BadAlignmentLarge> large{}; + OuterLargeT() = default; + OuterLargeT(const OuterLargeT &o); + OuterLargeT(OuterLargeT&&) FLATBUFFERS_NOEXCEPT = default; + OuterLargeT &operator=(OuterLargeT o) FLATBUFFERS_NOEXCEPT; +}; + +struct OuterLarge FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef OuterLargeT NativeTableType; + typedef OuterLargeBuilder Builder; + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return OuterLargeTypeTable(); + } + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_LARGE = 4 + }; + const BadAlignmentLarge *large() const { + return GetStruct<const BadAlignmentLarge *>(VT_LARGE); + } + BadAlignmentLarge *mutable_large() { + return GetStruct<BadAlignmentLarge *>(VT_LARGE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField<BadAlignmentLarge>(verifier, VT_LARGE, 8) && + verifier.EndTable(); + } + OuterLargeT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(OuterLargeT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset<OuterLarge> Pack(flatbuffers::FlatBufferBuilder &_fbb, const OuterLargeT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct OuterLargeBuilder { + typedef OuterLarge Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_large(const BadAlignmentLarge *large) { + fbb_.AddStruct(OuterLarge::VT_LARGE, large); + } + explicit OuterLargeBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset<OuterLarge> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<OuterLarge>(end); + return o; + } +}; + +inline flatbuffers::Offset<OuterLarge> CreateOuterLarge( + flatbuffers::FlatBufferBuilder &_fbb, + const BadAlignmentLarge *large = nullptr) { + OuterLargeBuilder builder_(_fbb); + builder_.add_large(large); + return builder_.Finish(); +} + +flatbuffers::Offset<OuterLarge> CreateOuterLarge(flatbuffers::FlatBufferBuilder &_fbb, const OuterLargeT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct BadAlignmentRootT : public flatbuffers::NativeTable { + typedef BadAlignmentRoot TableType; + flatbuffers::unique_ptr<OuterLargeT> large{}; + std::vector<BadAlignmentSmall> small{}; + BadAlignmentRootT() = default; + BadAlignmentRootT(const BadAlignmentRootT &o); + BadAlignmentRootT(BadAlignmentRootT&&) FLATBUFFERS_NOEXCEPT = default; + BadAlignmentRootT &operator=(BadAlignmentRootT o) FLATBUFFERS_NOEXCEPT; +}; + +struct BadAlignmentRoot FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef BadAlignmentRootT NativeTableType; + typedef BadAlignmentRootBuilder Builder; + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return BadAlignmentRootTypeTable(); + } + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_LARGE = 4, + VT_SMALL = 6 + }; + const OuterLarge *large() const { + return GetPointer<const OuterLarge *>(VT_LARGE); + } + OuterLarge *mutable_large() { + return GetPointer<OuterLarge *>(VT_LARGE); + } + const flatbuffers::Vector<const BadAlignmentSmall *> *small() const { + return GetPointer<const flatbuffers::Vector<const BadAlignmentSmall *> *>(VT_SMALL); + } + flatbuffers::Vector<const BadAlignmentSmall *> *mutable_small() { + return GetPointer<flatbuffers::Vector<const BadAlignmentSmall *> *>(VT_SMALL); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_LARGE) && + verifier.VerifyTable(large()) && + VerifyOffset(verifier, VT_SMALL) && + verifier.VerifyVector(small()) && + verifier.EndTable(); + } + BadAlignmentRootT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(BadAlignmentRootT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset<BadAlignmentRoot> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BadAlignmentRootT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct BadAlignmentRootBuilder { + typedef BadAlignmentRoot Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_large(flatbuffers::Offset<OuterLarge> large) { + fbb_.AddOffset(BadAlignmentRoot::VT_LARGE, large); + } + void add_small(flatbuffers::Offset<flatbuffers::Vector<const BadAlignmentSmall *>> small) { + fbb_.AddOffset(BadAlignmentRoot::VT_SMALL, small); + } + explicit BadAlignmentRootBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset<BadAlignmentRoot> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<BadAlignmentRoot>(end); + return o; + } +}; + +inline flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRoot( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset<OuterLarge> large = 0, + flatbuffers::Offset<flatbuffers::Vector<const BadAlignmentSmall *>> small = 0) { + BadAlignmentRootBuilder builder_(_fbb); + builder_.add_small(small); + builder_.add_large(large); + return builder_.Finish(); +} + +inline flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRootDirect( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset<OuterLarge> large = 0, + const std::vector<BadAlignmentSmall> *small = nullptr) { + auto small__ = small ? _fbb.CreateVectorOfStructs<BadAlignmentSmall>(*small) : 0; + return CreateBadAlignmentRoot( + _fbb, + large, + small__); +} + +flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRoot(flatbuffers::FlatBufferBuilder &_fbb, const BadAlignmentRootT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + + +inline bool operator==(const OuterLargeT &lhs, const OuterLargeT &rhs) { + return + ((lhs.large == rhs.large) || (lhs.large && rhs.large && *lhs.large == *rhs.large)); +} + +inline bool operator!=(const OuterLargeT &lhs, const OuterLargeT &rhs) { + return !(lhs == rhs); +} + + +inline OuterLargeT::OuterLargeT(const OuterLargeT &o) + : large((o.large) ? new BadAlignmentLarge(*o.large) : nullptr) { +} + +inline OuterLargeT &OuterLargeT::operator=(OuterLargeT o) FLATBUFFERS_NOEXCEPT { + std::swap(large, o.large); + return *this; +} + +inline OuterLargeT *OuterLarge::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr<OuterLargeT>(new OuterLargeT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void OuterLarge::UnPackTo(OuterLargeT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = large(); if (_e) _o->large = flatbuffers::unique_ptr<BadAlignmentLarge>(new BadAlignmentLarge(*_e)); } +} + +inline flatbuffers::Offset<OuterLarge> OuterLarge::Pack(flatbuffers::FlatBufferBuilder &_fbb, const OuterLargeT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateOuterLarge(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset<OuterLarge> CreateOuterLarge(flatbuffers::FlatBufferBuilder &_fbb, const OuterLargeT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const OuterLargeT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _large = _o->large ? _o->large.get() : nullptr; + return CreateOuterLarge( + _fbb, + _large); +} + + +inline bool operator==(const BadAlignmentRootT &lhs, const BadAlignmentRootT &rhs) { + return + ((lhs.large == rhs.large) || (lhs.large && rhs.large && *lhs.large == *rhs.large)) && + (lhs.small == rhs.small); +} + +inline bool operator!=(const BadAlignmentRootT &lhs, const BadAlignmentRootT &rhs) { + return !(lhs == rhs); +} + + +inline BadAlignmentRootT::BadAlignmentRootT(const BadAlignmentRootT &o) + : large((o.large) ? new OuterLargeT(*o.large) : nullptr), + small(o.small) { +} + +inline BadAlignmentRootT &BadAlignmentRootT::operator=(BadAlignmentRootT o) FLATBUFFERS_NOEXCEPT { + std::swap(large, o.large); + std::swap(small, o.small); + return *this; +} + +inline BadAlignmentRootT *BadAlignmentRoot::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr<BadAlignmentRootT>(new BadAlignmentRootT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void BadAlignmentRoot::UnPackTo(BadAlignmentRootT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = large(); if (_e) { if(_o->large) { _e->UnPackTo(_o->large.get(), _resolver); } else { _o->large = flatbuffers::unique_ptr<OuterLargeT>(_e->UnPack(_resolver)); } } else if (_o->large) { _o->large.reset(); } } + { auto _e = small(); if (_e) { _o->small.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->small[_i] = *_e->Get(_i); } } else { _o->small.resize(0); } } +} + +inline flatbuffers::Offset<BadAlignmentRoot> BadAlignmentRoot::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BadAlignmentRootT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateBadAlignmentRoot(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRoot(flatbuffers::FlatBufferBuilder &_fbb, const BadAlignmentRootT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BadAlignmentRootT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _large = _o->large ? CreateOuterLarge(_fbb, _o->large.get(), _rehasher) : 0; + auto _small = _o->small.size() ? _fbb.CreateVectorOfStructs(_o->small) : 0; + return CreateBadAlignmentRoot( + _fbb, + _large, + _small); +} + +inline const flatbuffers::TypeTable *BadAlignmentSmallTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_UINT, 0, -1 }, + { flatbuffers::ET_UINT, 0, -1 }, + { flatbuffers::ET_UINT, 0, -1 } + }; + static const int64_t values[] = { 0, 4, 8, 12 }; + static const char * const names[] = { + "var_0", + "var_1", + "var_2" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_STRUCT, 3, type_codes, nullptr, nullptr, values, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *BadAlignmentLargeTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_ULONG, 0, -1 } + }; + static const int64_t values[] = { 0, 8 }; + static const char * const names[] = { + "var_0" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *OuterLargeTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_SEQUENCE, 0, 0 } + }; + static const flatbuffers::TypeFunction type_refs[] = { + BadAlignmentLargeTypeTable + }; + static const char * const names[] = { + "large" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *BadAlignmentRootTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_SEQUENCE, 0, 0 }, + { flatbuffers::ET_SEQUENCE, 1, 1 } + }; + static const flatbuffers::TypeFunction type_refs[] = { + OuterLargeTypeTable, + BadAlignmentSmallTypeTable + }; + static const char * const names[] = { + "large", + "small" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, nullptr, names + }; + return &tt; +} + +inline const BadAlignmentRoot *GetBadAlignmentRoot(const void *buf) { + return flatbuffers::GetRoot<BadAlignmentRoot>(buf); +} + +inline const BadAlignmentRoot *GetSizePrefixedBadAlignmentRoot(const void *buf) { + return flatbuffers::GetSizePrefixedRoot<BadAlignmentRoot>(buf); +} + +inline BadAlignmentRoot *GetMutableBadAlignmentRoot(void *buf) { + return flatbuffers::GetMutableRoot<BadAlignmentRoot>(buf); +} + +inline BadAlignmentRoot *GetMutableSizePrefixedBadAlignmentRoot(void *buf) { + return flatbuffers::GetMutableSizePrefixedRoot<BadAlignmentRoot>(buf); +} + +inline bool VerifyBadAlignmentRootBuffer( + flatbuffers::Verifier &verifier) { + return verifier.VerifyBuffer<BadAlignmentRoot>(nullptr); +} + +inline bool VerifySizePrefixedBadAlignmentRootBuffer( + flatbuffers::Verifier &verifier) { + return verifier.VerifySizePrefixedBuffer<BadAlignmentRoot>(nullptr); +} + +inline void FinishBadAlignmentRootBuffer( + flatbuffers::FlatBufferBuilder &fbb, + flatbuffers::Offset<BadAlignmentRoot> root) { + fbb.Finish(root); +} + +inline void FinishSizePrefixedBadAlignmentRootBuffer( + flatbuffers::FlatBufferBuilder &fbb, + flatbuffers::Offset<BadAlignmentRoot> root) { + fbb.FinishSizePrefixed(root); +} + +inline flatbuffers::unique_ptr<BadAlignmentRootT> UnPackBadAlignmentRoot( + const void *buf, + const flatbuffers::resolver_function_t *res = nullptr) { + return flatbuffers::unique_ptr<BadAlignmentRootT>(GetBadAlignmentRoot(buf)->UnPack(res)); +} + +inline flatbuffers::unique_ptr<BadAlignmentRootT> UnPackSizePrefixedBadAlignmentRoot( + const void *buf, + const flatbuffers::resolver_function_t *res = nullptr) { + return flatbuffers::unique_ptr<BadAlignmentRootT>(GetSizePrefixedBadAlignmentRoot(buf)->UnPack(res)); +} + +#endif // FLATBUFFERS_GENERATED_ALIGNMENTTEST_H_ diff --git a/tests/test.cpp b/tests/test.cpp index 7e05c08f..60c9f5d9 100644 --- a/tests/test.cpp +++ b/tests/test.cpp @@ -20,6 +20,7 @@ #include <string> #include "evolution_test.h" +#include "alignment_test.h" #include "flatbuffers/flatbuffers.h" #include "flatbuffers/idl.h" #include "flatbuffers/minireflect.h" @@ -1416,6 +1417,8 @@ int FlatBufferTests(const std::string &tests_data_path) { SizePrefixedTest(); + AlignmentTest(); + #ifndef FLATBUFFERS_NO_FILE_TESTS ParseAndGenerateTextTest(tests_data_path, false); ParseAndGenerateTextTest(tests_data_path, true); |