/*

* Copyright 2014 Google Inc. All rights reserved.

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

#include "flatbuffers/flatbuffers.h"

#include "flatbuffers/idl.h"

#include "flatbuffers/util.h"

#include "flatbuffers/registry.h"

#include "flatbuffers/minireflect.h"

#include "monster_test_generated.h"

#include "namespace_test/namespace_test1_generated.h"

#include "namespace_test/namespace_test2_generated.h"

#include "union_vector/union_vector_generated.h"

#ifndef FLATBUFFERS_CPP98_STL

#include <random>

#endif

#include "flatbuffers/flexbuffers.h"

using namespace MyGame::Example;

#ifdef __ANDROID__

#include <android/log.h>

#define TEST_OUTPUT_LINE(...) \

__android_log_print(ANDROID_LOG_INFO, "FlatBuffers", __VA_ARGS__)

#define FLATBUFFERS_NO_FILE_TESTS

#else

#define TEST_OUTPUT_LINE(...) \

{ printf(__VA_ARGS__); printf("\n"); }

#endif

int testing_fails = 0;

void TestFail(const char *expval, const char *val, const char *exp,

const char *file, int line) {

TEST_OUTPUT_LINE("VALUE: \"%s\"", expval);

TEST_OUTPUT_LINE("EXPECTED: \"%s\"", val);

TEST_OUTPUT_LINE("TEST FAILED: %s:%d, %s", file, line, exp);

assert(0);

testing_fails++;

}

void TestEqStr(const char *expval, const char *val, const char *exp,

const char *file, int line) {

if (strcmp(expval, val) != 0) {

TestFail(expval, val, exp, file, line);

}

}

template<typename T, typename U>

void TestEq(T expval, U val, const char *exp, const char *file, int line) {

if (U(expval) != val) {

TestFail(flatbuffers::NumToString(expval).c_str(),

flatbuffers::NumToString(val).c_str(),

exp, file, line);

}

}

#define TEST_EQ(exp, val) TestEq(exp, val, #exp, __FILE__, __LINE__)

#define TEST_NOTNULL(exp) TestEq(exp == NULL, false, #exp, __FILE__, __LINE__)

#define TEST_EQ_STR(exp, val) TestEqStr(exp, val, #exp, __FILE__, __LINE__)

// Include simple random number generator to ensure results will be the

// same cross platform.

// http://en.wikipedia.org/wiki/Park%E2%80%93Miller_random_number_generator

uint32_t lcg_seed = 48271;

uint32_t lcg_rand() {

return lcg_seed = ((uint64_t)lcg_seed * 279470273UL) % 4294967291UL;

}

void lcg_reset() { lcg_seed = 48271; }

std::string test_data_path = "tests/";

// example of how to build up a serialized buffer algorithmically:

flatbuffers::DetachedBuffer CreateFlatBufferTest(std::string &buffer) {

flatbuffers::FlatBufferBuilder builder;

auto vec = Vec3(1, 2, 3, 0, Color_Red, Test(10, 20));

auto name = builder.CreateString("MyMonster");

unsigned char inv_data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

auto inventory = builder.CreateVector(inv_data, 10);

// Alternatively, create the vector first, and fill in data later:

// unsigned char *inv_buf = nullptr;

// auto inventory = builder.CreateUninitializedVector<unsigned char>(

// 10, &inv_buf);

// memcpy(inv_buf, inv_data, 10);

Test tests[] = { Test(10, 20), Test(30, 40) };

auto testv = builder.CreateVectorOfStructs(tests, 2);

#ifndef FLATBUFFERS_CPP98_STL

// Create a vector of structures from a lambda.

auto testv2 = builder.CreateVectorOfStructs<Test>(

2, [&](size_t i, Test* s) -> void {

*s = tests[i];

});

#else

// Create a vector of structures using a plain old C++ function.

auto testv2 = builder.CreateVectorOfStructs<Test>(

2, [](size_t i, Test* s, void *state) -> void {

*s = (reinterpret_cast<Test*>(state))[i];

}, tests);

#endif // FLATBUFFERS_CPP98_STL

// create monster with very few fields set:

// (same functionality as CreateMonster below, but sets fields manually)

flatbuffers::Offset<Monster> mlocs[3];

auto fred = builder.CreateString("Fred");

auto barney = builder.CreateString("Barney");

auto wilma = builder.CreateString("Wilma");

MonsterBuilder mb1(builder);

mb1.add_name(fred);

mlocs[0] = mb1.Finish();

MonsterBuilder mb2(builder);

mb2.add_name(barney);

mb2.add_hp(1000);

mlocs[1] = mb2.Finish();

MonsterBuilder mb3(builder);

mb3.add_name(wilma);

mlocs[2] = mb3.Finish();

// Create an array of strings. Also test string pooling, and lambdas.

auto vecofstrings =

builder.CreateVector<flatbuffers::Offset<flatbuffers::String>>(4,

[](size_t i, flatbuffers::FlatBufferBuilder *b)

-> flatbuffers::Offset<flatbuffers::String> {

static const char *names[] = { "bob", "fred", "bob", "fred" };

return b->CreateSharedString(names[i]);

}, &builder);

// Creating vectors of strings in one convenient call.

std::vector<std::string> names2;

names2.push_back("jane");

names2.push_back("mary");

auto vecofstrings2 = builder.CreateVectorOfStrings(names2);

// Create an array of sorted tables, can be used with binary search when read:

auto vecoftables = builder.CreateVectorOfSortedTables(mlocs, 3);

// Create an array of sorted structs,

// can be used with binary search when read:

std::vector<Ability> abilities;

abilities.push_back(Ability(4, 40));

abilities.push_back(Ability(3, 30));

abilities.push_back(Ability(2, 20));

abilities.push_back(Ability(1, 10));

auto vecofstructs = builder.CreateVectorOfSortedStructs(&abilities);

// Create a nested FlatBuffer.

// Nested FlatBuffers are stored in a ubyte vector, which can be convenient

// since they can be memcpy'd around much easier than other FlatBuffer

// values. They have little overhead compared to storing the table directly.

// As a test, create a mostly empty Monster buffer:

flatbuffers::FlatBufferBuilder nested_builder;

auto nmloc = CreateMonster(nested_builder, nullptr, 0, 0,

nested_builder.CreateString("NestedMonster"));

FinishMonsterBuffer(nested_builder, nmloc);

// Now we can store the buffer in the parent. Note that by default, vectors

// are only aligned to their elements or size field, so in this case if the

// buffer contains 64-bit elements, they may not be correctly aligned. We fix

// that with:

builder.ForceVectorAlignment(nested_builder.GetSize(), sizeof(uint8_t),

nested_builder.GetBufferMinAlignment());

// If for whatever reason you don't have the nested_builder available, you

// can substitute flatbuffers::largest_scalar_t (64-bit) for the alignment, or

// the largest force_align value in your schema if you're using it.

auto nested_flatbuffer_vector =

builder.CreateVector(nested_builder.GetBufferPointer(),

nested_builder.GetSize());

// Test a nested FlexBuffer:

flexbuffers::Builder flexbuild;

flexbuild.Int(1234);

flexbuild.Finish();

auto flex = builder.CreateVector(flexbuild.GetBuffer());

// shortcut for creating monster with all fields set:

auto mloc = CreateMonster(builder, &vec, 150, 80, name, inventory, Color_Blue,

Any_Monster, mlocs[1].Union(), // Store a union.

testv, vecofstrings, vecoftables, 0,

nested_flatbuffer_vector, 0, false,

0, 0, 0, 0, 0, 0, 0, 0, 0, 3.14159f, 3.0f, 0.0f,

vecofstrings2, vecofstructs, flex, testv2);

FinishMonsterBuffer(builder, mloc);

#ifdef FLATBUFFERS_TEST_VERBOSE

// print byte data for debugging:

auto p = builder.GetBufferPointer();

for (flatbuffers::uoffset_t i = 0; i < builder.GetSize(); i++)

printf("%d ", p[i]);

#endif

// return the buffer for the caller to use.

auto bufferpointer =

reinterpret_cast<const char *>(builder.GetBufferPointer());

buffer.assign(bufferpointer, bufferpointer + builder.GetSize());

return builder.ReleaseBufferPointer();

}

// example of accessing a buffer loaded in memory:

void AccessFlatBufferTest(const uint8_t *flatbuf, size_t length,

bool pooled = true) {

// First, verify the buffers integrity (optional)

flatbuffers::Verifier verifier(flatbuf, length);

TEST_EQ(VerifyMonsterBuffer(verifier), true);

std::vector<uint8_t> test_buff;

test_buff.resize(length * 2);

std::memcpy(&test_buff[0], flatbuf , length);

std::memcpy(&test_buff[length], flatbuf , length);

flatbuffers::Verifier verifier1(&test_buff[0], length);

TEST_EQ(VerifyMonsterBuffer(verifier1), true);

TEST_EQ(verifier1.GetComputedSize(), length);

flatbuffers::Verifier verifier2(&test_buff[length], length);

TEST_EQ(VerifyMonsterBuffer(verifier2), true);

TEST_EQ(verifier2.GetComputedSize(), length);

TEST_EQ(strcmp(MonsterIdentifier(), "MONS"), 0);

TEST_EQ(MonsterBufferHasIdentifier(flatbuf), true);

TEST_EQ(strcmp(MonsterExtension(), "mon"), 0);

// Access the buffer from the root.

auto monster = GetMonster(flatbuf);

TEST_EQ(monster->hp(), 80);

TEST_EQ(monster->mana(), 150); // default

TEST_EQ_STR(monster->name()->c_str(), "MyMonster");

// Can't access the following field, it is deprecated in the schema,

// which means accessors are not generated:

// monster.friendly()

auto pos = monster->pos();

TEST_NOTNULL(pos);

TEST_EQ(pos->z(), 3);

TEST_EQ(pos->test3().a(), 10);

TEST_EQ(pos->test3().b(), 20);

auto inventory = monster->inventory();

TEST_EQ(VectorLength(inventory), 10UL); // Works even if inventory is null.

TEST_NOTNULL(inventory);

unsigned char inv_data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

for (auto it = inventory->begin(); it != inventory->end(); ++it)

TEST_EQ(*it, inv_data[it - inventory->begin()]);

TEST_EQ(monster->color(), Color_Blue);

// Example of accessing a union:

TEST_EQ(monster->test_type(), Any_Monster); // First make sure which it is.

auto monster2 = reinterpret_cast<const Monster *>(monster->test());

TEST_NOTNULL(monster2);

TEST_EQ_STR(monster2->name()->c_str(), "Fred");

// Example of accessing a vector of strings:

auto vecofstrings = monster->testarrayofstring();

TEST_EQ(vecofstrings->Length(), 4U);

TEST_EQ_STR(vecofstrings->Get(0)->c_str(), "bob");

TEST_EQ_STR(vecofstrings->Get(1)->c_str(), "fred");

if (pooled) {

// These should have pointer equality because of string pooling.

TEST_EQ(vecofstrings->Get(0)->c_str(), vecofstrings->Get(2)->c_str());

TEST_EQ(vecofstrings->Get(1)->c_str(), vecofstrings->Get(3)->c_str());

}

auto vecofstrings2 = monster->testarrayofstring2();

if (vecofstrings2) {

TEST_EQ(vecofstrings2->Length(), 2U);

TEST_EQ_STR(vecofstrings2->Get(0)->c_str(), "jane");

TEST_EQ_STR(vecofstrings2->Get(1)->c_str(), "mary");

}

// Example of accessing a vector of tables:

auto vecoftables = monster->testarrayoftables();

TEST_EQ(vecoftables->Length(), 3U);

for (auto it = vecoftables->begin(); it != vecoftables->end(); ++it)

TEST_EQ(strlen(it->name()->c_str()) >= 4, true);

TEST_EQ_STR(vecoftables->Get(0)->name()->c_str(), "Barney");

TEST_EQ(vecoftables->Get(0)->hp(), 1000);

TEST_EQ_STR(vecoftables->Get(1)->name()->c_str(), "Fred");

TEST_EQ_STR(vecoftables->Get(2)->name()->c_str(), "Wilma");

TEST_NOTNULL(vecoftables->LookupByKey("Barney"));

TEST_NOTNULL(vecoftables->LookupByKey("Fred"));

TEST_NOTNULL(vecoftables->LookupByKey("Wilma"));

// Test accessing a vector of sorted structs

auto vecofstructs = monster->testarrayofsortedstruct();

if (vecofstructs) { // not filled in monster_test.bfbs

for (flatbuffers::uoffset_t i = 0; i < vecofstructs->size()-1; i++) {

auto left = vecofstructs->Get(i);

auto right = vecofstructs->Get(i+1);

TEST_EQ(true, (left->KeyCompareLessThan(right)));

}

TEST_NOTNULL(vecofstructs->LookupByKey(3));

TEST_EQ(static_cast<const Ability*>(nullptr), vecofstructs->LookupByKey(5));

}

// Test nested FlatBuffers if available:

auto nested_buffer = monster->testnestedflatbuffer();

if (nested_buffer) {

// nested_buffer is a vector of bytes you can memcpy. However, if you

// actually want to access the nested data, this is a convenient

// accessor that directly gives you the root table:

auto nested_monster = monster->testnestedflatbuffer_nested_root();

TEST_EQ_STR(nested_monster->name()->c_str(), "NestedMonster");

}

// Test flexbuffer if available:

auto flex = monster->flex();

// flex is a vector of bytes you can memcpy etc.

TEST_EQ(flex->size(), 4); // Encoded FlexBuffer bytes.

// However, if you actually want to access the nested data, this is a

// convenient accessor that directly gives you the root value:

TEST_EQ(monster->flex_flexbuffer_root().AsInt16(), 1234);

// Since Flatbuffers uses explicit mechanisms to override the default

// compiler alignment, double check that the compiler indeed obeys them:

// (Test consists of a short and byte):

TEST_EQ(flatbuffers::AlignOf<Test>(), 2UL);

TEST_EQ(sizeof(Test), 4UL);

const flatbuffers::Vector<const Test *>* tests_array[] = {

monster->test4(),

monster->test5(),

};

for (size_t i = 0; i < sizeof(tests_array) / sizeof(tests_array[0]); ++i) {

auto tests = tests_array[i];

TEST_NOTNULL(tests);

auto test_0 = tests->Get(0);

auto test_1 = tests->Get(1);

TEST_EQ(test_0->a(), 10);

TEST_EQ(test_0->b(), 20);

TEST_EQ(test_1->a(), 30);

TEST_EQ(test_1->b(), 40);

for (auto it = tests->begin(); it != tests->end(); ++it) {

TEST_EQ(it->a() == 10 || it->a() == 30, true); // Just testing iterators.

}

}

// Checking for presence of fields:

TEST_EQ(flatbuffers::IsFieldPresent(monster, Monster::VT_HP), true);

TEST_EQ(flatbuffers::IsFieldPresent(monster, Monster::VT_MANA), false);

// Obtaining a buffer from a root:

TEST_EQ(GetBufferStartFromRootPointer(monster), flatbuf);

}

// Change a FlatBuffer in-place, after it has been constructed.

void MutateFlatBuffersTest(uint8_t *flatbuf, std::size_t length) {

// Get non-const pointer to root.

auto monster = GetMutableMonster(flatbuf);

// Each of these tests mutates, then tests, then set back to the original,

// so we can test that the buffer in the end still passes our original test.

auto hp_ok = monster->mutate_hp(10);

TEST_EQ(hp_ok, true); // Field was present.

TEST_EQ(monster->hp(), 10);

// Mutate to default value

auto hp_ok_default = monster->mutate_hp(100);

TEST_EQ(hp_ok_default, true); // Field was present.

TEST_EQ(monster->hp(), 100);

// Test that mutate to default above keeps field valid for further mutations

auto hp_ok_2 = monster->mutate_hp(20);

TEST_EQ(hp_ok_2, true);

TEST_EQ(monster->hp(), 20);

monster->mutate_hp(80);

// Monster originally at 150 mana (default value)

auto mana_default_ok = monster->mutate_mana(150); // Mutate to default value.

TEST_EQ(mana_default_ok, true); // Mutation should succeed, because default value.

TEST_EQ(monster->mana(), 150);

auto mana_ok = monster->mutate_mana(10);

TEST_EQ(mana_ok, false); // Field was NOT present, because default value.

TEST_EQ(monster->mana(), 150);

// Mutate structs.

auto pos = monster->mutable_pos();

auto test3 = pos->mutable_test3(); // Struct inside a struct.

test3.mutate_a(50); // Struct fields never fail.

TEST_EQ(test3.a(), 50);

test3.mutate_a(10);

// Mutate vectors.

auto inventory = monster->mutable_inventory();

inventory->Mutate(9, 100);

TEST_EQ(inventory->Get(9), 100);

inventory->Mutate(9, 9);

auto tables = monster->mutable_testarrayoftables();

auto first = tables->GetMutableObject(0);

TEST_EQ(first->hp(), 1000);

first->mutate_hp(0);

TEST_EQ(first->hp(), 0);

first->mutate_hp(1000);

// Run the verifier and the regular test to make sure we didn't trample on

// anything.

AccessFlatBufferTest(flatbuf, length);

}

// Unpack a FlatBuffer into objects.

void ObjectFlatBuffersTest(uint8_t *flatbuf) {

// Optional: we can specify resolver and rehasher functions to turn hashed

// strings into object pointers and back, to implement remote references

// and such.

auto resolver = flatbuffers::resolver_function_t(

[](void **pointer_adr, flatbuffers::hash_value_t hash) {

(void)pointer_adr;

(void)hash;

// Don't actually do anything, leave variable null.

});

auto rehasher = flatbuffers::rehasher_function_t(

[](void *pointer) -> flatbuffers::hash_value_t {

(void)pointer;

return 0;

});

// Turn a buffer into C++ objects.

auto monster1 = UnPackMonster(flatbuf, &resolver);

// Re-serialize the data.

flatbuffers::FlatBufferBuilder fbb1;

fbb1.Finish(CreateMonster(fbb1, monster1.get(), &rehasher),

MonsterIdentifier());

// Unpack again, and re-serialize again.

auto monster2 = UnPackMonster(fbb1.GetBufferPointer(), &resolver);

flatbuffers::FlatBufferBuilder fbb2;

fbb2.Finish(CreateMonster(fbb2, monster2.get(), &rehasher),

MonsterIdentifier());

// Now we've gone full round-trip, the two buffers should match.

auto len1 = fbb1.GetSize();

auto len2 = fbb2.GetSize();

TEST_EQ(len1, len2);

TEST_EQ(memcmp(fbb1.GetBufferPointer(), fbb2.GetBufferPointer(),

len1), 0);

// Test it with the original buffer test to make sure all data survived.

AccessFlatBufferTest(fbb2.GetBufferPointer(), len2, false);

// Test accessing fields, similar to AccessFlatBufferTest above.

TEST_EQ(monster2->hp, 80);

TEST_EQ(monster2->mana, 150); // default

TEST_EQ_STR(monster2->name.c_str(), "MyMonster");

auto &pos = monster2->pos;

TEST_NOTNULL(pos);

TEST_EQ(pos->z(), 3);

TEST_EQ(pos->test3().a(), 10);

TEST_EQ(pos->test3().b(), 20);

auto &inventory = monster2->inventory;

TEST_EQ(inventory.size(), 10UL);

unsigned char inv_data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

for (auto it = inventory.begin(); it != inventory.end(); ++it)

TEST_EQ(*it, inv_data[it - inventory.begin()]);

TEST_EQ(monster2->color, Color_Blue);

auto monster3 = monster2->test.AsMonster();

TEST_NOTNULL(monster3);

TEST_EQ_STR(monster3->name.c_str(), "Fred");

auto &vecofstrings = monster2->testarrayofstring;

TEST_EQ(vecofstrings.size(), 4U);

TEST_EQ_STR(vecofstrings[0].c_str(), "bob");

TEST_EQ_STR(vecofstrings[1].c_str(), "fred");

auto &vecofstrings2 = monster2->testarrayofstring2;

TEST_EQ(vecofstrings2.size(), 2U);

TEST_EQ_STR(vecofstrings2[0].c_str(), "jane");

TEST_EQ_STR(vecofstrings2[1].c_str(), "mary");

auto &vecoftables = monster2->testarrayoftables;

TEST_EQ(vecoftables.size(), 3U);

TEST_EQ_STR(vecoftables[0]->name.c_str(), "Barney");

TEST_EQ(vecoftables[0]->hp, 1000);

TEST_EQ_STR(vecoftables[1]->name.c_str(), "Fred");

TEST_EQ_STR(vecoftables[2]->name.c_str(), "Wilma");

auto &tests = monster2->test4;

TEST_EQ(tests[0].a(), 10);

TEST_EQ(tests[0].b(), 20);

TEST_EQ(tests[1].a(), 30);

TEST_EQ(tests[1].b(), 40);

}

// Prefix a FlatBuffer with a size field.

void SizePrefixedTest() {

// Create size prefixed buffer.

flatbuffers::FlatBufferBuilder fbb;

fbb.FinishSizePrefixed(CreateMonster(fbb, 0, 200, 300,

fbb.CreateString("bob")));

// Verify it.

flatbuffers::Verifier verifier(fbb.GetBufferPointer(), fbb.GetSize());

TEST_EQ(verifier.VerifySizePrefixedBuffer<Monster>(nullptr), true);

// Access it.

auto m = flatbuffers::GetSizePrefixedRoot<MyGame::Example::Monster>(

fbb.GetBufferPointer());

TEST_EQ(m->mana(), 200);

TEST_EQ(m->hp(), 300);

TEST_EQ_STR(m->name()->c_str(), "bob");

}

void TriviallyCopyableTest() {

#if __GNUG__ && __GNUC__ < 5

TEST_EQ(__has_trivial_copy(Vec3), true);

#else

#if __cplusplus >= 201103L

TEST_EQ(std::is_trivially_copyable<Vec3>::value, true);

#endif

#endif

}

// example of parsing text straight into a buffer, and generating

// text back from it:

void ParseAndGenerateTextTest() {

// load FlatBuffer schema (.fbs) and JSON from disk

std::string schemafile;

std::string jsonfile;

TEST_EQ(flatbuffers::LoadFile(

(test_data_path + "monster_test.fbs").c_str(), false, &schemafile), true);

TEST_EQ(flatbuffers::LoadFile(

(test_data_path + "monsterdata_test.golden").c_str(), false, &jsonfile),

true);

// parse schema first, so we can use it to parse the data after

flatbuffers::Parser parser;

auto include_test_path =

flatbuffers::ConCatPathFileName(test_data_path, "include_test");

const char *include_directories[] = {

test_data_path.c_str(), include_test_path.c_str(), nullptr

};

TEST_EQ(parser.Parse(schemafile.c_str(), include_directories), true);

TEST_EQ(parser.Parse(jsonfile.c_str(), include_directories), true);

// here, parser.builder_ contains a binary buffer that is the parsed data.

// First, verify it, just in case:

flatbuffers::Verifier verifier(parser.builder_.GetBufferPointer(),

parser.builder_.GetSize());

TEST_EQ(VerifyMonsterBuffer(verifier), true);

AccessFlatBufferTest(parser.builder_.GetBufferPointer(),

parser.builder_.GetSize(), false);

// to ensure it is correct, we now generate text back from the binary,

// and compare the two:

std::string jsongen;

auto result = GenerateText(parser, parser.builder_.GetBufferPointer(), &jsongen);

TEST_EQ(result, true);

TEST_EQ_STR(jsongen.c_str(), jsonfile.c_str());

// We can also do the above using the convenient Registry that knows about

// a set of file_identifiers mapped to schemas.

flatbuffers::Registry registry;

// Make sure schemas can find their includes.

registry.AddIncludeDirectory(test_data_path.c_str());

registry.AddIncludeDirectory(include_test_path.c_str());

// Call this with many schemas if possible.

registry.Register(MonsterIdentifier(),

(test_data_path + "monster_test.fbs").c_str());

// Now we got this set up, we can parse by just specifying the identifier,

// the correct schema will be loaded on the fly:

auto buf = registry.TextToFlatBuffer(jsonfile.c_str(),

MonsterIdentifier());

// If this fails, check registry.lasterror_.

TEST_NOTNULL(buf.data());

// Test the buffer, to be sure:

AccessFlatBufferTest(buf.data(), buf.size(), false);

// We can use the registry to turn this back into text, in this case it

// will get the file_identifier from the binary:

std::string text;

auto ok = registry.FlatBufferToText(buf.data(), buf.size(), &text);

// If this fails, check registry.lasterror_.

TEST_EQ(ok, true);

TEST_EQ_STR(text.c_str(), jsonfile.c_str());

}

void ReflectionTest(uint8_t *flatbuf, size_t length) {

// Load a binary schema.

std::string bfbsfile;

TEST_EQ(flatbuffers::LoadFile(

(test_data_path + "monster_test.bfbs").c_str(), true, &bfbsfile),

true);

// Verify it, just in case:

flatbuffers::Verifier verifier(

reinterpret_cast<const uint8_t *>(bfbsfile.c_str()), bfbsfile.length());

TEST_EQ(reflection::VerifySchemaBuffer(verifier), true);

// Make sure the schema is what we expect it to be.

auto &schema = *reflection::GetSchema(bfbsfile.c_str());

auto root_table = schema.root_table();

TEST_EQ_STR(root_table->name()->c_str(), "MyGame.Example.Monster");

auto fields = root_table->fields();

auto hp_field_ptr = fields->LookupByKey("hp");

TEST_NOTNULL(hp_field_ptr);

auto &hp_field = *hp_field_ptr;

TEST_EQ_STR(hp_field.name()->c_str(), "hp");

TEST_EQ(hp_field.id(), 2);

TEST_EQ(hp_field.type()->base_type(), reflection::Short);

auto friendly_field_ptr = fields->LookupByKey("friendly");

TEST_NOTNULL(friendly_field_ptr);

TEST_NOTNULL(friendly_field_ptr->attributes());

TEST_NOTNULL(friendly_field_ptr->attributes()->LookupByKey("priority"));

// Make sure the table index is what we expect it to be.

auto pos_field_ptr = fields->LookupByKey("pos");

TEST_NOTNULL(pos_field_ptr);

TEST_EQ(pos_field_ptr->type()->base_type(), reflection::Obj);

auto pos_table_ptr = schema.objects()->Get(pos_field_ptr->type()->index());

TEST_NOTNULL(pos_table_ptr);

TEST_EQ_STR(pos_table_ptr->name()->c_str(), "MyGame.Example.Vec3");

// Now use it to dynamically access a buffer.

auto &root = *flatbuffers::GetAnyRoot(flatbuf);

// Verify the buffer first using reflection based verification

TEST_EQ(flatbuffers::Verify(schema, *schema.root_table(), flatbuf, length),

true);

auto hp = flatbuffers::GetFieldI<uint16_t>(root, hp_field);

TEST_EQ(hp, 80);

// Rather than needing to know the type, we can also get the value of

// any field as an int64_t/double/string, regardless of what it actually is.

auto hp_int64 = flatbuffers::GetAnyFieldI(root, hp_field);

TEST_EQ(hp_int64, 80);

auto hp_double = flatbuffers::GetAnyFieldF(root, hp_field);

TEST_EQ(hp_double, 80.0);

auto hp_string = flatbuffers::GetAnyFieldS(root, hp_field, &schema);

TEST_EQ_STR(hp_string.c_str(), "80");

// Get struct field through reflection

auto pos_struct = flatbuffers::GetFieldStruct(root, *pos_field_ptr);

TEST_NOTNULL(pos_struct);

TEST_EQ(flatbuffers::GetAnyFieldF(

*pos_struct, *pos_table_ptr->fields()->LookupByKey("z")), 3.0f);

auto test3_field = pos_table_ptr->fields()->LookupByKey("test3");

auto test3_struct = flatbuffers::GetFieldStruct(*pos_struct, *test3_field);

TEST_NOTNULL(test3_struct);

auto test3_object = schema.objects()->Get(test3_field->type()->index());

TEST_EQ(flatbuffers::GetAnyFieldF(

*test3_struct, *test3_object->fields()->LookupByKey("a")), 10);

// We can also modify it.

flatbuffers::SetField<uint16_t>(&root, hp_field, 200);

hp = flatbuffers::GetFieldI<uint16_t>(root, hp_field);

TEST_EQ(hp, 200);

// We can also set fields generically:

flatbuffers::SetAnyFieldI(&root, hp_field, 300);

hp_int64 = flatbuffers::GetAnyFieldI(root, hp_field);

TEST_EQ(hp_int64, 300);

flatbuffers::SetAnyFieldF(&root, hp_field, 300.5);

hp_int64 = flatbuffers::GetAnyFieldI(root, hp_field);

TEST_EQ(hp_int64, 300);

flatbuffers::SetAnyFieldS(&root, hp_field, "300");

hp_int64 = flatbuffers::GetAnyFieldI(root, hp_field);

TEST_EQ(hp_int64, 300);

// Test buffer is valid after the modifications

TEST_EQ(flatbuffers::Verify(schema, *schema.root_table(), flatbuf, length),

true);

// Reset it, for further tests.

flatbuffers::SetField<uint16_t>(&root, hp_field, 80);

// More advanced functionality: changing the size of items in-line!

// First we put the FlatBuffer inside an std::vector.

std::vector<uint8_t> resizingbuf(flatbuf, flatbuf + length);

// Find the field we want to modify.

auto &name_field = *fields->LookupByKey("name");

// Get the root.

// This time we wrap the result from GetAnyRoot in a smartpointer that

// will keep rroot valid as resizingbuf resizes.

auto rroot = flatbuffers::piv(flatbuffers::GetAnyRoot(

flatbuffers::vector_data(resizingbuf)), resizingbuf);

SetString(schema, "totally new string", GetFieldS(**rroot, name_field),

&resizingbuf);

// Here resizingbuf has changed, but rroot is still valid.

TEST_EQ_STR(GetFieldS(**rroot, name_field)->c_str(), "totally new string");

// Now lets extend a vector by 100 elements (10 -> 110).

auto &inventory_field = *fields->LookupByKey("inventory");

auto rinventory = flatbuffers::piv(

flatbuffers::GetFieldV<uint8_t>(**rroot, inventory_field),

resizingbuf);

flatbuffers::ResizeVector<uint8_t>(schema, 110, 50, *rinventory,

&resizingbuf);

// rinventory still valid, so lets read from it.

TEST_EQ(rinventory->Get(10), 50);

// For reflection uses not covered already, there is a more powerful way:

// we can simply generate whatever object we want to add/modify in a

// FlatBuffer of its own, then add that to an existing FlatBuffer:

// As an example, let's add a string to an array of strings.

// First, find our field:

auto &testarrayofstring_field = *fields->LookupByKey("testarrayofstring");

// Find the vector value:

auto rtestarrayofstring = flatbuffers::piv(

flatbuffers::GetFieldV<flatbuffers::Offset<flatbuffers::String>>(

**rroot, testarrayofstring_field),

resizingbuf);

// It's a vector of 2 strings, to which we add one more, initialized to

// offset 0.

flatbuffers::ResizeVector<flatbuffers::Offset<flatbuffers::String>>(

schema, 3, 0, *rtestarrayofstring, &resizingbuf);

// Here we just create a buffer that contans a single string, but this

// could also be any complex set of tables and other values.

flatbuffers::FlatBufferBuilder stringfbb;

stringfbb.Finish(stringfbb.CreateString("hank"));

// Add the contents of it to our existing FlatBuffer.

// We do this last, so the pointer doesn't get invalidated (since it is

// at the end of the buffer):

auto string_ptr = flatbuffers::AddFlatBuffer(resizingbuf,

stringfbb.GetBufferPointer(),

stringfbb.GetSize());

// Finally, set the new value in the vector.

rtestarrayofstring->MutateOffset(2, string_ptr);

TEST_EQ_STR(rtestarrayofstring->Get(0)->c_str(), "bob");

TEST_EQ_STR(rtestarrayofstring->Get(2)->c_str(), "hank");

// Test integrity of all resize operations above.

flatbuffers::Verifier resize_verifier(

reinterpret_cast<const uint8_t *>(

flatbuffers::vector_data(resizingbuf)),

resizingbuf.size());

TEST_EQ(VerifyMonsterBuffer(resize_verifier), true);

// Test buffer is valid using reflection as well

TEST_EQ(flatbuffers::Verify(schema, *schema.root_table(),

flatbuffers::vector_data(resizingbuf),

resizingbuf.size()), true);

// As an additional test, also set it on the name field.

// Note: unlike the name change above, this just overwrites the offset,

// rather than changing the string in-place.

SetFieldT(*rroot, name_field, string_ptr);

TEST_EQ_STR(GetFieldS(**rroot, name_field)->c_str(), "hank");

// Using reflection, rather than mutating binary FlatBuffers, we can also copy

// tables and other things out of other FlatBuffers into a FlatBufferBuilder,

// either part or whole.

flatbuffers::FlatBufferBuilder fbb;

auto root_offset = flatbuffers::CopyTable(fbb, schema, *root_table,

*flatbuffers::GetAnyRoot(flatbuf),

true);

fbb.Finish(root_offset, MonsterIdentifier());

// Test that it was copied correctly:

AccessFlatBufferTest(fbb.GetBufferPointer(), fbb.GetSize());

// Test buffer is valid using reflection as well

TEST_EQ(flatbuffers::Verify(schema, *schema.root_table(),

fbb.GetBufferPointer(), fbb.GetSize()), true);

}

void MiniReflectFlatBuffersTest(uint8_t *flatbuf) {

auto s = flatbuffers::FlatBufferToString(flatbuf, MonsterTypeTable());

TEST_EQ_STR(s.c_str(),

"{ "

"pos: { x: 1.0, y: 2.0, z: 3.0, test1: 0.0, test2: Red, test3: "

"{ a: 10, b: 20 } }, "

"hp: 80, "

"name: \"MyMonster\", "

"inventory: [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ], "

"test_type: Monster, "

"test: { name: \"Fred\" }, "

"test4: [ { a: 10, b: 20 }, { a: 30, b: 40 } ], "

"testarrayofstring: [ \"bob\", \"fred\", \"bob\", \"fred\" ], "

"testarrayoftables: [ { hp: 1000, name: \"Barney\" }, { name: \"Fred\" }, "

"{ name: \"Wilma\" } ], "

// TODO(wvo): should really print this nested buffer correctly.

"testnestedflatbuffer: [ 20, 0, 0, 0, 77, 79, 78, 83, 12, 0, 12, 0, 0, 0, "

"4, 0, 6, 0, 8, 0, 12, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 13, 0, 0, 0, 78, "

"101, 115, 116, 101, 100, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0 ], "

"testarrayofstring2: [ \"jane\", \"mary\" ], "

"testarrayofsortedstruct: [ { id: 1, distance: 10 }, "

"{ id: 2, distance: 20 }, { id: 3, distance: 30 }, "

"{ id: 4, distance: 40 } ], "

"flex: [ 210, 4, 5, 2 ], "

"test5: [ { a: 10, b: 20 }, { a: 30, b: 40 } ] "

"}");

}

// Parse a .proto schema, output as .fbs

void ParseProtoTest() {

// load the .proto and the golden file from disk

std::string protofile;

std::string goldenfile;

TEST_EQ(flatbuffers::LoadFile(

(test_data_path + "prototest/test.proto").c_str(), false, &protofile),

true);

TEST_EQ(flatbuffers::LoadFile(

(test_data_path + "prototest/test.golden").c_str(), false, &goldenfile),

true);

flatbuffers::IDLOptions opts;

opts.include_dependence_headers = false;

opts.proto_mode = true;

// Parse proto.

flatbuffers::Parser parser(opts);

auto protopath = test_data_path + "prototest/";

const char *include_directories[] = { protopath.c_str(), nullptr };

TEST_EQ(parser.Parse(protofile.c_str(), include_directories), true);

// Generate fbs.

auto fbs = flatbuffers::GenerateFBS(parser, "test");

// Ensure generated file is parsable.

flatbuffers::Parser parser2;

TEST_EQ(parser2.Parse(fbs.c_str(), nullptr), true);

TEST_EQ_STR(fbs.c_str(), goldenfile.c_str());

}

template<typename T> void CompareTableFieldValue(flatbuffers::Table *table,

flatbuffers::voffset_t voffset,

T val) {

T read = table->GetField(voffset, static_cast<T>(0));

TEST_EQ(read, val);

}

// Low level stress/fuzz test: serialize/deserialize a variety of

// different kinds of data in different combinations

void FuzzTest1() {

// Values we're testing against: chosen to ensure no bits get chopped

// off anywhere, and also be different from eachother.

const uint8_t bool_val = true;

const int8_t char_val = -127; // 0x81

const uint8_t uchar_val = 0xFF;

const int16_t short_val = -32222; // 0x8222;

const uint16_t ushort_val = 0xFEEE;

const int32_t int_val = 0x83333333;

const uint32_t uint_val = 0xFDDDDDDD;

const int64_t long_val = 0x8444444444444444LL;

const uint64_t ulong_val = 0xFCCCCCCCCCCCCCCCULL;

const float float_val = 3.14159f;

const double double_val = 3.14159265359;

const int test_values_max = 11;

const flatbuffers::voffset_t fields_per_object = 4;

const int num_fuzz_objects = 10000; // The higher, the more thorough :)

flatbuffers::FlatBufferBuilder builder;

lcg_reset(); // Keep it deterministic.

flatbuffers::uoffset_t objects[num_fuzz_objects];

// Generate num_fuzz_objects random objects each consisting of

// fields_per_object fields, each of a random type.

for (int i = 0; i < num_fuzz_objects; i++) {

auto start = builder.StartTable();

for (flatbuffers::voffset_t f = 0; f < fields_per_object; f++) {

int choice = lcg_rand() % test_values_max;

auto off = flatbuffers::FieldIndexToOffset(f);

switch (choice) {

case 0: builder.AddElement<uint8_t >(off, bool_val, 0); break;

case 1: builder.AddElement<int8_t >(off, char_val, 0); break;

case 2: builder.AddElement<uint8_t >(off, uchar_val, 0); break;

case 3: builder.AddElement<int16_t >(off, short_val, 0); break;

case 4: builder.AddElement<uint16_t>(off, ushort_val, 0); break;

case 5: builder.AddElement<int32_t >(off, int_val, 0); break;

case 6: builder.AddElement<uint32_t>(off, uint_val, 0); break;

case 7: builder.AddElement<int64_t >(off, long_val, 0); break;

case 8: builder.AddElement<uint64_t>(off, ulong_val, 0); break;

case 9: builder.AddElement<float >(off, float_val, 0); break;

case 10: builder.AddElement<double >(off, double_val, 0); break;

}

}

objects[i] = builder.EndTable(start);

}

builder.PreAlign<flatbuffers::largest_scalar_t>(0); // Align whole buffer.

lcg_reset(); // Reset.

uint8_t *eob = builder.GetCurrentBufferPointer() + builder.GetSize();

// Test that all objects we generated are readable and return the

// expected values. We generate random objects in the same order

// so this is deterministic.

for (int i = 0; i < num_fuzz_objects; i++) {

auto table = reinterpret_cast<flatbuffers::Table *>(eob - objects[i]);

for (flatbuffers::voffset_t f = 0; f < fields_per_object; f++) {

int choice = lcg_rand() % test_values_max;

flatbuffers::voffset_t off = flatbuffers::FieldIndexToOffset(f);

switch (choice) {

case 0: CompareTableFieldValue(table, off, bool_val ); break;

case 1: CompareTableFieldValue(table, off, char_val ); break;

case 2: CompareTableFieldValue(table, off, uchar_val ); break;

case 3: CompareTableFieldValue(table, off, short_val ); break;

case 4: CompareTableFieldValue(table, off, ushort_val); break;

case 5: CompareTableFieldValue(table, off, int_val ); break;

case 6: CompareTableFieldValue(table, off, uint_val ); break;

case 7: CompareTableFieldValue(table, off, long_val ); break;

case 8: CompareTableFieldValue(table, off, ulong_val ); break;

case 9: CompareTableFieldValue(table, off, float_val ); break;

case 10: CompareTableFieldValue(table, off, double_val); break;

}

}

}

}

// High level stress/fuzz test: generate a big schema and

// matching json data in random combinations, then parse both,

// generate json back from the binary, and compare with the original.

void FuzzTest2() {

lcg_reset(); // Keep it deterministic.

const int num_definitions = 30;

const int num_struct_definitions = 5; // Subset of num_definitions.

const int fields_per_definition = 15;

const int instances_per_definition = 5;

const int deprecation_rate = 10; // 1 in deprecation_rate fields will

// be deprecated.

std::string schema = "namespace test;\n\n";

struct RndDef {

std::string instances[instances_per_definition];

// Since we're generating schema and corresponding data in tandem,

// this convenience function adds strings to both at once.

static void Add(RndDef (&definitions_l)[num_definitions],

std::string &schema_l,

const int instances_per_definition_l,

const char *schema_add, const char *instance_add,

int definition) {

schema_l += schema_add;

for (int i = 0; i < instances_per_definition_l; i++)

definitions_l[definition].instances[i] += instance_add;

}

};

#define AddToSchemaAndInstances(schema_add, instance_add) \

RndDef::Add(definitions, schema, instances_per_definition, \

schema_add, instance_add, definition)

#define Dummy() \

RndDef::Add(definitions, schema, instances_per_definition, \

"byte", "1", definition)

RndDef definitions[num_definitions];

// We are going to generate num_definitions, the first

// num_struct_definitions will be structs, the rest tables. For each

// generate random fields, some of which may be struct/table types

// referring to previously generated structs/tables.

// Simultanenously, we generate instances_per_definition JSON data

// definitions, which will have identical structure to the schema

// being generated. We generate multiple instances such that when creating

// hierarchy, we get some variety by picking one randomly.

for (int definition = 0; definition < num_definitions; definition++) {

std::string definition_name = "D" + flatbuffers::NumToString(definition);

bool is_struct = definition < num_struct_definitions;

AddToSchemaAndInstances(

((is_struct ? "struct " : "table ") + definition_name + " {\n").c_str(),

"{\n");

for (int field = 0; field < fields_per_definition; field++) {

const bool is_last_field = field == fields_per_definition - 1;

// Deprecate 1 in deprecation_rate fields. Only table fields can be

// deprecated.

// Don't deprecate the last field to avoid dangling commas in JSON.

const bool deprecated = !is_struct &&

!is_last_field &&

(lcg_rand() % deprecation_rate == 0);