1 files changed, 365 insertions, 0 deletions
diff --git a/flatcc/test/monster_test/monster_test.fbs b/flatcc/test/monster_test/monster_test.fbs
new file mode 100755
index 0000000..f0f78aa
--- /dev/null
+++ b/flatcc/test/monster_test/monster_test.fbs
@@ -0,0 +1,365 @@
+// test schema file
+
+include "attributes.fbs";
+include "include_test1.fbs";
+
+struct InGlobalNamespace { unused: byte; }
+
+namespace MyGame;
+
+table InParentNamespace {}
+
+namespace MyGame.Example2;
+
+table Monster {}  // Test having same name as below, but in different namespace.
+
+table Strange {}
+
+// Test schema reserved keywords as identifier
+// Can be disabled in config/config.h
+// It is still a good idea to use a namespace
+// to avoid conflicts with host language names
+// especially for enums and structs.
+// Reserved names can be important in some JSON
+// related use cases.
+table S2 {
+    namespace : int;
+    table : int;
+    struct : int;
+    union : int;
+    int : int;
+}
+
+// Enums fields can also be reserved, and these are also visible in
+// JSON, but they cannot be used as table field defaults because
+// type expressions do interpret keywords as keywords. For the same
+// reason it is of no use to allow reserved names as type names
+// such as table names.
+enum foo:int { x, y, table }
+
+namespace MyGame.Example;
+
+// Note: parent namespace resolution only works without namespace prefix
+//
+// Won't work:
+//    union Foo { Example2.InParentNamespace }
+union Foo { InParentNamespace }
+
+
+namespace MyGame.Example2.SubSystem;
+
+// Note:
+//
+// parent namespace resolution only works without namespace prefix
+// or with a global namespace prefix (a fully qualified name), not
+// something in between.
+// (There is no really good reason for this, it just isn't implemented,
+//  and flatc JSON enum parsing works the same way.)
+// The more local name wins any conflict.
+//
+union SubSystemA { Strange }
+union SubSystemB { MyGame.Example2.Strange }
+
+// Works in C++ flatc 1.8 but won't work with flatcc:
+// union SubSystemC { Example2.Strange }
+
+
+namespace MyGame.Example;
+
+// test case for negative enum values
+enum neg_enum:int {
+  neg1 = -12,
+  neg2 = -11,
+  neg3 = -10,
+}
+
+enum int_enum:int {
+    intneg = -02,
+    intneg2 = -1,
+    int1 = 02,
+    int2 = 42,
+}
+
+// test for hex constants
+enum hex_enum:int {
+    hexneg = -0x02,
+    hex1 = 0x3,
+    hex2 = 0x7eafbeaf,
+}
+
+attribute "priority";
+
+enum Color:byte (bit_flags) { Red = 0, Green, Blue = 3, }
+
+// Note:
+// For historic reasons C++ flatc 1.8 does permit conflicting base names
+// from different namespaces without explicitly resolving the conflict.
+//
+// flatcc does not, and cannot, support this because it needs a unique
+// base name to assign to the enumaration of union members - otherwise
+// these enumerations could not have a namespace prefix - which is used
+// in JSON and in default value assignment in the schema.
+//
+// Wont' work in flatc:
+//    union Any { Monster, TestSimpleTableWithEnum, MyGame.Example2.Monster }
+
+union Any {
+    Monster,
+    TestSimpleTableWithEnum,
+    Monster2: MyGame.Example2.Monster,
+    Alt
+}
+
+struct Test { a:short; b:byte; }
+
+enum notemptyenum:int { x}
+
+table TestSimpleTableWithEnum (csharp_partial) {
+  color: Color = Green;
+  color2: Color = Color.Green;
+  uc : ubyte = MyGame.Example.Color.Green;
+  uc2 : ubyte = Color.Green;
+
+  // C++ flatc 1.8 dislikes enum values on non-enums
+  // color2: Color = Green;
+  // C++ flatc 1.8 dislikes enum values on non-enums
+  // uc : ubyte = 1;
+  // C++ flatc 1.8 dislikes enum values on non-enums, and namespace prefix
+  // uc2 : ubyte = 1;
+}
+
+table TestInclude {
+  global:InGlobalNamespace;
+  incval:MyGame.OtherNameSpace.FromInclude;
+  incval2:MyGame.OtherNameSpace.FromInclude = IncludeVal;
+  incval3 : int (included_attribute);
+  incval4:MyGame.OtherNameSpace.FromInclude = MyGame.OtherNameSpace.FromInclude.IncludeVal;
+  incval5: long = MyGame.OtherNameSpace.FromInclude.IncludeVal;
+
+  // C++ flatc 1.8 dislikes namespace prefix
+  // incval4:MyGame.OtherNameSpace.FromInclude = IncludeVal;
+  // C++ flatc 1.8 dislikes enum values on non-enums, and namespace prefix
+  // incval5: long = 0;
+}
+
+struct Vec3 (force_align: 16) {
+  x:float;
+  y:float;
+  z:float;
+  test1:double;
+  test2:Color;
+  test3:Test;
+}
+
+struct Ability {
+  id:uint(key);
+  distance:uint;
+}
+
+table Stat {
+  id:string;
+  val:long;
+  count:ushort;
+}
+
+// fixed length arrays new to flatcc 0.6.0
+struct FooBar {
+    foo:[float:0x10];
+    bar:[int:10];
+    col:[Color:3];
+    tests:[Test:2];
+    text:[char:5];
+}
+
+// `sorted` attribute new to flatcc 0.6.0, not supported by flatc 1.8.
+// tables with direct or indirect vector content marked as sorted
+// will get a mutable sort operation that recursively sorts all
+// such vectors. 'sorted` is only valid for non-union vectors.
+//
+// attribute "sorted";
+//
+table Alt {
+  prefix: TestJSONPrefix;
+  movie:Fantasy.Movie;
+  manyany: [Any];
+  multik: [MultipleKeys] (sorted);
+  rapunzels:[Fantasy.Rapunzel] (sorted);
+  names:[string] (sorted);
+  samples:[float32] (sorted);
+  fixed_array: FooBar;
+}
+
+table TestJSONPrefix {
+  testjsonprefixparsing:TestJSONPrefixParsing;
+  testjsonprefixparsing2:TestJSONPrefixParsing2;
+  testjsonprefixparsing3:TestJSONPrefixParsing3;
+}
+
+table TestJSONPrefixParsing
+{
+  aaaa: string;
+  aaaa12345: uint;
+
+  bbbb: string;
+  bbbb1234: long;
+
+  cccc: string;
+  cccc1234: long;
+  cccc12345: uint;
+
+  dddd1234: long;
+  dddd12345: uint;
+}
+
+// when there are two keys ending in same 8 character group
+table TestJSONPrefixParsing2
+{
+    aaaa_bbbb_steps: long;
+    aaaa_bbbb_start_: uint;
+}
+
+// when there are two keys ending in different 8 character group
+table TestJSONPrefixParsing3
+{
+    aaaa_bbbb_steps: long;
+    aaaa_bbbb_start_steps: uint;
+}
+
+// C++ flatc 1.8 does not yet support base64 as a built-in
+// attribute "base64";
+// attribute "base64url";
+
+table TestBase64
+{
+    data:[ubyte] (base64);
+    urldata:[ubyte] (base64url);
+    nested:[ubyte] (nested_flatbuffer: "Monster", base64);
+}
+
+// 'primary_key' attribute new to flatcc 0.6.0, not supported by flatc 1.8.
+// Allow multiple keys and allow one to be the default find and sort key
+// even if not listed first. A table with a single key field behaves the
+// same as a table with a single primary_key field, so use key for
+// compatiblity in that case.
+// 
+// attribute "primary_key";
+//
+table MultipleKeys
+{
+    hello: string;
+    world: string (key);
+    foobar: int64 (primary_key);
+}
+
+table Monster {
+  pos:Vec3 (id: 0);
+  hp:short = 100 (id: 2);
+  mana:short = 150 (id: 1);
+  name:string (id: 3, required, key);
+  color:Color = Blue (id: 6);
+  inventory:[ubyte] (id: 5);
+  friendly:bool = false (deprecated, priority: 1, id: 4);
+  /// an example documentation comment: this will end up in the generated code
+  /// multiline too
+  testarrayoftables:[Monster] (id: 11);
+  testarrayofstring:[string] (id: 10);
+  testarrayofstring2:[string] (id: 28);
+  testarrayofbools:[bool] (id: 24);
+  testarrayofsortedstruct:[Ability] (id: 29);
+  enemy:MyGame.Example.Monster (id:12);  // Test referring by full namespace.
+  // id 7 resever for Any_type
+  test:Any (id: 8);
+  test4:[Test] (id: 9);
+  test5:[Test] (id: 31);
+  testnestedflatbuffer:[ubyte] (id:13, nested_flatbuffer: "Monster");
+  testempty:Stat (id:14);
+  testbool:bool = 1 (id:15);
+  testhashs32_fnv1:int (id:16, hash:"fnv1_32");
+  testhashu32_fnv1:uint (id:17, hash:"fnv1_32");
+  testhashs64_fnv1:long (id:18, hash:"fnv1_64");
+  testhashu64_fnv1:ulong (id:19, hash:"fnv1_64");
+  testhashs32_fnv1a:int (id:20, hash:"fnv1a_32");
+  testhashu32_fnv1a:uint (id:21, hash:"fnv1a_32", cpp_type:"Stat");
+  testhashs64_fnv1a:long (id:22, hash:"fnv1a_64");
+  testhashu64_fnv1a:ulong (id:23, hash:"fnv1a_64");
+
+  // Googles flatc uses Pi as default be we don't because it
+  // messes up JSON tests because the numeric print format is
+  // configuration dependent.
+  //testf:float = 3.14159 (id:25);
+  testf:float = 3.14159e5 (id:25);
+  testf2:float = 3 (id:26);
+  testf3:float (id:27);
+  flex:[ubyte] (id:30, flexbuffer);
+  vector_of_longs:[long] (id:32);
+  vector_of_doubles:[double] (id:33);
+  parent_namespace_test:InParentNamespace (id:34);
+  testbase64:TestBase64 (id:35);
+}
+
+table TypeAliases {
+    i8:int8;
+    u8:uint8;
+    i16:int16;
+    u16:uint16;
+    i32:int32;
+    u32:uint32;
+    i64:int64;
+    u64:uint64;
+    f32:float32;
+    f64:float64;
+    v8:[int8];
+    vf64:[float64];
+}
+
+rpc_service MonsterStorage {
+  Store(Monster):Stat (streaming: "none");
+  Retrieve(Stat):Monster (streaming: "server", idempotent);
+}
+
+// Demonstrates the ability to have vectors of unions, and also to
+// store structs and strings in unions.
+
+namespace Fantasy;
+
+table Attacker {
+    sword_attack_damage: int;
+}
+
+struct Rapunzel {
+    hair_length: uint16 (key);
+    travel_points: int (deprecated);
+}
+
+struct BookReader {
+    books_read: int;
+}
+
+union Character {
+    MuLan: Attacker = 2,  // Can have name be different from type.
+    Rapunzel = 8,         // Or just both the same, as before.
+    Belle: Fantasy.BookReader,
+    BookFan: BookReader,
+    Other: string,
+    Unused: string = 255
+}
+
+table Movie {
+    main_character: Character;
+    antagonist: Character;
+    side_kick: Character;
+    cameo: Character;
+    characters: [Character];
+}
+
+root_type MyGame.Example.Monster;
+
+file_identifier "MONS";
+file_extension "mon";
+
+// Out of order enums
+
+enum ReorderedEnum: int { rx = 10, ry = 1, rz = 9 }
+
+enum ReorderedColor:byte (bit_flags) { RBlue = 3, RRed = 0, RGreen }
+