1361 lines
41 KiB
Lua
1361 lines
41 KiB
Lua
local lu = require "luaunit"
|
|
|
|
local pb = require "pb"
|
|
local pbio = require "pb.io"
|
|
local buffer = require "pb.buffer"
|
|
local slice = require "pb.slice"
|
|
local conv = require "pb.conv"
|
|
local protoc = require "protoc"
|
|
|
|
-- local assert_not = lu.assertEvalToFalse
|
|
local eq = lu.assertEquals
|
|
local table_eq = lu.assertItemsEquals
|
|
local fail = lu.assertErrorMsgContains
|
|
local is_true = lu.assertIsTrue
|
|
|
|
local types = 0
|
|
for _ in pb.types() do
|
|
types = types + 1
|
|
end
|
|
pbio.write("pb predefined types: ", tostring(types), "\n")
|
|
|
|
local function check_load(chunk, name)
|
|
local pbdata = protoc.new():compile(chunk, name)
|
|
local ret, offset = pb.load(pbdata)
|
|
if not ret then
|
|
error("load error at "..offset..
|
|
"\nproto: "..chunk..
|
|
"\ndata: "..buffer(pbdata):tohex())
|
|
end
|
|
end
|
|
|
|
local function check_msg(name, data, r)
|
|
local chunk2, _ = pb.encode(name, data)
|
|
local data2 = pb.decode(name, chunk2)
|
|
--print("msg: ", name, "<"..chunk2:gsub(".", function(s)
|
|
--return ("%02X "):format(s:byte())
|
|
--end)..">")
|
|
eq(data2, r or data)
|
|
end
|
|
|
|
local function withstate(f)
|
|
local old = pb.state(nil)
|
|
local ok, res = pcall(f, old)
|
|
pb.state(old)
|
|
assert(ok, res)
|
|
end
|
|
|
|
_G.test_io = {} do
|
|
|
|
function _G.test_io.setup()
|
|
pbio.dump("address.proto", [[
|
|
message Phone {
|
|
optional string name = 1;
|
|
optional int64 phonenumber = 2;
|
|
}
|
|
message Person {
|
|
optional string name = 1;
|
|
optional int32 age = 2;
|
|
optional string address = 3;
|
|
repeated Phone contacts = 4;
|
|
} ]])
|
|
end
|
|
|
|
function _G.test_io.teardown()
|
|
os.remove "address.proto"
|
|
os.remove "address.pb"
|
|
end
|
|
|
|
function _G.test_io.test()
|
|
local code = "assert(io.write(require 'pb.io'.read()))"
|
|
assert(pbio.dump("t.lua", code))
|
|
local fh = assert(io.popen(arg[-1].." t.lua < t.lua", "r"))
|
|
eq(fh:read "*a", code)
|
|
fh:close()
|
|
assert(os.remove "t.lua")
|
|
fail("-not-exists-", function() assert(pbio.read "-not-exists-") end)
|
|
|
|
local chunk = protoc.new():compile(pbio.read "address.proto",
|
|
"address.proto")
|
|
assert(pbio.dump("address.pb", chunk))
|
|
assert(pb.loadfile "address.pb")
|
|
assert(pb.type "Person")
|
|
eq(pb.type "-not-exists-", nil)
|
|
local ft = {}
|
|
for name in pb.fields "Person" do
|
|
ft[name] = true
|
|
end
|
|
table_eq(ft, { name=true, age=true,address=true,contacts=true })
|
|
|
|
eq(pb.decode("Person", "\240\255\255\255\255\255\255\255\255\1\1"), {})
|
|
eq(pb.decode("Person", "\240\255\255\255\255\255\255\255\255\255"), {})
|
|
eq(pb.decode("Person", "\240\255\255\255\255"), {})
|
|
eq(pb.decode("Person", "\242\255\255\255\255\1\255"), {})
|
|
eq(pb.decode("Person", "\x71"), {})
|
|
eq(pb.decode("Person", "\x33\1\2\3\4\x34"), {})
|
|
eq(pb.decode("Person", "\x33\1\2\3\4\x44"), {})
|
|
eq(pb.decode("Person", "\x33\1\2\3\4"), {})
|
|
eq(pb.decode("Person", "\x75"), {})
|
|
eq(pb.decode("Person", "\x75\1\1\1\1"), {})
|
|
|
|
fail("type 'Foo' does not exists", function() pb.encode("Foo", {}) end)
|
|
fail("type 'Foo' does not exists", function() pb.decode("Foo", "") end)
|
|
|
|
fail("string expected for field 'name', got boolean",
|
|
function() pb.encode("Person", { name = true }) end)
|
|
|
|
fail("type mismatch for field 'name' at offset 2, bytes expected for type string, got varint",
|
|
function() pb.decode("Person", "\8\1") end)
|
|
|
|
fail("invalid varint value at offset 2",
|
|
function() pb.decode("Person", "\16\255") end)
|
|
|
|
fail("invalid bytes length: 0 (at offset 2)",
|
|
function() pb.decode("Person", "\10\255") end)
|
|
|
|
fail("un-finished bytes (len 10 at offset 3)",
|
|
function() pb.decode("Person", "\10\10") end)
|
|
|
|
local data = {
|
|
name = "ilse",
|
|
age = 18,
|
|
contacts = {
|
|
{ name = "alice", phonenumber = 12312341234 },
|
|
{ name = "bob", phonenumber = 45645674567 }
|
|
}
|
|
}
|
|
check_msg(".Person", data)
|
|
|
|
pb.clear()
|
|
protoc.reload()
|
|
|
|
fail("-not-exists-", function() assert(pb.loadfile "-not-exists-") end)
|
|
assert(pb.type ".google.protobuf.FileDescriptorSet")
|
|
end
|
|
|
|
end
|
|
|
|
_G.test_depend = {} do
|
|
|
|
function _G.test_depend.setup()
|
|
pbio.dump("depend1.proto", [[
|
|
syntax = "proto2";
|
|
|
|
message Depend1Msg {
|
|
optional int32 id = 1;
|
|
optional string name = 2;
|
|
} ]])
|
|
end
|
|
|
|
function _G.test_depend.teardown()
|
|
os.remove "depend1.proto"
|
|
end
|
|
|
|
function _G.test_depend.test()
|
|
local function load_depend(p)
|
|
p:load [[
|
|
syntax = "proto2";
|
|
|
|
import "depend1.proto";
|
|
|
|
message Depend2Msg {
|
|
optional Depend1Msg dep1 = 1;
|
|
optional int32 other = 2;
|
|
} ]]
|
|
end
|
|
|
|
load_depend(protoc.new())
|
|
local t = { dep1 = { id = 1, name = "foo" }, other = 2 }
|
|
check_msg("Depend2Msg", t, { dep1 = {}, other = 2 })
|
|
|
|
eq(protoc.new():loadfile "depend1.proto", true)
|
|
local chunk = pb.encode("Depend2Msg", t)
|
|
check_msg("Depend2Msg", t)
|
|
|
|
pb.clear "Depend1Msg"
|
|
check_msg("Depend2Msg", t, { other = 2 })
|
|
table_eq(pb.decode("Depend2Msg", chunk), { other = 2 })
|
|
|
|
eq(protoc.new():loadfile "depend1.proto", true)
|
|
check_msg("Depend2Msg", t)
|
|
|
|
pb.clear "Depend1Msg"
|
|
pb.clear "Depend2Msg"
|
|
|
|
local p = protoc.new()
|
|
p.include_imports = true
|
|
load_depend(p)
|
|
check_msg("Depend2Msg", t)
|
|
assert(pb.type ".google.protobuf.FileDescriptorSet")
|
|
end
|
|
|
|
end
|
|
|
|
function _G.test_extend()
|
|
local P = protoc.new()
|
|
|
|
P.unknown_import = true
|
|
P.unknown_type = true
|
|
assert(P:load([[
|
|
syntax = "proto2";
|
|
import "descriptor.proto";
|
|
|
|
extend google.protobuf.EnumValueOptions {
|
|
optional string name = 51000;
|
|
}
|
|
|
|
message Extendable {
|
|
extend NestExtend {
|
|
optional string ext_name = 100;
|
|
}
|
|
optional int32 id = 1;
|
|
extensions 100 to max;
|
|
} ]], "extend1.proto"))
|
|
eq(pb.type "Extendable", ".Extendable")
|
|
|
|
P.unknown_import = nil
|
|
P.unknown_type = nil
|
|
local chunk = assert(P:compile [[
|
|
syntax = "proto2";
|
|
import "extend1.proto"
|
|
|
|
enum MyEnum {
|
|
First = 1 [(name) = "first"];
|
|
Second = 2 [(name) = "second"];
|
|
Third = 3 [(name) = "third"];
|
|
}
|
|
|
|
message NestExtend {
|
|
optional uint32 id = 1;
|
|
extensions 100 to max;
|
|
}
|
|
|
|
extend Extendable {
|
|
optional string ext_name = 100;
|
|
} ]])
|
|
assert(pb.load(chunk))
|
|
assert(pb.type "MyEnum")
|
|
|
|
local t = { ext_name = "foo", id = 10 }
|
|
check_msg("Extendable", t)
|
|
|
|
local t2 = { ext_name = "foo", id = 10 }
|
|
check_msg("NestExtend", t2)
|
|
|
|
local data = pb.decode("google.protobuf.FileDescriptorSet", chunk)
|
|
eq(data.file[1].enum_type[1].value[1].options.name, "first")
|
|
eq(data.file[1].enum_type[1].value[2].options.name, "second")
|
|
eq(data.file[1].enum_type[1].value[3].options.name, "third")
|
|
assert(pb.type ".google.protobuf.FileDescriptorSet")
|
|
end
|
|
|
|
function _G.test_type()
|
|
pb.clear "not-exists"
|
|
check_load [[
|
|
message TestTypes {
|
|
optional double dv = 1;
|
|
optional float fv = 2;
|
|
optional int64 i64v = 3;
|
|
optional uint64 u64v = 4;
|
|
optional int32 i32v = 5;
|
|
optional uint32 u32v = 13;
|
|
optional fixed64 f64v = 6;
|
|
optional fixed32 f32v = 7;
|
|
optional bool bv = 8;
|
|
optional string sv = 9;
|
|
optional bytes btv = 12;
|
|
optional sfixed32 sf32v = 15;
|
|
optional sfixed64 sf64v = 16;
|
|
optional sint32 s32v = 17;
|
|
optional sint64 s64v = 18;
|
|
} ]]
|
|
|
|
local data = {
|
|
dv = 0.125;
|
|
fv = 0.5;
|
|
i64v = -12345678901234567;
|
|
u64v = 12345678901234567;
|
|
i32v = -2101112222;
|
|
u32v = 2101112222;
|
|
f64v = 12345678901234567;
|
|
f32v = 1231231234;
|
|
bv = true;
|
|
sv = "foo";
|
|
btv = "bar";
|
|
sf32v = -123;
|
|
sf64v = -456;
|
|
s32v = -1234;
|
|
s64v = -4321;
|
|
}
|
|
|
|
check_msg(".TestTypes", data)
|
|
pb.clear "TestTypes"
|
|
|
|
check_load [[
|
|
message test_type {
|
|
optional uint32 r = 1;
|
|
}
|
|
message test2 {
|
|
optional test_type test_type = 1;
|
|
} ]]
|
|
check_msg("test_type", {r = 1})
|
|
pb.clear "test_type"
|
|
pb.clear "test2"
|
|
assert(pb.type ".google.protobuf.FileDescriptorSet")
|
|
end
|
|
|
|
function _G.test_default()
|
|
check_load [[
|
|
enum TestDefaultColor {
|
|
RED = 0;
|
|
GREEN = 1;
|
|
BLUE = 2;
|
|
}
|
|
message TestDefault {
|
|
// some fields here
|
|
optional int32 foo = 1;
|
|
|
|
optional int32 defaulted_int = 10 [ default = 777 ];
|
|
optional bool defaulted_bool = 11 [ default = true ];
|
|
optional string defaulted_str = 12 [ default = "foo" ];
|
|
optional float defaulted_num = 13 [ default = 0.125 ];
|
|
|
|
optional TestDefaultColor color = 14 [default = RED];
|
|
optional bool bool1 = 15 [default=false];
|
|
optional bool bool2 = 16 [default=foo];
|
|
repeated int32 array = 17;
|
|
} ]]
|
|
check_msg("TestDefault", { foo = 1 })
|
|
local function copy_no_meta(t)
|
|
local r = {}
|
|
for k, v in pairs(t) do
|
|
if k ~= "__index" then
|
|
r[k] = v
|
|
end
|
|
end
|
|
return r
|
|
end
|
|
pb.option "enum_as_value"
|
|
table_eq(copy_no_meta(pb.defaults "TestDefault"), {
|
|
defaulted_int = 777,
|
|
defaulted_bool = true,
|
|
defaulted_str = "foo",
|
|
defaulted_num = 0.125,
|
|
color = 0,
|
|
bool1 = false,
|
|
bool2 = nil
|
|
})
|
|
pb.option "enum_as_name"
|
|
pb.defaults("TestDefault", "clear")
|
|
table_eq(copy_no_meta(pb.defaults "TestDefault"), {
|
|
defaulted_int = 777,
|
|
defaulted_bool = true,
|
|
defaulted_str = "foo",
|
|
defaulted_num = 0.125,
|
|
color = "RED",
|
|
bool1 = false,
|
|
bool2 = nil
|
|
})
|
|
pb.clear "TestDefault"
|
|
pb.clear "TestDefaultColor"
|
|
fail("type not found",
|
|
function() pb.defaults "-invalid-type-" end)
|
|
|
|
check_load [[
|
|
syntax = "proto3";
|
|
enum TestDefaultColor {
|
|
RED = 0;
|
|
GREEN = 1;
|
|
BLUE = 2;
|
|
}
|
|
message TestNest{}
|
|
message TestDefault {
|
|
// some fields here
|
|
int32 foo = 1;
|
|
|
|
int32 defaulted_int = 10;
|
|
bool defaulted_bool = 11;
|
|
string defaulted_str = 12;
|
|
float defaulted_num = 13;
|
|
|
|
TestDefaultColor color = 14;
|
|
bool bool1 = 15;
|
|
bool bool2 = 16;
|
|
TestNest nest = 17;
|
|
repeated int32 array = 18;
|
|
} ]]
|
|
|
|
local _, _, _, _, rep = pb.field("TestDefault", "foo")
|
|
eq(rep, "optional")
|
|
table_eq(copy_no_meta(pb.defaults "TestDefault"), {
|
|
defaulted_int = 0,
|
|
defaulted_bool = false,
|
|
defaulted_str = "",
|
|
defaulted_num = 0.0,
|
|
color = "RED",
|
|
bool1 = false,
|
|
bool2 = false,
|
|
})
|
|
pb.option "enum_as_value"
|
|
pb.defaults("TestDefault", "clear")
|
|
table_eq(copy_no_meta(pb.defaults "TestDefault"), {
|
|
defaulted_int = 0,
|
|
defaulted_bool = false,
|
|
defaulted_str = "",
|
|
defaulted_num = 0.0,
|
|
color = 0,
|
|
bool1 = false,
|
|
bool2 = false,
|
|
})
|
|
|
|
pb.option "use_default_metatable"
|
|
local dt = pb.decode("TestDefault", "")
|
|
eq(getmetatable(dt), pb.defaults "TestDefault")
|
|
eq(dt.defaulted_int, 0)
|
|
eq(dt.defaulted_bool, false)
|
|
eq(dt.defaulted_str, "")
|
|
eq(dt.defaulted_num, 0.0)
|
|
eq(dt.color, 0)
|
|
eq(dt.bool1, false)
|
|
eq(dt.bool2, false)
|
|
table_eq(dt.array, {})
|
|
table_eq(pb.decode "TestDefault", pb.decode("TestDefault", ""))
|
|
|
|
pb.option "use_default_values"
|
|
dt = pb.decode("TestDefault", "")
|
|
eq(getmetatable(dt), nil)
|
|
table_eq(dt, {
|
|
defaulted_int = 0,
|
|
defaulted_bool = false,
|
|
defaulted_str = "",
|
|
defaulted_num = 0.0,
|
|
color = 0,
|
|
bool1 = false,
|
|
bool2 = false,
|
|
array = {}
|
|
})
|
|
eq(dt.defaulted_int, 0)
|
|
eq(dt.defaulted_bool, false)
|
|
eq(dt.defaulted_str, "")
|
|
eq(dt.defaulted_num, 0.0)
|
|
eq(dt.color, 0)
|
|
eq(dt.bool1, false)
|
|
eq(dt.bool2, false)
|
|
table_eq(dt.array, {})
|
|
|
|
pb.option "no_default_values"
|
|
pb.option "encode_default_values"
|
|
pb.option "decode_default_array"
|
|
local dt = pb.decode("TestDefault", "")
|
|
eq(getmetatable(dt), nil)
|
|
table_eq(dt,{
|
|
array = {},
|
|
})
|
|
local chunk2, _ = pb.encode("TestDefault", {defaulted_int = 0,defaulted_bool = true})
|
|
local dt = pb.decode("TestDefault", chunk2)
|
|
eq(dt.defaulted_int, 0)
|
|
eq(dt.defaulted_bool, true)
|
|
eq(dt.defaulted_str, nil)
|
|
eq(dt.defaulted_num, nil)
|
|
eq(dt.color, nil)
|
|
eq(dt.bool1, nil)
|
|
eq(dt.bool2, nil)
|
|
table_eq(dt.array, {})
|
|
|
|
pb.option "no_encode_default_values"
|
|
pb.option "no_decode_default_array"
|
|
pb.option "no_default_values"
|
|
|
|
pb.option "enum_as_name"
|
|
pb.clear "TestDefault"
|
|
pb.clear "TestNest"
|
|
pb.option "auto_default_values"
|
|
assert(pb.type ".google.protobuf.FileDescriptorSet")
|
|
end
|
|
|
|
function _G.test_enum()
|
|
check_load [[
|
|
enum Color {
|
|
Red = 0;
|
|
Green = 1;
|
|
Blue = 2;
|
|
}
|
|
message TestEnum {
|
|
optional Color color = 1;
|
|
} ]]
|
|
eq(pb.enum("Color", 0), "Red")
|
|
eq(pb.enum("Color", "Red"), 0)
|
|
eq(pb.enum("Color", 1), "Green")
|
|
eq(pb.enum("Color", "Green"), 1)
|
|
local t = {}
|
|
for name, number in pb.fields "Color" do
|
|
t[name] = number
|
|
end
|
|
table_eq(t, {Red=0, Green=1, Blue=2})
|
|
eq({pb.field("TestEnum", "color")}, {"color", 1, ".Color", nil, "optional"})
|
|
|
|
local data = { color = "Red" }
|
|
check_msg("TestEnum", data)
|
|
|
|
local data2 = { color = 123 }
|
|
check_msg("TestEnum", data2)
|
|
|
|
pb.option "enum_as_value"
|
|
check_msg("TestEnum", data, { color = 0 })
|
|
|
|
pb.option "enum_as_name"
|
|
check_msg("TestEnum", data, { color = "Red" })
|
|
|
|
fail("invalid varint value at offset 2",
|
|
function() pb.decode("TestEnum", "\8\255") end)
|
|
fail("number/string expected at field 'color', got boolean",
|
|
function() pb.encode("TestEnum", { color = true }) end)
|
|
fail("can not encode unknown enum 'foo' at field 'color'",
|
|
function() pb.encode("TestEnum", { color = "foo" }) end)
|
|
|
|
check_load [[
|
|
message TestAlias {
|
|
enum AliasedEnum {
|
|
option allow_alias = true;
|
|
ZERO = 0;
|
|
ONE = 1;
|
|
TWO = 2;
|
|
FIRST = 1;
|
|
}
|
|
repeated AliasedEnum aliased_enumf = 2;
|
|
} ]]
|
|
check_msg("TestAlias",
|
|
{ aliased_enumf = { "ZERO", "FIRST", "TWO", 23, "ONE" } },
|
|
{ aliased_enumf = { "ZERO", "FIRST", "TWO", 23, "FIRST" } })
|
|
assert(pb.type ".google.protobuf.FileDescriptorSet")
|
|
end
|
|
|
|
function _G.test_packed()
|
|
check_load [[
|
|
message Empty {}
|
|
message TestPacked {
|
|
repeated int64 packs = 1 [packed=true];
|
|
} ]]
|
|
|
|
local data = {
|
|
packs = { 1,2,3,4,-1,-2,3 }
|
|
}
|
|
check_msg(".TestPacked", data)
|
|
fail("table expected at field 'packs', got boolean",
|
|
function() pb.encode("TestPacked", { packs = true }) end)
|
|
|
|
local data = {packs = {}}
|
|
check_msg(".TestPacked", data, {})
|
|
|
|
local hasEmpty
|
|
for _, name in pb.types() do
|
|
if name == "Empty" then
|
|
hasEmpty = true
|
|
break
|
|
end
|
|
end
|
|
assert(hasEmpty)
|
|
|
|
pb.clear "TestPacked"
|
|
pb.clear "Empty"
|
|
eq(pb.type("TestPacked"), nil)
|
|
for _, name in pb.types() do
|
|
assert(name ~= "TestPacked", name)
|
|
assert(name ~= "Empty", name)
|
|
end
|
|
eq(pb.types()(nil, "not-exists"), nil)
|
|
|
|
check_load [[
|
|
syntax="proto3";
|
|
|
|
message MyMessage
|
|
{
|
|
repeated int32 intList = 1;
|
|
} ]]
|
|
local b = pb.encode("MyMessage", { intList = { 1,2,3 } })
|
|
eq(pb.tohex(b), "0A 03 01 02 03")
|
|
|
|
check_load [[
|
|
syntax="proto3";
|
|
|
|
message MessageA
|
|
{
|
|
int32 intValue = 1;
|
|
}
|
|
message MessageB
|
|
{
|
|
repeated MessageA messageValue = 1;
|
|
} ]]
|
|
pb.option "use_default_values"
|
|
check_msg("MessageB", { messageValue = { { intValue = 0 } } })
|
|
pb.option "no_default_values"
|
|
check_msg("MessageB", { messageValue = { {} } })
|
|
check_msg("MessageB", { messageValue = { { intValue = 1 } } })
|
|
eq(pb.tohex(pb.encode(
|
|
"MessageB", { messageValue = { {} } })), "0A 00")
|
|
eq(pb.tohex(pb.encode(
|
|
"MessageB", { messageValue = { { intValue = 1 } } })), "0A 02 08 01")
|
|
pb.clear "MessageA"
|
|
pb.clear "MessageB"
|
|
|
|
check_load [[
|
|
syntax="proto3";
|
|
message Message3
|
|
{
|
|
repeated int32 v1 = 1;
|
|
} ]]
|
|
check_load [[
|
|
message Message2
|
|
{
|
|
repeated int32 v1 = 1;
|
|
} ]]
|
|
local t = { v1 = {1,2,3,4,5} }
|
|
local bytes = pb.encode("Message2", t)
|
|
eq(pb.decode("Message3", bytes), t)
|
|
bytes = pb.encode("Message3", t)
|
|
eq(pb.decode("Message2", bytes), t)
|
|
pb.clear "Message2"
|
|
pb.clear "Message3"
|
|
pb.option "auto_default_values"
|
|
assert(pb.type ".google.protobuf.FileDescriptorSet")
|
|
end
|
|
|
|
function _G.test_map()
|
|
check_load [[
|
|
syntax = "proto3";
|
|
message TestEmpty {}
|
|
message TestMap {
|
|
map<string, int32> map = 1;
|
|
map<string, int32> packed_map = 2 [packed=true];
|
|
map<string, TestEmpty> msg_map = 3;
|
|
} ]]
|
|
|
|
check_msg("TestMap", { map = {}, packed_map = {}, msg_map = {} })
|
|
|
|
check_msg(".TestMap", {
|
|
map = { one = 1, two = 2, three = 3 };
|
|
packed_map = { one = 1, two = 2, three = 3 }
|
|
}, {
|
|
map = { one = 1, two = 2, three = 3 };
|
|
packed_map = { one = 1, two = 2, three = 3 };
|
|
msg_map = {}
|
|
})
|
|
|
|
local data2 = { map = { one = 1, [1]=1 } }
|
|
fail("string expected for field 'key', got number", function()
|
|
local chunk = pb.encode("TestMap", data2)
|
|
table_eq(pb.decode("TestMap", chunk), {
|
|
map = {one = 1},
|
|
packed_map = {},
|
|
msg_map = {},
|
|
})
|
|
end)
|
|
--eq(pb.decode("TestMap", "\10\4\3\10\1\1"), { map = {} })
|
|
eq(pb.decode("TestMap", "\10\0"), {
|
|
map = { [""] = 0 },
|
|
packed_map = {},
|
|
msg_map = {}
|
|
})
|
|
eq(pb.decode("TestMap", "\26\0"), {
|
|
map = {},
|
|
packed_map = {},
|
|
msg_map = {}
|
|
})
|
|
|
|
check_load [[
|
|
syntax = "proto2";
|
|
message TestMap2 {
|
|
map<string, int32> map = 1;
|
|
} ]]
|
|
check_msg("TestMap2", { map = { one = 1, two = 2, three = 3 } })
|
|
end
|
|
|
|
function _G.test_oneof()
|
|
check_load [[
|
|
syntax = "proto3";
|
|
message TO_M1 {
|
|
}
|
|
message TO_M2 {
|
|
}
|
|
message TO_M3 {
|
|
int32 value = 1;
|
|
}
|
|
message TestOneof {
|
|
oneof body_oneof {
|
|
TO_M1 m1 = 100;
|
|
TO_M2 m2 = 200;
|
|
TO_M3 m3 = 300;
|
|
}
|
|
} ]]
|
|
check_msg("TestOneof", {})
|
|
check_msg("TestOneof", { m1 = {}, body_oneof = "m1" })
|
|
check_msg("TestOneof", { m2 = {}, body_oneof = "m2" })
|
|
check_msg("TestOneof", { m3 = { value = 0 }, body_oneof = "m3" })
|
|
check_msg("TestOneof", { m3 = { value = 10 }, body_oneof = "m3" })
|
|
pb.clear "TestOneof"
|
|
|
|
check_load [[
|
|
syntax = "proto3";
|
|
message TestOneof {
|
|
oneof body {
|
|
uint32 foo = 1;
|
|
string bar = 2;
|
|
}
|
|
}
|
|
message Outter {
|
|
TestOneof msg = 1;
|
|
}
|
|
]]
|
|
|
|
check_msg("TestOneof", { foo = 0, body = "foo" })
|
|
check_msg("TestOneof", { bar = "", body = "bar" })
|
|
local chunk = pb.encode("TestOneof", { foo = 0, bar = "" })
|
|
local data = pb.decode("TestOneof", chunk)
|
|
is_true(data.body == "foo" or data.body == "bar")
|
|
check_msg("Outter", { msg = { foo = 0, body = "foo" }})
|
|
check_msg("Outter", { msg = { bar = "", body = "bar" }})
|
|
local chunk = pb.encode("Outter", {msg = { foo = 0, bar = "" }})
|
|
local data = pb.decode("Outter", chunk)
|
|
is_true(data.msg.body == "foo" or data.msg.body == "bar")
|
|
pb.clear "TestOneof"
|
|
pb.clear "Outter"
|
|
|
|
check_load [[
|
|
syntax = "proto3";
|
|
message TestOneof {
|
|
oneof test_oneof {
|
|
string name = 4;
|
|
int32 value = 5;
|
|
}
|
|
} ]]
|
|
|
|
check_msg("TestOneof", { name = "foo", test_oneof = "name" })
|
|
check_msg("TestOneof", { value = 0, test_oneof = "value" })
|
|
local chunk = pb.encode("TestOneof", { name = "foo", value = 0 })
|
|
local data = pb.decode("TestOneof", chunk)
|
|
is_true(data.test_oneof == "name" or data.test_oneof == "value")
|
|
|
|
eq(pb.field("TestOneof", "name"), "name")
|
|
pb.clear("TestOneof", "name")
|
|
eq(pb.field("TestOneof", "name"), nil)
|
|
eq(pb.type "TestOneof", ".TestOneof")
|
|
pb.clear "TestOneof"
|
|
eq(pb.type "TestOneof", nil)
|
|
pb.option "auto_default_values"
|
|
assert(pb.type ".google.protobuf.FileDescriptorSet")
|
|
end
|
|
|
|
function _G.test_conv()
|
|
eq(conv.encode_uint32(-1), 0xFFFFFFFF)
|
|
eq(conv.decode_uint32(0xFFFFFFFF), 0xFFFFFFFF)
|
|
eq(conv.decode_uint32(conv.encode_uint32(-1)), 0xFFFFFFFF)
|
|
|
|
eq(conv.encode_int32(0x12300000123), 0x123)
|
|
eq(conv.encode_int32(0xFFFFFFFF), -1)
|
|
eq(conv.encode_int32(0x123FFFFFFFF), -1)
|
|
eq(conv.encode_int32(0x123FFFFFFFE), -2)
|
|
eq(conv.decode_int32(0x12300000123), 0x123)
|
|
eq(conv.decode_int32(0xFFFFFFFF), -1)
|
|
eq(conv.decode_int32(0x123FFFFFFFF), -1)
|
|
eq(conv.decode_int32(0x123FFFFFFFE), -2)
|
|
eq(conv.decode_int32(conv.encode_int32(-1)), -1)
|
|
|
|
eq(conv.encode_sint32(0), 0)
|
|
eq(conv.encode_sint32(-1), 1)
|
|
eq(conv.encode_sint32(1), 2)
|
|
eq(conv.encode_sint32(-2), 3)
|
|
eq(conv.encode_sint32(2), 4)
|
|
eq(conv.encode_sint32(-3), 5)
|
|
eq(conv.encode_sint32(-123), 245)
|
|
eq(conv.encode_sint32(123), 246)
|
|
eq(conv.encode_sint64(-123), 245)
|
|
eq(conv.encode_sint64(123), 246)
|
|
|
|
eq(conv.decode_sint32(0), 0)
|
|
eq(conv.decode_sint32(1), -1)
|
|
eq(conv.decode_sint32(2), 1)
|
|
eq(conv.decode_sint32(3), -2)
|
|
eq(conv.decode_sint32(4), 2)
|
|
eq(conv.decode_sint32(5), -3)
|
|
eq(conv.decode_sint32(245), -123)
|
|
eq(conv.decode_sint32(246), 123)
|
|
eq(conv.decode_sint32(0xFFFFFFFF), -0x80000000)
|
|
eq(conv.decode_sint32(0xFFFFFFFE), 0x7FFFFFFF)
|
|
eq(conv.decode_sint64(0xFFFFFFFF), -0x80000000)
|
|
eq(conv.decode_sint64(0xFFFFFFFE), 0x7FFFFFFF)
|
|
|
|
eq(conv.decode_float(conv.encode_float(123.125)), 123.125)
|
|
eq(conv.decode_double(conv.encode_double(123.125)), 123.125)
|
|
|
|
pb.option "int64_as_string"
|
|
eq(conv.decode_sint64(conv.encode_sint64("#1311768467294899695")), "#1311768467294899695")
|
|
pb.option "int64_as_hexstring"
|
|
eq(conv.decode_sint64(conv.encode_sint64("#0x1234567890ABCDEF")), "#0x1234567890ABCDEF")
|
|
pb.option "int64_as_number"
|
|
if _VERSION == "Lua 5.3" then
|
|
eq(conv.decode_sint64(conv.encode_sint64("#0x1234567890ABCDEF")), 0x1234567890ABCDEF)
|
|
else
|
|
assert(conv.decode_sint64(conv.encode_sint64("#0x1234567890ABCDEF")))
|
|
end
|
|
|
|
eq(conv.encode_sint32('---1'), 1)
|
|
fail("number/string expected, got boolean", function() conv.encode_sint64(true) end)
|
|
fail("integer format error: '@xyz'", function() conv.encode_sint64('@xyz') end)
|
|
assert(pb.type ".google.protobuf.FileDescriptorSet")
|
|
end
|
|
|
|
function _G.test_buffer()
|
|
eq(buffer.pack("vvv", 1,2,3), "\1\2\3")
|
|
eq(buffer.tohex(pb.pack("d", 4294967295)), "FF FF FF FF")
|
|
if _VERSION == "Lua 5.3" then
|
|
eq(buffer.tohex(pb.pack("q", 9223372036854775807)), "FF FF FF FF FF FF FF 7F")
|
|
else
|
|
eq(buffer.tohex(pb.pack("q", "#9223372036854775807")), "FF FF FF FF FF FF FF 7F")
|
|
end
|
|
eq(pb.pack("s", "foo"), "\3foo")
|
|
eq(pb.pack("cc", "foo", "bar"), "foobar")
|
|
eq(buffer():pack("vvv", 1,2,3):result(), "\1\2\3")
|
|
|
|
eq(buffer("foo", "bar"):result(), "foobar")
|
|
eq(buffer.new("foo", "bar"):result(), "foobar")
|
|
|
|
eq(pb.fromhex"01 23 456789ABCDEF", "\1\35\69\103\137\171\205\239")
|
|
|
|
local b = buffer.new()
|
|
b:pack("b", true); eq(b:tohex(-1), "01")
|
|
b:pack("f", 0.125); eq(b:tohex(-4), "00 00 00 3E")
|
|
b:pack("F", 0.125); eq(b:tohex(-8), "00 00 00 00 00 00 C0 3F")
|
|
b:pack("i", 4294967295); eq(b:tohex(-10), "FF FF FF FF FF FF FF FF FF 01")
|
|
b:pack("j", 4294967295); eq(b:tohex(-1), "01")
|
|
b:pack("u", 4294967295); eq(b:tohex(-5), "FF FF FF FF 0F")
|
|
b:pack("x", 4294967295); eq(b:tohex(-4), "FF FF FF FF")
|
|
b:pack("y", 4294967295); eq(b:tohex(-4), "FF FF FF FF")
|
|
if _VERSION == "Lua 5.3" then
|
|
b:pack("I", 9223372036854775807); eq(b:tohex(-9), "FF FF FF FF FF FF FF FF 7F")
|
|
b:pack("J", 9223372036854775807); eq(b:tohex(-10), "FE FF FF FF FF FF FF FF FF 01")
|
|
b:pack("U", 9223372036854775807); eq(b:tohex(-9), "FF FF FF FF FF FF FF FF 7F")
|
|
b:pack("X", 9223372036854775807); eq(b:tohex(-8), "FF FF FF FF FF FF FF 7F")
|
|
b:pack("Y", 9223372036854775807); eq(b:tohex(-8), "FF FF FF FF FF FF FF 7F")
|
|
else
|
|
b:pack("I", "#9223372036854775807"); eq(b:tohex(-9), "FF FF FF FF FF FF FF FF 7F")
|
|
b:pack("J", "#9223372036854775807"); eq(b:tohex(-10), "FE FF FF FF FF FF FF FF FF 01")
|
|
b:pack("U", "#9223372036854775807"); eq(b:tohex(-9), "FF FF FF FF FF FF FF FF 7F")
|
|
b:pack("X", "#9223372036854775807"); eq(b:tohex(-8), "FF FF FF FF FF FF FF 7F")
|
|
b:pack("Y", "#9223372036854775807"); eq(b:tohex(-8), "FF FF FF FF FF FF FF 7F")
|
|
end
|
|
assert(#b ~= 0)
|
|
assert(#b:reset() == 0)
|
|
assert(tostring(b):match 'pb.Buffer')
|
|
|
|
b = buffer.new "foo"
|
|
assert(#b == 3)
|
|
b:delete()
|
|
assert(#b == 0)
|
|
b:pack("vvv", 1,2,3)
|
|
assert(#b == 3)
|
|
|
|
b = buffer.new()
|
|
eq(b:pack("(vvv)", 1,2,3):tohex(-4), "03 01 02 03")
|
|
eq(b:pack("((vvv))", 1,2,3):tohex(-5), "04 03 01 02 03")
|
|
fail("unmatch '(' in format", function() pb.pack "(" end)
|
|
fail("unexpected ')' in format", function() pb.pack ")" end)
|
|
fail("integer format error: 'foo'", function() pb.pack("i", "foo") end)
|
|
fail("number expected for type 'int32', got boolean", function() pb.pack("i", true) end)
|
|
fail("invalid formater: '!'", function() pb.pack '!' end)
|
|
|
|
b = buffer.new()
|
|
eq(b:pack("c", ("a"):rep(1025)):result(), ("a"):rep(1025))
|
|
eq(b:pack("c", ("b"):rep(1025)):result(), ("a"):rep(1025)..("b"):rep(1025))
|
|
eq(#b, 2050)
|
|
b:reset("foo", "bar")
|
|
eq(#b, 6)
|
|
|
|
fail("integer format error: 'foo'", function() pb.pack("v", "foo") end)
|
|
if _VERSION == "Lua 5.3" or _VERSION == "Lua 5.4" then
|
|
fail("integer format error", function() pb.pack("v", 1e308) end)
|
|
else
|
|
fail("number has no integer representation", function() pb.pack("v", 1e308) end)
|
|
end
|
|
|
|
b = buffer.new()
|
|
fail("encode bytes fail", function() b:pack("#", 10) end)
|
|
check_load [[
|
|
message Test { optional int32 value = 1 }
|
|
]]
|
|
local len = #b
|
|
eq(#b, 0)
|
|
eq(pb.encode("Test", { value = 1 }, b), b)
|
|
eq(#b, 2)
|
|
b:pack("#", len)
|
|
eq(b:tohex(), "02 08 01")
|
|
|
|
b = buffer.new()
|
|
eq(b:pack("i", -1):tohex(), "FF FF FF FF FF FF FF FF FF 01")
|
|
assert(pb.type ".google.protobuf.FileDescriptorSet")
|
|
end
|
|
|
|
function _G.test_slice()
|
|
local s = slice.new "\3\1\2\3"
|
|
eq(#s, 4)
|
|
eq(s:level(), 1)
|
|
eq(s:level(1), 1)
|
|
eq(s:level(2), nil)
|
|
eq({s:level(-1)}, {1,1,4})
|
|
eq(s:enter(), s)
|
|
eq(s:level(), 2)
|
|
eq({s:level(-1)}, {2,2,4})
|
|
eq({s:level(1)}, {5,1,4})
|
|
eq({s:unpack "vvv"}, {1,2,3})
|
|
eq(s:unpack "v", nil)
|
|
eq(s:leave(), s)
|
|
eq(s:unpack("+s", -4), "\1\2\3")
|
|
|
|
s = slice "\3\1\2\3"
|
|
for i = 2, 20 do
|
|
s:enter(1, 4); eq(s:level(), i)
|
|
end
|
|
for i = 19, 1 do
|
|
s:leave(); eq(s:level(), i)
|
|
end
|
|
eq(s:tohex(), "03 01 02 03")
|
|
eq(s:result(-3), "\1\2\3")
|
|
eq(#s, 4)
|
|
eq(#s:reset(), 0)
|
|
eq(#s:reset"foo", 3)
|
|
|
|
eq({pb.unpack("\255\1", "v@")}, { 255, 3 })
|
|
eq({pb.unpack("\1", "v*v", 1)}, { 1, 1 })
|
|
fail("invalid formater: '!'", function() pb.unpack("\1", '!') end)
|
|
|
|
table_eq({slice.unpack("\1\2\3", "vvv")}, {1,2,3})
|
|
eq(pb.unpack("\255\255\255\255", "d"), 4294967295)
|
|
if _VERSION == "Lua 5.3" then
|
|
eq(pb.unpack("\255\255\255\255\255\255\255\127", "q"), 9223372036854775807)
|
|
else
|
|
pb.option 'int64_as_string'
|
|
eq(pb.unpack("\255\255\255\255\255\255\255\127", "q"), '#9223372036854775807')
|
|
pb.option 'int64_as_number'
|
|
end
|
|
eq(pb.unpack("\3foo", "s"), "foo")
|
|
eq({pb.unpack("foobar", "cc", 3, 3)}, {"foo", "bar"})
|
|
|
|
eq(pb.unpack("\255\255\255\127\255", "v"), 0xFFFFFFF)
|
|
fail("invalid varint value at offset 1", function()
|
|
pb.unpack(("\255"):rep(10), "v") end)
|
|
fail("invalid varint value at offset 1", function() pb.unpack("\255\255\255", "v") end)
|
|
fail("invalid varint value at offset 1", function() pb.unpack("\255\255\255", "v") end)
|
|
fail("invalid bytes value at offset 1", function() pb.unpack("\3\1\2", "s") end)
|
|
fail("invalid fixed32 value at offset 1", function() pb.unpack("\1\2\3", "d") end)
|
|
fail("invalid fixed64 value at offset 1", function() pb.unpack("\1\2\3", "q") end)
|
|
fail("invalid sub string at offset 1", function() pb.unpack("\3\1\2", "c", 5) end)
|
|
fail("invalid varint value at offset 1", function() pb.unpack("\255\255\255", "i") end)
|
|
fail("invalid fixed32 value at offset 1", function() pb.unpack("\255\255\255", "x") end)
|
|
fail("invalid fixed64 value at offset 1", function() pb.unpack("\255\255\255", "X") end)
|
|
fail("string/buffer/slice expected, got boolean", function() pb.unpack(true, "v") end)
|
|
fail("bytes wireformat expected at offset 1", function() slice"\1":enter() end)
|
|
|
|
fail("level (3) exceed max level 2", function()
|
|
local s1 = slice.new "\1\2\3"
|
|
s1:enter()
|
|
s1:leave(3)
|
|
end)
|
|
|
|
s:reset "\1\2\3"
|
|
eq({s:leave()}, {s, 1})
|
|
eq(s:level(), 1)
|
|
eq({s:level(-1)}, {1,1,3})
|
|
|
|
|
|
assert(tostring(s):match 'pb.Slice')
|
|
assert(pb.type ".google.protobuf.FileDescriptorSet")
|
|
end
|
|
|
|
function _G.test_typefmt()
|
|
-- load schema from text
|
|
assert(protoc:load [[
|
|
message Phone {
|
|
optional string name = 1;
|
|
optional int64 phonenumber = 2;
|
|
}
|
|
message Person {
|
|
optional string name = 1;
|
|
optional int32 age = 2;
|
|
optional string address = 3;
|
|
repeated Phone contacts = 4;
|
|
} ]])
|
|
|
|
-- lua table data
|
|
local data = {
|
|
name = "ilse",
|
|
age = 18,
|
|
contacts = {
|
|
{ name = "alice", phonenumber = 12312341234 },
|
|
{ name = "bob", phonenumber = 45645674567 }
|
|
}
|
|
}
|
|
|
|
local bytes = assert(pb.encode("Person", data))
|
|
local s = require "pb.slice".new(bytes)
|
|
local function decode(type, str, d)
|
|
while #str > 0 do
|
|
local _, tag = str:unpack"@v"
|
|
local name, _, pbtype = pb.field(type, math.floor(tag / 8))
|
|
local fmt = pb.typefmt(pbtype)
|
|
if fmt == "message" then
|
|
str:enter()
|
|
if d[name][1] then
|
|
decode(pbtype, str, d[name][1])
|
|
table.remove(d[name], 1)
|
|
end
|
|
str:leave()
|
|
else
|
|
assert(d[name] == str:unpack(fmt))
|
|
end
|
|
end
|
|
end
|
|
decode("Person", s, data)
|
|
|
|
assert(pb.typefmt'F' == "double" )
|
|
assert(pb.typefmt'f' == "float" )
|
|
assert(pb.typefmt'I' == "int64" )
|
|
assert(pb.typefmt'U' == "uint64" )
|
|
assert(pb.typefmt'i' == "int32" )
|
|
assert(pb.typefmt'X' == "fixed64" )
|
|
assert(pb.typefmt'x' == "fixed32" )
|
|
assert(pb.typefmt'b' == "bool" )
|
|
assert(pb.typefmt't' == "string" )
|
|
assert(pb.typefmt'g' == "group" )
|
|
assert(pb.typefmt'S' == "message" )
|
|
assert(pb.typefmt's' == "bytes" )
|
|
assert(pb.typefmt'u' == "uint32" )
|
|
assert(pb.typefmt'v' == "enum" )
|
|
assert(pb.typefmt'y' == "sfixed32")
|
|
assert(pb.typefmt'Y' == "sfixed64")
|
|
assert(pb.typefmt'j' == "sint32" )
|
|
assert(pb.typefmt'J' == "sint64" )
|
|
|
|
assert(pb.typefmt"varint" == 'v')
|
|
assert(pb.typefmt"64bit" == 'q')
|
|
assert(pb.typefmt"bytes" == 's')
|
|
assert(pb.typefmt"gstart" == '!')
|
|
assert(pb.typefmt"gend" == '!')
|
|
assert(pb.typefmt"32bit" == 'd')
|
|
assert(pb.typefmt"double" == 'F')
|
|
assert(pb.typefmt"float" == 'f')
|
|
assert(pb.typefmt"int64" == 'I')
|
|
assert(pb.typefmt"uint64" == 'U')
|
|
assert(pb.typefmt"int32" == 'i')
|
|
assert(pb.typefmt"fixed64" == 'X')
|
|
assert(pb.typefmt"fixed32" == 'x')
|
|
assert(pb.typefmt"bool" == 'b')
|
|
assert(pb.typefmt"string" == 't')
|
|
assert(pb.typefmt"group" == 'g')
|
|
assert(pb.typefmt"bytes" == 's')
|
|
assert(pb.typefmt"uint32" == 'u')
|
|
assert(pb.typefmt"enum" == 'v')
|
|
assert(pb.typefmt"sfixed32" == 'y')
|
|
assert(pb.typefmt"sfixed64" == 'Y')
|
|
assert(pb.typefmt"sint32" == 'j')
|
|
assert(pb.typefmt"sint64" == 'J')
|
|
|
|
assert(pb.typefmt "whatever" == '!')
|
|
end
|
|
|
|
function _G.test_load()
|
|
withstate(function()
|
|
protoc.reload()
|
|
assert(protoc:load [[ message Test_Load1 { optional int32 t = 1; } ]])
|
|
assert(pb.type "Test_Load1")
|
|
assert(protoc:load [[ message Test_Load2 { optional int32 t = 2; } ]])
|
|
assert(pb.type "Test_Load2")
|
|
protoc.reload()
|
|
local p = protoc.new()
|
|
assert(p:load [[ message Test_Load1 { optional int32 t = 1; } ]])
|
|
assert(pb.type "Test_Load1")
|
|
assert(p:load [[ message Test_Load2 { optional int32 t = 2; } ]])
|
|
assert(pb.type "Test_Load2")
|
|
end)
|
|
|
|
withstate(function(old)
|
|
assert(old.setdefault)
|
|
eq(pb.type ".google.protobuf.FileDescriptorSet", nil)
|
|
eq({pb.load "\16\255\255\1\10\2\18\3"}, {false, 8})
|
|
pb.state(nil) -- discard previous one
|
|
eq(pb.type ".google.protobuf.FileDescriptorSet", nil)
|
|
|
|
local buf = buffer.new()
|
|
local function v(n) return n*8 + 0 end
|
|
local function s(n) return n*8 + 2 end
|
|
buf:pack("v(v(vsv(vsvvvvv(vvvv)vv)vvv(vv)v(vv)))vv",
|
|
s(1), -- FileDescriptorSet.file
|
|
s(4), -- FileDescriptorProto.message_type
|
|
s(1), -- DescriptorProto.name
|
|
"load_test",
|
|
s(2), -- DescriptorProto.field
|
|
s(1), -- FieldDescriptorProto.name
|
|
"test_unknown",
|
|
v(3), -- FieldDescriptorProto.number
|
|
1,
|
|
v(4), -- FieldDescriptorProto.label
|
|
1,
|
|
s(8), -- FieldDescriptorProto.options
|
|
v(2), -- FieldOptions.packed
|
|
1,
|
|
v(100), 0, -- unknown field options
|
|
v(100), 0, -- unknown field entry
|
|
v(100), 0, -- unknown type entry
|
|
s(8), -- DescriptorProto.oneof_decl
|
|
v(100), 0, -- unknown oneof entry
|
|
s(7), -- DescriptorProto.options
|
|
v(100), 0, -- unknown type options
|
|
v(100), 0 -- unknown file options
|
|
)
|
|
eq(pb.load(buf:result()), true)
|
|
fail("unknown type <unknown>", function() pb.encode("load_test", { test_unknown = 1 }) end)
|
|
fail("<unknown> expected for type <unknown>, got varint", function() pb.decode("load_test", "\8\1") end)
|
|
fail("unknown type <unknown> (0)", function() pb.decode("load_test", "\14\1") end)
|
|
|
|
buf:reset()
|
|
buf:pack("v(v(vsv(vsvvvv)))",
|
|
s(1), s(4), s(1), "load_test",
|
|
s(2), s(1), "test_unknown", v(3), 1, v(4), 1)
|
|
eq(pb.load(buf:result()), true)
|
|
fail("type mismatch for field 'test_unknown' at offset 2, <unknown> expected for type <unknown>, got varint",
|
|
function() pb.decode("load_test", "\8\1") end)
|
|
fail("type mismatch for field 'test_unknown' at offset 2, <unknown> expected for type <unknown>, got 64bit",
|
|
function() pb.decode("load_test", "\9\1") end)
|
|
fail("type mismatch for field 'test_unknown' at offset 2, <unknown> expected for type <unknown>, got bytes",
|
|
function() pb.decode("load_test", "\10\1") end)
|
|
fail("type mismatch for field 'test_unknown' at offset 2, <unknown> expected for type <unknown>, got gstart",
|
|
function() pb.decode("load_test", "\11\1") end)
|
|
fail("type mismatch for field 'test_unknown' at offset 2, <unknown> expected for type <unknown>, got gend",
|
|
function() pb.decode("load_test", "\12\1") end)
|
|
fail("type mismatch for field 'test_unknown' at offset 2, <unknown> expected for type <unknown>, got 32bit",
|
|
function() pb.decode("load_test", "\13\1") end)
|
|
|
|
buf:reset()
|
|
buf:pack("v(v(vsv(vsvvvv)))",
|
|
s(1), s(4), s(1), "load_test",
|
|
s(2), s(1), "test_unknown", v(3), 2, v(4), 1)
|
|
eq(pb.load(buf:result()), true)
|
|
|
|
buf:reset()
|
|
buf:pack("v(v(vsv(vsvvvv)))",
|
|
s(1), s(4), s(1), "load_test",
|
|
s(2), s(1), "test_unknown", v(3), 1, v(4), 1)
|
|
eq(pb.load(buf:result()), true)
|
|
|
|
buf:reset()
|
|
buf:pack("v(v(vsv(vsvvvv)))",
|
|
s(1), s(4), s(1), "load_test",
|
|
s(2), s(1), "test_unknown2", v(3), 1, v(4), 1)
|
|
eq(pb.load(buf:result()), true)
|
|
|
|
buf:reset()
|
|
buf:pack("v(v(vsv(vsvvvv)))",
|
|
s(1), s(4), s(1), "load_test",
|
|
s(2), s(1), "test_unknown", v(3), 1, v(4), 1)
|
|
eq(pb.load(buf:result()), true)
|
|
|
|
buf:reset()
|
|
buf:pack("v(v(vsv(vvvv)))",
|
|
s(1), s(4), s(1), "load_test",
|
|
s(2), v(3), 1, v(4), 1)
|
|
eq(pb.load(buf:result()), false)
|
|
|
|
buf:reset()
|
|
buf:pack("v(v(vsv(vvvvvv)))",
|
|
s(1), s(4), s(1), "load_test",
|
|
s(2), v(3), 1, v(4), 1, v(5), 11)
|
|
eq(pb.load(buf:result()), false)
|
|
|
|
buf:reset()
|
|
buf:pack("v(v(vsv(vvvv)))",
|
|
s(1), s(4), s(1), "load_test",
|
|
s(6), v(3), 1, v(4), 1)
|
|
eq(pb.load(buf:result()), false)
|
|
|
|
buf:reset()
|
|
buf:pack("v(v(v(vx)))", s(1), s(4), s(6), v(3), -1)
|
|
eq({pb.load(buf:result())}, { false, 8 })
|
|
end)
|
|
assert(pb.type ".google.protobuf.FileDescriptorSet")
|
|
end
|
|
|
|
function _G.test_hook()
|
|
withstate(function()
|
|
protoc.reload()
|
|
check_load [[
|
|
enum Type {
|
|
HOME = 1;
|
|
WORK = 2;
|
|
}
|
|
message Phone {
|
|
optional string name = 1;
|
|
optional int64 phonenumber = 2;
|
|
optional Type type = 3;
|
|
}
|
|
message Person {
|
|
optional string name = 1;
|
|
optional int32 age = 2;
|
|
optional string address = 3;
|
|
repeated Phone contacts = 4;
|
|
} ]]
|
|
pb.option "enable_hooks"
|
|
assert(pb.hook "Phone" == nil)
|
|
fail("function expected, got boolean",
|
|
function() pb.hook("Phone", true) end)
|
|
fail("type not found",
|
|
function() pb.hook "-invalid-type-" end)
|
|
local function make_hook(name, func)
|
|
local fetch = pb.hook(name)
|
|
local function helper(t)
|
|
return func(name, t)
|
|
end
|
|
local oldh = pb.hook(name, helper)
|
|
assert(fetch == oldh)
|
|
assert(pb.hook(name) == helper)
|
|
end
|
|
local s = {}
|
|
make_hook("Person", function(name, t)
|
|
s[#s+1] = ("(%s|%s)"):format(name, t.name)
|
|
t.hooked = true
|
|
end)
|
|
make_hook("Phone", function(name, t)
|
|
s[#s+1] = ("(%s|%s|%s)"):format(name, t.name, t.phonenumber)
|
|
t.hooked = true
|
|
return t
|
|
end)
|
|
make_hook("Type", function(name, t)
|
|
s[#s+1] = ("(%s|%s)"):format(name, t)
|
|
return { type = name, value = t }
|
|
end)
|
|
local data = {
|
|
name = "ilse",
|
|
age = 18,
|
|
contacts = {
|
|
{ name = "alice", type = "HOME", phonenumber = 12312341234 },
|
|
{ name = "bob", type = "WORK", phonenumber = 45645674567 }
|
|
}
|
|
}
|
|
local res = pb.decode("Person", pb.encode("Person", data))
|
|
s = table.concat(s)
|
|
assert(s == "(Type|HOME)(Phone|alice|12312341234)"..
|
|
"(Type|WORK)(Phone|bob|45645674567)"..
|
|
"(Person|ilse)")
|
|
assert(res.hooked)
|
|
assert(res.contacts[1].hooked)
|
|
assert(res.contacts[2].hooked)
|
|
assert(type(res.contacts[1].type) == "table")
|
|
assert(type(res.contacts[2].type) == "table")
|
|
end)
|
|
end
|
|
|
|
function _G.test_encode_hook()
|
|
withstate(function()
|
|
protoc.reload()
|
|
check_load [[
|
|
enum Type {
|
|
HOME = 1;
|
|
WORK = 2;
|
|
}
|
|
message Phone {
|
|
optional string name = 1;
|
|
optional int64 phonenumber = 2;
|
|
optional Type type = 3;
|
|
}
|
|
message Person {
|
|
optional string name = 1;
|
|
optional int32 age = 2;
|
|
optional string address = 3;
|
|
repeated Phone contacts = 4;
|
|
} ]]
|
|
pb.option "enable_hooks"
|
|
assert(pb.encode_hook "Phone" == nil)
|
|
fail("function expected, got boolean",
|
|
function() pb.encode_hook("Phone", true) end)
|
|
fail("type not found",
|
|
function() pb.encode_hook "-invalid-type-" end)
|
|
local function make_encode_hook(name, func)
|
|
local fetch = pb.encode_hook(name)
|
|
local function helper(t)
|
|
return func(name, t)
|
|
end
|
|
local oldh = pb.encode_hook(name, helper)
|
|
assert(fetch == oldh)
|
|
assert(pb.encode_hook(name) == helper)
|
|
end
|
|
local s = {}
|
|
make_encode_hook("Person", function(name, t)
|
|
s[#s+1] = ("(%s|%s)"):format(name, t.name)
|
|
return t
|
|
end)
|
|
make_encode_hook("Phone", function(name, ph)
|
|
ph_name, ty, num = ph:match("(%w+)|(%w+)|(%d+)")
|
|
t = {
|
|
name = ph_name,
|
|
type = ty,
|
|
phonenumber = tonumber(num),
|
|
}
|
|
s[#s+1] = ("(%s|%s|%s)"):format(name, t.name, t.phonenumber)
|
|
return t
|
|
end)
|
|
make_encode_hook("Type", function(name, v)
|
|
local t = v:lower() == v and "HOME" or "WORK"
|
|
s[#s+1] = ("(%s|(%s)%s)"):format(name, v, t)
|
|
return t
|
|
end)
|
|
local data = {
|
|
name = "ilse",
|
|
age = 18,
|
|
contacts = {
|
|
"alice|zzz|12312341234",
|
|
"bob|Grr|45645674567",
|
|
}
|
|
}
|
|
local res = pb.decode("Person", pb.encode("Person", data))
|
|
s = table.concat(s)
|
|
assert(s == "(Person|ilse)(Phone|alice|12312341234)"..
|
|
"(Type|(zzz)HOME)(Phone|bob|45645674567)"..
|
|
"(Type|(Grr)WORK)")
|
|
end)
|
|
end
|
|
|
|
function _G.test_unsafe()
|
|
local unsafe = require "pb.unsafe"
|
|
assert(type(unsafe.decode) == "function")
|
|
assert(type(unsafe.use) == "function")
|
|
fail("userdata expected, got boolean",
|
|
function() unsafe.decode("", true, 1)
|
|
end)
|
|
fail("userdata expected, got boolean",
|
|
function() unsafe.slice(true, 1)
|
|
end)
|
|
local s, len = unsafe.touserdata(io.stdin, 0)
|
|
-- s is a null pointer!
|
|
fail("userdata expected, got userdata",
|
|
function() unsafe.slice(s, len)
|
|
end)
|
|
check_load [[
|
|
message TestType {
|
|
}
|
|
]]
|
|
s, len = unsafe.touserdata("", 0)
|
|
eq(type(s), "userdata")
|
|
eq(len, 0)
|
|
table_eq(unsafe.decode("TestType", s, len), {})
|
|
table_eq(pb.decode("TestType", unsafe.slice(s, len)), {})
|
|
pb.clear "TestType"
|
|
eq((unsafe.use "global"), true)
|
|
eq((unsafe.use "local"), true)
|
|
end
|
|
|
|
if _VERSION == "Lua 5.1" and not _G.jit then
|
|
lu.LuaUnit.run()
|
|
else
|
|
os.exit(lu.LuaUnit.run(), true)
|
|
end
|
|
|
|
-- unixcc: run='rm -f *.gcda; lua test.lua; gcov pb.c'
|
|
-- win32cc: run='del *.gcda & lua test.lua & gcov pb.c'
|