Merge commit '0f6aab9da6fe982218a01f4a5b896e65fcced437' as 'third_party/flatbuffers'

2024-06-22 13:33:34 +02:00
parent b223785c4d 0f6aab9da6
commit bf3c2d8f4f
1814 changed files with 326902 additions and 0 deletions
@@ -0,0 +1,202 @@
+// Copyright 2018 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.
+
+import from "../lobster/"
+import monster_test_generated
+import optional_scalars_generated
+
+def check_read_buffer(buf):
+    // Check that the given buffer is evaluated correctly as the example Monster.
+    assert flatbuffers.has_identifier(buf, "MONS")
+
+    let monster = MyGame.Example.GetRootAsMonster(buf)
+
+    assert monster.hp == 80
+    assert monster.mana == 150
+    assert monster.name == "MyMonster"
+
+    let vec = monster.pos
+    assert vec
+    assert vec.x == 1.0
+    assert vec.y == 2.0
+    assert vec.z == 3.0
+    assert vec.test1 == 3.0
+    assert vec.test2 == 2
+
+    let t = vec.test3
+    assert t
+    assert t.a == 5
+    assert t.b == 6
+
+    assert monster.test_type == MyGame.Example.Any_Monster
+    assert monster.test_as_Monster.name == "Fred"
+
+    assert monster.inventory_length == 5
+    assert sum(map(monster.inventory_length) i: monster.inventory(i)) == 10
+
+    for(5) i:
+        assert monster.vector_of_longs(i) == pow(10, i * 2)
+
+    assert equal([-1.7976931348623157e+308, 0.0, 1.7976931348623157e+308],
+                 (map(monster.vector_of_doubles_length) i: monster.vector_of_doubles(i)))
+
+    assert monster.test4_length == 2
+    let test0 = monster.test4(0)
+    let test1 = monster.test4(1)
+    assert test0.a + test0.b + test1.a + test1.b == 100
+
+    assert monster.testarrayofstring_length == 2
+    assert monster.testarrayofstring(0) == "test1"
+    assert monster.testarrayofstring(1) == "test2"
+
+    assert monster.testarrayoftables_length == 0
+    assert monster.testnestedflatbuffer_length == 0
+    assert not monster.testempty()
+
+def make_monster_from_generated_code():
+    // Use generated code to build the example Monster.
+    let b = flatbuffers.builder {}
+
+    let name = b.CreateString("MyMonster")
+    let fred = b.CreateString("Fred")
+
+    let inv = b.MyGame.Example.MonsterCreateInventoryVector([ 0, 1, 2, 3, 4 ])
+
+    let mon2 = MyGame.Example.MonsterBuilder { b }
+        .start()
+        .add_name(fred)
+        .end()
+
+    b.MyGame.Example.MonsterStartTest4Vector(2)
+    b.MyGame.Example.CreateTest(10, 20)
+    b.MyGame.Example.CreateTest(30, 40)
+    let test4 = b.EndVector(2)
+
+    let test_array_of_string = b.MyGame.Example.MonsterCreateTestarrayofstringVector(
+                                   [ b.CreateString("test1"), b.CreateString("test2") ])
+
+    let vector_of_longs = b.MyGame.Example.MonsterCreateVectorOfLongsVector(
+                              [ 1, 100, 10000, 1000000, 100000000 ])
+
+    let vector_of_doubles = b.MyGame.Example.MonsterCreateVectorOfDoublesVector(
+                                [ -1.7976931348623157e+308, 0.0, 1.7976931348623157e+308 ])
+
+    let mon = MyGame.Example.MonsterBuilder { b }
+        .start()
+        .add_pos(b.MyGame.Example.CreateVec3(1.0, 2.0, 3.0, 3.0,
+                 MyGame.Example.Color_Green, 5, 6))
+        .add_hp(80)
+        .add_name(name)
+        .add_inventory(inv)
+        .add_test_type(MyGame.Example.Any_Monster)
+        .add_test(mon2)
+        .add_test4(test4)
+        .add_testarrayofstring(test_array_of_string)
+        .add_vector_of_longs(vector_of_longs)
+        .add_vector_of_doubles(vector_of_doubles)
+        .end()
+
+    b.Finish(mon, "MONS")
+
+    return b.SizedCopy()
+
+def test_optional_scalars():
+    def build(add_fields):
+        let b = flatbuffers.builder {}
+        let ss = optional_scalars.ScalarStuffBuilder { b }.start()
+        if add_fields:
+            ss.add_just_i8(1)
+            ss.add_maybe_i8(1)
+            ss.add_default_i8(1)
+            ss.add_just_f64(1.0)
+            ss.add_maybe_f64(1.0)
+            ss.add_default_f64(1.0)
+            ss.add_just_bool(true)
+            ss.add_maybe_bool(true)
+            ss.add_default_bool(true)
+            ss.add_just_enum(optional_scalars.OptionalByte_Two)
+            ss.add_maybe_enum(optional_scalars.OptionalByte_Two)
+            ss.add_default_enum(optional_scalars.OptionalByte_Two)
+        b.Finish(ss.end(), "NULL")
+        let buf = b.SizedCopy()
+        assert flatbuffers.has_identifier(buf, "NULL")
+        return optional_scalars.GetRootAsScalarStuff(buf)
+
+    var root = build(true)
+
+    assert root.just_i8() == 1 and root.default_i8() == 1
+    var maybe_val_i8, maybe_present_i8 = root.maybe_i8()
+    assert maybe_val_i8 == 1 and maybe_present_i8 == true
+
+    assert root.just_f64() == 1.0 and root.default_f64() == 1.0
+    var maybe_val_f64, maybe_present_f64 = root.maybe_f64()
+    assert maybe_val_f64 == 1.0 and maybe_present_f64 == true
+
+    assert root.just_bool() == true and root.default_bool() == true
+    var maybe_val_bool, maybe_present_bool = root.maybe_bool()
+    assert maybe_val_bool == true and maybe_present_bool == true
+
+    assert root.just_enum() == optional_scalars.OptionalByte_Two and root.default_enum() == optional_scalars.OptionalByte_Two
+    var maybe_val_enum, maybe_present_enum = root.maybe_enum()
+    assert maybe_val_enum == optional_scalars.OptionalByte_Two and maybe_present_enum == true
+
+    root = build(false)
+
+    assert root.just_i8() == 0 and root.default_i8() == 42
+    maybe_val_i8, maybe_present_i8 = root.maybe_i8()
+    assert maybe_val_i8 == 0 and maybe_present_i8 == false
+
+    assert root.just_f64() == 0.0 and root.default_f64() == 42.0
+    maybe_val_f64, maybe_present_f64 = root.maybe_f64()
+    assert maybe_val_f64 == 0.0 and maybe_present_f64 == false
+
+    assert root.just_bool() == false and root.default_bool() == true
+    maybe_val_bool, maybe_present_bool = root.maybe_bool()
+    assert maybe_val_bool == false and maybe_present_bool == false
+
+    assert root.just_enum() == optional_scalars.OptionalByte_None and root.default_enum() == optional_scalars.OptionalByte_One
+    maybe_val_enum, maybe_present_enum = root.maybe_enum()
+    assert maybe_val_enum == optional_scalars.OptionalByte_None and maybe_present_enum == false
+
+
+// Verify that the canonical flatbuffer file (produced by the C++ implementation)
+// is readable by the generated Lobster code.
+let fb2 = read_file("monsterdata_test.mon")
+assert fb2
+check_read_buffer(fb2)
+
+// Verify that using the generated Lobster code builds a buffer without
+// returning errors, and is interpreted correctly.
+let fb1 = make_monster_from_generated_code()
+check_read_buffer(fb1)
+// Write the result to file for no good reason.
+write_file("monsterdata_lobster_wire.mon", fb1)
+
+// Test converting the buffer to JSON and parsing the JSON back again.
+let schema = read_file("monster_test.fbs")
+assert schema
+let includedirs = [ "include_test" ]
+// Convert binary to JSON:
+let json, err1 = flatbuffers.binary_to_json(schema, fb1, includedirs)
+assert not err1
+// Parse JSON back to binary:
+let fb3, err2 = flatbuffers.json_to_binary(schema, json, includedirs)
+assert not err2
+// Check the resulting binary again (full roundtrip test):
+check_read_buffer(fb3)
+
+// Additional tests.
+test_optional_scalars()
+
+print "Lobster test successful!"