aos/flatbuffer_merge_test.cc

#include "aos/flatbuffer_merge.h"

#include <string_view>

#include "absl/strings/escaping.h"
#include "gtest/gtest.h"

#include "aos/json_to_flatbuffer.h"
#include "aos/json_to_flatbuffer_generated.h"
#include "flatbuffers/minireflect.h"

namespace aos {
namespace testing {

std::string_view FromFbb(const flatbuffers::FlatBufferBuilder &fbb) {
  return std::string_view(
      reinterpret_cast<const char *>(fbb.GetCurrentBufferPointer()),
      fbb.GetSize());
}

std::string_view FromFbb(const flatbuffers::DetachedBuffer &b) {
  return std::string_view(reinterpret_cast<const char *>(b.data()), b.size());
}

absl::Span<const uint8_t> ToSpan(const flatbuffers::DetachedBuffer &b) {
  return absl::Span<const uint8_t>(b.data(), b.size());
}

class FlatbufferMerge : public ::testing::Test {
 public:
  FlatbufferMerge() {}

  void ExpectMergedOutput(const flatbuffers::DetachedBuffer &fb_merged,
                          std::string_view expected_output) {
    ASSERT_NE(fb_merged.size(), 0u);

    const ::std::string merged_output =
        FlatbufferToJson(fb_merged, ConfigurationTypeTable());
    EXPECT_EQ(expected_output, merged_output);

    aos::FlatbufferDetachedBuffer<Configuration> expected_message(
        JsonToFlatbuffer(std::string(expected_output).c_str(),
                         ConfigurationTypeTable()));
    EXPECT_TRUE(
        CompareFlatBuffer(flatbuffers::GetRoot<Configuration>(fb_merged.data()),
                          &expected_message.message()));
  }

  void JsonMerge(const ::std::string in1, const ::std::string in2,
                 const ::std::string out) {
    printf("Merging: %s\n", in1.c_str());
    printf("Merging: %s\n", in2.c_str());
    const flatbuffers::DetachedBuffer fb1 = JsonToFlatbuffer(
        static_cast<const char *>(in1.c_str()), ConfigurationTypeTable());

    const ::std::string in1_nested = "{ \"nested_config\": " + in1 + " }";
    const flatbuffers::DetachedBuffer fb1_nested =
        JsonToFlatbuffer(static_cast<const char *>(in1_nested.c_str()),
                         ConfigurationTypeTable());

    const flatbuffers::DetachedBuffer fb2 = JsonToFlatbuffer(
        static_cast<const char *>(in2.c_str()), ConfigurationTypeTable());

    const ::std::string in2_nested = "{ \"nested_config\": " + in2 + " }";
    const flatbuffers::DetachedBuffer fb2_nested =
        JsonToFlatbuffer(static_cast<const char *>(in2_nested.c_str()),
                         ConfigurationTypeTable());

    const ::std::string out_nested = "{ \"nested_config\": " + out + " }";

    const flatbuffers::DetachedBuffer empty =
        JsonToFlatbuffer("{ }", ConfigurationTypeTable());

    ASSERT_NE(fb1.size(), 0u);
    ASSERT_NE(fb2.size(), 0u);
    ASSERT_NE(fb1_nested.size(), 0u);
    ASSERT_NE(fb2_nested.size(), 0u);

    // We now want to run 7 tests.
    //  in1 merged "" -> in1.
    //  in2 merged "" -> in2.
    //  "" merged in1 -> in1.
    //  "" merged in2 -> in2.
    //  nullptr merged in1 -> in1.
    //  in1 merged nullptr -> in1.
    //  in1 merged in2 -> out.

    {
      // in1 merged with "" => in1.
      flatbuffers::DetachedBuffer fb_merged =
          MergeFlatBuffers<Configuration>(fb1.data(), empty.data());
      ASSERT_NE(fb_merged.size(), 0u);

      EXPECT_EQ(in1, FlatbufferToJson(fb_merged, ConfigurationTypeTable()));
    }

    {
      // in2 merged with "" => in2.
      flatbuffers::DetachedBuffer fb_merged =
          MergeFlatBuffers<Configuration>(fb2.data(), empty.data());
      ASSERT_NE(fb_merged.size(), 0u);

      EXPECT_EQ(in2, FlatbufferToJson(fb_merged, ConfigurationTypeTable()));
    }

    {
      // "" merged with in1 => in1.
      flatbuffers::DetachedBuffer fb_merged =
          MergeFlatBuffers<Configuration>(empty.data(), fb1.data());
      ASSERT_NE(fb_merged.size(), 0u);

      EXPECT_EQ(in1, FlatbufferToJson(fb_merged, ConfigurationTypeTable()));
    }

    {
      // "" merged with in2 => in2.
      flatbuffers::DetachedBuffer fb_merged =
          MergeFlatBuffers<Configuration>(empty.data(), fb2.data());
      ASSERT_NE(fb_merged.size(), 0u);

      EXPECT_EQ(in2, FlatbufferToJson(fb_merged, ConfigurationTypeTable()));
    }

    {
      // nullptr merged with in1 => in1.
      flatbuffers::DetachedBuffer fb_merged =
          MergeFlatBuffers<Configuration>(nullptr, fb1.data());
      ASSERT_NE(fb_merged.size(), 0u);

      EXPECT_EQ(in1, FlatbufferToJson(fb_merged, ConfigurationTypeTable()));
    }

    {
      // in1 merged with nullptr => in1.
      flatbuffers::DetachedBuffer fb_merged =
          MergeFlatBuffers<Configuration>(fb1.data(), nullptr);
      ASSERT_NE(fb_merged.size(), 0u);

      EXPECT_EQ(in1, FlatbufferToJson(fb_merged, ConfigurationTypeTable()));
    }

    {
      // in1 merged with in2 => out.
      flatbuffers::DetachedBuffer fb_merged =
          MergeFlatBuffers<Configuration>(fb1.data(), fb2.data());

      ExpectMergedOutput(fb_merged, out);
    }

    // Test all the different merge methods:
    ExpectMergedOutput(
        MergeFlatBuffers(ConfigurationTypeTable(), fb1.data(), fb2.data()),
        out);
    {
      flatbuffers::FlatBufferBuilder fbb;
      fbb.ForceDefaults(true);
      fbb.Finish(MergeFlatBuffers(
          ConfigurationTypeTable(),
          flatbuffers::GetRoot<flatbuffers::Table>(fb1.data()),
          flatbuffers::GetRoot<flatbuffers::Table>(fb2.data()), &fbb));
      ExpectMergedOutput(fbb.Release(), out);
    }
    {
      flatbuffers::FlatBufferBuilder fbb;
      fbb.ForceDefaults(true);
      fbb.Finish(MergeFlatBuffers<Configuration>(
          flatbuffers::GetRoot<flatbuffers::Table>(fb1.data()),
          flatbuffers::GetRoot<flatbuffers::Table>(fb2.data()), &fbb));
      ExpectMergedOutput(fbb.Release(), out);
    }
    ExpectMergedOutput(MergeFlatBuffers<Configuration>(fb1.data(), fb2.data()),
                       out);
    ExpectMergedOutput(MergeFlatBuffers<Configuration>(fb1, fb2), out);
    ExpectMergedOutput(MergeFlatBuffers<Configuration>(
                           flatbuffers::GetRoot<Configuration>(fb1.data()),
                           flatbuffers::GetRoot<Configuration>(fb2.data()))
                           .buffer(),
                       out);

    // Now, to make things extra exciting, nest a config inside a config.  And
    // run all the tests.  This will exercise some fun nested merges and copies.

    {
      // in1_nested merged with "" => in1.
      flatbuffers::DetachedBuffer fb_merged =
          MergeFlatBuffers<Configuration>(fb1_nested.data(), empty.data());
      ASSERT_NE(fb_merged.size(), 0u);

      EXPECT_EQ(in1_nested,
                FlatbufferToJson(fb_merged, ConfigurationTypeTable()));
    }

    {
      // in2_nested merged with "" => in2_nested.
      flatbuffers::DetachedBuffer fb_merged =
          MergeFlatBuffers<Configuration>(fb2_nested.data(), empty.data());
      ASSERT_NE(fb_merged.size(), 0u);

      EXPECT_EQ(in2_nested,
                FlatbufferToJson(fb_merged, ConfigurationTypeTable()));
    }

    {
      // "" merged with in1_nested => in1_nested.
      flatbuffers::DetachedBuffer fb_merged =
          MergeFlatBuffers<Configuration>(empty.data(), fb1_nested.data());
      ASSERT_NE(fb_merged.size(), 0u);

      EXPECT_EQ(in1_nested,
                FlatbufferToJson(fb_merged, ConfigurationTypeTable()));
    }

    {
      // "" merged with in2_nested => in2_nested.
      flatbuffers::DetachedBuffer fb_merged =
          MergeFlatBuffers<Configuration>(empty.data(), fb2_nested.data());
      ASSERT_NE(fb_merged.size(), 0u);

      EXPECT_EQ(in2_nested,
                FlatbufferToJson(fb_merged, ConfigurationTypeTable()));
    }

    {
      // nullptr merged with in1_nested => in1_nested.
      flatbuffers::DetachedBuffer fb_merged =
          MergeFlatBuffers<Configuration>(nullptr, fb1_nested.data());
      ASSERT_NE(fb_merged.size(), 0u);

      EXPECT_EQ(in1_nested,
                FlatbufferToJson(fb_merged, ConfigurationTypeTable()));
    }

    {
      // nullptr merged with in1_nested => in1_nested.
      flatbuffers::DetachedBuffer fb_merged =
          MergeFlatBuffers<Configuration>(fb1_nested.data(), nullptr);
      ASSERT_NE(fb_merged.size(), 0u);

      EXPECT_EQ(in1_nested,
                FlatbufferToJson(fb_merged, ConfigurationTypeTable()));
    }

    {
      // in1_nested merged with in2_nested => out_nested.
      flatbuffers::DetachedBuffer fb_merged =
          MergeFlatBuffers<Configuration>(fb1_nested, fb2_nested);
      ASSERT_NE(fb_merged.size(), 0u);

      EXPECT_EQ(out_nested,
                FlatbufferToJson(fb_merged, ConfigurationTypeTable()));
    }

    // TODO(austin): Try more flatbuffers...
    // Now try copying various flatbuffers and confirming they match.
    {
      flatbuffers::FlatBufferBuilder aos_flatbuffer_copy_fbb;
      aos_flatbuffer_copy_fbb.ForceDefaults(true);

      LOG(INFO) << "Copying " << in1 << " "
                << absl::BytesToHexString(FromFbb(fb1)) << " at "
                << reinterpret_cast<const void *>(fb1.data()) << " size "
                << fb1.size();
      aos_flatbuffer_copy_fbb.Finish(CopyFlatBuffer<Configuration>(
          flatbuffers::GetRoot<Configuration>(fb1.data()),
          &aos_flatbuffer_copy_fbb));

      aos::FlatbufferDetachedBuffer<Configuration> fb_copy(
          aos_flatbuffer_copy_fbb.Release());
      ASSERT_NE(fb_copy.size(), 0u);

      flatbuffers::Verifier v(fb1.data(), fb1.size());
      EXPECT_TRUE(
          v.VerifyTable(flatbuffers::GetRoot<Configuration>(fb1.data())));

      ASSERT_TRUE(fb_copy.Verify()) << in1;

      EXPECT_EQ(in1, FlatbufferToJson(fb_copy));
    }

    {
      flatbuffers::FlatBufferBuilder aos_flatbuffer_copy_message_ptr_fbb;
      aos_flatbuffer_copy_message_ptr_fbb.ForceDefaults(true);

      aos_flatbuffer_copy_message_ptr_fbb.Finish(CopyFlatBuffer<Configuration>(
          flatbuffers::GetRoot<Configuration>(fb2.data()),
          &aos_flatbuffer_copy_message_ptr_fbb));

      aos::FlatbufferDetachedBuffer<Configuration> fb_copy_message_ptr(
          aos_flatbuffer_copy_message_ptr_fbb.Release());
      ASSERT_NE(fb_copy_message_ptr.size(), 0u);

      flatbuffers::FlatBufferBuilder aos_flatbuffer_copy_full_fbb;
      aos_flatbuffer_copy_full_fbb.ForceDefaults(true);

      aos_flatbuffer_copy_full_fbb.Finish(BlindCopyFlatBuffer<Configuration>(
          aos::FlatbufferSpan<Configuration>(ToSpan(fb2)),
          &aos_flatbuffer_copy_full_fbb));

      aos::FlatbufferDetachedBuffer<Configuration> fb_copy_full(
          aos_flatbuffer_copy_full_fbb.Release());
      ASSERT_NE(fb_copy_full.size(), 0u);

      flatbuffers::Verifier v(fb2.data(), fb2.size());
      EXPECT_TRUE(
          v.VerifyTable(flatbuffers::GetRoot<Configuration>(fb2.data())));

      LOG(INFO) << "Verifying copy of " << in2;
      ASSERT_TRUE(fb_copy_message_ptr.Verify()) << in2;
      LOG(INFO) << "Verifying full of " << in2;
      ASSERT_TRUE(fb_copy_full.Verify()) << in2;

      EXPECT_EQ(in2, FlatbufferToJson(fb_copy_message_ptr));
      EXPECT_EQ(in2, FlatbufferToJson(fb_copy_full));
    }

    {
      flatbuffers::FlatBufferBuilder aos_flatbuffer_copy_fbb;
      aos_flatbuffer_copy_fbb.ForceDefaults(true);

      aos_flatbuffer_copy_fbb.Finish(CopyFlatBuffer<Configuration>(
          flatbuffers::GetRoot<Configuration>(fb1_nested.data()),
          &aos_flatbuffer_copy_fbb));

      aos::FlatbufferDetachedBuffer<Configuration> fb_copy(
          aos_flatbuffer_copy_fbb.Release());
      ASSERT_NE(fb_copy.size(), 0u);

      ASSERT_TRUE(fb_copy.Verify());

      EXPECT_EQ(in1_nested, FlatbufferToJson(fb_copy));
    }

    {
      flatbuffers::FlatBufferBuilder aos_flatbuffer_copy_fbb;
      aos_flatbuffer_copy_fbb.ForceDefaults(true);

      aos_flatbuffer_copy_fbb.Finish(CopyFlatBuffer<Configuration>(
          flatbuffers::GetRoot<Configuration>(fb2_nested.data()),
          &aos_flatbuffer_copy_fbb));

      aos::FlatbufferDetachedBuffer<Configuration> fb_copy(
          aos_flatbuffer_copy_fbb.Release());
      ASSERT_NE(fb_copy.size(), 0u);

      ASSERT_TRUE(fb_copy.Verify());

      EXPECT_EQ(in2_nested, FlatbufferToJson(fb_copy));
    }
  }
};

// Test the easy ones.  Test every type, single, no nesting.
TEST_F(FlatbufferMerge, Basic) {
  JsonMerge("{  }", "{  }", "{  }");

  JsonMerge("{ \"foo_bool\": true }", "{ \"foo_bool\": false }",
            "{ \"foo_bool\": false }");

  JsonMerge("{ \"foo_bool\": false }", "{ \"foo_bool\": true }",
            "{ \"foo_bool\": true }");

  JsonMerge("{ \"foo_byte\": 5 }", "{ \"foo_byte\": -7 }",
            "{ \"foo_byte\": -7 }");

  JsonMerge("{ \"foo_ubyte\": 5 }", "{ \"foo_ubyte\": 7 }",
            "{ \"foo_ubyte\": 7 }");

  JsonMerge("{ \"foo_short\": 5 }", "{ \"foo_short\": 7 }",
            "{ \"foo_short\": 7 }");

  JsonMerge("{ \"foo_int\": 5 }", "{ \"foo_int\": 7 }", "{ \"foo_int\": 7 }");

  JsonMerge("{ \"foo_uint\": 5 }", "{ \"foo_uint\": 7 }",
            "{ \"foo_uint\": 7 }");

  JsonMerge("{ \"foo_long\": 5 }", "{ \"foo_long\": 7 }",
            "{ \"foo_long\": 7 }");

  JsonMerge("{ \"foo_ulong\": 5 }", "{ \"foo_ulong\": 7 }",
            "{ \"foo_ulong\": 7 }");

  JsonMerge("{ \"foo_float\": 5.0 }", "{ \"foo_float\": 7.1 }",
            "{ \"foo_float\": 7.1 }");

  JsonMerge("{ \"foo_double\": 5.0 }", "{ \"foo_double\": 7.1 }",
            "{ \"foo_double\": 7.1 }");
}

// Test arrays of simple types.
TEST_F(FlatbufferMerge, Array) {
  JsonMerge("{ \"foo_string\": \"baz\" }", "{ \"foo_string\": \"bar\" }",
            "{ \"foo_string\": \"bar\" }");

  JsonMerge("{ \"vector_foo_bool\": [ true, true, false ] }",
            "{ \"vector_foo_bool\": [ false, true, true, false ] }",
            "{ \"vector_foo_bool\": [ true, true, false, false, "
            "true, true, false ] }");

  JsonMerge("{ \"vector_foo_byte\": [ 9, 7, 1 ] }",
            "{ \"vector_foo_byte\": [ -3, 1, 3, 2 ] }",
            "{ \"vector_foo_byte\": [ 9, 7, 1, -3, 1, 3, 2 ] }");

  JsonMerge("{ \"vector_foo_ubyte\": [ 9, 7, 1 ] }",
            "{ \"vector_foo_ubyte\": [ 3, 1, 3, 2 ] }",
            "{ \"vector_foo_ubyte\": [ 9, 7, 1, 3, 1, 3, 2 ] }");

  JsonMerge("{ \"vector_foo_short\": [ 9, 7, 1 ] }",
            "{ \"vector_foo_short\": [ -3, 1, 3, 2 ] }",
            "{ \"vector_foo_short\": [ 9, 7, 1, -3, 1, 3, 2 ] }");

  JsonMerge("{ \"vector_foo_ushort\": [ 9, 7, 1 ] }",
            "{ \"vector_foo_ushort\": [ 3, 1, 3, 2 ] }",
            "{ \"vector_foo_ushort\": [ 9, 7, 1, 3, 1, 3, 2 ] }");

  JsonMerge("{ \"vector_foo_int\": [ 9, 7, 1 ] }",
            "{ \"vector_foo_int\": [ -3, 1, 3, 2 ] }",
            "{ \"vector_foo_int\": [ 9, 7, 1, -3, 1, 3, 2 ] }");

  JsonMerge("{ \"vector_foo_uint\": [ 9, 7, 1 ] }",
            "{ \"vector_foo_uint\": [ 3, 1, 3, 2 ] }",
            "{ \"vector_foo_uint\": [ 9, 7, 1, 3, 1, 3, 2 ] }");

  JsonMerge("{ \"vector_foo_long\": [ 9, 7, 1 ] }",
            "{ \"vector_foo_long\": [ -3, 1, 3, 2 ] }",
            "{ \"vector_foo_long\": [ 9, 7, 1, -3, 1, 3, 2 ] }");

  JsonMerge("{ \"vector_foo_ulong\": [ 9, 7, 1 ] }",
            "{ \"vector_foo_ulong\": [ 3, 1, 3, 2 ] }",
            "{ \"vector_foo_ulong\": [ 9, 7, 1, 3, 1, 3, 2 ] }");

  JsonMerge("{ \"vector_foo_float\": [ 9.0, 7.0, 1.0 ] }",
            "{ \"vector_foo_float\": [ -3.0, 1.3, 3.0, 2.0 ] }",
            "{ \"vector_foo_float\": [ 9.0, 7.0, 1.0, -3.0, 1.3, 3.0, 2.0 ] }");

  JsonMerge(
      "{ \"vector_foo_string\": [ \"9\", \"7\", \"1 \" ] }",
      "{ \"vector_foo_string\": [ \"31\", \"32\" ] }",
      "{ \"vector_foo_string\": [ \"9\", \"7\", \"1 \", \"31\", \"32\" ] }");
}

// Test nested messages, and arrays of nested messages.
TEST_F(FlatbufferMerge, NestedStruct) {
  JsonMerge(
      "{ \"single_application\": { \"name\": \"woot\" } }",
      "{ \"single_application\": { \"name\": \"wow\", \"priority\": 7 } }",
      "{ \"single_application\": { \"name\": \"wow\", \"priority\": 7 } }");

  JsonMerge(
      "{ \"single_application\": { \"name\": \"wow\", \"priority\": 7 } }",
      "{ \"single_application\": { \"name\": \"woot\" } }",
      "{ \"single_application\": { \"name\": \"woot\", \"priority\": 7 } }");

  JsonMerge("{ \"apps\": [ { \"name\": \"woot\" }, { \"name\": \"wow\" } ] }",
            "{ \"apps\": [ { \"name\": \"woo2\" }, { \"name\": \"wo3\" } ] }",
            "{ \"apps\": [ { \"name\": \"woot\" }, { \"name\": \"wow\" }, { "
            "\"name\": \"woo2\" }, { \"name\": \"wo3\" } ] }");
}

// Test nested messages, and arrays of nested messages.
TEST(FlatbufferCopy, WholesaleCopy) {
  flatbuffers::FlatBufferBuilder fbb_expected;
  fbb_expected.ForceDefaults(true);
  fbb_expected.DedupVtables(false);

  {
    flatbuffers::Offset<flatbuffers::String> name1_offset =
        fbb_expected.CreateString("wow");

    std::vector<flatbuffers::Offset<Application>> application_offsets;
    Application::Builder a1_builder(fbb_expected);
    a1_builder.add_name(name1_offset);
    a1_builder.add_priority(7);
    a1_builder.add_long_thingy(0x2549713132LL);
    application_offsets.emplace_back(a1_builder.Finish());

    flatbuffers::Offset<flatbuffers::String> name2_offset =
        fbb_expected.CreateString("foo");
    Application::Builder a2_builder(fbb_expected);
    a2_builder.add_name(name2_offset);
    a2_builder.add_priority(3);
    a2_builder.add_long_thingy(9);
    application_offsets.emplace_back(a2_builder.Finish());

    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Application>>>
        applications_offset = fbb_expected.CreateVector(application_offsets);

    Configuration::Builder configuration_builder(fbb_expected);
    configuration_builder.add_apps(applications_offset);
    fbb_expected.Finish(configuration_builder.Finish());
  }

  LOG(INFO) << "Initial alignment " << fbb_expected.GetBufferMinAlignment();

  aos::FlatbufferDetachedBuffer<Configuration> expected(fbb_expected.Release());

  LOG(INFO) << "Expected "
            << absl::BytesToHexString(std::string_view(
                   reinterpret_cast<char *>(expected.span().data()),
                   expected.span().size()));

  aos::FlatbufferDetachedBuffer<Application> a1 = []() {
    flatbuffers::FlatBufferBuilder fbb;
    fbb.ForceDefaults(true);

    flatbuffers::Offset<flatbuffers::String> name1_offset =
        fbb.CreateString("wow");

    Application::Builder a1_builder(fbb);
    a1_builder.add_name(name1_offset);
    a1_builder.add_priority(7);
    a1_builder.add_long_thingy(0x2549713132LL);
    flatbuffers::Offset<Application> a1 = a1_builder.Finish();

    fbb.Finish(a1);
    return fbb.Release();
  }();

  aos::FlatbufferDetachedBuffer<Application> a2 =
      JsonToFlatbuffer<Application>(static_cast<const char *>(
          "{ \"name\": \"foo\", \"priority\": 3, \"long_thingy\": 9 }"));

  aos::FlatbufferDetachedBuffer<Configuration> c1 = [&a1, &a2]() {
    flatbuffers::FlatBufferBuilder fbb;
    fbb.ForceDefaults(true);

    std::vector<flatbuffers::Offset<Application>> application_offsets;
    application_offsets.emplace_back(BlindCopyFlatBuffer(a1, &fbb));
    application_offsets.emplace_back(BlindCopyFlatBuffer(a2, &fbb));

    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Application>>>
        applications_offset = fbb.CreateVector(application_offsets);

    Configuration::Builder configuration_builder(fbb);
    configuration_builder.add_apps(applications_offset);
    fbb.Finish(configuration_builder.Finish());

    return fbb.Release();
  }();

  LOG(INFO) << "Got      "
            << absl::BytesToHexString(
                   std::string_view(reinterpret_cast<char *>(c1.span().data()),
                                    c1.span().size()));

  aos::FlatbufferDetachedBuffer<Configuration> c2 = [&a1, &a2]() {
    flatbuffers::FlatBufferBuilder fbb;
    fbb.ForceDefaults(true);

    std::vector<flatbuffers::Offset<Application>> application_offsets;
    application_offsets.emplace_back(CopyFlatBuffer(&a1.message(), &fbb));
    application_offsets.emplace_back(CopyFlatBuffer(&a2.message(), &fbb));

    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Application>>>
        applications_offset = fbb.CreateVector(application_offsets);

    Configuration::Builder configuration_builder(fbb);
    configuration_builder.add_apps(applications_offset);
    fbb.Finish(configuration_builder.Finish());

    return fbb.Release();
  }();

  LOG(INFO) << "Got      "
            << absl::BytesToHexString(
                   std::string_view(reinterpret_cast<char *>(c2.span().data()),
                                    c2.span().size()));

  ASSERT_TRUE(expected.Verify());
  ASSERT_TRUE(c1.Verify());
  ASSERT_TRUE(c2.Verify());

  LOG(INFO) << FlatbufferToJson(expected);
  LOG(INFO) << FlatbufferToJson(c1);
  LOG(INFO) << FlatbufferToJson(c2);
  EXPECT_EQ(FlatbufferToJson(expected), FlatbufferToJson(c1));
  EXPECT_EQ(FlatbufferToJson(expected), FlatbufferToJson(c2));
}

// Tests a compare of 2 basic (different) messages.
TEST_F(FlatbufferMerge, CompareDifferent) {
  aos::FlatbufferDetachedBuffer<Configuration> message1(JsonToFlatbuffer(
      "{ \"single_application\": { \"name\": \"wow\", \"priority\": 7 } }",
      ConfigurationTypeTable()));
  aos::FlatbufferDetachedBuffer<Configuration> message2(JsonToFlatbuffer(
      "{ \"single_application\": { \"name\": \"wow\", \"priority\": 8 } }",
      ConfigurationTypeTable()));

  EXPECT_FALSE(CompareFlatBuffer(&message1.message(), &message2.message()));
}

// TODO(austin): enums
// TODO(austin): unions
// TODO(austin): struct

}  // namespace testing
}  // namespace aos