1802 lines
59 KiB
Ruby
1802 lines
59 KiB
Ruby
require 'google/protobuf/wrappers_pb.rb'
|
|
|
|
# Defines tests which are common between proto2 and proto3 syntax.
|
|
#
|
|
# Requires that the proto messages are exactly the same in proto2 and proto3 syntax
|
|
# and that the including class should define a 'proto_module' method which returns
|
|
# the enclosing module of the proto message classes.
|
|
|
|
require 'bigdecimal'
|
|
|
|
module CommonTests
|
|
# Ruby 2.5 changed to raise FrozenError instead of RuntimeError
|
|
FrozenErrorType = Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.5') ? RuntimeError : FrozenError
|
|
|
|
def test_defaults
|
|
m = proto_module::TestMessage.new
|
|
assert m.optional_int32 == 0
|
|
assert m.optional_int64 == 0
|
|
assert m.optional_uint32 == 0
|
|
assert m.optional_uint64 == 0
|
|
assert m.optional_bool == false
|
|
assert m.optional_float == 0.0
|
|
assert m.optional_double == 0.0
|
|
assert m.optional_string == ""
|
|
assert m.optional_bytes == ""
|
|
assert m.optional_msg == nil
|
|
assert m.optional_enum == :Default
|
|
end
|
|
|
|
def test_setters
|
|
m = proto_module::TestMessage.new
|
|
m.optional_int32 = -42
|
|
assert m.optional_int32 == -42
|
|
m.optional_int64 = -0x1_0000_0000
|
|
assert m.optional_int64 == -0x1_0000_0000
|
|
m.optional_uint32 = 0x9000_0000
|
|
assert m.optional_uint32 == 0x9000_0000
|
|
m.optional_uint64 = 0x9000_0000_0000_0000
|
|
assert m.optional_uint64 == 0x9000_0000_0000_0000
|
|
m.optional_bool = true
|
|
assert m.optional_bool == true
|
|
m.optional_float = 0.5
|
|
assert m.optional_float == 0.5
|
|
m.optional_double = 0.5
|
|
assert m.optional_double == 0.5
|
|
m.optional_string = "hello"
|
|
assert m.optional_string == "hello"
|
|
m.optional_string = :hello
|
|
assert m.optional_string == "hello"
|
|
m.optional_bytes = "world".encode!('ASCII-8BIT')
|
|
assert m.optional_bytes == "world"
|
|
m.optional_msg = proto_module::TestMessage2.new(:foo => 42)
|
|
assert m.optional_msg == proto_module::TestMessage2.new(:foo => 42)
|
|
m.optional_msg = nil
|
|
assert m.optional_msg == nil
|
|
m.optional_enum = :C
|
|
assert m.optional_enum == :C
|
|
m.optional_enum = 'C'
|
|
assert m.optional_enum == :C
|
|
end
|
|
|
|
def test_ctor_args
|
|
m = proto_module::TestMessage.new(:optional_int32 => -42,
|
|
:optional_msg => proto_module::TestMessage2.new,
|
|
:optional_enum => :C,
|
|
:repeated_string => ["hello", "there", "world"])
|
|
assert m.optional_int32 == -42
|
|
assert m.optional_msg.class == proto_module::TestMessage2
|
|
assert m.repeated_string.length == 3
|
|
assert m.optional_enum == :C
|
|
assert m.repeated_string[0] == "hello"
|
|
assert m.repeated_string[1] == "there"
|
|
assert m.repeated_string[2] == "world"
|
|
end
|
|
|
|
def test_ctor_string_symbol_args
|
|
m = proto_module::TestMessage.new(:optional_enum => 'C', :repeated_enum => ['A', 'B'])
|
|
assert_equal :C, m.optional_enum
|
|
assert_equal [:A, :B], m.repeated_enum
|
|
|
|
m = proto_module::TestMessage.new(:optional_string => :foo, :repeated_string => [:foo, :bar])
|
|
assert_equal 'foo', m.optional_string
|
|
assert_equal ['foo', 'bar'], m.repeated_string
|
|
end
|
|
|
|
def test_ctor_nil_args
|
|
m = proto_module::TestMessage.new(:optional_enum => nil, :optional_int32 => nil, :optional_string => nil, :optional_msg => nil)
|
|
|
|
assert_equal :Default, m.optional_enum
|
|
assert_equal 0, m.optional_int32
|
|
assert_equal "", m.optional_string
|
|
assert_nil m.optional_msg
|
|
end
|
|
|
|
def test_embeddedmsg_hash_init
|
|
m = proto_module::TestEmbeddedMessageParent.new(
|
|
:child_msg => {sub_child: {optional_int32: 1}},
|
|
:number => 2,
|
|
:repeated_msg => [{sub_child: {optional_int32: 3}}],
|
|
:repeated_number => [10, 20, 30])
|
|
|
|
assert_equal 2, m.number
|
|
assert_equal [10, 20, 30], m.repeated_number
|
|
|
|
assert_not_nil m.child_msg
|
|
assert_not_nil m.child_msg.sub_child
|
|
assert_equal m.child_msg.sub_child.optional_int32, 1
|
|
|
|
assert_not_nil m.repeated_msg
|
|
assert_equal 1, m.repeated_msg.length
|
|
assert_equal 3, m.repeated_msg.first.sub_child.optional_int32
|
|
end
|
|
|
|
def test_inspect_eq_to_s
|
|
m = proto_module::TestMessage.new(
|
|
:optional_int32 => -42,
|
|
:optional_enum => :A,
|
|
:optional_msg => proto_module::TestMessage2.new(foo: 0),
|
|
:repeated_string => ["hello", "there", "world"])
|
|
expected = "<#{proto_module}::TestMessage: optional_int32: -42, optional_msg: <#{proto_module}::TestMessage2: foo: 0>, optional_enum: :A, repeated_int32: [], repeated_int64: [], repeated_uint32: [], repeated_uint64: [], repeated_bool: [], repeated_float: [], repeated_double: [], repeated_string: [\"hello\", \"there\", \"world\"], repeated_bytes: [], repeated_msg: [], repeated_enum: []>"
|
|
assert_equal expected, m.inspect
|
|
assert_equal expected, m.to_s
|
|
|
|
m = proto_module::OneofMessage.new(:b => -42)
|
|
expected = "<#{proto_module}::OneofMessage: b: -42>"
|
|
assert_equal expected, m.inspect
|
|
assert_equal expected, m.to_s
|
|
end
|
|
|
|
def test_hash
|
|
m1 = proto_module::TestMessage.new(:optional_int32 => 42)
|
|
m2 = proto_module::TestMessage.new(:optional_int32 => 102, repeated_string: ['please', 'work', 'ok?'])
|
|
m3 = proto_module::TestMessage.new(:optional_int32 => 102, repeated_string: ['please', 'work', 'ok?'])
|
|
assert m1.hash != 0
|
|
assert m2.hash != 0
|
|
assert m3.hash != 0
|
|
# relying on the randomness here -- if hash function changes and we are
|
|
# unlucky enough to get a collision, then change the values above.
|
|
assert m1.hash != m2.hash
|
|
assert_equal m2.hash, m3.hash
|
|
end
|
|
|
|
def test_unknown_field_errors
|
|
e = assert_raise NoMethodError do
|
|
proto_module::TestMessage.new.hello
|
|
end
|
|
assert_match(/hello/, e.message)
|
|
|
|
e = assert_raise NoMethodError do
|
|
proto_module::TestMessage.new.hello = "world"
|
|
end
|
|
assert_match(/hello/, e.message)
|
|
end
|
|
|
|
def test_type_errors
|
|
m = proto_module::TestMessage.new
|
|
e = assert_raise Google::Protobuf::TypeError do
|
|
m.optional_int32 = "hello"
|
|
end
|
|
|
|
# Google::Protobuf::TypeError should inherit from TypeError for backwards compatibility
|
|
# TODO: This can be removed when we can safely migrate to Google::Protobuf::TypeError
|
|
assert e.is_a?(::TypeError)
|
|
|
|
assert_raise Google::Protobuf::TypeError do
|
|
m.optional_string = 42
|
|
end
|
|
assert_raise Google::Protobuf::TypeError do
|
|
m.optional_string = nil
|
|
end
|
|
assert_raise Google::Protobuf::TypeError do
|
|
m.optional_bool = 42
|
|
end
|
|
assert_raise Google::Protobuf::TypeError do
|
|
m.optional_msg = proto_module::TestMessage.new # expects TestMessage2
|
|
end
|
|
|
|
assert_raise Google::Protobuf::TypeError do
|
|
m.repeated_int32 = [] # needs RepeatedField
|
|
end
|
|
|
|
assert_raise Google::Protobuf::TypeError do
|
|
m.repeated_int32.push "hello"
|
|
end
|
|
|
|
assert_raise Google::Protobuf::TypeError do
|
|
m.repeated_msg.push proto_module::TestMessage.new
|
|
end
|
|
end
|
|
|
|
def test_string_encoding
|
|
m = proto_module::TestMessage.new
|
|
|
|
# Assigning a normal (ASCII or UTF8) string to a bytes field, or
|
|
# ASCII-8BIT to a string field will convert to the proper encoding.
|
|
m.optional_bytes = "Test string ASCII".encode!('ASCII')
|
|
assert m.optional_bytes.frozen?
|
|
assert_equal Encoding::ASCII_8BIT, m.optional_bytes.encoding
|
|
assert_equal "Test string ASCII", m.optional_bytes
|
|
|
|
assert_raise Encoding::UndefinedConversionError do
|
|
m.optional_bytes = "Test string UTF-8 \u0100".encode!('UTF-8')
|
|
end
|
|
|
|
assert_raise Encoding::UndefinedConversionError do
|
|
m.optional_string = ["FFFF"].pack('H*')
|
|
end
|
|
|
|
# "Ordinary" use case.
|
|
m.optional_bytes = ["FFFF"].pack('H*')
|
|
m.optional_string = "\u0100"
|
|
|
|
# strings are immutable so we can't do this, but serialize should catch it.
|
|
m.optional_string = "asdf".encode!('UTF-8')
|
|
assert_raise(FrozenErrorType) { m.optional_string.encode!('ASCII-8BIT') }
|
|
end
|
|
|
|
def test_rptfield_int32
|
|
l = Google::Protobuf::RepeatedField.new(:int32)
|
|
assert l.count == 0
|
|
l = Google::Protobuf::RepeatedField.new(:int32, [1, 2, 3])
|
|
assert l.count == 3
|
|
assert_equal [1, 2, 3], l
|
|
assert_equal l, [1, 2, 3]
|
|
l.push 4
|
|
assert l == [1, 2, 3, 4]
|
|
dst_list = []
|
|
l.each { |val| dst_list.push val }
|
|
assert dst_list == [1, 2, 3, 4]
|
|
assert l.to_a == [1, 2, 3, 4]
|
|
assert l[0] == 1
|
|
assert l[3] == 4
|
|
l[0] = 5
|
|
assert l == [5, 2, 3, 4]
|
|
|
|
l2 = l.dup
|
|
assert l == l2
|
|
assert l.object_id != l2.object_id
|
|
l2.push 6
|
|
assert l.count == 4
|
|
assert l2.count == 5
|
|
|
|
assert l.inspect == '[5, 2, 3, 4]'
|
|
|
|
l.concat([7, 8, 9])
|
|
assert l == [5, 2, 3, 4, 7, 8, 9]
|
|
assert l.pop == 9
|
|
assert l == [5, 2, 3, 4, 7, 8]
|
|
|
|
assert_raise Google::Protobuf::TypeError do
|
|
m = proto_module::TestMessage.new
|
|
l.push m
|
|
end
|
|
|
|
m = proto_module::TestMessage.new
|
|
m.repeated_int32 = l
|
|
assert m.repeated_int32 == [5, 2, 3, 4, 7, 8]
|
|
assert m.repeated_int32.object_id == l.object_id
|
|
l.push 42
|
|
assert m.repeated_int32.pop == 42
|
|
|
|
l3 = l + l.dup
|
|
assert l3.count == l.count * 2
|
|
l.count.times do |i|
|
|
assert l3[i] == l[i]
|
|
assert l3[l.count + i] == l[i]
|
|
end
|
|
|
|
l.clear
|
|
assert l.count == 0
|
|
l += [1, 2, 3, 4]
|
|
l.replace([5, 6, 7, 8])
|
|
assert l == [5, 6, 7, 8]
|
|
|
|
l4 = Google::Protobuf::RepeatedField.new(:int32)
|
|
l4[5] = 42
|
|
assert l4 == [0, 0, 0, 0, 0, 42]
|
|
|
|
l4 << 100
|
|
assert l4 == [0, 0, 0, 0, 0, 42, 100]
|
|
l4 << 101 << 102
|
|
assert l4 == [0, 0, 0, 0, 0, 42, 100, 101, 102]
|
|
end
|
|
|
|
def test_parent_rptfield
|
|
#make sure we set the RepeatedField and can add to it
|
|
m = proto_module::TestMessage.new
|
|
assert m.repeated_string == []
|
|
m.repeated_string << 'ok'
|
|
m.repeated_string.push('ok2')
|
|
assert m.repeated_string == ['ok', 'ok2']
|
|
m.repeated_string += ['ok3']
|
|
assert m.repeated_string == ['ok', 'ok2', 'ok3']
|
|
end
|
|
|
|
def test_rptfield_msg
|
|
l = Google::Protobuf::RepeatedField.new(:message, proto_module::TestMessage)
|
|
l.push proto_module::TestMessage.new
|
|
assert l.count == 1
|
|
assert_raise Google::Protobuf::TypeError do
|
|
l.push proto_module::TestMessage2.new
|
|
end
|
|
assert_raise Google::Protobuf::TypeError do
|
|
l.push 42
|
|
end
|
|
|
|
l2 = l.dup
|
|
assert l2[0] == l[0]
|
|
assert l2[0].object_id == l[0].object_id
|
|
|
|
l2 = Google::Protobuf.deep_copy(l)
|
|
assert l2[0] == l[0]
|
|
assert l2[0].object_id != l[0].object_id
|
|
|
|
l3 = l + l2
|
|
assert l3.count == 2
|
|
assert l3[0] == l[0]
|
|
assert l3[1] == l2[0]
|
|
l3[0].optional_int32 = 1000
|
|
assert l[0].optional_int32 == 1000
|
|
|
|
new_msg = proto_module::TestMessage.new(:optional_int32 => 200)
|
|
l4 = l + [new_msg]
|
|
assert l4.count == 2
|
|
new_msg.optional_int32 = 1000
|
|
assert l4[1].optional_int32 == 1000
|
|
end
|
|
|
|
def test_rptfield_enum
|
|
l = Google::Protobuf::RepeatedField.new(:enum, proto_module::TestEnum)
|
|
l.push :A
|
|
l.push :B
|
|
l.push :C
|
|
assert l.count == 3
|
|
assert_raise RangeError do
|
|
l.push :D
|
|
end
|
|
assert l[0] == :A
|
|
|
|
l.push 4
|
|
assert l[3] == 4
|
|
end
|
|
|
|
def test_rptfield_initialize
|
|
assert_raise ArgumentError do
|
|
Google::Protobuf::RepeatedField.new
|
|
end
|
|
assert_raise ArgumentError do
|
|
Google::Protobuf::RepeatedField.new(:message)
|
|
end
|
|
assert_raise ArgumentError do
|
|
Google::Protobuf::RepeatedField.new([1, 2, 3])
|
|
end
|
|
assert_raise ArgumentError do
|
|
Google::Protobuf::RepeatedField.new(:message, [proto_module::TestMessage2.new])
|
|
end
|
|
end
|
|
|
|
def test_rptfield_array_ducktyping
|
|
l = Google::Protobuf::RepeatedField.new(:int32)
|
|
length_methods = %w(count length size)
|
|
length_methods.each do |lm|
|
|
assert l.send(lm) == 0
|
|
end
|
|
# out of bounds returns a nil
|
|
assert l[0] == nil
|
|
assert l[1] == nil
|
|
assert l[-1] == nil
|
|
l.push 4
|
|
length_methods.each do |lm|
|
|
assert l.send(lm) == 1
|
|
end
|
|
assert l[0] == 4
|
|
assert l[1] == nil
|
|
assert l[-1] == 4
|
|
assert l[-2] == nil
|
|
|
|
l.push 2
|
|
length_methods.each do |lm|
|
|
assert l.send(lm) == 2
|
|
end
|
|
assert l[0] == 4
|
|
assert l[1] == 2
|
|
assert l[2] == nil
|
|
assert l[-1] == 2
|
|
assert l[-2] == 4
|
|
assert l[-3] == nil
|
|
|
|
#adding out of scope will backfill with empty objects
|
|
end
|
|
|
|
def test_map_basic
|
|
# allowed key types:
|
|
# :int32, :int64, :uint32, :uint64, :bool, :string, :bytes.
|
|
|
|
m = Google::Protobuf::Map.new(:string, :int32)
|
|
m["asdf"] = 1
|
|
assert m["asdf"] == 1
|
|
m["jkl;"] = 42
|
|
assert m == { "jkl;" => 42, "asdf" => 1 }
|
|
assert m.has_key?("asdf")
|
|
assert !m.has_key?("qwerty")
|
|
assert m.length == 2
|
|
|
|
m2 = m.dup
|
|
assert_equal m, m2
|
|
assert m.hash != 0
|
|
assert_equal m.hash, m2.hash
|
|
|
|
collected = {}
|
|
m.each { |k,v| collected[v] = k }
|
|
assert collected == { 42 => "jkl;", 1 => "asdf" }
|
|
|
|
assert m.delete("asdf") == 1
|
|
assert !m.has_key?("asdf")
|
|
assert m["asdf"] == nil
|
|
assert !m.has_key?("asdf")
|
|
|
|
# We only assert on inspect value when there is one map entry because the
|
|
# order in which elements appear is unspecified (depends on the internal
|
|
# hash function). We don't want a brittle test.
|
|
assert m.inspect == "{\"jkl;\"=>42}"
|
|
|
|
assert m.keys == ["jkl;"]
|
|
assert m.values == [42]
|
|
|
|
m.clear
|
|
assert m.length == 0
|
|
assert m == {}
|
|
|
|
assert_raise Google::Protobuf::TypeError do
|
|
m[1] = 1
|
|
end
|
|
assert_raise RangeError do
|
|
m["asdf"] = 0x1_0000_0000
|
|
end
|
|
end
|
|
|
|
def test_b_8385
|
|
m1 = Google::Protobuf::Map.new(:string, :string)
|
|
m2 = Google::Protobuf::Map.new(:string, :string)
|
|
|
|
assert_equal m1, m2
|
|
|
|
m1["counter"] = "a"
|
|
m2["counter"] = "aa"
|
|
|
|
assert_not_equal m1, m2
|
|
end
|
|
|
|
def test_map_ctor
|
|
m = Google::Protobuf::Map.new(:string, :int32,
|
|
{"a" => 1, "b" => 2, "c" => 3})
|
|
assert m == {"a" => 1, "c" => 3, "b" => 2}
|
|
end
|
|
|
|
def test_map_keytypes
|
|
m = Google::Protobuf::Map.new(:int32, :int32)
|
|
m[1] = 42
|
|
m[-1] = 42
|
|
assert_raise RangeError do
|
|
m[0x8000_0000] = 1
|
|
end
|
|
assert_raise Google::Protobuf::TypeError do
|
|
m["asdf"] = 1
|
|
end
|
|
|
|
m = Google::Protobuf::Map.new(:int64, :int32)
|
|
m[0x1000_0000_0000_0000] = 1
|
|
assert_raise RangeError do
|
|
m[0x1_0000_0000_0000_0000] = 1
|
|
end
|
|
assert_raise Google::Protobuf::TypeError do
|
|
m["asdf"] = 1
|
|
end
|
|
|
|
m = Google::Protobuf::Map.new(:uint32, :int32)
|
|
m[0x8000_0000] = 1
|
|
assert_raise RangeError do
|
|
m[0x1_0000_0000] = 1
|
|
end
|
|
assert_raise RangeError do
|
|
m[-1] = 1
|
|
end
|
|
|
|
m = Google::Protobuf::Map.new(:uint64, :int32)
|
|
m[0x8000_0000_0000_0000] = 1
|
|
assert_raise RangeError do
|
|
m[0x1_0000_0000_0000_0000] = 1
|
|
end
|
|
assert_raise RangeError do
|
|
m[-1] = 1
|
|
end
|
|
|
|
m = Google::Protobuf::Map.new(:bool, :int32)
|
|
m[true] = 1
|
|
m[false] = 2
|
|
assert_raise Google::Protobuf::TypeError do
|
|
m[1] = 1
|
|
end
|
|
assert_raise Google::Protobuf::TypeError do
|
|
m["asdf"] = 1
|
|
end
|
|
|
|
m = Google::Protobuf::Map.new(:string, :int32)
|
|
m["asdf"] = 1
|
|
assert_raise Google::Protobuf::TypeError do
|
|
m[1] = 1
|
|
end
|
|
assert_raise Encoding::UndefinedConversionError do
|
|
bytestring = ["FFFF"].pack("H*")
|
|
m[bytestring] = 1
|
|
end
|
|
|
|
m = Google::Protobuf::Map.new(:bytes, :int32)
|
|
bytestring = ["FFFF"].pack("H*")
|
|
m[bytestring] = 1
|
|
# Allowed -- we will automatically convert to ASCII-8BIT.
|
|
m["asdf"] = 1
|
|
assert_raise Google::Protobuf::TypeError do
|
|
m[1] = 1
|
|
end
|
|
end
|
|
|
|
def test_map_msg_enum_valuetypes
|
|
m = Google::Protobuf::Map.new(:string, :message, proto_module::TestMessage)
|
|
m["asdf"] = proto_module::TestMessage.new
|
|
assert_raise Google::Protobuf::TypeError do
|
|
m["jkl;"] = proto_module::TestMessage2.new
|
|
end
|
|
|
|
m = Google::Protobuf::Map.new(
|
|
:string, :message, proto_module::TestMessage,
|
|
{ "a" => proto_module::TestMessage.new(:optional_int32 => 42),
|
|
"b" => proto_module::TestMessage.new(:optional_int32 => 84) })
|
|
assert m.length == 2
|
|
assert m.values.map{|msg| msg.optional_int32}.sort == [42, 84]
|
|
|
|
m = Google::Protobuf::Map.new(:string, :enum, proto_module::TestEnum,
|
|
{ "x" => :A, "y" => :B, "z" => :C })
|
|
assert m.length == 3
|
|
assert m["z"] == :C
|
|
m["z"] = 2
|
|
assert m["z"] == :B
|
|
m["z"] = 4
|
|
assert m["z"] == 4
|
|
assert_raise RangeError do
|
|
m["z"] = :Z
|
|
end
|
|
assert_raise RangeError do
|
|
m["z"] = "z"
|
|
end
|
|
end
|
|
|
|
def test_map_dup_deep_copy
|
|
m = Google::Protobuf::Map.new(
|
|
:string, :message, proto_module::TestMessage,
|
|
{ "a" => proto_module::TestMessage.new(:optional_int32 => 42),
|
|
"b" => proto_module::TestMessage.new(:optional_int32 => 84) })
|
|
|
|
m2 = m.dup
|
|
assert m.to_h == m2.to_h
|
|
assert m == m2
|
|
assert m.object_id != m2.object_id
|
|
assert m["a"].object_id == m2["a"].object_id
|
|
assert m["b"].object_id == m2["b"].object_id
|
|
|
|
m2 = Google::Protobuf.deep_copy(m)
|
|
assert m == m2
|
|
assert m.object_id != m2.object_id
|
|
assert m["a"].object_id != m2["a"].object_id
|
|
assert m["b"].object_id != m2["b"].object_id
|
|
end
|
|
|
|
def test_oneof_descriptors
|
|
d = proto_module::OneofMessage.descriptor
|
|
o = d.lookup_oneof("my_oneof")
|
|
assert o != nil
|
|
assert o.class == Google::Protobuf::OneofDescriptor
|
|
assert o.name == "my_oneof"
|
|
oneof_count = 0
|
|
d.each_oneof{ |oneof|
|
|
oneof_count += 1
|
|
assert oneof == o
|
|
}
|
|
assert oneof_count == 1
|
|
assert o.count == 4
|
|
field_names = o.map{|f| f.name}.sort
|
|
assert field_names == ["a", "b", "c", "d"]
|
|
end
|
|
|
|
def test_oneof
|
|
d = proto_module::OneofMessage.new
|
|
assert d.a == ""
|
|
assert d.b == 0
|
|
assert d.c == nil
|
|
assert d.d == :Default
|
|
assert d.my_oneof == nil
|
|
|
|
d.a = "hi"
|
|
assert d.a == "hi"
|
|
assert d.b == 0
|
|
assert d.c == nil
|
|
assert d.d == :Default
|
|
assert d.my_oneof == :a
|
|
|
|
d.b = 42
|
|
assert d.a == ""
|
|
assert d.b == 42
|
|
assert d.c == nil
|
|
assert d.d == :Default
|
|
assert d.my_oneof == :b
|
|
|
|
d.c = proto_module::TestMessage2.new(:foo => 100)
|
|
assert d.a == ""
|
|
assert d.b == 0
|
|
assert d.c.foo == 100
|
|
assert d.d == :Default
|
|
assert d.my_oneof == :c
|
|
|
|
d.d = :C
|
|
assert d.a == ""
|
|
assert d.b == 0
|
|
assert d.c == nil
|
|
assert d.d == :C
|
|
assert d.my_oneof == :d
|
|
|
|
d2 = proto_module::OneofMessage.decode(proto_module::OneofMessage.encode(d))
|
|
assert d2 == d
|
|
|
|
encoded_field_a = proto_module::OneofMessage.encode(proto_module::OneofMessage.new(:a => "string"))
|
|
encoded_field_b = proto_module::OneofMessage.encode(proto_module::OneofMessage.new(:b => 1000))
|
|
encoded_field_c = proto_module::OneofMessage.encode(
|
|
proto_module::OneofMessage.new(:c => proto_module::TestMessage2.new(:foo => 1)))
|
|
encoded_field_d = proto_module::OneofMessage.encode(proto_module::OneofMessage.new(:d => :B))
|
|
|
|
d3 = proto_module::OneofMessage.decode(
|
|
encoded_field_c + encoded_field_a + encoded_field_b + encoded_field_d)
|
|
assert d3.a == ""
|
|
assert d3.b == 0
|
|
assert d3.c == nil
|
|
assert d3.d == :B
|
|
|
|
d4 = proto_module::OneofMessage.decode(
|
|
encoded_field_c + encoded_field_a + encoded_field_b + encoded_field_d +
|
|
encoded_field_c)
|
|
assert d4.a == ""
|
|
assert d4.b == 0
|
|
assert d4.c.foo == 1
|
|
assert d4.d == :Default
|
|
|
|
d5 = proto_module::OneofMessage.new(:a => "hello")
|
|
assert d5.a == "hello"
|
|
d5.a = nil
|
|
assert d5.a == ""
|
|
assert proto_module::OneofMessage.encode(d5) == ''
|
|
assert d5.my_oneof == nil
|
|
end
|
|
|
|
def test_enum_field
|
|
m = proto_module::TestMessage.new
|
|
assert m.optional_enum == :Default
|
|
m.optional_enum = :A
|
|
assert m.optional_enum == :A
|
|
assert_raise RangeError do
|
|
m.optional_enum = :ASDF
|
|
end
|
|
m.optional_enum = 1
|
|
assert m.optional_enum == :A
|
|
m.optional_enum = 100
|
|
assert m.optional_enum == 100
|
|
end
|
|
|
|
def test_dup
|
|
m = proto_module::TestMessage.new
|
|
m.optional_string = "hello"
|
|
m.optional_int32 = 42
|
|
tm1 = proto_module::TestMessage2.new(:foo => 100)
|
|
tm2 = proto_module::TestMessage2.new(:foo => 200)
|
|
m.repeated_msg.push tm1
|
|
assert m.repeated_msg[-1] == tm1
|
|
m.repeated_msg.push tm2
|
|
assert m.repeated_msg[-1] == tm2
|
|
m2 = m.dup
|
|
assert m == m2
|
|
m.optional_int32 += 1
|
|
assert m != m2
|
|
assert m.repeated_msg[0] == m2.repeated_msg[0]
|
|
assert m.repeated_msg[0].object_id == m2.repeated_msg[0].object_id
|
|
end
|
|
|
|
def test_deep_copy
|
|
m = proto_module::TestMessage.new(:optional_int32 => 42,
|
|
:repeated_msg => [proto_module::TestMessage2.new(:foo => 100)])
|
|
m2 = Google::Protobuf.deep_copy(m)
|
|
assert m == m2
|
|
assert m.repeated_msg == m2.repeated_msg
|
|
assert m.repeated_msg.object_id != m2.repeated_msg.object_id
|
|
assert m.repeated_msg[0].object_id != m2.repeated_msg[0].object_id
|
|
end
|
|
|
|
def test_message_eq
|
|
m = proto_module::TestMessage.new(:optional_int32 => 42,
|
|
:repeated_int32 => [1, 2, 3])
|
|
m2 = proto_module::TestMessage.new(:optional_int32 => 43,
|
|
:repeated_int32 => [1, 2, 3])
|
|
assert m != m2
|
|
assert_not_equal proto_module::TestMessage.new, proto_module::TestMessage2.new
|
|
end
|
|
|
|
def test_enum_lookup
|
|
assert proto_module::TestEnum::A == 1
|
|
assert proto_module::TestEnum::B == 2
|
|
assert proto_module::TestEnum::C == 3
|
|
|
|
assert proto_module::TestEnum::lookup(1) == :A
|
|
assert proto_module::TestEnum::lookup(2) == :B
|
|
assert proto_module::TestEnum::lookup(3) == :C
|
|
|
|
assert proto_module::TestEnum::resolve(:A) == 1
|
|
assert proto_module::TestEnum::resolve(:B) == 2
|
|
assert proto_module::TestEnum::resolve(:C) == 3
|
|
end
|
|
|
|
def test_enum_const_get_helpers
|
|
m = proto_module::TestMessage.new
|
|
assert_equal proto_module::TestEnum::Default, m.optional_enum_const
|
|
assert_equal proto_module::TestEnum.const_get(:Default), m.optional_enum_const
|
|
|
|
m = proto_module::TestMessage.new({optional_enum: proto_module::TestEnum::A})
|
|
assert_equal proto_module::TestEnum::A, m.optional_enum_const
|
|
assert_equal proto_module::TestEnum.const_get(:A), m.optional_enum_const
|
|
|
|
m = proto_module::TestMessage.new({optional_enum: proto_module::TestEnum::B})
|
|
assert_equal proto_module::TestEnum::B, m.optional_enum_const
|
|
assert_equal proto_module::TestEnum.const_get(:B), m.optional_enum_const
|
|
|
|
m = proto_module::TestMessage.new({optional_enum: proto_module::TestEnum::C})
|
|
assert_equal proto_module::TestEnum::C, m.optional_enum_const
|
|
assert_equal proto_module::TestEnum.const_get(:C), m.optional_enum_const
|
|
|
|
m = proto_module::TestMessage2.new({foo: 2})
|
|
assert_equal 2, m.foo
|
|
assert_raise(NoMethodError) { m.foo_ }
|
|
assert_raise(NoMethodError) { m.foo_X }
|
|
assert_raise(NoMethodError) { m.foo_XX }
|
|
assert_raise(NoMethodError) { m.foo_XXX }
|
|
assert_raise(NoMethodError) { m.foo_XXXX }
|
|
assert_raise(NoMethodError) { m.foo_XXXXX }
|
|
assert_raise(NoMethodError) { m.foo_XXXXXX }
|
|
|
|
m = proto_module::Enumer.new({optional_enum: :B})
|
|
assert_equal :B, m.optional_enum
|
|
assert_raise(NoMethodError) { m.optional_enum_ }
|
|
assert_raise(NoMethodError) { m.optional_enum_X }
|
|
assert_raise(NoMethodError) { m.optional_enum_XX }
|
|
assert_raise(NoMethodError) { m.optional_enum_XXX }
|
|
assert_raise(NoMethodError) { m.optional_enum_XXXX }
|
|
assert_raise(NoMethodError) { m.optional_enum_XXXXX }
|
|
assert_raise(NoMethodError) { m.optional_enum_XXXXXX }
|
|
end
|
|
|
|
def test_enum_getter
|
|
m = proto_module::Enumer.new(:optional_enum => :B, :repeated_enum => [:A, :C])
|
|
|
|
assert_equal :B, m.optional_enum
|
|
assert_equal 2, m.optional_enum_const
|
|
assert_equal proto_module::TestEnum::B, m.optional_enum_const
|
|
assert_equal [:A, :C], m.repeated_enum
|
|
assert_equal [1, 3], m.repeated_enum_const
|
|
assert_equal [proto_module::TestEnum::A, proto_module::TestEnum::C], m.repeated_enum_const
|
|
end
|
|
|
|
def test_enum_getter_oneof
|
|
m = proto_module::Enumer.new(:const => :C)
|
|
|
|
assert_equal :C, m.const
|
|
assert_equal 3, m.const_const
|
|
assert_equal proto_module::TestEnum::C, m.const_const
|
|
end
|
|
|
|
def test_enum_getter_only_enums
|
|
m = proto_module::Enumer.new(:optional_enum => :B, :a_const => 'thing')
|
|
|
|
assert_equal 'thing', m.a_const
|
|
assert_equal :B, m.optional_enum
|
|
|
|
assert_raise(NoMethodError) { m.a }
|
|
assert_raise(NoMethodError) { m.a_const_const }
|
|
end
|
|
|
|
def test_repeated_push
|
|
m = proto_module::TestMessage.new
|
|
|
|
m.repeated_string += ['one']
|
|
m.repeated_string += %w[two three]
|
|
assert_equal %w[one two three], m.repeated_string
|
|
|
|
m.repeated_string.push *['four', 'five']
|
|
assert_equal %w[one two three four five], m.repeated_string
|
|
|
|
m.repeated_string.push 'six', 'seven'
|
|
assert_equal %w[one two three four five six seven], m.repeated_string
|
|
|
|
m = proto_module::TestMessage.new
|
|
|
|
m.repeated_msg += [proto_module::TestMessage2.new(:foo => 1), proto_module::TestMessage2.new(:foo => 2)]
|
|
m.repeated_msg += [proto_module::TestMessage2.new(:foo => 3)]
|
|
m.repeated_msg.push proto_module::TestMessage2.new(:foo => 4), proto_module::TestMessage2.new(:foo => 5)
|
|
assert_equal [1, 2, 3, 4, 5], m.repeated_msg.map {|x| x.foo}
|
|
end
|
|
|
|
def test_parse_serialize
|
|
m = proto_module::TestMessage.new(:optional_int32 => 42,
|
|
:optional_string => "hello world",
|
|
:optional_enum => :B,
|
|
:repeated_string => ["a", "b", "c"],
|
|
:repeated_int32 => [42, 43, 44],
|
|
:repeated_enum => [:A, :B, :C, 100],
|
|
:repeated_msg => [proto_module::TestMessage2.new(:foo => 1),
|
|
proto_module::TestMessage2.new(:foo => 2)])
|
|
data = proto_module::TestMessage.encode m
|
|
m2 = proto_module::TestMessage.decode data
|
|
assert_equal m, m2
|
|
|
|
data = Google::Protobuf.encode m
|
|
m2 = Google::Protobuf.decode(proto_module::TestMessage, data)
|
|
assert m == m2
|
|
end
|
|
|
|
def test_encode_decode_helpers
|
|
m = proto_module::TestMessage.new(:optional_string => 'foo', :repeated_string => ['bar1', 'bar2'])
|
|
assert_equal 'foo', m.optional_string
|
|
assert_equal ['bar1', 'bar2'], m.repeated_string
|
|
|
|
json = m.to_json
|
|
m2 = proto_module::TestMessage.decode_json(json)
|
|
assert_equal 'foo', m2.optional_string
|
|
assert_equal ['bar1', 'bar2'], m2.repeated_string
|
|
if RUBY_PLATFORM != "java"
|
|
assert m2.optional_string.frozen?
|
|
assert m2.repeated_string[0].frozen?
|
|
end
|
|
|
|
proto = m.to_proto
|
|
m2 = proto_module::TestMessage.decode(proto)
|
|
assert_equal 'foo', m2.optional_string
|
|
assert_equal ['bar1', 'bar2'], m2.repeated_string
|
|
end
|
|
|
|
def test_protobuf_encode_decode_helpers
|
|
m = proto_module::TestMessage.new(:optional_string => 'foo', :repeated_string => ['bar1', 'bar2'])
|
|
encoded_msg = Google::Protobuf.encode(m)
|
|
assert_equal m.to_proto, encoded_msg
|
|
|
|
decoded_msg = Google::Protobuf.decode(proto_module::TestMessage, encoded_msg)
|
|
assert_equal proto_module::TestMessage.decode(m.to_proto), decoded_msg
|
|
end
|
|
|
|
def test_protobuf_encode_decode_json_helpers
|
|
m = proto_module::TestMessage.new(:optional_string => 'foo', :repeated_string => ['bar1', 'bar2'])
|
|
encoded_msg = Google::Protobuf.encode_json(m)
|
|
assert_equal m.to_json, encoded_msg
|
|
|
|
decoded_msg = Google::Protobuf.decode_json(proto_module::TestMessage, encoded_msg)
|
|
assert_equal proto_module::TestMessage.decode_json(m.to_json), decoded_msg
|
|
end
|
|
|
|
def test_def_errors
|
|
s = Google::Protobuf::DescriptorPool.new
|
|
assert_raise Google::Protobuf::TypeError do
|
|
s.build do
|
|
# enum with no default (integer value 0)
|
|
add_enum "MyEnum" do
|
|
value :A, 1
|
|
end
|
|
end
|
|
end
|
|
assert_raise Google::Protobuf::TypeError do
|
|
s.build do
|
|
# message with required field (unsupported in proto3)
|
|
add_message "MyMessage" do
|
|
required :foo, :int32, 1
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
def test_corecursive
|
|
# just be sure that we can instantiate types with corecursive field-type
|
|
# references.
|
|
m = proto_module::Recursive1.new(:foo => proto_module::Recursive2.new(:foo => proto_module::Recursive1.new))
|
|
assert proto_module::Recursive1.descriptor.lookup("foo").subtype ==
|
|
proto_module::Recursive2.descriptor
|
|
assert proto_module::Recursive2.descriptor.lookup("foo").subtype ==
|
|
proto_module::Recursive1.descriptor
|
|
|
|
serialized = proto_module::Recursive1.encode(m)
|
|
m2 = proto_module::Recursive1.decode(serialized)
|
|
assert m == m2
|
|
end
|
|
|
|
def test_serialize_cycle
|
|
m = proto_module::Recursive1.new(:foo => proto_module::Recursive2.new)
|
|
m.foo.foo = m
|
|
assert_raise RuntimeError do
|
|
proto_module::Recursive1.encode(m)
|
|
end
|
|
end
|
|
|
|
def test_bad_field_names
|
|
m = proto_module::BadFieldNames.new(:dup => 1, :class => 2)
|
|
m2 = m.dup
|
|
assert m == m2
|
|
assert m['dup'] == 1
|
|
assert m['class'] == 2
|
|
m['dup'] = 3
|
|
assert m['dup'] == 3
|
|
end
|
|
|
|
def test_int_ranges
|
|
m = proto_module::TestMessage.new
|
|
|
|
m.optional_int32 = 0
|
|
m.optional_int32 = -0x8000_0000
|
|
m.optional_int32 = +0x7fff_ffff
|
|
m.optional_int32 = 1.0
|
|
m.optional_int32 = -1.0
|
|
m.optional_int32 = 2e9
|
|
assert_raise RangeError do
|
|
m.optional_int32 = -0x8000_0001
|
|
end
|
|
assert_raise RangeError do
|
|
m.optional_int32 = +0x8000_0000
|
|
end
|
|
assert_raise RangeError do
|
|
m.optional_int32 = +0x1000_0000_0000_0000_0000_0000 # force Bignum
|
|
end
|
|
assert_raise RangeError do
|
|
m.optional_int32 = 1e12
|
|
end
|
|
assert_raise RangeError do
|
|
m.optional_int32 = 1.5
|
|
end
|
|
|
|
m.optional_uint32 = 0
|
|
m.optional_uint32 = +0xffff_ffff
|
|
m.optional_uint32 = 1.0
|
|
m.optional_uint32 = 4e9
|
|
assert_raise RangeError do
|
|
m.optional_uint32 = -1
|
|
end
|
|
assert_raise RangeError do
|
|
m.optional_uint32 = -1.5
|
|
end
|
|
assert_raise RangeError do
|
|
m.optional_uint32 = -1.5e12
|
|
end
|
|
assert_raise RangeError do
|
|
m.optional_uint32 = -0x1000_0000_0000_0000
|
|
end
|
|
assert_raise RangeError do
|
|
m.optional_uint32 = +0x1_0000_0000
|
|
end
|
|
assert_raise RangeError do
|
|
m.optional_uint32 = +0x1000_0000_0000_0000_0000_0000 # force Bignum
|
|
end
|
|
assert_raise RangeError do
|
|
m.optional_uint32 = 1e12
|
|
end
|
|
assert_raise RangeError do
|
|
m.optional_uint32 = 1.5
|
|
end
|
|
|
|
m.optional_int64 = 0
|
|
m.optional_int64 = -0x8000_0000_0000_0000
|
|
m.optional_int64 = +0x7fff_ffff_ffff_ffff
|
|
m.optional_int64 = 1.0
|
|
m.optional_int64 = -1.0
|
|
m.optional_int64 = 8e18
|
|
m.optional_int64 = -8e18
|
|
assert_raise RangeError do
|
|
m.optional_int64 = -0x8000_0000_0000_0001
|
|
end
|
|
assert_raise RangeError do
|
|
m.optional_int64 = +0x8000_0000_0000_0000
|
|
end
|
|
assert_raise RangeError do
|
|
m.optional_int64 = +0x1000_0000_0000_0000_0000_0000 # force Bignum
|
|
end
|
|
assert_raise RangeError do
|
|
m.optional_int64 = 1e50
|
|
end
|
|
assert_raise RangeError do
|
|
m.optional_int64 = 1.5
|
|
end
|
|
|
|
m.optional_uint64 = 0
|
|
m.optional_uint64 = +0xffff_ffff_ffff_ffff
|
|
m.optional_uint64 = 1.0
|
|
m.optional_uint64 = 16e18
|
|
assert_raise RangeError do
|
|
m.optional_uint64 = -1
|
|
end
|
|
assert_raise RangeError do
|
|
m.optional_uint64 = -1.5
|
|
end
|
|
assert_raise RangeError do
|
|
m.optional_uint64 = -1.5e12
|
|
end
|
|
assert_raise RangeError do
|
|
m.optional_uint64 = -0x1_0000_0000_0000_0000
|
|
end
|
|
assert_raise RangeError do
|
|
m.optional_uint64 = +0x1_0000_0000_0000_0000
|
|
end
|
|
assert_raise RangeError do
|
|
m.optional_uint64 = +0x1000_0000_0000_0000_0000_0000 # force Bignum
|
|
end
|
|
assert_raise RangeError do
|
|
m.optional_uint64 = 1e50
|
|
end
|
|
assert_raise RangeError do
|
|
m.optional_uint64 = 1.5
|
|
end
|
|
end
|
|
|
|
def test_stress_test
|
|
m = proto_module::TestMessage.new
|
|
m.optional_int32 = 42
|
|
m.optional_int64 = 0x100000000
|
|
m.optional_string = "hello world"
|
|
10.times do m.repeated_msg.push proto_module::TestMessage2.new(:foo => 42) end
|
|
10.times do m.repeated_string.push "hello world" end
|
|
|
|
data = proto_module::TestMessage.encode(m)
|
|
|
|
10_000.times do
|
|
m = proto_module::TestMessage.decode(data)
|
|
data_new = proto_module::TestMessage.encode(m)
|
|
assert data_new == data
|
|
data = data_new
|
|
end
|
|
end
|
|
|
|
def test_reflection
|
|
m = proto_module::TestMessage.new(:optional_int32 => 1234)
|
|
msgdef = m.class.descriptor
|
|
assert msgdef.class == Google::Protobuf::Descriptor
|
|
assert msgdef.any? {|field| field.name == "optional_int32"}
|
|
optional_int32 = msgdef.lookup "optional_int32"
|
|
assert optional_int32.class == Google::Protobuf::FieldDescriptor
|
|
assert optional_int32 != nil
|
|
assert optional_int32.name == "optional_int32"
|
|
assert optional_int32.type == :int32
|
|
optional_int32.set(m, 5678)
|
|
assert m.optional_int32 == 5678
|
|
m.optional_int32 = 1000
|
|
assert optional_int32.get(m) == 1000
|
|
|
|
optional_msg = msgdef.lookup "optional_msg"
|
|
assert optional_msg.subtype == proto_module::TestMessage2.descriptor
|
|
|
|
optional_msg.set(m, optional_msg.subtype.msgclass.new)
|
|
|
|
assert msgdef.msgclass == proto_module::TestMessage
|
|
|
|
optional_enum = msgdef.lookup "optional_enum"
|
|
assert optional_enum.subtype == proto_module::TestEnum.descriptor
|
|
assert optional_enum.subtype.class == Google::Protobuf::EnumDescriptor
|
|
optional_enum.subtype.each do |k, v|
|
|
# set with integer, check resolution to symbolic name
|
|
optional_enum.set(m, v)
|
|
assert optional_enum.get(m) == k
|
|
end
|
|
end
|
|
|
|
def test_json
|
|
# TODO: Fix JSON in JRuby version.
|
|
return if RUBY_PLATFORM == "java"
|
|
m = proto_module::TestMessage.new(:optional_int32 => 1234,
|
|
:optional_int64 => -0x1_0000_0000,
|
|
:optional_uint32 => 0x8000_0000,
|
|
:optional_uint64 => 0xffff_ffff_ffff_ffff,
|
|
:optional_bool => true,
|
|
:optional_float => 1.0,
|
|
:optional_double => -1e100,
|
|
:optional_string => "Test string",
|
|
:optional_bytes => ["FFFFFFFF"].pack('H*'),
|
|
:optional_msg => proto_module::TestMessage2.new(:foo => 42),
|
|
:repeated_int32 => [1, 2, 3, 4],
|
|
:repeated_string => ["a", "b", "c"],
|
|
:repeated_bool => [true, false, true, false],
|
|
:repeated_msg => [proto_module::TestMessage2.new(:foo => 1),
|
|
proto_module::TestMessage2.new(:foo => 2)])
|
|
|
|
json_text = proto_module::TestMessage.encode_json(m)
|
|
m2 = proto_module::TestMessage.decode_json(json_text)
|
|
assert_equal m, m2
|
|
|
|
# Crash case from GitHub issue 283.
|
|
bar = proto_module::Bar.new(msg: "bar")
|
|
baz1 = proto_module::Baz.new(msg: "baz")
|
|
baz2 = proto_module::Baz.new(msg: "quux")
|
|
proto_module::Foo.encode_json(proto_module::Foo.new)
|
|
proto_module::Foo.encode_json(proto_module::Foo.new(bar: bar))
|
|
proto_module::Foo.encode_json(proto_module::Foo.new(bar: bar, baz: [baz1, baz2]))
|
|
end
|
|
|
|
def test_json_empty
|
|
assert proto_module::TestMessage.encode_json(proto_module::TestMessage.new) == '{}'
|
|
end
|
|
|
|
def test_json_emit_defaults
|
|
# TODO: Fix JSON in JRuby version.
|
|
return if RUBY_PLATFORM == "java"
|
|
m = proto_module::TestMessage.new
|
|
|
|
expected = {
|
|
repeatedInt32: [],
|
|
repeatedInt64: [],
|
|
repeatedUint32: [],
|
|
repeatedUint64: [],
|
|
repeatedBool: [],
|
|
repeatedFloat: [],
|
|
repeatedDouble: [],
|
|
repeatedString: [],
|
|
repeatedBytes: [],
|
|
repeatedMsg: [],
|
|
repeatedEnum: []
|
|
}
|
|
|
|
actual = proto_module::TestMessage.encode_json(m, :emit_defaults => true)
|
|
|
|
assert_equal expected, JSON.parse(actual, :symbolize_names => true)
|
|
end
|
|
|
|
def test_json_emit_defaults_submsg
|
|
# TODO: Fix JSON in JRuby version.
|
|
return if RUBY_PLATFORM == "java"
|
|
m = proto_module::TestMessage.new(optional_msg: proto_module::TestMessage2.new)
|
|
|
|
expected = {
|
|
optionalMsg: {},
|
|
repeatedInt32: [],
|
|
repeatedInt64: [],
|
|
repeatedUint32: [],
|
|
repeatedUint64: [],
|
|
repeatedBool: [],
|
|
repeatedFloat: [],
|
|
repeatedDouble: [],
|
|
repeatedString: [],
|
|
repeatedBytes: [],
|
|
repeatedMsg: [],
|
|
repeatedEnum: []
|
|
}
|
|
|
|
actual = proto_module::TestMessage.encode_json(m, :emit_defaults => true)
|
|
|
|
assert_equal expected, JSON.parse(actual, :symbolize_names => true)
|
|
end
|
|
|
|
def test_json_emit_defaults_repeated_submsg
|
|
# TODO: Fix JSON in JRuby version.
|
|
return if RUBY_PLATFORM == "java"
|
|
m = proto_module::TestMessage.new(repeated_msg: [proto_module::TestMessage2.new])
|
|
|
|
expected = {
|
|
repeatedInt32: [],
|
|
repeatedInt64: [],
|
|
repeatedUint32: [],
|
|
repeatedUint64: [],
|
|
repeatedBool: [],
|
|
repeatedFloat: [],
|
|
repeatedDouble: [],
|
|
repeatedString: [],
|
|
repeatedBytes: [],
|
|
repeatedMsg: [{}],
|
|
repeatedEnum: []
|
|
}
|
|
|
|
actual = proto_module::TestMessage.encode_json(m, :emit_defaults => true)
|
|
|
|
assert_equal expected, JSON.parse(actual, :symbolize_names => true)
|
|
end
|
|
|
|
def value_from_ruby(value)
|
|
ret = Google::Protobuf::Value.new
|
|
case value
|
|
when String
|
|
ret.string_value = value
|
|
when Google::Protobuf::Struct
|
|
ret.struct_value = value
|
|
when Hash
|
|
ret.struct_value = struct_from_ruby(value)
|
|
when Google::Protobuf::ListValue
|
|
ret.list_value = value
|
|
when Array
|
|
ret.list_value = list_from_ruby(value)
|
|
else
|
|
@log.error "Unknown type: #{value.class}"
|
|
raise Google::Protobuf::Error, "Unknown type: #{value.class}"
|
|
end
|
|
ret
|
|
end
|
|
|
|
def list_from_ruby(arr)
|
|
ret = Google::Protobuf::ListValue.new
|
|
arr.each do |v|
|
|
ret.values << value_from_ruby(v)
|
|
end
|
|
ret
|
|
end
|
|
|
|
def struct_from_ruby(hash)
|
|
ret = Google::Protobuf::Struct.new
|
|
hash.each do |k, v|
|
|
ret.fields[k] ||= value_from_ruby(v)
|
|
end
|
|
ret
|
|
end
|
|
|
|
def test_deep_json
|
|
# will not overflow
|
|
json = '{"a":{"a":{"a":{"a":{"a":{"a":{"a":{"a":{"a":{"a":{"a":'\
|
|
'{"a":{"a":{"a":{"a":{}}}}}}}}}}}}}}}}'
|
|
|
|
struct = struct_from_ruby(JSON.parse(json))
|
|
assert_equal json, struct.to_json
|
|
|
|
encoded = proto_module::MyRepeatedStruct.encode(
|
|
proto_module::MyRepeatedStruct.new(structs: [proto_module::MyStruct.new(struct: struct)]))
|
|
assert_equal json, proto_module::MyRepeatedStruct.decode(encoded).structs[0].struct.to_json
|
|
|
|
# will overflow
|
|
json = '{"a":{"a":{"a":[{"a":{"a":[{"a":[{"a":{"a":[{"a":[{"a":'\
|
|
'{"a":[{"a":[{"a":{"a":{"a":[{"a":"a"}]}}}]}]}}]}]}}]}]}}]}}}'
|
|
|
|
struct = struct_from_ruby(JSON.parse(json))
|
|
assert_equal json, struct.to_json
|
|
|
|
assert_raise(RuntimeError, "Maximum recursion depth exceeded during encoding") do
|
|
struct = Google::Protobuf::Struct.new
|
|
struct.fields["foobar"] = Google::Protobuf::Value.new(struct_value: struct)
|
|
Google::Protobuf::Struct.encode(struct)
|
|
end
|
|
end
|
|
|
|
def test_comparison_with_arbitrary_object
|
|
assert proto_module::TestMessage.new != nil
|
|
end
|
|
|
|
def test_wrappers_set_to_default
|
|
run_asserts = ->(m) {
|
|
assert_equal 0.0, m.double.value
|
|
assert_equal 0.0, m.float.value
|
|
assert_equal 0, m.int32.value
|
|
assert_equal 0, m.int64.value
|
|
assert_equal 0, m.uint32.value
|
|
assert_equal 0, m.uint64.value
|
|
assert_equal false, m.bool.value
|
|
assert_equal '', m.string.value
|
|
assert_equal '', m.bytes.value
|
|
}
|
|
|
|
m = proto_module::Wrapper.new(
|
|
double: Google::Protobuf::DoubleValue.new(value: 0.0),
|
|
float: Google::Protobuf::FloatValue.new(value: 0.0),
|
|
int32: Google::Protobuf::Int32Value.new(value: 0),
|
|
int64: Google::Protobuf::Int64Value.new(value: 0),
|
|
uint32: Google::Protobuf::UInt32Value.new(value: 0),
|
|
uint64: Google::Protobuf::UInt64Value.new(value: 0),
|
|
bool: Google::Protobuf::BoolValue.new(value: false),
|
|
string: Google::Protobuf::StringValue.new(value: ""),
|
|
bytes: Google::Protobuf::BytesValue.new(value: ''),
|
|
)
|
|
|
|
run_asserts.call(m)
|
|
m2 = proto_module::Wrapper.decode(m.to_proto)
|
|
run_asserts.call(m2)
|
|
m3 = proto_module::Wrapper.decode_json(m.to_json)
|
|
end
|
|
|
|
def test_wrapper_getters
|
|
run_asserts = ->(m) {
|
|
assert_equal 2.0, m.double_as_value
|
|
assert_equal 2.0, m.double.value
|
|
assert_equal 2.0, m.double_as_value
|
|
|
|
assert_equal 4.0, m.float_as_value
|
|
assert_equal 4.0, m.float.value
|
|
assert_equal 4.0, m.float_as_value
|
|
|
|
assert_equal 3, m.int32_as_value
|
|
assert_equal 3, m.int32.value
|
|
assert_equal 3, m.int32_as_value
|
|
|
|
assert_equal 4, m.int64_as_value
|
|
assert_equal 4, m.int64.value
|
|
assert_equal 4, m.int64_as_value
|
|
|
|
assert_equal 5, m.uint32_as_value
|
|
assert_equal 5, m.uint32.value
|
|
assert_equal 5, m.uint32_as_value
|
|
|
|
assert_equal 6, m.uint64_as_value
|
|
assert_equal 6, m.uint64.value
|
|
assert_equal 6, m.uint64_as_value
|
|
|
|
assert_equal true, m.bool_as_value
|
|
assert_equal true, m.bool.value
|
|
assert_equal true, m.bool_as_value
|
|
|
|
assert_equal "st\nr", m.string_as_value
|
|
assert_equal "st\nr", m.string.value
|
|
assert_equal "st\nr", m.string_as_value
|
|
|
|
assert_equal 'fun', m.bytes_as_value
|
|
assert_equal 'fun', m.bytes.value
|
|
assert_equal 'fun', m.bytes_as_value
|
|
}
|
|
|
|
m = proto_module::Wrapper.new(
|
|
double: Google::Protobuf::DoubleValue.new(value: 2.0),
|
|
float: Google::Protobuf::FloatValue.new(value: 4.0),
|
|
int32: Google::Protobuf::Int32Value.new(value: 3),
|
|
int64: Google::Protobuf::Int64Value.new(value: 4),
|
|
uint32: Google::Protobuf::UInt32Value.new(value: 5),
|
|
uint64: Google::Protobuf::UInt64Value.new(value: 6),
|
|
bool: Google::Protobuf::BoolValue.new(value: true),
|
|
string: Google::Protobuf::StringValue.new(value: "st\nr"),
|
|
bytes: Google::Protobuf::BytesValue.new(value: 'fun'),
|
|
real_string: '100'
|
|
)
|
|
|
|
run_asserts.call(m)
|
|
serialized = proto_module::Wrapper::encode(m)
|
|
m2 = proto_module::Wrapper::decode(serialized)
|
|
run_asserts.call(m2)
|
|
|
|
# Test the case where we are serializing directly from the parsed form
|
|
# (before anything lazy is materialized).
|
|
m3 = proto_module::Wrapper::decode(serialized)
|
|
serialized2 = proto_module::Wrapper::encode(m3)
|
|
m4 = proto_module::Wrapper::decode(serialized2)
|
|
run_asserts.call(m4)
|
|
|
|
# Test that the lazy form compares equal to the expanded form.
|
|
m5 = proto_module::Wrapper::decode(serialized2)
|
|
assert_equal m5, m
|
|
|
|
serialized_json = proto_module::Wrapper::encode_json(m)
|
|
m6 = proto_module::Wrapper::decode_json(serialized_json)
|
|
assert_equal m6, m
|
|
end
|
|
|
|
def test_repeated_wrappers
|
|
run_asserts = ->(m) {
|
|
assert_equal 2.0, m.repeated_double[0].value
|
|
assert_equal 4.0, m.repeated_float[0].value
|
|
assert_equal 3, m.repeated_int32[0].value
|
|
assert_equal 4, m.repeated_int64[0].value
|
|
assert_equal 5, m.repeated_uint32[0].value
|
|
assert_equal 6, m.repeated_uint64[0].value
|
|
assert_equal true, m.repeated_bool[0].value
|
|
assert_equal 'str', m.repeated_string[0].value
|
|
assert_equal 'fun', m.repeated_bytes[0].value
|
|
}
|
|
|
|
m = proto_module::Wrapper.new(
|
|
repeated_double: [Google::Protobuf::DoubleValue.new(value: 2.0)],
|
|
repeated_float: [Google::Protobuf::FloatValue.new(value: 4.0)],
|
|
repeated_int32: [Google::Protobuf::Int32Value.new(value: 3)],
|
|
repeated_int64: [Google::Protobuf::Int64Value.new(value: 4)],
|
|
repeated_uint32: [Google::Protobuf::UInt32Value.new(value: 5)],
|
|
repeated_uint64: [Google::Protobuf::UInt64Value.new(value: 6)],
|
|
repeated_bool: [Google::Protobuf::BoolValue.new(value: true)],
|
|
repeated_string: [Google::Protobuf::StringValue.new(value: 'str')],
|
|
repeated_bytes: [Google::Protobuf::BytesValue.new(value: 'fun')],
|
|
)
|
|
|
|
run_asserts.call(m)
|
|
serialized = proto_module::Wrapper::encode(m)
|
|
m2 = proto_module::Wrapper::decode(serialized)
|
|
run_asserts.call(m2)
|
|
|
|
# Test the case where we are serializing directly from the parsed form
|
|
# (before anything lazy is materialized).
|
|
m3 = proto_module::Wrapper::decode(serialized)
|
|
serialized2 = proto_module::Wrapper::encode(m3)
|
|
m4 = proto_module::Wrapper::decode(serialized2)
|
|
run_asserts.call(m4)
|
|
|
|
# Test that the lazy form compares equal to the expanded form.
|
|
m5 = proto_module::Wrapper::decode(serialized2)
|
|
assert_equal m5, m
|
|
|
|
# Test JSON.
|
|
serialized_json = proto_module::Wrapper::encode_json(m5)
|
|
m6 = proto_module::Wrapper::decode_json(serialized_json)
|
|
run_asserts.call(m6)
|
|
assert_equal m6, m
|
|
end
|
|
|
|
def test_oneof_wrappers
|
|
run_test = ->(m) {
|
|
serialized = proto_module::Wrapper::encode(m)
|
|
m2 = proto_module::Wrapper::decode(serialized)
|
|
|
|
# Encode directly from lazy form.
|
|
serialized2 = proto_module::Wrapper::encode(m2)
|
|
|
|
assert_equal m, m2
|
|
assert_equal serialized, serialized2
|
|
|
|
serialized_json = proto_module::Wrapper::encode_json(m)
|
|
m3 = proto_module::Wrapper::decode_json(serialized_json)
|
|
assert_equal m, m3
|
|
}
|
|
|
|
m = proto_module::Wrapper.new()
|
|
|
|
run_test.call(m)
|
|
m.oneof_double_as_value = 2.0
|
|
run_test.call(m)
|
|
m.oneof_float_as_value = 4.0
|
|
run_test.call(m)
|
|
m.oneof_int32_as_value = 3
|
|
run_test.call(m)
|
|
m.oneof_int64_as_value = 5
|
|
run_test.call(m)
|
|
m.oneof_uint32_as_value = 6
|
|
run_test.call(m)
|
|
m.oneof_uint64_as_value = 7
|
|
run_test.call(m)
|
|
m.oneof_string_as_value = 'str'
|
|
run_test.call(m)
|
|
m.oneof_bytes_as_value = 'fun'
|
|
run_test.call(m)
|
|
end
|
|
|
|
def test_top_level_wrappers
|
|
# We don't expect anyone to do this, but we should also make sure it does
|
|
# the right thing.
|
|
run_test = ->(klass, val) {
|
|
m = klass.new(value: val)
|
|
serialized = klass::encode(m)
|
|
m2 = klass::decode(serialized)
|
|
|
|
# Encode directly from lazy form.
|
|
serialized2 = klass::encode(m2)
|
|
|
|
assert_equal m, m2
|
|
assert_equal serialized, serialized2
|
|
|
|
serialized_json = klass::encode_json(m)
|
|
|
|
# This is nonsensical to do and does not work. There is no good reason
|
|
# to parse a wrapper type directly.
|
|
assert_raise(RuntimeError) { klass::decode_json(serialized_json) }
|
|
}
|
|
|
|
run_test.call(Google::Protobuf::DoubleValue, 2.0)
|
|
run_test.call(Google::Protobuf::FloatValue, 4.0)
|
|
run_test.call(Google::Protobuf::Int32Value, 3)
|
|
run_test.call(Google::Protobuf::Int64Value, 4)
|
|
run_test.call(Google::Protobuf::UInt32Value, 5)
|
|
run_test.call(Google::Protobuf::UInt64Value, 6)
|
|
run_test.call(Google::Protobuf::BoolValue, true)
|
|
run_test.call(Google::Protobuf::StringValue, 'str')
|
|
run_test.call(Google::Protobuf::BytesValue, 'fun')
|
|
end
|
|
|
|
def test_wrapper_setters_as_value
|
|
run_asserts = ->(m) {
|
|
m.double_as_value = 4.8
|
|
assert_equal 4.8, m.double_as_value
|
|
assert_equal Google::Protobuf::DoubleValue.new(value: 4.8), m.double
|
|
m.float_as_value = 2.4
|
|
assert_in_delta 2.4, m.float_as_value
|
|
assert_in_delta Google::Protobuf::FloatValue.new(value: 2.4).value, m.float.value
|
|
m.int32_as_value = 5
|
|
assert_equal 5, m.int32_as_value
|
|
assert_equal Google::Protobuf::Int32Value.new(value: 5), m.int32
|
|
m.int64_as_value = 15
|
|
assert_equal 15, m.int64_as_value
|
|
assert_equal Google::Protobuf::Int64Value.new(value: 15), m.int64
|
|
m.uint32_as_value = 50
|
|
assert_equal 50, m.uint32_as_value
|
|
assert_equal Google::Protobuf::UInt32Value.new(value: 50), m.uint32
|
|
m.uint64_as_value = 500
|
|
assert_equal 500, m.uint64_as_value
|
|
assert_equal Google::Protobuf::UInt64Value.new(value: 500), m.uint64
|
|
m.bool_as_value = false
|
|
assert_equal false, m.bool_as_value
|
|
assert_equal Google::Protobuf::BoolValue.new(value: false), m.bool
|
|
m.string_as_value = 'xy'
|
|
assert_equal 'xy', m.string_as_value
|
|
assert_equal Google::Protobuf::StringValue.new(value: 'xy'), m.string
|
|
m.bytes_as_value = '123'
|
|
assert_equal '123', m.bytes_as_value
|
|
assert_equal Google::Protobuf::BytesValue.new(value: '123'), m.bytes
|
|
|
|
m.double_as_value = nil
|
|
assert_nil m.double
|
|
assert_nil m.double_as_value
|
|
m.float_as_value = nil
|
|
assert_nil m.float
|
|
assert_nil m.float_as_value
|
|
m.int32_as_value = nil
|
|
assert_nil m.int32
|
|
assert_nil m.int32_as_value
|
|
m.int64_as_value = nil
|
|
assert_nil m.int64
|
|
assert_nil m.int64_as_value
|
|
m.uint32_as_value = nil
|
|
assert_nil m.uint32
|
|
assert_nil m.uint32_as_value
|
|
m.uint64_as_value = nil
|
|
assert_nil m.uint64
|
|
assert_nil m.uint64_as_value
|
|
m.bool_as_value = nil
|
|
assert_nil m.bool
|
|
assert_nil m.bool_as_value
|
|
m.string_as_value = nil
|
|
assert_nil m.string
|
|
assert_nil m.string_as_value
|
|
m.bytes_as_value = nil
|
|
assert_nil m.bytes
|
|
assert_nil m.bytes_as_value
|
|
}
|
|
|
|
m = proto_module::Wrapper.new
|
|
|
|
m2 = proto_module::Wrapper.new(
|
|
double: Google::Protobuf::DoubleValue.new(value: 2.0),
|
|
float: Google::Protobuf::FloatValue.new(value: 4.0),
|
|
int32: Google::Protobuf::Int32Value.new(value: 3),
|
|
int64: Google::Protobuf::Int64Value.new(value: 4),
|
|
uint32: Google::Protobuf::UInt32Value.new(value: 5),
|
|
uint64: Google::Protobuf::UInt64Value.new(value: 6),
|
|
bool: Google::Protobuf::BoolValue.new(value: true),
|
|
string: Google::Protobuf::StringValue.new(value: 'str'),
|
|
bytes: Google::Protobuf::BytesValue.new(value: 'fun'),
|
|
real_string: '100'
|
|
)
|
|
|
|
run_asserts.call(m2)
|
|
|
|
serialized = proto_module::Wrapper::encode(m2)
|
|
m3 = proto_module::Wrapper::decode(serialized)
|
|
run_asserts.call(m3)
|
|
end
|
|
|
|
def test_wrapper_setters
|
|
run_asserts = ->(m) {
|
|
m.double = Google::Protobuf::DoubleValue.new(value: 4.8)
|
|
assert_equal 4.8, m.double_as_value
|
|
assert_equal Google::Protobuf::DoubleValue.new(value: 4.8), m.double
|
|
m.float = Google::Protobuf::FloatValue.new(value: 2.4)
|
|
assert_in_delta 2.4, m.float_as_value
|
|
assert_in_delta Google::Protobuf::FloatValue.new(value: 2.4).value, m.float.value
|
|
m.int32 = Google::Protobuf::Int32Value.new(value: 5)
|
|
assert_equal 5, m.int32_as_value
|
|
assert_equal Google::Protobuf::Int32Value.new(value: 5), m.int32
|
|
m.int64 = Google::Protobuf::Int64Value.new(value: 15)
|
|
assert_equal 15, m.int64_as_value
|
|
assert_equal Google::Protobuf::Int64Value.new(value: 15), m.int64
|
|
m.uint32 = Google::Protobuf::UInt32Value.new(value: 50)
|
|
assert_equal 50, m.uint32_as_value
|
|
assert_equal Google::Protobuf::UInt32Value.new(value: 50), m.uint32
|
|
m.uint64 = Google::Protobuf::UInt64Value.new(value: 500)
|
|
assert_equal 500, m.uint64_as_value
|
|
assert_equal Google::Protobuf::UInt64Value.new(value: 500), m.uint64
|
|
m.bool = Google::Protobuf::BoolValue.new(value: false)
|
|
assert_equal false, m.bool_as_value
|
|
assert_equal Google::Protobuf::BoolValue.new(value: false), m.bool
|
|
m.string = Google::Protobuf::StringValue.new(value: 'xy')
|
|
assert_equal 'xy', m.string_as_value
|
|
assert_equal Google::Protobuf::StringValue.new(value: 'xy'), m.string
|
|
m.bytes = Google::Protobuf::BytesValue.new(value: '123')
|
|
assert_equal '123', m.bytes_as_value
|
|
assert_equal Google::Protobuf::BytesValue.new(value: '123'), m.bytes
|
|
|
|
m.double = nil
|
|
assert_nil m.double
|
|
assert_nil m.double_as_value
|
|
m.float = nil
|
|
assert_nil m.float
|
|
assert_nil m.float_as_value
|
|
m.int32 = nil
|
|
assert_nil m.int32
|
|
assert_nil m.int32_as_value
|
|
m.int64 = nil
|
|
assert_nil m.int64
|
|
assert_nil m.int64_as_value
|
|
m.uint32 = nil
|
|
assert_nil m.uint32
|
|
assert_nil m.uint32_as_value
|
|
m.uint64 = nil
|
|
assert_nil m.uint64
|
|
assert_nil m.uint64_as_value
|
|
m.bool = nil
|
|
assert_nil m.bool
|
|
assert_nil m.bool_as_value
|
|
m.string = nil
|
|
assert_nil m.string
|
|
assert_nil m.string_as_value
|
|
m.bytes = nil
|
|
assert_nil m.bytes
|
|
assert_nil m.bytes_as_value
|
|
}
|
|
|
|
m = proto_module::Wrapper.new
|
|
run_asserts.call(m)
|
|
|
|
m2 = proto_module::Wrapper.new(
|
|
double: Google::Protobuf::DoubleValue.new(value: 2.0),
|
|
float: Google::Protobuf::FloatValue.new(value: 4.0),
|
|
int32: Google::Protobuf::Int32Value.new(value: 3),
|
|
int64: Google::Protobuf::Int64Value.new(value: 4),
|
|
uint32: Google::Protobuf::UInt32Value.new(value: 5),
|
|
uint64: Google::Protobuf::UInt64Value.new(value: 6),
|
|
bool: Google::Protobuf::BoolValue.new(value: true),
|
|
string: Google::Protobuf::StringValue.new(value: 'str'),
|
|
bytes: Google::Protobuf::BytesValue.new(value: 'fun'),
|
|
real_string: '100'
|
|
)
|
|
|
|
run_asserts.call(m2)
|
|
|
|
serialized = proto_module::Wrapper::encode(m2)
|
|
m3 = proto_module::Wrapper::decode(serialized)
|
|
run_asserts.call(m3)
|
|
end
|
|
|
|
def test_wrappers_only
|
|
m = proto_module::Wrapper.new(real_string: 'hi', string_in_oneof: 'there')
|
|
|
|
assert_raise(NoMethodError) { m.real_string_as_value }
|
|
assert_raise(NoMethodError) { m.as_value }
|
|
assert_raise(NoMethodError) { m._as_value }
|
|
assert_raise(NoMethodError) { m.string_in_oneof_as_value }
|
|
|
|
m = proto_module::Wrapper.new
|
|
m.string_as_value = 'you'
|
|
assert_equal 'you', m.string.value
|
|
assert_equal 'you', m.string_as_value
|
|
assert_raise(NoMethodError) { m.string_ }
|
|
assert_raise(NoMethodError) { m.string_X }
|
|
assert_raise(NoMethodError) { m.string_XX }
|
|
assert_raise(NoMethodError) { m.string_XXX }
|
|
assert_raise(NoMethodError) { m.string_XXXX }
|
|
assert_raise(NoMethodError) { m.string_XXXXX }
|
|
assert_raise(NoMethodError) { m.string_XXXXXX }
|
|
assert_raise(NoMethodError) { m.string_XXXXXXX }
|
|
assert_raise(NoMethodError) { m.string_XXXXXXXX }
|
|
assert_raise(NoMethodError) { m.string_XXXXXXXXX }
|
|
assert_raise(NoMethodError) { m.string_XXXXXXXXXX }
|
|
end
|
|
|
|
def test_converts_time
|
|
m = proto_module::TimeMessage.new
|
|
|
|
m.timestamp = Google::Protobuf::Timestamp.new(seconds: 5, nanos: 6)
|
|
assert_kind_of Google::Protobuf::Timestamp, m.timestamp
|
|
assert_equal 5, m.timestamp.seconds
|
|
assert_equal 6, m.timestamp.nanos
|
|
|
|
m.timestamp = Time.at(9466, 123456.789)
|
|
assert_equal Google::Protobuf::Timestamp.new(seconds: 9466, nanos: 123456789), m.timestamp
|
|
|
|
m = proto_module::TimeMessage.new(timestamp: Time.at(1))
|
|
assert_equal Google::Protobuf::Timestamp.new(seconds: 1, nanos: 0), m.timestamp
|
|
|
|
assert_raise(Google::Protobuf::TypeError) { m.timestamp = 2 }
|
|
assert_raise(Google::Protobuf::TypeError) { m.timestamp = 2.4 }
|
|
assert_raise(Google::Protobuf::TypeError) { m.timestamp = '4' }
|
|
assert_raise(Google::Protobuf::TypeError) { m.timestamp = proto_module::TimeMessage.new }
|
|
|
|
def test_time(year, month, day)
|
|
str = ("\"%04d-%02d-%02dT00:00:00.000+00:00\"" % [year, month, day])
|
|
t = Google::Protobuf::Timestamp.decode_json(str)
|
|
time = Time.new(year, month, day, 0, 0, 0, "+00:00")
|
|
assert_equal t.seconds, time.to_i
|
|
end
|
|
|
|
(1970..2010).each do |year|
|
|
test_time(year, 2, 28)
|
|
test_time(year, 3, 01)
|
|
end
|
|
end
|
|
|
|
def test_converts_duration
|
|
m = proto_module::TimeMessage.new
|
|
|
|
m.duration = Google::Protobuf::Duration.new(seconds: 2, nanos: 22)
|
|
assert_kind_of Google::Protobuf::Duration, m.duration
|
|
assert_equal 2, m.duration.seconds
|
|
assert_equal 22, m.duration.nanos
|
|
|
|
m.duration = 10.5
|
|
assert_equal Google::Protobuf::Duration.new(seconds: 10, nanos: 500_000_000), m.duration
|
|
|
|
m.duration = 200
|
|
assert_equal Google::Protobuf::Duration.new(seconds: 200, nanos: 0), m.duration
|
|
|
|
m.duration = Rational(3, 2)
|
|
assert_equal Google::Protobuf::Duration.new(seconds: 1, nanos: 500_000_000), m.duration
|
|
|
|
m.duration = BigDecimal("5")
|
|
assert_equal Google::Protobuf::Duration.new(seconds: 5, nanos: 0), m.duration
|
|
|
|
m = proto_module::TimeMessage.new(duration: 1.1)
|
|
assert_equal Google::Protobuf::Duration.new(seconds: 1, nanos: 100_000_000), m.duration
|
|
|
|
m = proto_module::TimeMessage.new(duration: 123.321)
|
|
assert_equal Google::Protobuf::Duration.new(seconds: 123, nanos: 321_000_000), m.duration
|
|
|
|
m = proto_module::TimeMessage.new(duration: -123.321)
|
|
assert_equal Google::Protobuf::Duration.new(seconds: -123, nanos: -321_000_000), m.duration
|
|
|
|
assert_raise(Google::Protobuf::TypeError) { m.duration = '2' }
|
|
assert_raise(Google::Protobuf::TypeError) { m.duration = proto_module::TimeMessage.new }
|
|
end
|
|
|
|
def test_freeze
|
|
m = proto_module::TestMessage.new
|
|
m.optional_int32 = 10
|
|
m.freeze
|
|
|
|
frozen_error = assert_raise(FrozenErrorType) { m.optional_int32 = 20 }
|
|
assert_match "can't modify frozen #{proto_module}::TestMessage", frozen_error.message
|
|
assert_equal 10, m.optional_int32
|
|
assert_equal true, m.frozen?
|
|
|
|
assert_raise(FrozenErrorType) { m.optional_int64 = 2 }
|
|
assert_raise(FrozenErrorType) { m.optional_uint32 = 3 }
|
|
assert_raise(FrozenErrorType) { m.optional_uint64 = 4 }
|
|
assert_raise(FrozenErrorType) { m.optional_bool = true }
|
|
assert_raise(FrozenErrorType) { m.optional_float = 6.0 }
|
|
assert_raise(FrozenErrorType) { m.optional_double = 7.0 }
|
|
assert_raise(FrozenErrorType) { m.optional_string = '8' }
|
|
assert_raise(FrozenErrorType) { m.optional_bytes = nil }
|
|
assert_raise(FrozenErrorType) { m.optional_msg = proto_module::TestMessage2.new }
|
|
assert_raise(FrozenErrorType) { m.optional_enum = :A }
|
|
assert_raise(FrozenErrorType) { m.repeated_int32 = 1 }
|
|
assert_raise(FrozenErrorType) { m.repeated_int64 = 2 }
|
|
assert_raise(FrozenErrorType) { m.repeated_uint32 = 3 }
|
|
assert_raise(FrozenErrorType) { m.repeated_uint64 = 4 }
|
|
assert_raise(FrozenErrorType) { m.repeated_bool = true }
|
|
assert_raise(FrozenErrorType) { m.repeated_float = 6.0 }
|
|
assert_raise(FrozenErrorType) { m.repeated_double = 7.0 }
|
|
assert_raise(FrozenErrorType) { m.repeated_string = '8' }
|
|
assert_raise(FrozenErrorType) { m.repeated_bytes = nil }
|
|
assert_raise(FrozenErrorType) { m.repeated_msg = proto_module::TestMessage2.new }
|
|
assert_raise(FrozenErrorType) { m.repeated_enum = :A }
|
|
end
|
|
|
|
def test_eq
|
|
m1 = proto_module::TestMessage.new(:optional_string => 'foo', :repeated_string => ['bar1', 'bar2'])
|
|
m2 = proto_module::TestMessage.new(:optional_string => 'foo', :repeated_string => ['bar1', 'bar2'])
|
|
|
|
h = {}
|
|
h[m1] = :yes
|
|
|
|
assert m1 == m2
|
|
assert m1.eql?(m2)
|
|
assert m1.hash == m2.hash
|
|
assert h[m1] == :yes
|
|
assert h[m2] == :yes
|
|
|
|
m1.optional_int32 = 2
|
|
|
|
assert m1 != m2
|
|
assert !m1.eql?(m2)
|
|
assert m1.hash != m2.hash
|
|
assert_nil h[m2]
|
|
end
|
|
|
|
def test_object_gc
|
|
m = proto_module::TestMessage.new(optional_msg: proto_module::TestMessage2.new)
|
|
m.optional_msg
|
|
GC.start(full_mark: true, immediate_sweep: true)
|
|
m.optional_msg.inspect
|
|
end
|
|
|
|
def test_object_gc_freeze
|
|
m = proto_module::TestMessage.new
|
|
m.repeated_float.freeze
|
|
GC.start(full_mark: true)
|
|
|
|
# Make sure we remember that the object is frozen.
|
|
# The wrapper object contains this information, so we need to ensure that
|
|
# the previous GC did not collect it.
|
|
assert m.repeated_float.frozen?
|
|
|
|
GC.start(full_mark: true, immediate_sweep: true)
|
|
assert m.repeated_float.frozen?
|
|
end
|
|
end
|