Disable armeabi builds for Android and re-enable CI builds. (#4970)

armeabi support was removed from the Android NDK so we should no longer build it. Since this fixes the Android build failures this commit also re-enables Travis Android builds. While re-enabling Android builds, some recent changes broke C++98 support so this fixes those issues as well which include: - Conditionally compiling use of move constructors, operators and std::move. - Changing sample to use flatbuffers::unique_ptr rather than std::unique_ptr. Finally, added the special "default_ptr_type" value for the "cpp_ptr_type" attribute. This expands to the value passed to the "--cpp-ptr-type" argument of flatc.
2026-06-27 23:38:05 +00:00 · 2018-10-08 12:43:57 -07:00
parent d840856093
commit 569492e890
11 changed files with 158 additions and 67 deletions
--- a/tests/monster_test.bfbs
+++ b/tests/monster_test.bfbs
--- a/tests/monster_test.fbs
+++ b/tests/monster_test.fbs
@@ -89,9 +89,9 @@ table Monster {
  vector_of_referrables:[Referrable](id:35);
  single_weak_reference:ulong(id:36, hash:"fnv1a_64", cpp_type:"ReferrableT");
  vector_of_weak_references:[ulong](id:37, hash:"fnv1a_64", cpp_type:"ReferrableT");
-  vector_of_strong_referrables:[Referrable](id:38, cpp_ptr_type:"std::unique_ptr");                 //was shared_ptr
+  vector_of_strong_referrables:[Referrable](id:38, cpp_ptr_type:"default_ptr_type");                 //was shared_ptr
  co_owning_reference:ulong(id:39, hash:"fnv1a_64", cpp_type:"ReferrableT", cpp_ptr_type:"naked");  //was shared_ptr as well
-  vector_of_co_owning_references:[ulong](id:40, hash:"fnv1a_64", cpp_type:"ReferrableT", cpp_ptr_type:"std::unique_ptr", cpp_ptr_type_get:".get()");  //was shared_ptr
+  vector_of_co_owning_references:[ulong](id:40, hash:"fnv1a_64", cpp_type:"ReferrableT", cpp_ptr_type:"default_ptr_type", cpp_ptr_type_get:".get()");  //was shared_ptr
  non_owning_reference:ulong(id:41, hash:"fnv1a_64", cpp_type:"ReferrableT", cpp_ptr_type:"naked", cpp_ptr_type_get:"");                              //was weak_ptr
  vector_of_non_owning_references:[ulong](id:42, hash:"fnv1a_64", cpp_type:"ReferrableT", cpp_ptr_type:"naked", cpp_ptr_type_get:"");                 //was weak_ptr
 }
--- a/tests/monster_test_generated.h
+++ b/tests/monster_test_generated.h
@@ -802,9 +802,9 @@ struct MonsterT : public flatbuffers::NativeTable {
  std::vector<flatbuffers::unique_ptr<ReferrableT>> vector_of_referrables;
  ReferrableT *single_weak_reference;
  std::vector<ReferrableT *> vector_of_weak_references;
-  std::vector<std::unique_ptr<ReferrableT>> vector_of_strong_referrables;
+  std::vector<flatbuffers::unique_ptr<ReferrableT>> vector_of_strong_referrables;
  ReferrableT *co_owning_reference;
-  std::vector<std::unique_ptr<ReferrableT>> vector_of_co_owning_references;
+  std::vector<flatbuffers::unique_ptr<ReferrableT>> vector_of_co_owning_references;
  ReferrableT *non_owning_reference;
  std::vector<ReferrableT *> vector_of_non_owning_references;
  MonsterT()
@@ -2072,10 +2072,10 @@ if (_resolver) (*_resolver)(reinterpret_cast<void **>(&_o->testhashu32_fnv1a), s
 if (_resolver) (*_resolver)(reinterpret_cast<void **>(&_o->single_weak_reference), static_cast<flatbuffers::hash_value_t>(_e)); else _o->single_weak_reference = nullptr; };
  { auto _e = vector_of_weak_references(); if (_e) { _o->vector_of_weak_references.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { //vector resolver, naked
 if (_resolver) (*_resolver)(reinterpret_cast<void **>(&_o->vector_of_weak_references[_i]), static_cast<flatbuffers::hash_value_t>(_e->Get(_i))); else _o->vector_of_weak_references[_i] = nullptr; } } };
-  { auto _e = vector_of_strong_referrables(); if (_e) { _o->vector_of_strong_referrables.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vector_of_strong_referrables[_i] = std::unique_ptr<ReferrableT>(_e->Get(_i)->UnPack(_resolver)); } } };
+  { auto _e = vector_of_strong_referrables(); if (_e) { _o->vector_of_strong_referrables.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vector_of_strong_referrables[_i] = flatbuffers::unique_ptr<ReferrableT>(_e->Get(_i)->UnPack(_resolver)); } } };
  { auto _e = co_owning_reference(); //scalar resolver, naked 
 if (_resolver) (*_resolver)(reinterpret_cast<void **>(&_o->co_owning_reference), static_cast<flatbuffers::hash_value_t>(_e)); else _o->co_owning_reference = nullptr; };
-  { auto _e = vector_of_co_owning_references(); if (_e) { _o->vector_of_co_owning_references.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { //vector resolver, std::unique_ptr
+  { auto _e = vector_of_co_owning_references(); if (_e) { _o->vector_of_co_owning_references.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { //vector resolver, default_ptr_type
 if (_resolver) (*_resolver)(reinterpret_cast<void **>(&_o->vector_of_co_owning_references[_i]), static_cast<flatbuffers::hash_value_t>(_e->Get(_i)));/* else do nothing */; } } };
  { auto _e = non_owning_reference(); //scalar resolver, naked 
 if (_resolver) (*_resolver)(reinterpret_cast<void **>(&_o->non_owning_reference), static_cast<flatbuffers::hash_value_t>(_e)); else _o->non_owning_reference = nullptr; };
--- a/tests/test_builder.cpp
+++ b/tests/test_builder.cpp
@@ -1,3 +1,5 @@
+#include "flatbuffers/stl_emulation.h"
+
 #include "monster_test_generated.h"
 #include "test_builder.h"

@@ -12,13 +14,20 @@ 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)) { }

@@ -26,6 +35,9 @@ public:
    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
@@ -49,12 +61,18 @@ public:
    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.
--- a/tests/test_builder.h
+++ b/tests/test_builder.h
@@ -34,6 +34,9 @@ bool release_n_verify(flatbuffers::grpc::MessageBuilder &mbb, const std::string

 template <class Builder>
 struct BuilderTests {
+  // clang-format off
+  #if !defined(FLATBUFFERS_CPP98_STL)
+  // clang-format on
  static void empty_builder_movector_test() {
    Builder b1;
    size_t b1_size = b1.GetSize();
@@ -97,38 +100,6 @@ struct BuilderTests {
    TEST_EQ_FUNC(b1.GetSize(), 0);
  }

-  static void builder_swap_before_finish_test() {
-    Builder b1;
-    auto root_offset1 = populate1(b1);
-    auto size1 = b1.GetSize();
-    Builder b2;
-    auto root_offset2 = populate2(b2);
-    auto size2 = b2.GetSize();
-    b1.Swap(b2);
-    b1.Finish(root_offset2);
-    b2.Finish(root_offset1);
-    TEST_EQ_FUNC(b1.GetSize() > size2, true);
-    TEST_EQ_FUNC(b2.GetSize() > size1, true);
-    TEST_ASSERT_FUNC(release_n_verify(b1, m2_name, m2_color));
-    TEST_ASSERT_FUNC(release_n_verify(b2, m1_name, m1_color));
-  }
-
-  static void builder_swap_after_finish_test() {
-    Builder b1;
-    auto root_offset1 = populate1(b1);
-    b1.Finish(root_offset1);
-    auto size1 = b1.GetSize();
-    Builder b2;
-    auto root_offset2 = populate2(b2);
-    b2.Finish(root_offset2);
-    auto size2 = b2.GetSize();
-    b1.Swap(b2);
-    TEST_EQ_FUNC(b1.GetSize(), size2);
-    TEST_EQ_FUNC(b2.GetSize(), size1);
-    TEST_ASSERT_FUNC(release_n_verify(b1, m2_name, m2_color));
-    TEST_ASSERT_FUNC(release_n_verify(b2, m1_name, m1_color));
-  }
-
  static void builder_move_assign_after_release_test() {
    Builder b1;
    auto root_offset1 = populate1(b1);
@@ -166,18 +137,59 @@ struct BuilderTests {
    TEST_ASSERT_FUNC(release_n_verify(b1, m2_name, m2_color));
    TEST_EQ_FUNC(b2.GetSize(), 0);
  }
+  // clang-format off
+  #endif  // !defined(FLATBUFFERS_CPP98_STL)
+  // clang-format on
+
+  static void builder_swap_before_finish_test() {
+    Builder b1;
+    auto root_offset1 = populate1(b1);
+    auto size1 = b1.GetSize();
+    Builder b2;
+    auto root_offset2 = populate2(b2);
+    auto size2 = b2.GetSize();
+    b1.Swap(b2);
+    b1.Finish(root_offset2);
+    b2.Finish(root_offset1);
+    TEST_EQ_FUNC(b1.GetSize() > size2, true);
+    TEST_EQ_FUNC(b2.GetSize() > size1, true);
+    TEST_ASSERT_FUNC(release_n_verify(b1, m2_name, m2_color));
+    TEST_ASSERT_FUNC(release_n_verify(b2, m1_name, m1_color));
+  }
+
+  static void builder_swap_after_finish_test() {
+    Builder b1;
+    auto root_offset1 = populate1(b1);
+    b1.Finish(root_offset1);
+    auto size1 = b1.GetSize();
+    Builder b2;
+    auto root_offset2 = populate2(b2);
+    b2.Finish(root_offset2);
+    auto size2 = b2.GetSize();
+    b1.Swap(b2);
+    TEST_EQ_FUNC(b1.GetSize(), size2);
+    TEST_EQ_FUNC(b2.GetSize(), size1);
+    TEST_ASSERT_FUNC(release_n_verify(b1, m2_name, m2_color));
+    TEST_ASSERT_FUNC(release_n_verify(b2, m1_name, m1_color));
+  }

  static void all_tests() {
+    // clang-format off
+    #if !defined(FLATBUFFERS_CPP98_STL)
+    // clang-format on
    empty_builder_movector_test();
    nonempty_builder_movector_test();
    builder_movector_before_finish_test();
    builder_movector_after_finish_test();
    builder_move_assign_before_finish_test();
    builder_move_assign_after_finish_test();
-    builder_swap_before_finish_test();
-    builder_swap_after_finish_test();
    builder_move_assign_after_release_test();
    builder_move_assign_after_releaseraw_test();
+    // clang-format off
+    #endif   // !defined(FLATBUFFERS_CPP98_STL)
+    // clang-format on
+    builder_swap_before_finish_test();
+    builder_swap_after_finish_test();
  }
 };

@@ -225,6 +237,9 @@ struct BuilderReuseTests {
    }
  }

+  // clang-format off
+  #if !defined(FLATBUFFERS_CPP98_STL)
+  // clang-format on
  static void builder_reusable_after_release_and_move_assign_test(TestSelector selector) {
    if (!selector.count(REUSABLE_AFTER_RELEASE_AND_MOVE_ASSIGN)) {
      return;
@@ -261,12 +276,21 @@ struct BuilderReuseTests {
      TEST_EQ_FUNC(b2.GetSize(), 0);
    }
  }
+  // clang-format off
+  #endif  // !defined(FLATBUFFERS_CPP98_STL)
+  // clang-format on

  static void run_tests(TestSelector selector) {
    builder_reusable_after_release_test(selector);
    builder_reusable_after_releaseraw_test(selector);
+    // clang-format off
+    #if !defined(FLATBUFFERS_CPP98_STL)
+    // clang-format on
    builder_reusable_after_release_and_move_assign_test(selector);
    builder_reusable_after_releaseraw_and_move_assign_test(selector);
+    // clang-format off
+    #endif  // !defined(FLATBUFFERS_CPP98_STL)
+    // clang-format on
  }
 };