Squashed 'third_party/flatbuffers/' changes from acc9990ab..d6a8dbd26
d6a8dbd26 Experimental fix for failing oss-fuzz coverage build (#6259)
ed391e177 BREAKING: Rust flexbuffers serde human readable set to false (#6257)
a49531414 Update to flags in fuzzing-cmake file (#6256)
de1f0342c Remove _POSIX_C_SOURCE and _XOPEN_SOURCE definitions when compiling o… (#6205)
d0d51e2a5 flatc should support --binary --schema with optional scalar fields. (#6252)
33ab26017 Bump version of rules_go to 0.24.5 (#6234)
febb9d87c Union As Accessors for C# (#6251)
8778dc7c2 Resets buffer without deallocating current pointer (#6247)
aae376e9a Add GetBufferSpan() function to bufferbuilder (#6235)
0ff047148 Modernize android build and sample (#6229)
46a8c7e95 Added required-nested-flatbuffer to monster_test and fixed rust (#6236)
bc56c553e Notify based on Labelling issues and PR (#6241)
07d7cd78a Converted globs to use single quotes (#6240)
cdef70e24 More adjustments to the auto labeler (#6239)
9dd44df35 Updated Lua labeller glob (#6238)
c9b29d088 Support size-prefixed buffers and add tests for size-prefixed messages (#6232)
fba93e0ab Removes duplicate swift in labeler (#6228)
d1a545b1f Added more labels for auto labeler (#6227)
ea92a668d [C#] Optional Scalars (#6217)
6034de286 [Label Bot] Add Java and Kotlin support for the label bot (#6226)
b08b0a440 Implement `Debug` trait for Rust flatbuffers. (#6207)
17ae48dec [Label Bot] Adds some languages to labeler bot (#6222)
fc8097925 Auto Labeler Setup, Just C# for now (#6221)
55658f523 Auto Labeler Setup, Just C# for now (#6218)
14ecfe423 Updated comments and fixed a fundamental type error. (#6214)
a0182cdb1 optional scalars for ts/js (#6215)
0dfcc0a37 Adds NetTest.bat to run .NET Core tests on Windows (#6216)
f9a18ea63 [Java] Implement optional scalars (#6212)
c7586e85a Empties the sharedString map on reset on go and csharp (#6187)
914c64601 Removed C# references from java generator. Move annotations closer to definitions (#6204)
42d7c7997 Adds readable size to asserts in read functions (#6210)
e68e8d7de Refactor idl_gen_rust (#6206)
84809be7e Fix typo in flatbuffers::span declaration. (#6202)
1606fb637 Kotlin test optional enum (#6201)
fe8e3c7e5 Mass Refactoring to use `IsString` and other BASE_TYPE helpers (#6193)
8f6fa4b71 Updated SupportsAdvancedUnionFeatures to look out for string (#6190)
b46db38f5 [JS/TS] Rewrite flexbuffers JS to TS (#6148)
9fa1d2705 Rework enums in rust. (#6098)
a402b3aba idl_gen_json_schema Fix generation of arrays of enums (#6184)
0e1415b99 fix(go_test): remove deprecated grpc call (#6183)
5cd713710 Add generation of JSON Schema to library (#6165)
5be777e1d Bump junit from 4.12 to 4.13.1 in /grpc/tests (#6173)
a49d440ec Bump junit from 4.12 to 4.13.1 in /grpc (#6172)
4ec5e8db9 [C++] Add option to not generate direct copy methods. (#6166)
04bec23a3 Add Array initialization from struct constructor (#5865) (#6147)
77d57fd07 Cast to right type for reserved_ subtraction (#6167)
543c1bbeb Fixed rust nested flatbuffers for tables other than self (#6062)
cb971eece [C++] Fix -Wnarrowing and -Woverflow due to signed bitfields on G++ ARM (#6163)
7b9e61fcc [TS] GRPC Implementation (#6141)
3359e3042 Moved C++ to optional_scalars2 and added some tests. (#6162)
187a4787f [Rust] Upgrade flatbuffers library to 2018 edition (#6159)
08943aa26 Flatbuffer C++ UnpackTo optimization for vectors of non-bool bytes. (#6154)
5975658eb Enables optional enums in swift (#6160)
5d3cf440e Updated Lobster test for optional bools/enums
8ec8322f0 Ruopt enum (#6156)
bbcc85fd4 Fix generation of C++ code with Optional<Enum> (#6155)
0bdf2fa15 [C#] Fix and improve project files (#6142)
2eedc769d possibility to create a vector from an iterator (#6135)
ab01ae162 flatc should output a warning, when an attribute is attached more than once (#6146)
689bfafa7 [Python/JS/TS] Codegen SizeOf method for structs (#6136)
641309a5b unix2dos on tests/FlatBuffers.Test/FlatBuffers.Core.Test.csproj (#6133)
52e362879 SpanT is available in .Net Standard 2.0. (#6137)
dca12522a Add static cast to avoid implicit double promotion. (#6132)
e0bbaa6f9 [C#]Change to ENABLE_SPAN_T that doesn't require UNSAFE_BYTEBUFFER. (#6073)
ab139d6be Revert "[C#] Fix and improve project files (#6116)" (#6130)
34d67b425 Minireflect fixed array (#6129)
96d5e3597 [JS/TS] fix flatbuffers default export (#6123)
eb686a86f Add missed file generated by optional_scalar.fbs (#6125)
750281630 [C#] Fix and improve project files (#6116)
fb4e1c34f Add CharToLower and CharToUpper into util.s (#6126)
8c67b5b12 Add support of Optional<T> scalars to C++ code generator (#6092)
6228b66d3 [Kotlin] Support for optional scalars. (#6115)
e1be8aaad Bump version for latest swift version (#6121)
94873e595 [JS/TS] Modernize TypeScript / JavaScript flatbuffers support (#6095)
b8e87fafe [JS] Add getFullyQualifiedName() (#6119)
f96d1ef74 [Java] allowing larger buffer sizes when growing a byte buffer (#6118)
89435303b [Swift] Migrates struct write APIS to write directly to the buffer (#6093)
c75ae2429 Optional-ness in reflection (#6097)
338944d3d Rename Nullable scalars to Optional scalars (#6112)
f5ab24bc4 Avoid memcpy call for empty vectors (#6111)
92a8c1a0f [JS] FlexBuffers Fix for wrong type of offset and length values (#6107)
6cea45dcd fix c# json serializer commandline argument docs (#6104)
fec58aa12 Fix for issue 6100: incorrect shrinking logic in ResizeContext() (#6102)
71aca81ff [JS] FlexBuffers Support (#5973)
04d87ffec [C++] Small refactoring of the C++ code generator (#6091)
bb25956f0 Wrap verify file id condition in Check call (#6085)
49f4948f0 + Add `removable-media` plug to the snapcraft config (#6083)
eeacc53d2 Adds proper access types for swift object api & flatbuffers & grpc (#6081)
f3003e08d [Lobster] missed a test
d713a0084 [CMake] enabled multi-core builds in VS projects
77f966f89 [Lobster] optional scalars support
e86d5b8e9 [Kotlin] Attach JvmStatic annotation to each method in companion object (#6052)
db2aa9b4e [C#] Cleaned up .NET testing script for Mono (#6016)
63cc0eec4 Adds a serialize helper function to native table (#6059)
c30a87de6 [TS] Fix four bugs with imported types in TypeScript. (#6054)
a0fb30575 [Swift] Append namespace for Swift Grpc implementation (#6049)
77c18c1d6 export a __version__ variable for python module (#5309)
f1f23d08e adding fb import when no other imports are present (#6030)
f1025b284 [Feature] Checks for Nullable strings (#6050)
5d052f4e5 [Swift] RFC: Switch Swift namespace from public enum to ordinary concat with _ (#6045)
18b015d25 Rust codegen improvements and lint fixes (#6046)
d76e93f27 adds code gen for optional scalars in swift (#6038)
82fac326c [C++] Fix compiler error from deleted assignment operator (#6036) (#6047)
043b52bd4 Optional Scalars support for Rust (#6034)
c8fa0afdf Allow to run cpp tests under grpc/tests/ using bazel. (#6040)
6d0aae73c Fix git command executed in wrong folder when doing cmake superbuild (#6039)
ff1b73128 [Swift] Optional Scalars Preparation (#6028)
2e48c8dd3 tests: Check for both quiet and signaling NaN on mipsel/hppa (#6029)
6942704f2 support deprecated flag in json schema (#6022)
9ecd2e16c Flatc parser support for nullable scalars (#6026)
33e2d8079 [Dart] Generate constant values map for enums (#6025)
969d0f7a6 Using proper symbol name for reexport (#6021)
515a4052a Silence false positive "-Wstringop-overflow" on GCC 10.0 to 11.0 (#6020)
36fbe6f13 Updated FB import (#6019)
b69fc8cc9 [Java] Add support for shared strings on FlatBufferBuilder. (#6012)
ab6af18d9 Not using non-existent create method for obj api (#6015)
37a5dee10 Code cleanup + updates test and readme (#6004)
8a721f69a Serde with bytes maps to Blob (#6009)
e810635ea [Swift] FlatBuffers createMonster method doesn't treat struct properly (#5992)
4995e1527 Manage grpc dependency in Bazel's WORKSPACE file. (#5995)
60b6066fe Add warning to schema parser if field name is not snake_case. (#6005)
35d45cac7 [Rust] Flexbuffers dependency cleanup and fixes (#5998)
165a6e3d1 Re-added Evolution Schema Code Generation Command (#5999)
13d3fb2ea Fix RPM install conflict (#6003)
d64078eb2 [Swift] Initialize memory when clear ByteBuffer (#5982)
ca1190a3d [TS] Use proper TypedArray in create*Vector (#5991)
7571b2ac5 [C++] Updates real_path to be truly portable (#5787)
e5a8f76a4 [C++] Generate default member initializers for >= C++11 (#5989)
413bb9b55 [Kotlin] Fix Access to union of vector element (#5994)
f35184aef [Swift] Add parsing from unowned UnsafeMutableRawPointer for ByteBuffer (#5981)
b124b7625 Removed requirement that enums be declared in ascending order. (#5887)
0ec7600c6 Do not remove the last digit from float values (#5974)
14baf45c9 Mark GetBufferMinAlignment() const (#5985)
9abb2ec2c TypeScript/JavaScript docs improvements (#5984)
2e57d80b1 [Swift] Internal library improvements (#5965)
cfc7753a4 [Doc] Added missing letters to compiler options (#5976)
12ddc8a92 Rust Flexbuffers Documentation update (#5979)
24ad35709 [docs] typo: updates monsterdata.json to be valid json (#5978)
cc44a4442 [idl_parser] Mark typefield as deprecated (#5958)
9ab4a5c0e Deleted old stale bot
6682cfe87 Increased Operations per run in stale.yml
64922904b Adding Stale Action to clean up PR and Issues
8e505cb67 [C++] Fixed/Enabled --cpp-ptr-type std::shared_ptr [#5813] (#5959)
a28357d7a Propagate boolean default values from proto to fbs (#5964)
7cb4762a6 [Swift] Improving reallocation time by using memcpy and moving reallocation code to storage (#5960)
4e45f7c9e Fix error in SimpleQSort (#5955)
7ac026405 fix error on GRPC Python - ignore namespace tree if not specified (#5862) (#5922)
108e981db Required is now implemented in swift (#5952)
94a78e385 Fixed: Access violation and ASAN/UNSAN failures with sorted tables
53fb453e0 [rust] Add FlatBufferBuilder::force_defaults API (#5946)
17c1f35fa [FlexBuffer][Java] ReadWriteBuf and ReadBuf interface public (#5948)
2eaf57778 [Java] Grow ArrayReadWriteBuf enough to match requested capacity. (#5921)
666800da3 Adds bool support in structs + updates grpc support + CI upgrades (#5943)
38ed69eb3 fixed mutating inline values (#5942)
d026e6f07 Add static asserts to ensure that reflection API arrays are kept in sync (#5934)
988164f6e [C++] Got rid of memset's in constructors (#5938)
7179a5a8b General Codebase clean up (#5939)
a0da0c08c Add GetStringView like GetString, GetCstring (#5937)
ac203b209 [C#] Add file identifier to ObjectAPI Serialization Utility. (#5920)
8dd1bf25b not creating creation methods when using structs (#5919)
5aa443d98 [Dart] Adding FlexBuffers support (#5853)
0fa087657 [Dart] Getting tests/DartTest.sh to work on master. (#5915)
424a473e1 Schema parser: prohibit declaration of an array of pointers inside structs (#5907)
c3faa8346 Fix Cargo.toml dependencies (#5911)
91399ad05 fix union type names (#5902)
32782e4ad Update Rust Flexbuffers metadata before publishing (#5905)
e7f3b1690 [TS] Make Obj-API work with --short-names (#5898)
12ed1fe4a fixed invalid imports with --gen-all (#5895)
85ee4df7a [C#] Thread safe reads of Double and Float values from a ByteBuffer (#5900)
de89bd193 Implement flexbuffers in python (#5880)
8be05f6bd Rust Flexbuffers (#5669)
870ecbc09 [swift] Moves code to use VTablesStorage (#5888)
c2da8d5d8 [Java][FlexBuffers] Make FlexBuffersBuilder reusable by adding clear() (#5889) (#5890)
e84cbff67 Align package name to FindFlatBuffers.cmake (#5899)
f94e6c84e Small tutorial improvements - documentation only (#5894)
f12cca8bc Attempt at adding Github Actions CI
7e4124d6e Handle git program or .git folder absence (#5878)
a875d247a only add native_include_files if object based api is enabled (#5886)
6e9f5d981 Respect shared attribute in Parser (#5885)
ff1c78233 include/flatbuffers: typo fixes in comments (#5884)
2e9a19673 Updates swift docs for package management (#5883)
e3cb07d32 [Rust] idl_gen_rust.cpp: (Option/required-aware codegen for unions) (#5850)
712866d57 Propagate use_string_pooling in CopyTable (#5879)
44c919a9e Not using reexports with --gen-all (#5873)
99aa1ef21 Added INCLUDE_PREFIX option for flatbuffers_generate_headers (#5866)
40ba170c9 Fixed text in internals doc that implied structs can be root
cb4d0f72e [Swift] Object API support (#5826)
003e16405 [TS] Add Obj API (#5788)
21cf300f4 fix cpp usage markdown error (#5845)
9655e12d6 Upgraded swift implementation for grpc (#5843)
fb96fadc2 [C#] Fix nested structs and arrays in Object API (#5765)
408f11fbd [ts] Fix empty source/dest namespaces when reexporting. (#5841)
a83caf591 Improves performance for the swift library by using structs + a storage class (#5835)
925fab6b1 [Java][FlexBuffers] Optimize Map access (#5735)
d9fecc332 [CMake] : Add precompiled header support with FLATBUFFERS_ENABLE_PCH (#5827)
e9d453240 Added flatbuffers_generate_headers and flatbuffers_generate_binary_files cmake functions. (#5830)
c37c989ed Correct calculation of vector element size (#5831)
6b271b7ec Fix Clang-trunk warnings about special members deprecated in C++20. (#5829)
90f3b8e8c Fix `float_constant` definition in './doc/Grammar.md` (#5828)
3af735934 [csharp] flatc should generate a 'Create…' method for tables with struct field… (#5818)
c4231c3cb Updated doxyfile - added missing files (#5824)
9657df184 Update Grammar.md (#5820)
97ffc590e Include CPack only when explictly packaging (#5817)
8b52af65b [C++] Add max_depth and max_tables parameters to reflection::Verify (#5815)
9b034eee1 Fix interpretation of 'nan(number)' by the idl_parser (#5810)
3e9ac3cff [Scripts] Adds swift to generated code (#5806)
697147a2e updated maven build files
6df40a247 pre-tag version bump for 1.12
0dba63909 Removes the inner loop in the endtable check written tables (#5803)
0e3fdd0ee Escape characters in jsonschema descriptions (#5644)
45a2b07cb Remove `noexcept` qualifier copy-ctor of `union` type (#5800) (#5802)
d10c16314 Replace 'assert' by 'FLATBUFFERS_ASSERT' inside idl_parser.cpp (#5799)
35abb7f89 Add non-nullable modifier to return type of functions never returning null (#5797)
9954e09ab [C++] Generate code for vector force_align attribute. (#5796)
95a21327f rust: pub export the VectorIter type (#5736)
89b6183ee Fix Python min alignment
5a98d65e8 [Rust] Add gen-name-strings for Rust (#5757)
f73d205bc Removed assert that wasn't backwards compatible.
7c37abe92 [C#] add ObjectAPI Serialization Utility (#5785)
4749e77b0 Fixed docs on how to obtain parser error.
6ff189841 Added --filename-suffix and --filename-ext to flatc (#5778)
c9a30c9ca Fixed refractoring issue in reflection/generate_code.sh. Also, mv deletes the original file, so I don't need to clean it up manually in that case. (#5777)
8c02d17be Skip writing reflection_generated.h if not changed (#5776)
34305c4ce [Swift] Adds GRPC to Swift (#5758)
cd88e6b2a [Java][FlexBuffers] Abstract buffer access from ByteBuffer (#5743)
3ec7a53c6 Adds cocoapods and a readme of how to get the package (#5771)
6d44cede7 [snap] Fix versioning (#5727)
cc08c0835 [Python] Fixed potential allignment issue (#5768)
54f8b787c Fix memory leak on cpp object api (#5761)
17557f913 [Python] Fixed issue #5499 (#5764)
d54af8cd4 [C++] Use strong enum type for vectors when scoped-enums is on. (#5750)
173e10fdf [C#] support Json Serialization (#5752)
8f56990f6 FlexBuffers: C++: scalar-only typed vectors were not aligned.
6400c9b05 Bump Rust port to 0.6.1 (#5747)
7418d8587 [C#] support Object API (#5710)
c580fa284 Adds min and max, comments, and all of swift's keywords + fix docs (#5737)
f2a127230 Use VS 2017 and 2019 on CI, fix cast issue in dart_idl (#5740)
316d7c208 Creates a flatbuffers validation function + small fix (#5725)
47026ea6b Added the code to embed the binary schema to the source (--bfbs-gen-embed). (#5701)
3f677f241 [Java][FlexBuffers] Deprecate typed vector strings due to design flaw (#5722)
a593a11e5 [Go] Implements a SharedStrings function (#5733)
7cdfc8475 [Swift] Fix padding function overflow when bufSize is 0 (#5721)
bab2b0db4 Add vcpkg installation instructions (#5732)
89418eb84 [Dart] Fix deprecated field support, inf/nan (#5724)
9cadf05d8 [typescript] Size-prefixed root accessors not taking into account size prefix (#5717)
6da1cf79d [rust] Add use declarations to Rust-generated bindings for imported FB definitions (#5645)
bee1df96d [Go] Replace references to hardcoded ”Monster" etc with idiomatic go wherever possible (#5716)
01189d7ed [C++] Fix for printing of enum in case output_enum_identifiers=1. (#5706)
c4b2b0a25 [Swift] Support create long string (#5709)
a4b2884e4 Added create function for swift (#5707)
04d80f255 [Swift] Swift implementation 🎉🎉 (#5603)
55686100a Changed direct calls to strtod to use StringToNumber
718351831 Document JSON compatibility guarantees. (#5704)
d1b34f0f2 Add CMake 'generated_code' target to simplify resolution of build dependencies (#5697)
21b706196 (Optionally) add an additional suffix namespace to generated fbs files. (#5698)
35daaf83d [Java] Replace Table.UTF8_CHARSET with StandardCharsets.UTF_8 (#5696)
3b458f7a1 Rust: Temporarily disable 2 endianness unit tests (#5695)
a5d9d0f7d [C++17] Add Traits class for Tables and Factory function within it. (#5678)
3cd9b6434 Removed code_generators.cpp from library targets
355dfd48d [rust] Make enum names public (#5690)
bcd58a159 Correct inverted logic around include prefixes. (#5689)
a2c12900a Optimize Pack method using numpy (#5662)
901b89e73 [C++] Add Builder and Table typedefs (#5685)
31f879908 Minor doc updates: FlexBuffers C#, Discord, CppUsage.
8023d99e2 Upgrade rules_go (#5684)
b4154405d Fix --incompatible_load_cc_rules_from_bzl (#5683)
04c17c7a7 Add support for absl::string_view when available (#5682)
62ec7d52c [Bazel] Add support for compatible_with and restricted_to (#5681)
7de668053 CI: New Docker tests for Python with numpy (#5677)
3a70e0b30 Fixed struct initialization error on older versions of C#
9b1320135 Fixed warnings in FlexBuffers.java
5e3916050 Fixed out of date licenses on gRPC Python files.
c95755051 Removed test proto output.
44bf71988 Add flatc '--cpp_std' switch (#5656)
3e8f15df9 Fix for FlexBuffers FBT_VECTOR_STRING size bit-width.
602721a73 Added Check to VerifyAlignment (#5675)
13c05f4da Improve import handling for proto conversion (#5673)
ce3a1c43a [Dart] Fix prepare space for writeListInt64 and writeListUint64 (#5654)
aa75e5734 Make Rust constants public (#5659)
2790fee25 Add namespace qualification to union types (#5666)
eddebec1b Bugfix for Rust generation of union fields named with language keywords (#5592)
030fee36a wrap multiple statements in do {} while(!IsConstTrue(true)) (#5655)
f9724d1bd [gRPC] Uncomment MessageBuilder (#5658)
b20801ca4 Supress unsigned-integer-overflow for PaddingBytes (#5647)
a8e800bd7 Add --force-empty-vectors option (#5653)
d7530ae96 Fixed enum min/max values not properly escaped.
99d11e279 Split Bazel targets into multiple packages (#5640)
4fd8eb214 Remove a static_assert (#5643)
65f870357 Flatbuffers Python Object API (#5616)
75823cc27 [Clang 10]: definition of implicit copy constructor for 'TableKeyComparatoris deprecated #5649 (#5650)
58e279244 [docs]: add missing semicolon (#5648)
3c964e10a [GO] Fix support for enums with underscores and Unions with imported members (#5600)
c3c32ec94 Fix ambiguity of a type deduction in TEST_EQ macro if arguments have `enum class` type. (#5630)
075e8d676 Simplify declarations of x-macro FLATBUFFERS_TD (#5638)
bcf1bd5c9 read vtable size through ReadScalar() (#5636)
136d75fa6 Changed null checks in test. Removed verifier pointer usage (#5634)
091fa1fd1 Add testing of C++ with sanitizers (CI-Docker) (#5631)
ff3781dc2 add namespace prefix in FLATBUFFERS_MAX_BUFFER_SIZE (#5629)
6beb9f49c Support for python grpc - continuing the work from the pull request #4270 #4705 (#5613)
80988ea86 Removed idl_gen_general.cpp and move contents to code_generators.cpp (#5625)
0f2ff7eaa Lua cleanup (#5624)
dda095023 [C++] Adds basic schema evolution tests (#5611)
adbcbba5d [C++, C#, Java] Separated C# and Java generators into their own classes (#5618)
cbbd6aca0 add check for root_type specified for json schema generation (#5622)
405c64e07 [Rust] Bump smallvec version to 1.0 (#5621)
42c08cbca Ran src/clang-format-all.sh (#5617)
33d5dd9bd Improved pull request & clang-format instructions.
105dd528e Change monster_extra generation to use flatbuffers::unique_ptr (#5612)
f0f0efe7b [C++] Refactor to conform to Google C++ style guide (#5608)
e837d5a29 Fixed deprecated method in GRPC Java test.
9834ee978 Fixed Apache license not using canonical version.
44b2ab087 include/flatbuffers/base.h: fix no_sanitize issue with old clang (#5610)
46ae3f80a [C++, Java, C#, TypeScript, JavaScript] Skip generation of mutable union types (#5599)
7b38aa71e flatbuffers.h: fix documentation warning (#5607)
661bedd83 Add Lua FlatbufferBuilder Clean() method to enable reuseable builders (#5606)
8526e12d7 [Kotlin] Fix union vector accessor after change in Java API (#5605)
3c7b660d6 [flatc] Remove an always true condition for flexbuffers (#5604)
964365ba6 [Go] Add UnPackTo functions (#5598)
32254b7ac [Go] Object API support (#5339)
521e255ad Rust: Add idiomatic iterator for Vector type (#5579)
1b85292fd Fix typos in comments (#5590)
480815447 C++ verifier for evolved union fields should return true (#5586)
8d5e424c6 Add ByteBuffer copy for vector of bytes in Java (#5587)
b4774d235 Rust: Fix Copy and Clone impls for a few generic types (#5577)
26f238c24 Add `--clean-first` to the cmake-build command (travis) (#5574)
e93c8c46e Fix Follow implementation for bool (#5554)
e21516b9d Fix issue #5557 (#5573)
fbc11e8ae Avoid intentional unsigned integer overflow getting caught by sanitizers (#5572)
e9d29c21a Python: Add forceDefaults opt to python Builder (#5564)
8bfafc76d Java: Don't annotate vector-of-tables item getters with @nullable. (#5562)
df3e8bf4a Fixed warnings generated by recent JSON sorting feature.
5665cfe49 [Java] byte buffer factory returned buffer capcity is used instead of the requested size (#5558)
5797540ed #5544 Fix of Array of table is not sorted if Create<type>Direct() is used (#5546)
7f1af7cb0 Fix build with gcc version 7.4.0 (#5570)
32f47ad24 Fixed JSON parser not sorting vectors of tables/structs with key.
842f672ba [FlexBuffers][Java] Cache size of Sized objects in FlexBuffers (#5551)
d4cae0a62 Fix issue #5542 (#5543)
f1147f65b Fixed Android STLPort related error.
69d3fec48 Fix namespaced struct/field name collision detection (#5540) (#5545)
cfb4ecf6f [flac] Add FlexBuffers option for generating data (#5519)
a92039687 Update Rust versions under test from 1.30.1 to 1.37.0 (#5538)
625338d09 Adds XOPEN_SOURCE for PATH_MAX and POSIX 1993 for stat (#5529)
3f8ce99c5 [FlexBuffers][Java] Add override Key::toString (#5533)
0798b7b69 [FlexBuffers][Java] Fix wrong access to a string using Reference::asString(). (#5532)
cbdf82e2f Fix Mutate() methods of Array<scalar/struct> (override 5508) (#5526)
e365c502f Java: Added access object for vector of struct and vector of tables. (#5233)
97f3aa917 Fixed DetachedBuffer self move assignment (#5521)
2f5bb2eec Fix buildifier warnings found in new bazel (#5517)
917687c7a Fixed Reflection Verifier not handling vectors of unions.
f9277e691 Fixed GenerateText not handling vectors of unions.
2706381ee Add element size parameter to __vector_as_arraysegment [c#] (#5512)
b5560fcd5 [Java][FlexBuffers] Improve documentation for FlexBuffers in Java. (#5506)
782b865c5 Annotate getters with @Pure when --java-checkerframework is specified. (#5510)
3bfc86eaf [Dart]fix: segment fault with empty namespace when generating dart file (#5507)
c0282873f Rust: Fixed cargo clippy on non-generated code (#5485)
4b870aca9 [Javascript] Fix syntax error for signed enum (#5503)
d0e3870c0 [C#] Fix retrieving enumeration vectors as arrays (#5457)
fb25eb87f Doc typo fixes (#5505)
cb35d3a0e Use all of the available space in the buffer returned by ByteBufferFactory to allow the factory to keep a pool of larger than initialsize sized buffers. (#5500)
8e6cabb31 [FlexBuffers][Java] Implementation of FlexBuffers API (#5476)
bd31dd242 Clarified value reuse in FlexBuffers
65b67d213 Fixed test build invocation of arrays_test.fbs
1fbb71132 FlexBuffers: allow any values to be shared.
cd75a3658 Android: remove app_dummy() calls
ec6b0bf29 Fixed STLPort Android compile error
c11b5d744 [bugfix]flexbuffers isvector bugfix (#5488)
4525c91be Fix incorrect padding in arrays of structs (Issue #5484) (#5491)
b97b342f5 Fixed missing generated code.
c1058a903 C++ IDL generation adds superfluous semicolon in GenTablePost, causing (#5483)
303044934 [go]add Name() for ForceCodec interface (#5486)
a2485d4ec reflection: check for valid union enum value during object verification (#5475)
a20e71ac9 has_method support for primitive fields in java runtime. Changed: idl.h, FlatBufferBuilder.java , idl_gen_general.cpp, idl_parser.cpp, flatc.cpp (#5468)
Change-Id: I836f4b43e6818bb16425a87899e6234ac86242aa
git-subtree-dir: third_party/flatbuffers
git-subtree-split: d6a8dbd26ff08a8868e0d0c1b4b67d31b40e4a7f
diff --git a/tests/JavaTest.java b/tests/JavaTest.java
index 6505767..23ebb5b 100644
--- a/tests/JavaTest.java
+++ b/tests/JavaTest.java
@@ -1,3 +1,37 @@
+
+import static com.google.flatbuffers.Constants.*;
+
+import MyGame.Example.*;
+import optional_scalars.ScalarStuff;
+import optional_scalars.OptionalByte;
+import MyGame.MonsterExtra;
+import NamespaceA.*;
+import NamespaceA.NamespaceB.*;
+import com.google.flatbuffers.ByteBufferUtil;
+import com.google.flatbuffers.ByteVector;
+import com.google.flatbuffers.FlatBufferBuilder;
+import com.google.flatbuffers.FlexBuffers;
+import com.google.flatbuffers.FlexBuffersBuilder;
+import com.google.flatbuffers.StringVector;
+import com.google.flatbuffers.UnionVector;
+
+import com.google.flatbuffers.FlexBuffers.FlexBufferException;
+import com.google.flatbuffers.FlexBuffers.Reference;
+import com.google.flatbuffers.FlexBuffers.Vector;
+import com.google.flatbuffers.ArrayReadWriteBuf;
+import com.google.flatbuffers.FlexBuffers.KeyVector;
+
+import java.io.*;
+import java.math.BigInteger;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.CharBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
/*
* Copyright 2014 Google Inc. All rights reserved.
*
@@ -14,17 +48,7 @@
* limitations under the License.
*/
-import java.io.*;
-import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
-import java.nio.channels.FileChannel;
-import MyGame.Example.*;
-import NamespaceA.*;
-import NamespaceA.NamespaceB.*;
-import com.google.flatbuffers.ByteBufferUtil;
-import static com.google.flatbuffers.Constants.*;
-import com.google.flatbuffers.FlatBufferBuilder;
-import MyGame.MonsterExtra;
+
class JavaTest {
public static void main(String[] args) {
@@ -77,6 +101,14 @@
TestFixedLengthArrays();
+ TestFlexBuffers();
+
+ TestVectorOfBytes();
+
+ TestSharedStringPool();
+
+ TestScalarOptional();
+
System.out.println("FlatBuffers test: completed successfully");
}
@@ -120,6 +152,14 @@
invsum += monster.inventory(i);
TestEq(invsum, 10);
+ // Method using a vector access object:
+ ByteVector inventoryVector = monster.inventoryVector();
+ TestEq(inventoryVector.length(), 5);
+ invsum = 0;
+ for (int i = 0; i < inventoryVector.length(); i++)
+ invsum += inventoryVector.getAsUnsigned(i);
+ TestEq(invsum, 10);
+
// Alternative way of accessing a vector:
ByteBuffer ibb = monster.inventoryAsByteBuffer();
invsum = 0;
@@ -132,10 +172,22 @@
TestEq(monster.test4Length(), 2);
TestEq(test_0.a() + test_0.b() + test_1.a() + test_1.b(), 100);
+ Test.Vector test4Vector = monster.test4Vector();
+ test_0 = test4Vector.get(0);
+ test_1 = test4Vector.get(1);
+ TestEq(test4Vector.length(), 2);
+ TestEq(test_0.a() + test_0.b() + test_1.a() + test_1.b(), 100);
+
TestEq(monster.testarrayofstringLength(), 2);
TestEq(monster.testarrayofstring(0),"test1");
TestEq(monster.testarrayofstring(1),"test2");
+ // Method using a vector access object:
+ StringVector testarrayofstringVector = monster.testarrayofstringVector();
+ TestEq(testarrayofstringVector.length(), 2);
+ TestEq(testarrayofstringVector.get(0),"test1");
+ TestEq(testarrayofstringVector.get(1),"test2");
+
TestEq(monster.testbool(), true);
}
@@ -212,6 +264,10 @@
TestEq(monsterObject.inventory(1), (int)inventory[1]);
TestEq(monsterObject.inventoryLength(), inventory.length);
+ ByteVector inventoryVector = monsterObject.inventoryVector();
+ TestEq(inventoryVector.getAsUnsigned(1), (int)inventory[1]);
+ TestEq(inventoryVector.length(), inventory.length);
+
TestEq(ByteBuffer.wrap(inventory), monsterObject.inventoryAsByteBuffer());
}
@@ -233,6 +289,9 @@
TestEq(monsterObject.inventory(1), (int)inventory[1]);
TestEq(monsterObject.inventoryLength(), inventory.length);
+ ByteVector inventoryVector = monsterObject.inventoryVector();
+ TestEq(inventoryVector.getAsUnsigned(1), (int)inventory[1]);
+ TestEq(inventoryVector.length(), inventory.length);
TestEq(ByteBuffer.wrap(inventory), monsterObject.inventoryAsByteBuffer());
}
@@ -242,7 +301,9 @@
public ByteBuffer newByteBuffer(int capacity) {
ByteBuffer bb;
try {
- bb = new RandomAccessFile("javatest.bin", "rw").getChannel().map(FileChannel.MapMode.READ_WRITE, 0, capacity).order(ByteOrder.LITTLE_ENDIAN);
+ RandomAccessFile f = new RandomAccessFile("javatest.bin", "rw");
+ bb = f.getChannel().map(FileChannel.MapMode.READ_WRITE, 0, capacity).order(ByteOrder.LITTLE_ENDIAN);
+ f.close();
} catch(Throwable e) {
System.out.println("FlatBuffers test: couldn't map ByteBuffer to a file");
bb = null;
@@ -380,18 +441,21 @@
TestEq(monster.testarrayoftables(0).name(), "Barney");
TestEq(monster.testarrayoftables(1).name(), "Frodo");
TestEq(monster.testarrayoftables(2).name(), "Wilma");
+ Monster.Vector testarrayoftablesVector = monster.testarrayoftablesVector();
+ TestEq(testarrayoftablesVector.get(0).name(), "Barney");
+ TestEq(testarrayoftablesVector.get(1).name(), "Frodo");
+ TestEq(testarrayoftablesVector.get(2).name(), "Wilma");
// Example of searching for a table by the key
TestEq(monster.testarrayoftablesByKey("Frodo").name(), "Frodo");
TestEq(monster.testarrayoftablesByKey("Barney").name(), "Barney");
TestEq(monster.testarrayoftablesByKey("Wilma").name(), "Wilma");
+ TestEq(testarrayoftablesVector.getByKey("Frodo").name(), "Frodo");
+ TestEq(testarrayoftablesVector.getByKey("Barney").name(), "Barney");
+ TestEq(testarrayoftablesVector.getByKey("Wilma").name(), "Wilma");
// testType is an existing field and mutating it should succeed
TestEq(monster.testType(), (byte)Any.Monster);
- TestEq(monster.mutateTestType(Any.NONE), true);
- TestEq(monster.testType(), (byte)Any.NONE);
- TestEq(monster.mutateTestType(Any.Monster), true);
- TestEq(monster.testType(), (byte)Any.Monster);
//mutate the inventory vector
TestEq(monster.mutateInventory(0, 1), true);
@@ -403,6 +467,10 @@
for (int i = 0; i < monster.inventoryLength(); i++) {
TestEq(monster.inventory(i), i + 1);
}
+ ByteVector inventoryVector = monster.inventoryVector();
+ for (int i = 0; i < inventoryVector.length(); i++) {
+ TestEq((int)inventoryVector.get(i), i + 1);
+ }
//reverse mutation
TestEq(monster.mutateInventory(0, 0), true);
@@ -445,11 +513,16 @@
);
final Movie movie = Movie.getRootAsMovie(fbb.dataBuffer());
+ ByteVector charactersTypeByteVector = movie.charactersTypeVector();
+ UnionVector charactersVector = movie.charactersVector();
TestEq(movie.charactersTypeLength(), characterTypeVector.length);
+ TestEq(charactersTypeByteVector.length(), characterTypeVector.length);
TestEq(movie.charactersLength(), characterVector.length);
+ TestEq(charactersVector.length(), characterVector.length);
TestEq(movie.charactersType(0), characterTypeVector[0]);
+ TestEq(charactersTypeByteVector.get(0), characterTypeVector[0]);
TestEq(((Attacker)movie.characters(new Attacker(), 0)).swordAttackDamage(), swordAttackDamage);
}
@@ -463,6 +536,9 @@
int[][] d_a = new int[2][2];
byte[] d_b = new byte[2];
byte[][] d_c = new byte[2][2];
+ long[][] d_d = new long[2][2];
+ int e;
+ long[] f = new long[2];
a = 0.5f;
for (int i = 0; i < 15; i++) b[i] = i;
@@ -477,9 +553,16 @@
d_c[0][1] = TestEnum.B;
d_c[1][0] = TestEnum.C;
d_c[1][1] = TestEnum.B;
+ d_d[0][0] = -1;
+ d_d[0][1] = 1;
+ d_d[1][0] = -2;
+ d_d[1][1] = 2;
+ e = 2;
+ f[0] = -1;
+ f[1] = 1;
int arrayOffset = ArrayStruct.createArrayStruct(builder,
- a, b, c, d_a, d_b, d_c);
+ a, b, c, d_a, d_b, d_c, d_d, e, f);
// Create a table with the ArrayStruct.
ArrayTable.startArrayTable(builder);
@@ -504,14 +587,807 @@
TestEq(table.a().d(nested, 0).c(1), TestEnum.B);
TestEq(table.a().d(nested, 1).c(0), TestEnum.C);
TestEq(table.a().d(nested, 1).c(1), TestEnum.B);
+ TestEq(table.a().d(nested, 0).d(0), (long)-1);
+ TestEq(table.a().d(nested, 0).d(1), (long)1);
+ TestEq(table.a().d(nested, 1).d(0), (long)-2);
+ TestEq(table.a().d(nested, 1).d(1), (long)2);
+ TestEq(table.a().e(), 2);
+ TestEq(table.a().f(0), (long)-1);
+ TestEq(table.a().f(1), (long)1);
+ }
+
+ public static void testFlexBuffersTest() {
+ FlexBuffersBuilder builder = new FlexBuffersBuilder(ByteBuffer.allocate(512),
+ FlexBuffersBuilder.BUILDER_FLAG_SHARE_KEYS_AND_STRINGS);
+ testFlexBuffersTest(builder);
+ int bufferLimit1 = ((ArrayReadWriteBuf) builder.getBuffer()).limit();
+
+ // Repeat after clearing the builder to ensure the builder is reusable
+ builder.clear();
+ testFlexBuffersTest(builder);
+ int bufferLimit2 = ((ArrayReadWriteBuf) builder.getBuffer()).limit();
+ TestEq(bufferLimit1, bufferLimit2);
+ }
+
+ public static void testFlexBuffersTest(FlexBuffersBuilder builder) {
+ // Write the equivalent of:
+ // { vec: [ -100, "Fred", 4.0, false ], bar: [ 1, 2, 3 ], bar3: [ 1, 2, 3 ],
+ // foo: 100, bool: true, mymap: { foo: "Fred" } }
+ // It's possible to do this without std::function support as well.
+ int map1 = builder.startMap();
+
+ int vec1 = builder.startVector();
+ builder.putInt(-100);
+ builder.putString("Fred");
+ builder.putBlob(new byte[]{(byte) 77});
+ builder.putBoolean(false);
+ builder.putInt(Long.MAX_VALUE);
+
+ int map2 = builder.startMap();
+ builder.putInt("test", 200);
+ builder.endMap(null, map2);
+
+ builder.putFloat(150.9);
+ builder.putFloat(150.9999998);
+ builder.endVector("vec", vec1, false, false);
+
+ vec1 = builder.startVector();
+ builder.putInt(1);
+ builder.putInt(2);
+ builder.putInt(3);
+ builder.endVector("bar", vec1, true, false);
+
+ vec1 = builder.startVector();
+ builder.putBoolean(true);
+ builder.putBoolean(false);
+ builder.putBoolean(true);
+ builder.putBoolean(false);
+ builder.endVector("bools", vec1, true, false);
+
+ builder.putBoolean("bool", true);
+ builder.putFloat("foo", 100);
+
+ map2 = builder.startMap();
+ builder.putString("bar", "Fred"); // Testing key and string reuse.
+ builder.putInt("int", -120);
+ builder.putFloat("float", -123.0f);
+ builder.putBlob("blob", new byte[]{ 65, 67 });
+ builder.endMap("mymap", map2);
+
+ builder.endMap(null, map1);
+ builder.finish();
+
+ FlexBuffers.Map m = FlexBuffers.getRoot(builder.getBuffer()).asMap();
+
+ TestEq(m.size(), 6);
+
+ // test empty (an null)
+ TestEq(m.get("no_key").asString(), ""); // empty if fail
+ TestEq(m.get("no_key").asMap(), FlexBuffers.Map.empty()); // empty if fail
+ TestEq(m.get("no_key").asKey(), FlexBuffers.Key.empty()); // empty if fail
+ TestEq(m.get("no_key").asVector(), FlexBuffers.Vector.empty()); // empty if fail
+ TestEq(m.get("no_key").asBlob(), FlexBuffers.Blob.empty()); // empty if fail
+ assert(m.get("no_key").asVector().isEmpty()); // empty if fail
+
+ // testing "vec" field
+ FlexBuffers.Vector vec = m.get("vec").asVector();
+ TestEq(vec.size(), 8);
+ TestEq(vec.get(0).asLong(), (long) -100);
+ TestEq(vec.get(1).asString(), "Fred");
+ TestEq(vec.get(2).isBlob(), true);
+ TestEq(vec.get(2).asBlob().size(), 1);
+ TestEq(vec.get(2).asBlob().data().get(0), (byte) 77);
+ TestEq(vec.get(3).isBoolean(), true); // Check if type is a bool
+ TestEq(vec.get(3).asBoolean(), false); // Check if value is false
+ TestEq(vec.get(4).asLong(), Long.MAX_VALUE);
+ TestEq(vec.get(5).isMap(), true);
+ TestEq(vec.get(5).asMap().get("test").asInt(), 200);
+ TestEq(Float.compare((float)vec.get(6).asFloat(), 150.9f), 0);
+ TestEq(Double.compare(vec.get(7).asFloat(), 150.9999998), 0);
+ TestEq((long)0, (long)vec.get(1).asLong()); //conversion fail returns 0 as C++
+
+ // bar vector
+ FlexBuffers.Vector tvec = m.get("bar").asVector();
+ TestEq(tvec.size(), 3);
+ TestEq(tvec.get(0).asInt(), 1);
+ TestEq(tvec.get(1).asInt(), 2);
+ TestEq(tvec.get(2).asInt(), 3);
+ TestEq(((FlexBuffers.TypedVector) tvec).getElemType(), FlexBuffers.FBT_INT);
+
+ // bools vector
+ FlexBuffers.Vector bvec = m.get("bools").asVector();
+ TestEq(bvec.size(), 4);
+ TestEq(bvec.get(0).asBoolean(), true);
+ TestEq(bvec.get(1).asBoolean(), false);
+ TestEq(bvec.get(2).asBoolean(), true);
+ TestEq(bvec.get(3).asBoolean(), false);
+ TestEq(((FlexBuffers.TypedVector) bvec).getElemType(), FlexBuffers.FBT_BOOL);
+
+
+ TestEq((float)m.get("foo").asFloat(), (float) 100);
+ TestEq(m.get("unknown").isNull(), true);
+
+ // mymap vector
+ FlexBuffers.Map mymap = m.get("mymap").asMap();
+ TestEq(mymap.keys().get(0), m.keys().get(0)); // These should be equal by pointer equality, since key and value are shared.
+ TestEq(mymap.keys().get(0).toString(), "bar");
+ TestEq(mymap.values().get(0).asString(), vec.get(1).asString());
+ TestEq(mymap.get("int").asInt(), -120);
+ TestEq((float)mymap.get("float").asFloat(), -123.0f);
+ TestEq(Arrays.equals(mymap.get("blob").asBlob().getBytes(), new byte[]{ 65, 67 }), true);
+ TestEq(mymap.get("blob").asBlob().toString(), "AC");
+ TestEq(mymap.get("blob").toString(), "\"AC\"");
+ }
+
+ public static void testFlexBufferVectorStrings() {
+ FlexBuffersBuilder builder = new FlexBuffersBuilder(ByteBuffer.allocate(10000000));
+
+ int size = 3000;
+ StringBuilder sb = new StringBuilder();
+ for (int i=0; i< size; i++) {
+ sb.append("a");
+ }
+
+ String text = sb.toString();
+ TestEq(text.length(), size);
+
+ int pos = builder.startVector();
+
+ for (int i=0; i<size; i++) {
+ builder.putString(text);
+ }
+
+ try {
+ builder.endVector(null, pos, true, false);
+ // this should raise an exception as
+ // typed vector of string was deprecated
+ assert false;
+ } catch(FlexBufferException fb) {
+ // no op
+ }
+ // we finish the vector again as non-typed
+ builder.endVector(null, pos, false, false);
+
+ ByteBuffer b = builder.finish();
+ Vector v = FlexBuffers.getRoot(b).asVector();
+
+ TestEq(v.size(), size);
+ for (int i=0; i<size; i++) {
+ TestEq(v.get(i).asString().length(), size);
+ TestEq(v.get(i).asString(), text);
+ }
+ }
+
+ public static void testDeprecatedTypedVectorString() {
+ // tests whether we are able to support reading deprecated typed vector string
+ // data is equivalent to [ "abc", "abc", "abc", "abc"]
+ byte[] data = new byte[] {0x03, 0x61, 0x62, 0x63, 0x00, 0x03, 0x61, 0x62, 0x63, 0x00,
+ 0x03, 0x61, 0x62, 0x63, 0x00, 0x03, 0x61, 0x62, 0x63, 0x00, 0x04, 0x14, 0x10,
+ 0x0c, 0x08, 0x04, 0x3c, 0x01};
+ Reference ref = FlexBuffers.getRoot(ByteBuffer.wrap(data));
+ TestEq(ref.getType(), FlexBuffers.FBT_VECTOR_STRING_DEPRECATED);
+ TestEq(ref.isTypedVector(), true);
+ Vector vec = ref.asVector();
+ for (int i=0; i< vec.size(); i++) {
+ TestEq("abc", vec.get(i).asString());
+ }
+ }
+
+ public static void testSingleElementBoolean() {
+ FlexBuffersBuilder builder = new FlexBuffersBuilder(ByteBuffer.allocate(100));
+ builder.putBoolean(true);
+ ByteBuffer b = builder.finish();
+ assert(FlexBuffers.getRoot(b).asBoolean());
+ }
+
+ public static void testSingleElementByte() {
+ FlexBuffersBuilder builder = new FlexBuffersBuilder();
+ builder.putInt(10);
+ ByteBuffer b = builder.finish();
+ TestEq(10, FlexBuffers.getRoot(b).asInt());
+ }
+
+ public static void testSingleElementShort() {
+ FlexBuffersBuilder builder = new FlexBuffersBuilder();
+ builder.putInt(Short.MAX_VALUE);
+ ByteBuffer b = builder.finish();
+ TestEq(Short.MAX_VALUE, (short)FlexBuffers.getRoot(b).asInt());
+ }
+
+ public static void testSingleElementInt() {
+ FlexBuffersBuilder builder = new FlexBuffersBuilder();
+ builder.putInt(Integer.MIN_VALUE);
+ ByteBuffer b = builder.finish();
+ TestEq(Integer.MIN_VALUE, FlexBuffers.getRoot(b).asInt());
+ }
+
+ public static void testSingleElementLong() {
+ FlexBuffersBuilder builder = new FlexBuffersBuilder();
+ builder.putInt(Long.MAX_VALUE);
+ ByteBuffer b = builder.finish();
+ TestEq(Long.MAX_VALUE, FlexBuffers.getRoot(b).asLong());
+ }
+
+ public static void testSingleElementFloat() {
+ FlexBuffersBuilder builder = new FlexBuffersBuilder();
+ builder.putFloat(Float.MAX_VALUE);
+ ByteBuffer b = builder.finish();
+ TestEq(Float.compare(Float.MAX_VALUE, (float) FlexBuffers.getRoot(b).asFloat()), 0);
+ }
+
+ public static void testSingleElementDouble() {
+ FlexBuffersBuilder builder = new FlexBuffersBuilder();
+ builder.putFloat(Double.MAX_VALUE);
+ ByteBuffer b = builder.finish();
+ TestEq(Double.compare(Double.MAX_VALUE, FlexBuffers.getRoot(b).asFloat()), 0);
+ }
+
+ public static void testSingleElementBigString() {
+ FlexBuffersBuilder builder = new FlexBuffersBuilder(ByteBuffer.allocate(10000));
+ StringBuilder sb = new StringBuilder();
+
+ for (int i=0; i< 3000; i++) {
+ sb.append("a");
+ }
+
+ builder.putString(sb.toString());
+ ByteBuffer b = builder.finish();
+
+ FlexBuffers.Reference r = FlexBuffers.getRoot(b);
+
+ TestEq(FlexBuffers.FBT_STRING, r.getType());
+ TestEq(sb.toString(), r.asString());
+ }
+
+ public static void testSingleElementSmallString() {
+ FlexBuffersBuilder builder = new FlexBuffersBuilder(ByteBuffer.allocate(10000));
+
+ builder.putString("aa");
+ ByteBuffer b = builder.finish();
+ FlexBuffers.Reference r = FlexBuffers.getRoot(b);
+
+ TestEq(FlexBuffers.FBT_STRING, r.getType());
+ TestEq("aa", r.asString());
+ }
+
+ public static void testSingleElementBlob() {
+ FlexBuffersBuilder builder = new FlexBuffersBuilder();
+ builder.putBlob(new byte[]{5, 124, 118, -1});
+ ByteBuffer b = builder.finish();
+ FlexBuffers.Reference r = FlexBuffers.getRoot(b);
+ byte[] result = r.asBlob().getBytes();
+ TestEq((byte)5, result[0]);
+ TestEq((byte)124, result[1]);
+ TestEq((byte)118, result[2]);
+ TestEq((byte)-1, result[3]);
+ }
+
+ public static void testSingleElementUByte() {
+ FlexBuffersBuilder builder = new FlexBuffersBuilder();
+ builder.putUInt(0xFF);
+ ByteBuffer b = builder.finish();
+ FlexBuffers.Reference r = FlexBuffers.getRoot(b);
+ TestEq(255, (int)r.asUInt());
+ }
+
+ public static void testSingleElementUShort() {
+ FlexBuffersBuilder builder = new FlexBuffersBuilder();
+ builder.putUInt(0xFFFF);
+ ByteBuffer b = builder.finish();
+ FlexBuffers.Reference r = FlexBuffers.getRoot(b);
+ TestEq(65535, (int)r.asUInt());
+ }
+
+ public static void testSingleElementUInt() {
+ FlexBuffersBuilder builder = new FlexBuffersBuilder();
+ builder.putUInt(0xFFFF_FFFFL);
+ ByteBuffer b = builder.finish();
+ FlexBuffers.Reference r = FlexBuffers.getRoot(b);
+ TestEq(4294967295L, r.asUInt());
+ }
+
+ public static void testSingleFixedTypeVector() {
+
+ int[] ints = new int[]{5, 124, 118, -1};
+ float[] floats = new float[]{5.5f, 124.124f, 118.118f, -1.1f};
+ String[] strings = new String[]{"This", "is", "a", "typed", "array"};
+ boolean[] booleans = new boolean[]{false, true, true, false};
+
+
+ FlexBuffersBuilder builder = new FlexBuffersBuilder(ByteBuffer.allocate(512),
+ FlexBuffersBuilder.BUILDER_FLAG_NONE);
+
+ int mapPos = builder.startMap();
+
+ int vecPos = builder.startVector();
+ for (final int i : ints) {
+ builder.putInt(i);
+ }
+ builder.endVector("ints", vecPos, true, false);
+
+ vecPos = builder.startVector();
+ for (final float i : floats) {
+ builder.putFloat(i);
+ }
+ builder.endVector("floats", vecPos, true, false);
+
+ vecPos = builder.startVector();
+ for (final boolean i : booleans) {
+ builder.putBoolean(i);
+ }
+ builder.endVector("booleans", vecPos, true, false);
+
+ builder.endMap(null, mapPos);
+
+
+ ByteBuffer b = builder.finish();
+ FlexBuffers.Reference r = FlexBuffers.getRoot(b);
+ assert(r.asMap().get("ints").isTypedVector());
+ assert(r.asMap().get("floats").isTypedVector());
+ assert(r.asMap().get("booleans").isTypedVector());
+ }
+
+ public static void testSingleElementVector() {
+ FlexBuffersBuilder b = new FlexBuffersBuilder();
+
+ int vecPos = b.startVector();
+ b.putInt(99);
+ b.putString("wow");
+ int vecpos2 = b.startVector();
+ b.putInt(99);
+ b.putString("wow");
+ b.endVector(null, vecpos2, false, false);
+ b.endVector(null, vecPos, false, false);
+ b.finish();
+
+ FlexBuffers.Reference r = FlexBuffers.getRoot(b.getBuffer());
+ TestEq(FlexBuffers.FBT_VECTOR, r.getType());
+ FlexBuffers.Vector vec = FlexBuffers.getRoot(b.getBuffer()).asVector();
+ TestEq(3, vec.size());
+ TestEq(99, vec.get(0).asInt());
+ TestEq("wow", vec.get(1).asString());
+ TestEq("[ 99, \"wow\" ]", vec.get(2).toString());
+ TestEq("[ 99, \"wow\", [ 99, \"wow\" ] ]", FlexBuffers.getRoot(b.getBuffer()).toString());
+ }
+
+ public static void testSingleElementMap() {
+ FlexBuffersBuilder b = new FlexBuffersBuilder();
+
+ int mapPost = b.startMap();
+ b.putInt("myInt", 0x7fffffbbbfffffffL);
+ b.putString("myString", "wow");
+ b.putString("myString2", "incredible");
+ int start = b.startVector();
+ b.putInt(99);
+ b.putString("wow");
+ b.endVector("myVec", start, false, false);
+
+ b.putFloat("double", 0x1.ffffbbbffffffP+1023);
+ b.endMap(null, mapPost);
+ b.finish();
+
+ FlexBuffers.Reference r = FlexBuffers.getRoot(b.getBuffer());
+ TestEq(FlexBuffers.FBT_MAP, r.getType());
+ FlexBuffers.Map map = FlexBuffers.getRoot(b.getBuffer()).asMap();
+ TestEq(5, map.size());
+ TestEq(0x7fffffbbbfffffffL, map.get("myInt").asLong());
+ TestEq("wow", map.get("myString").asString());
+ TestEq("incredible", map.get("myString2").asString());
+ TestEq(99, map.get("myVec").asVector().get(0).asInt());
+ TestEq("wow", map.get("myVec").asVector().get(1).asString());
+ TestEq(Double.compare(0x1.ffffbbbffffffP+1023, map.get("double").asFloat()), 0);
+ TestEq("{ \"double\" : 1.7976894783391937E308, \"myInt\" : 9223371743723257855, \"myString\" : \"wow\", \"myString2\" : \"incredible\", \"myVec\" : [ 99, \"wow\" ] }",
+ FlexBuffers.getRoot(b.getBuffer()).toString());
+ }
+
+ public static void testFlexBuferEmpty() {
+ FlexBuffers.Blob blob = FlexBuffers.Blob.empty();
+ FlexBuffers.Map ary = FlexBuffers.Map.empty();
+ FlexBuffers.Vector map = FlexBuffers.Vector.empty();
+ FlexBuffers.TypedVector typedAry = FlexBuffers.TypedVector.empty();
+ TestEq(blob.size(), 0);
+ TestEq(map.size(), 0);
+ TestEq(ary.size(), 0);
+ TestEq(typedAry.size(), 0);
+ }
+
+ public static void testHashMapToMap() {
+ int entriesCount = 12;
+
+ HashMap<String, String> source = new HashMap<>();
+ for (int i = 0; i < entriesCount; i++) {
+ source.put("foo_param_" + i, "foo_value_" + i);
+ }
+
+ FlexBuffersBuilder builder = new FlexBuffersBuilder(1000);
+ int mapStart = builder.startMap();
+ for (Map.Entry<String, String> entry : source.entrySet()) {
+ builder.putString(entry.getKey(), entry.getValue());
+ }
+ builder.endMap(null, mapStart);
+ ByteBuffer bb = builder.finish();
+ bb.rewind();
+
+ FlexBuffers.Reference rootReference = FlexBuffers.getRoot(bb);
+
+ TestEq(rootReference.isMap(), true);
+
+ FlexBuffers.Map flexMap = rootReference.asMap();
+
+ FlexBuffers.KeyVector keys = flexMap.keys();
+ FlexBuffers.Vector values = flexMap.values();
+
+ TestEq(entriesCount, keys.size());
+ TestEq(entriesCount, values.size());
+
+ HashMap<String, String> result = new HashMap<>();
+ for (int i = 0; i < keys.size(); i++) {
+ result.put(keys.get(i).toString(), values.get(i).asString());
+ }
+
+ TestEq(source, result);
+ }
+
+ public static void testBuilderGrowth() {
+ FlexBuffersBuilder builder = new FlexBuffersBuilder();
+ String someString = "This is a small string";
+ builder.putString(someString);
+ ByteBuffer b = builder.finish();
+ TestEq(someString, FlexBuffers.getRoot(b).asString());
+
+ FlexBuffersBuilder failBuilder = new FlexBuffersBuilder(ByteBuffer.allocate(1));
+ failBuilder.putString(someString);
+ }
+
+ public static void testFlexBuffersUtf8Map() {
+ FlexBuffersBuilder builder = new FlexBuffersBuilder(ByteBuffer.allocate(512),
+ FlexBuffersBuilder.BUILDER_FLAG_SHARE_KEYS_AND_STRINGS);
+
+ String key0 = "😨 face1";
+ String key1 = "😩 face2";
+ String key2 = "😨 face3";
+ String key3 = "trademark ®";
+ String key4 = "€ euro";
+ String utf8keys[] = { "😨 face1", "😩 face2", "😨 face3", "trademark ®", "€ euro"};
+
+ int map = builder.startMap();
+
+ for (int i=0; i< utf8keys.length; i++) {
+ builder.putString(utf8keys[i], utf8keys[i]); // Testing key and string reuse.
+ }
+ builder.endMap(null, map);
+ builder.finish();
+
+ FlexBuffers.Map m = FlexBuffers.getRoot(builder.getBuffer()).asMap();
+
+ TestEq(m.size(), 5);
+
+ KeyVector kv = m.keys();
+ for (int i=0; i< utf8keys.length; i++) {
+ TestEq(kv.get(i).toString(), m.get(i).asString());
+ }
+
+ TestEq(m.get(key0).asString(), utf8keys[0]);
+ TestEq(m.get(key1).asString(), utf8keys[1]);
+ TestEq(m.get(key2).asString(), utf8keys[2]);
+ TestEq(m.get(key3).asString(), utf8keys[3]);
+ TestEq(m.get(key4).asString(), utf8keys[4]);
+ }
+
+ public static void TestFlexBuffers() {
+ testSingleElementByte();
+ testSingleElementShort();
+ testSingleElementInt();
+ testSingleElementLong();
+ testSingleElementFloat();
+ testSingleElementDouble();
+ testSingleElementSmallString();
+ testSingleElementBigString();
+ testSingleElementBlob();
+ testSingleElementVector();
+ testSingleFixedTypeVector();
+ testSingleElementUShort();
+ testSingleElementUInt();
+ testSingleElementUByte();
+ testSingleElementMap();
+ testFlexBuffersTest();
+ testHashMapToMap();
+ testFlexBuferEmpty();
+ testFlexBufferVectorStrings();
+ testDeprecatedTypedVectorString();
+ testBuilderGrowth();
+ testFlexBuffersUtf8Map();
+ }
+
+ static void TestVectorOfBytes() {
+ FlatBufferBuilder fbb = new FlatBufferBuilder(16);
+ int str = fbb.createString("ByteMonster");
+ byte[] data = new byte[] {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+ int offset = Monster.createInventoryVector(fbb, data);
+ Monster.startMonster(fbb);
+ Monster.addName(fbb, str);
+ Monster.addInventory(fbb, offset);
+ int monster1 = Monster.endMonster(fbb);
+ Monster.finishMonsterBuffer(fbb, monster1);
+ Monster monsterObject = Monster.getRootAsMonster(fbb.dataBuffer());
+
+ TestEq(monsterObject.inventoryLength(), data.length);
+ TestEq(monsterObject.inventory(4), (int) data[4]);
+ TestEq(ByteBuffer.wrap(data), monsterObject.inventoryAsByteBuffer());
+
+ fbb.clear();
+ ByteBuffer bb = ByteBuffer.wrap(data);
+ offset = fbb.createByteVector(bb);
+ str = fbb.createString("ByteMonster");
+ Monster.startMonster(fbb);
+ Monster.addName(fbb, str);
+ Monster.addInventory(fbb, offset);
+ monster1 = Monster.endMonster(fbb);
+ Monster.finishMonsterBuffer(fbb, monster1);
+ Monster monsterObject2 = Monster.getRootAsMonster(fbb.dataBuffer());
+
+ TestEq(monsterObject2.inventoryLength(), data.length);
+ for (int i = 0; i < data.length; i++) {
+ TestEq(monsterObject2.inventory(i), (int) bb.get(i));
+ }
+
+ fbb.clear();
+ offset = fbb.createByteVector(data, 3, 4);
+ str = fbb.createString("ByteMonster");
+ Monster.startMonster(fbb);
+ Monster.addName(fbb, str);
+ Monster.addInventory(fbb, offset);
+ monster1 = Monster.endMonster(fbb);
+ Monster.finishMonsterBuffer(fbb, monster1);
+ Monster monsterObject3 = Monster.getRootAsMonster(fbb.dataBuffer());
+
+ TestEq(monsterObject3.inventoryLength(), 4);
+ TestEq(monsterObject3.inventory(0), (int) data[3]);
+
+ fbb.clear();
+ bb = ByteBuffer.wrap(data);
+ offset = Monster.createInventoryVector(fbb, bb);
+ str = fbb.createString("ByteMonster");
+ Monster.startMonster(fbb);
+ Monster.addName(fbb, str);
+ Monster.addInventory(fbb, offset);
+ monster1 = Monster.endMonster(fbb);
+ Monster.finishMonsterBuffer(fbb, monster1);
+ Monster monsterObject4 = Monster.getRootAsMonster(fbb.dataBuffer());
+
+ TestEq(monsterObject4.inventoryLength(), data.length);
+ TestEq(monsterObject4.inventory(8), (int) 8);
+
+ fbb.clear();
+ byte[] largeData = new byte[1024];
+ offset = fbb.createByteVector(largeData);
+ str = fbb.createString("ByteMonster");
+ Monster.startMonster(fbb);
+ Monster.addName(fbb, str);
+ Monster.addInventory(fbb, offset);
+ monster1 = Monster.endMonster(fbb);
+ Monster.finishMonsterBuffer(fbb, monster1);
+ Monster monsterObject5 = Monster.getRootAsMonster(fbb.dataBuffer());
+
+ TestEq(monsterObject5.inventoryLength(), largeData.length);
+ TestEq(monsterObject5.inventory(25), (int) largeData[25]);
+
+ fbb.clear();
+ bb = ByteBuffer.wrap(largeData);
+ bb.position(512);
+ ByteBuffer bb2 = bb.slice();
+ TestEq(bb2.arrayOffset(), 512);
+ offset = fbb.createByteVector(bb2);
+ str = fbb.createString("ByteMonster");
+ Monster.startMonster(fbb);
+ Monster.addName(fbb, str);
+ Monster.addInventory(fbb, offset);
+ monster1 = Monster.endMonster(fbb);
+ Monster.finishMonsterBuffer(fbb, monster1);
+ Monster monsterObject6 = Monster.getRootAsMonster(fbb.dataBuffer());
+
+ TestEq(monsterObject6.inventoryLength(), 512);
+ TestEq(monsterObject6.inventory(0), (int) largeData[512]);
+
+ fbb.clear();
+ bb = ByteBuffer.wrap(largeData);
+ bb.limit(256);
+ offset = fbb.createByteVector(bb);
+ str = fbb.createString("ByteMonster");
+ Monster.startMonster(fbb);
+ Monster.addName(fbb, str);
+ Monster.addInventory(fbb, offset);
+ monster1 = Monster.endMonster(fbb);
+ Monster.finishMonsterBuffer(fbb, monster1);
+ Monster monsterObject7 = Monster.getRootAsMonster(fbb.dataBuffer());
+
+ TestEq(monsterObject7.inventoryLength(), 256);
+
+ fbb.clear();
+ bb = ByteBuffer.allocateDirect(2048);
+ offset = fbb.createByteVector(bb);
+ str = fbb.createString("ByteMonster");
+ Monster.startMonster(fbb);
+ Monster.addName(fbb, str);
+ Monster.addInventory(fbb, offset);
+ monster1 = Monster.endMonster(fbb);
+ Monster.finishMonsterBuffer(fbb, monster1);
+ Monster monsterObject8 = Monster.getRootAsMonster(fbb.dataBuffer());
+
+ TestEq(monsterObject8.inventoryLength(), 2048);
+ }
+
+ static void TestSharedStringPool() {
+ FlatBufferBuilder fb = new FlatBufferBuilder(1);
+ String testString = "My string";
+ int offset = fb.createSharedString(testString);
+ for (int i=0; i< 10; i++) {
+ TestEq(offset, fb.createSharedString(testString));
+ }
+ }
+
+ static void TestScalarOptional() {
+ FlatBufferBuilder fbb = new FlatBufferBuilder(1);
+ ScalarStuff.startScalarStuff(fbb);
+ int pos = ScalarStuff.endScalarStuff(fbb);
+ fbb.finish(pos);
+
+ ScalarStuff scalarStuff = ScalarStuff.getRootAsScalarStuff(fbb.dataBuffer());
+ TestEq(scalarStuff.justI8(), (byte)0);
+ TestEq(scalarStuff.maybeI8(), (byte)0);
+ TestEq(scalarStuff.defaultI8(), (byte)42);
+ TestEq(scalarStuff.justU8(), 0);
+ TestEq(scalarStuff.maybeU8(), 0);
+ TestEq(scalarStuff.defaultU8(), 42);
+ TestEq(scalarStuff.justI16(), (short)0);
+ TestEq(scalarStuff.maybeI16(), (short)0);
+ TestEq(scalarStuff.defaultI16(), (short)42);
+ TestEq(scalarStuff.justU16(), 0);
+ TestEq(scalarStuff.maybeU16(), 0);
+ TestEq(scalarStuff.defaultU16(), 42);
+ TestEq(scalarStuff.justI32(), 0);
+ TestEq(scalarStuff.maybeI32(), 0);
+ TestEq(scalarStuff.defaultI32(), 42);
+ TestEq(scalarStuff.justU32(), 0L);
+ TestEq(scalarStuff.maybeU32(), 0L);
+ TestEq(scalarStuff.defaultU32(), 42L);
+ TestEq(scalarStuff.justI64(), 0L);
+ TestEq(scalarStuff.maybeI64(), 0L);
+ TestEq(scalarStuff.defaultI64(), 42L);
+ TestEq(scalarStuff.justU64(), 0L);
+ TestEq(scalarStuff.maybeU64(), 0L);
+ TestEq(scalarStuff.defaultU64(), 42L);
+ TestEq(scalarStuff.justF32(), 0.0f);
+ TestEq(scalarStuff.maybeF32(), 0f);
+ TestEq(scalarStuff.defaultF32(), 42.0f);
+ TestEq(scalarStuff.justF64(), 0.0);
+ TestEq(scalarStuff.maybeF64(), 0.0);
+ TestEq(scalarStuff.defaultF64(), 42.0);
+ TestEq(scalarStuff.justBool(), false);
+ TestEq(scalarStuff.maybeBool(), false);
+ TestEq(scalarStuff.defaultBool(), true);
+ TestEq(scalarStuff.justEnum(), OptionalByte.None);
+ TestEq(scalarStuff.maybeEnum(), OptionalByte.None);
+ TestEq(scalarStuff.defaultEnum(), OptionalByte.One);
+
+ TestEq(scalarStuff.hasMaybeI8(), false);
+ TestEq(scalarStuff.hasMaybeI16(), false);
+ TestEq(scalarStuff.hasMaybeI32(), false);
+ TestEq(scalarStuff.hasMaybeI64(), false);
+ TestEq(scalarStuff.hasMaybeU8(), false);
+ TestEq(scalarStuff.hasMaybeU16(), false);
+ TestEq(scalarStuff.hasMaybeU32(), false);
+ TestEq(scalarStuff.hasMaybeU64(), false);
+ TestEq(scalarStuff.hasMaybeF32(), false);
+ TestEq(scalarStuff.hasMaybeF64(), false);
+ TestEq(scalarStuff.hasMaybeBool(), false);
+ TestEq(scalarStuff.hasMaybeEnum(), false);
+
+ fbb.clear();
+
+ ScalarStuff.startScalarStuff(fbb);
+ ScalarStuff.addJustI8(fbb, (byte)5);
+ ScalarStuff.addMaybeI8(fbb, (byte)5);
+ ScalarStuff.addDefaultI8(fbb, (byte)5);
+ ScalarStuff.addJustU8(fbb, 6);
+ ScalarStuff.addMaybeU8(fbb, 6);
+ ScalarStuff.addDefaultU8(fbb, 6);
+ ScalarStuff.addJustI16(fbb, (short)7);
+ ScalarStuff.addMaybeI16(fbb, (short)7);
+ ScalarStuff.addDefaultI16(fbb, (short)7);
+ ScalarStuff.addJustU16(fbb, 8);
+ ScalarStuff.addMaybeU16(fbb, 8);
+ ScalarStuff.addDefaultU16(fbb, 8);
+ ScalarStuff.addJustI32(fbb, 9);
+ ScalarStuff.addMaybeI32(fbb, 9);
+ ScalarStuff.addDefaultI32(fbb, 9);
+ ScalarStuff.addJustU32(fbb, (long)10);
+ ScalarStuff.addMaybeU32(fbb, (long)10);
+ ScalarStuff.addDefaultU32(fbb, (long)10);
+ ScalarStuff.addJustI64(fbb, 11L);
+ ScalarStuff.addMaybeI64(fbb, 11L);
+ ScalarStuff.addDefaultI64(fbb, 11L);
+ ScalarStuff.addJustU64(fbb, 12L);
+ ScalarStuff.addMaybeU64(fbb, 12L);
+ ScalarStuff.addDefaultU64(fbb, 12L);
+ ScalarStuff.addJustF32(fbb, 13.0f);
+ ScalarStuff.addMaybeF32(fbb, 13.0f);
+ ScalarStuff.addDefaultF32(fbb, 13.0f);
+ ScalarStuff.addJustF64(fbb, 14.0);
+ ScalarStuff.addMaybeF64(fbb, 14.0);
+ ScalarStuff.addDefaultF64(fbb, 14.0);
+ ScalarStuff.addJustBool(fbb, true);
+ ScalarStuff.addMaybeBool(fbb, true);
+ ScalarStuff.addDefaultBool(fbb, true);
+ ScalarStuff.addJustEnum(fbb, OptionalByte.Two);
+ ScalarStuff.addMaybeEnum(fbb, OptionalByte.Two);
+ ScalarStuff.addDefaultEnum(fbb, OptionalByte.Two);
+
+ pos = ScalarStuff.endScalarStuff(fbb);
+
+ fbb.finish(pos);
+
+ scalarStuff = ScalarStuff.getRootAsScalarStuff(fbb.dataBuffer());
+
+ TestEq(scalarStuff.justI8(), (byte)5);
+ TestEq(scalarStuff.maybeI8(), (byte)5);
+ TestEq(scalarStuff.defaultI8(), (byte)5);
+ TestEq(scalarStuff.justU8(), 6);
+ TestEq(scalarStuff.maybeU8(), 6);
+ TestEq(scalarStuff.defaultU8(), 6);
+ TestEq(scalarStuff.justI16(), (short)7);
+ TestEq(scalarStuff.maybeI16(), (short)7);
+ TestEq(scalarStuff.defaultI16(), (short)7);
+ TestEq(scalarStuff.justU16(), 8);
+ TestEq(scalarStuff.maybeU16(), 8);
+ TestEq(scalarStuff.defaultU16(), 8);
+ TestEq(scalarStuff.justI32(), 9);
+ TestEq(scalarStuff.maybeI32(), 9);
+ TestEq(scalarStuff.defaultI32(), 9);
+ TestEq(scalarStuff.justU32(), 10L);
+ TestEq(scalarStuff.maybeU32(), 10L);
+ TestEq(scalarStuff.defaultU32(), 10L);
+ TestEq(scalarStuff.justI64(), 11L);
+ TestEq(scalarStuff.maybeI64(), 11L);
+ TestEq(scalarStuff.defaultI64(), 11L);
+ TestEq(scalarStuff.justU64(), 12L);
+ TestEq(scalarStuff.maybeU64(), 12L);
+ TestEq(scalarStuff.defaultU64(), 12L);
+ TestEq(scalarStuff.justF32(), 13.0f);
+ TestEq(scalarStuff.maybeF32(), 13.0f);
+ TestEq(scalarStuff.defaultF32(), 13.0f);
+ TestEq(scalarStuff.justF64(), 14.0);
+ TestEq(scalarStuff.maybeF64(), 14.0);
+ TestEq(scalarStuff.defaultF64(), 14.0);
+ TestEq(scalarStuff.justBool(), true);
+ TestEq(scalarStuff.maybeBool(), true);
+ TestEq(scalarStuff.defaultBool(), true);
+ TestEq(scalarStuff.justEnum(), OptionalByte.Two);
+ TestEq(scalarStuff.maybeEnum(), OptionalByte.Two);
+ TestEq(scalarStuff.defaultEnum(), OptionalByte.Two);
+
+ TestEq(scalarStuff.hasMaybeI8(), true);
+ TestEq(scalarStuff.hasMaybeI16(), true);
+ TestEq(scalarStuff.hasMaybeI32(), true);
+ TestEq(scalarStuff.hasMaybeI64(), true);
+ TestEq(scalarStuff.hasMaybeU8(), true);
+ TestEq(scalarStuff.hasMaybeU16(), true);
+ TestEq(scalarStuff.hasMaybeU32(), true);
+ TestEq(scalarStuff.hasMaybeU64(), true);
+ TestEq(scalarStuff.hasMaybeF32(), true);
+ TestEq(scalarStuff.hasMaybeF64(), true);
+ TestEq(scalarStuff.hasMaybeBool(), true);
+ TestEq(scalarStuff.hasMaybeEnum(), true);
}
static <T> void TestEq(T a, T b) {
- if (!a.equals(b)) {
+ if ((a == null && a != b) || (a != null && !a.equals(b))) {
System.out.println("" + a.getClass().getName() + " " + b.getClass().getName());
System.out.println("FlatBuffers test FAILED: \'" + a + "\' != \'" + b + "\'");
+ new Throwable().printStackTrace();
assert false;
System.exit(1);
}
}
+
}