1// Copyright 2018 Google Inc. All rights reserved. 2// 3// Licensed under the Apache License, Version 2.0 (the "License"); 4// you may not use this file except in compliance with the License. 5// You may obtain a copy of the License at 6// 7// http://www.apache.org/licenses/LICENSE-2.0 8// 9// Unless required by applicable law or agreed to in writing, software 10// distributed under the License is distributed on an "AS IS" BASIS, 11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12// See the License for the specific language governing permissions and 13// limitations under the License. 14 15import from "../lobster/" 16import monster_test_generated 17import optional_scalars_generated 18 19def check_read_buffer(buf): 20 // Check that the given buffer is evaluated correctly as the example Monster. 21 assert flatbuffers_has_identifier(buf, "MONS") 22 23 let monster = MyGame_Example_GetRootAsMonster(buf) 24 25 assert monster.hp == 80 26 assert monster.mana == 150 27 assert monster.name == "MyMonster" 28 29 let vec = monster.pos 30 assert vec 31 assert vec.x == 1.0 32 assert vec.y == 2.0 33 assert vec.z == 3.0 34 assert vec.test1 == 3.0 35 assert vec.test2 == 2 36 37 let t = vec.test3 38 assert t 39 assert t.a == 5 40 assert t.b == 6 41 42 assert monster.test_type == MyGame_Example_Any_Monster 43 assert monster.test_as_Monster.name == "Fred" 44 45 assert monster.inventory_length == 5 46 assert sum(map(monster.inventory_length) i: monster.inventory(i)) == 10 47 48 for(5) i: 49 assert monster.vector_of_longs(i) == pow(10, i * 2) 50 51 assert equal([-1.7976931348623157e+308, 0, 1.7976931348623157e+308], 52 (map(monster.vector_of_doubles_length) i: monster.vector_of_doubles(i))) 53 54 assert monster.test4_length == 2 55 let test0 = monster.test4(0) 56 let test1 = monster.test4(1) 57 assert test0.a + test0.b + test1.a + test1.b == 100 58 59 assert monster.testarrayofstring_length == 2 60 assert monster.testarrayofstring(0) == "test1" 61 assert monster.testarrayofstring(1) == "test2" 62 63 assert monster.testarrayoftables_length == 0 64 assert monster.testnestedflatbuffer_length == 0 65 assert not monster.testempty() 66 67def make_monster_from_generated_code(): 68 // Use generated code to build the example Monster. 69 let b = flatbuffers_builder {} 70 71 let name = b.CreateString("MyMonster") 72 let fred = b.CreateString("Fred") 73 74 let inv = b.MyGame_Example_MonsterCreateInventoryVector([ 0, 1, 2, 3, 4 ]) 75 76 let mon2 = MyGame_Example_MonsterBuilder { b } 77 .start() 78 .add_name(fred) 79 .end() 80 81 b.MyGame_Example_MonsterStartTest4Vector(2) 82 b.MyGame_Example_CreateTest(10, 20) 83 b.MyGame_Example_CreateTest(30, 40) 84 let test4 = b.EndVector(2) 85 86 let test_array_of_string = b.MyGame_Example_MonsterCreateTestarrayofstringVector( 87 [ b.CreateString("test1"), b.CreateString("test2") ]) 88 89 let vector_of_longs = b.MyGame_Example_MonsterCreateVectorOfLongsVector( 90 [ 1, 100, 10000, 1000000, 100000000 ]) 91 92 let vector_of_doubles = b.MyGame_Example_MonsterCreateVectorOfDoublesVector( 93 [ -1.7976931348623157e+308, 0, 1.7976931348623157e+308 ]) 94 95 let mon = MyGame_Example_MonsterBuilder { b } 96 .start() 97 .add_pos(b.MyGame_Example_CreateVec3(1.0, 2.0, 3.0, 3.0, 98 MyGame_Example_Color_Green, 5, 6)) 99 .add_hp(80) 100 .add_name(name) 101 .add_inventory(inv) 102 .add_test_type(MyGame_Example_Any_Monster) 103 .add_test(mon2) 104 .add_test4(test4) 105 .add_testarrayofstring(test_array_of_string) 106 .add_vector_of_longs(vector_of_longs) 107 .add_vector_of_doubles(vector_of_doubles) 108 .end() 109 110 b.Finish(mon, "MONS") 111 112 return b.SizedCopy() 113 114def test_optional_scalars(): 115 def build(add_fields): 116 let b = flatbuffers_builder {} 117 let ss = optional_scalars_ScalarStuffBuilder { b }.start() 118 if add_fields: 119 ss.add_just_i8(1) 120 ss.add_maybe_i8(1) 121 ss.add_default_i8(1) 122 ss.add_just_f64(1.0) 123 ss.add_maybe_f64(1.0) 124 ss.add_default_f64(1.0) 125 ss.add_just_bool(true) 126 ss.add_maybe_bool(true) 127 ss.add_default_bool(true) 128 ss.add_just_enum(optional_scalars_OptionalByte_Two) 129 ss.add_maybe_enum(optional_scalars_OptionalByte_Two) 130 ss.add_default_enum(optional_scalars_OptionalByte_Two) 131 b.Finish(ss.end(), "NULL") 132 let buf = b.SizedCopy() 133 assert flatbuffers_has_identifier(buf, "NULL") 134 return optional_scalars_GetRootAsScalarStuff(buf) 135 136 var root = build(true) 137 138 assert root.just_i8() == 1 and root.default_i8() == 1 139 var maybe_val_i8, maybe_present_i8 = root.maybe_i8() 140 assert maybe_val_i8 == 1 and maybe_present_i8 == true 141 142 assert root.just_f64() == 1.0 and root.default_f64() == 1.0 143 var maybe_val_f64, maybe_present_f64 = root.maybe_f64() 144 assert maybe_val_f64 == 1.0 and maybe_present_f64 == true 145 146 assert root.just_bool() == true and root.default_bool() == true 147 var maybe_val_bool, maybe_present_bool = root.maybe_bool() 148 assert maybe_val_bool == true and maybe_present_bool == true 149 150 assert root.just_enum() == optional_scalars_OptionalByte_Two and root.default_enum() == optional_scalars_OptionalByte_Two 151 var maybe_val_enum, maybe_present_enum = root.maybe_enum() 152 assert maybe_val_enum == optional_scalars_OptionalByte_Two and maybe_present_enum == true 153 154 root = build(false) 155 156 assert root.just_i8() == 0 and root.default_i8() == 42 157 maybe_val_i8, maybe_present_i8 = root.maybe_i8() 158 assert maybe_val_i8 == 0 and maybe_present_i8 == false 159 160 assert root.just_f64() == 0.0 and root.default_f64() == 42.0 161 maybe_val_f64, maybe_present_f64 = root.maybe_f64() 162 assert maybe_val_f64 == 0.0 and maybe_present_f64 == false 163 164 assert root.just_bool() == false and root.default_bool() == true 165 maybe_val_bool, maybe_present_bool = root.maybe_bool() 166 assert maybe_val_bool == false and maybe_present_bool == false 167 168 assert root.just_enum() == optional_scalars_OptionalByte_None and root.default_enum() == optional_scalars_OptionalByte_One 169 maybe_val_enum, maybe_present_enum = root.maybe_enum() 170 assert maybe_val_enum == optional_scalars_OptionalByte_None and maybe_present_enum == false 171 172 173// Verify that the canonical flatbuffer file (produced by the C++ implementation) 174// is readable by the generated Lobster code. 175let fb2 = read_file("monsterdata_test.mon") 176assert fb2 177check_read_buffer(fb2) 178 179// Verify that using the generated Lobster code builds a buffer without 180// returning errors, and is interpreted correctly. 181let fb1 = make_monster_from_generated_code() 182check_read_buffer(fb1) 183// Write the result to file for no good reason. 184write_file("monsterdata_lobster_wire.mon", fb1) 185 186// Test converting the buffer to JSON and parsing the JSON back again. 187let schema = read_file("monster_test.fbs") 188assert schema 189let includedirs = [ "include_test" ] 190// Convert binary to JSON: 191let json, err1 = flatbuffers_binary_to_json(schema, fb1, includedirs) 192assert not err1 193// Parse JSON back to binary: 194let fb3, err2 = flatbuffers_json_to_binary(schema, json, includedirs) 195assert not err2 196// Check the resulting binary again (full roundtrip test): 197check_read_buffer(fb3) 198 199// Additional tests. 200test_optional_scalars() 201 202print "Lobster test succesful!" 203