Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 277b5507 authored by Sadaf Ebrahimi's avatar Sadaf Ebrahimi Committed by Gerrit Code Review
Browse files

Merge "Add genrule" into main

parents 18ca5ac7 8a97b3d2

system/gd/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -370,6 +370,7 @@ cc_test { 
    generated_headers: [

        "BluetoothGeneratedBundlerSchema_h_bfbs",

        "BluetoothGeneratedDumpsysDataSchema_h",

        "BluetoothGeneratedDumpsysInternalTestData_h",

        "BluetoothGeneratedDumpsysTestData_h",

        "BluetoothGeneratedPackets_h",

    ],

system/gd/dumpsys/Android.bp

+21 −1
Original line number Diff line number Diff line
@@ -131,6 +131,26 @@ genrule { 
    ],

}



genrule {

    name: "BluetoothGeneratedDumpsysInternalTestData_h",

    tools: [

        "flatc",

    ],

    cmd: "$(location flatc) --cpp -o $(genDir)/dumpsys/internal/test_data $(in)",

    srcs: [

        "internal/test_data/float.fbs",

        "internal/test_data/integer.fbs",

        "internal/test_data/string.fbs",

        "internal/test_data/struct.fbs",

    ],

    out: [

        "dumpsys/internal/test_data/float_generated.h",

        "dumpsys/internal/test_data/integer_generated.h",

        "dumpsys/internal/test_data/string_generated.h",

        "dumpsys/internal/test_data/struct_generated.h",

    ],

}



cc_library {

    name: "libbluetooth-dumpsys",

    host_supported: true,
@@ -175,8 +195,8 @@ cc_test { 
    name: "bluetooth_flatbuffer_tests",

    test_suites: ["device-tests"],

    defaults: [

        "bluetooth_gtest_x86_asan_workaround",

        "bluetooth_cflags",

        "bluetooth_gtest_x86_asan_workaround",

        "mts_defaults",

    ],

    host_supported: true,

system/gd/dumpsys/internal/test_data/float_generated.h

deleted100644 → 0
+0 −86
Original line number Diff line number Diff line 
// automatically generated by the FlatBuffers compiler, do not modify



#ifndef FLATBUFFERS_GENERATED_FLOAT_TESTING_H_

#define FLATBUFFERS_GENERATED_FLOAT_TESTING_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 == 7,

    "Non-compatible flatbuffers version included");



namespace testing {



struct TestTableFloat;

struct TestTableFloatBuilder;



struct TestTableFloat FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {

  typedef TestTableFloatBuilder Builder;

  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_TEST_FLOAT = 4 };

  float test_float() const {

    return GetField<float>(VT_TEST_FLOAT, 0.0f);

  }

  bool Verify(flatbuffers::Verifier& verifier) const {

    return VerifyTableStart(verifier) && VerifyField<float>(verifier, VT_TEST_FLOAT, 4) && verifier.EndTable();

  }

};



struct TestTableFloatBuilder {

  typedef TestTableFloat Table;

  flatbuffers::FlatBufferBuilder& fbb_;

  flatbuffers::uoffset_t start_;

  void add_test_float(float test_float) {

    fbb_.AddElement<float>(TestTableFloat::VT_TEST_FLOAT, test_float, 0.0f);

  }

  explicit TestTableFloatBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {

    start_ = fbb_.StartTable();

  }

  flatbuffers::Offset<TestTableFloat> Finish() {

    const auto end = fbb_.EndTable(start_);

    auto o = flatbuffers::Offset<TestTableFloat>(end);

    return o;

  }

};



inline flatbuffers::Offset<TestTableFloat> CreateTestTableFloat(

    flatbuffers::FlatBufferBuilder& _fbb, float test_float = 0.0f) {

  TestTableFloatBuilder builder_(_fbb);

  builder_.add_test_float(test_float);

  return builder_.Finish();

}



inline const testing::TestTableFloat* GetTestTableFloat(const void* buf) {

  return flatbuffers::GetRoot<testing::TestTableFloat>(buf);

}



inline const testing::TestTableFloat* GetSizePrefixedTestTableFloat(const void* buf) {

  return flatbuffers::GetSizePrefixedRoot<testing::TestTableFloat>(buf);

}



inline bool VerifyTestTableFloatBuffer(flatbuffers::Verifier& verifier) {

  return verifier.VerifyBuffer<testing::TestTableFloat>(nullptr);

}



inline bool VerifySizePrefixedTestTableFloatBuffer(flatbuffers::Verifier& verifier) {

  return verifier.VerifySizePrefixedBuffer<testing::TestTableFloat>(nullptr);

}



inline const char* TestTableFloatExtension() {

  return "bfbs";

}



inline void FinishTestTableFloatBuffer(

    flatbuffers::FlatBufferBuilder& fbb, flatbuffers::Offset<testing::TestTableFloat> root) {

  fbb.Finish(root);

}



inline void FinishSizePrefixedTestTableFloatBuffer(

    flatbuffers::FlatBufferBuilder& fbb, flatbuffers::Offset<testing::TestTableFloat> root) {

  fbb.FinishSizePrefixed(root);

}



}  // namespace testing



#endif  // FLATBUFFERS_GENERATED_FLOAT_TESTING_H_

system/gd/dumpsys/internal/test_data/integer_generated.h

deleted100644 → 0
+0 −86
Original line number Diff line number Diff line 
// automatically generated by the FlatBuffers compiler, do not modify



#ifndef FLATBUFFERS_GENERATED_INTEGER_TESTING_H_

#define FLATBUFFERS_GENERATED_INTEGER_TESTING_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 == 7,

    "Non-compatible flatbuffers version included");



namespace testing {



struct TestTableInteger;

struct TestTableIntegerBuilder;



struct TestTableInteger FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {

  typedef TestTableIntegerBuilder Builder;

  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_TEST_INT = 4 };

  int32_t test_int() const {

    return GetField<int32_t>(VT_TEST_INT, 0);

  }

  bool Verify(flatbuffers::Verifier& verifier) const {

    return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_TEST_INT, 4) && verifier.EndTable();

  }

};



struct TestTableIntegerBuilder {

  typedef TestTableInteger Table;

  flatbuffers::FlatBufferBuilder& fbb_;

  flatbuffers::uoffset_t start_;

  void add_test_int(int32_t test_int) {

    fbb_.AddElement<int32_t>(TestTableInteger::VT_TEST_INT, test_int, 0);

  }

  explicit TestTableIntegerBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {

    start_ = fbb_.StartTable();

  }

  flatbuffers::Offset<TestTableInteger> Finish() {

    const auto end = fbb_.EndTable(start_);

    auto o = flatbuffers::Offset<TestTableInteger>(end);

    return o;

  }

};



inline flatbuffers::Offset<TestTableInteger> CreateTestTableInteger(

    flatbuffers::FlatBufferBuilder& _fbb, int32_t test_int = 0) {

  TestTableIntegerBuilder builder_(_fbb);

  builder_.add_test_int(test_int);

  return builder_.Finish();

}



inline const testing::TestTableInteger* GetTestTableInteger(const void* buf) {

  return flatbuffers::GetRoot<testing::TestTableInteger>(buf);

}



inline const testing::TestTableInteger* GetSizePrefixedTestTableInteger(const void* buf) {

  return flatbuffers::GetSizePrefixedRoot<testing::TestTableInteger>(buf);

}



inline bool VerifyTestTableIntegerBuffer(flatbuffers::Verifier& verifier) {

  return verifier.VerifyBuffer<testing::TestTableInteger>(nullptr);

}



inline bool VerifySizePrefixedTestTableIntegerBuffer(flatbuffers::Verifier& verifier) {

  return verifier.VerifySizePrefixedBuffer<testing::TestTableInteger>(nullptr);

}



inline const char* TestTableIntegerExtension() {

  return "bfbs";

}



inline void FinishTestTableIntegerBuffer(

    flatbuffers::FlatBufferBuilder& fbb, flatbuffers::Offset<testing::TestTableInteger> root) {

  fbb.Finish(root);

}



inline void FinishSizePrefixedTestTableIntegerBuffer(

    flatbuffers::FlatBufferBuilder& fbb, flatbuffers::Offset<testing::TestTableInteger> root) {

  fbb.FinishSizePrefixed(root);

}



}  // namespace testing



#endif  // FLATBUFFERS_GENERATED_INTEGER_TESTING_H_

system/gd/dumpsys/internal/test_data/string_generated.h

deleted100644 → 0
+0 −88
Original line number Diff line number Diff line 
// automatically generated by the FlatBuffers compiler, do not modify



#ifndef FLATBUFFERS_GENERATED_STRING_TESTING_H_

#define FLATBUFFERS_GENERATED_STRING_TESTING_H_



#include "flatbuffers/flatbuffers.h"



namespace testing {



struct TestTableString;

struct TestTableStringBuilder;



struct TestTableString FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {

  typedef TestTableStringBuilder Builder;

  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_TEST_STRING = 4 };

  const flatbuffers::String* test_string() const {

    return GetPointer<const flatbuffers::String*>(VT_TEST_STRING);

  }

  bool Verify(flatbuffers::Verifier& verifier) const {

    return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_TEST_STRING) &&

           verifier.VerifyString(test_string()) && verifier.EndTable();

  }

};



struct TestTableStringBuilder {

  typedef TestTableString Table;

  flatbuffers::FlatBufferBuilder& fbb_;

  flatbuffers::uoffset_t start_;

  void add_test_string(flatbuffers::Offset<flatbuffers::String> test_string) {

    fbb_.AddOffset(TestTableString::VT_TEST_STRING, test_string);

  }

  explicit TestTableStringBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {

    start_ = fbb_.StartTable();

  }

  TestTableStringBuilder& operator=(const TestTableStringBuilder&);

  flatbuffers::Offset<TestTableString> Finish() {

    const auto end = fbb_.EndTable(start_);

    auto o = flatbuffers::Offset<TestTableString>(end);

    return o;

  }

};



inline flatbuffers::Offset<TestTableString> CreateTestTableString(

    flatbuffers::FlatBufferBuilder& _fbb, flatbuffers::Offset<flatbuffers::String> test_string = 0) {

  TestTableStringBuilder builder_(_fbb);

  builder_.add_test_string(test_string);

  return builder_.Finish();

}



inline flatbuffers::Offset<TestTableString> CreateTestTableStringDirect(

    flatbuffers::FlatBufferBuilder& _fbb, const char* test_string = nullptr) {

  auto test_string__ = test_string ? _fbb.CreateString(test_string) : 0;

  return testing::CreateTestTableString(_fbb, test_string__);

}



inline const testing::TestTableString* GetTestTableString(const void* buf) {

  return flatbuffers::GetRoot<testing::TestTableString>(buf);

}



inline const testing::TestTableString* GetSizePrefixedTestTableString(const void* buf) {

  return flatbuffers::GetSizePrefixedRoot<testing::TestTableString>(buf);

}



inline bool VerifyTestTableStringBuffer(flatbuffers::Verifier& verifier) {

  return verifier.VerifyBuffer<testing::TestTableString>(nullptr);

}



inline bool VerifySizePrefixedTestTableStringBuffer(flatbuffers::Verifier& verifier) {

  return verifier.VerifySizePrefixedBuffer<testing::TestTableString>(nullptr);

}



inline const char* TestTableStringExtension() {

  return "bfbs";

}



inline void FinishTestTableStringBuffer(

    flatbuffers::FlatBufferBuilder& fbb, flatbuffers::Offset<testing::TestTableString> root) {

  fbb.Finish(root);

}



inline void FinishSizePrefixedTestTableStringBuffer(

    flatbuffers::FlatBufferBuilder& fbb, flatbuffers::Offset<testing::TestTableString> root) {

  fbb.FinishSizePrefixed(root);

}



}  // namespace testing



#endif  // FLATBUFFERS_GENERATED_STRING_TESTING_H_