Chiebot-Mirror
/
protobuf
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Bulk update to use `assert_*` methods wherever possible. (#13156)

Browse Source 
Influenced by https://minitest.rubystyle.guide/

Closes #13156

COPYBARA_INTEGRATE_REVIEW=https://github.com/protocolbuffers/protobuf/pull/13156 from JasonLunn:flakes-fix 503d3c7745
PiperOrigin-RevId: 544234585
pull/13159/head
Jason Lunn 2 years ago committed by Copybara-Service
parent c108278083
commit 15b215f30b
12 changed files with 1020 additions and 1219 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 11
      ruby/README.md
  2. 769
      ruby/compatibility_tests/v3.0.0/tests/basic.rb
  3. 24
      ruby/compatibility_tests/v3.0.0/tests/repeated_field_test.rb
  4. 4
      ruby/compatibility_tests/v3.0.0/tests/stress.rb
  5. 69
      ruby/tests/BUILD.bazel
  6. 195
      ruby/tests/basic.rb
  7. 143
      ruby/tests/basic_proto2.rb
  8. 892
      ruby/tests/common_tests.rb
  9. 23
      ruby/tests/encode_decode_test.rb
  10. 32
      ruby/tests/repeated_field_test.rb
  11. 2
      ruby/tests/stress.rb
  12. 75
      ruby/tests/well_known_types_test.rb

11
ruby/README.md
Unescape View File

@ -43,8 +43,7 @@ mymessage.field3 = SubMessage.new(:foo => 100)
encoded_data = MyTestMessage.encode(mymessage)
decoded = MyTestMessage.decode(encoded_data)
assert decoded == mymessage
assert_equal mymessage, decoded
puts "JSON:"
puts MyTestMessage.encode_json(mymessage)
```
@ -86,6 +85,14 @@ This gem includes the upb parsing and serialization library as a single-file
amalgamation. It is up-to-date with upb git commit
`535bc2fe2f2b467f59347ffc9449e11e47791257`.
Alternatively, you can use Bazel to build and to run tests.
From the project root (rather than the `ruby` directory):
```
$ bazel test //ruby/tests/...
```
Version Number Scheme
---------------------

769
ruby/compatibility_tests/v3.0.0/tests/basic.rb
View File

File diff suppressed because it is too large Load Diff

24
ruby/compatibility_tests/v3.0.0/tests/repeated_field_test.rb
Unescape View File

@ -8,7 +8,7 @@ class RepeatedFieldTest < Test::Unit::TestCase
def test_acts_like_enumerator
m = TestMessage.new
(Enumerable.instance_methods - TestMessage.new.repeated_string.methods).each do |method_name|
assert m.repeated_string.respond_to?(method_name) == true, "does not respond to #{method_name}"
assert_equal "does not respond to #{method_name}", m.repeated_string.respond_to?(method_name), true
end
end
@ -23,7 +23,7 @@ class RepeatedFieldTest < Test::Unit::TestCase
arr_methods -= [:intersection, :deconstruct] # ruby 2.7 methods we can ignore
arr_methods -= [:intersect?] # ruby 3.1 methods we can ignore
arr_methods.each do |method_name|
assert m.repeated_string.respond_to?(method_name) == true, "does not respond to #{method_name}"
assert_respond_to m.repeated_string, method_name
end
end
@ -37,7 +37,7 @@ class RepeatedFieldTest < Test::Unit::TestCase
assert_equal -1_000_000, m.repeated_int64.first
assert_equal 10, m.repeated_uint32.first
assert_equal 1_000_000, m.repeated_uint64.first
assert_equal true, m.repeated_bool.first
assert m.repeated_bool.first
assert_equal -1.01, m.repeated_float.first.round(2)
assert_equal -1.0000000000001, m.repeated_double.first
assert_equal 'foo', m.repeated_string.first
@ -57,7 +57,7 @@ class RepeatedFieldTest < Test::Unit::TestCase
assert_equal -1_000_001, m.repeated_int64.last
assert_equal 11, m.repeated_uint32.last
assert_equal 1_000_001, m.repeated_uint64.last
assert_equal false, m.repeated_bool.last
refute m.repeated_bool.last
assert_equal -1.02, m.repeated_float.last.round(2)
assert_equal -1.0000000000002, m.repeated_double.last
assert_equal 'bar', m.repeated_string.last
@ -82,8 +82,8 @@ class RepeatedFieldTest < Test::Unit::TestCase
assert_equal 10, m.repeated_uint32.pop
assert_equal 1_000_001, m.repeated_uint64.pop
assert_equal 1_000_000, m.repeated_uint64.pop
assert_equal false, m.repeated_bool.pop
assert_equal true, m.repeated_bool.pop
refute m.repeated_bool.pop
assert m.repeated_bool.pop
assert_equal -1.02, m.repeated_float.pop.round(2)
assert_equal -1.01, m.repeated_float.pop.round(2)
assert_equal -1.0000000000002, m.repeated_double.pop
@ -122,11 +122,11 @@ class RepeatedFieldTest < Test::Unit::TestCase
def test_empty?
m = TestMessage.new
assert_equal true, m.repeated_string.empty?
assert_empty m.repeated_string
m.repeated_string << 'foo'
assert_equal false, m.repeated_string.empty?
refute_empty m.repeated_string
m.repeated_string << 'bar'
assert_equal false, m.repeated_string.empty?
refute_empty m.repeated_string
end
def test_array_accessor
@ -252,7 +252,7 @@ class RepeatedFieldTest < Test::Unit::TestCase
m.repeated_string += reference_arr.clone
assert_equal reference_arr, m.repeated_string
reference_arr << 'fizz'
assert_not_equal reference_arr, m.repeated_string
refute_equal reference_arr, m.repeated_string
m.repeated_string << 'fizz'
assert_equal reference_arr, m.repeated_string
end
@ -266,7 +266,7 @@ class RepeatedFieldTest < Test::Unit::TestCase
hash = m.repeated_string.hash
assert_equal hash, m.repeated_string.hash
m.repeated_string << 'j'
assert_not_equal hash, m.repeated_string.hash
refute_equal hash, m.repeated_string.hash
end
def test_plus
@ -469,7 +469,7 @@ class RepeatedFieldTest < Test::Unit::TestCase
result = m.repeated_string.shuffle!
assert_equal m.repeated_string, result
# NOTE: sometimes it doesn't change the order...
# assert_not_equal m.repeated_string.to_a, orig_repeated_string.to_a
# refute_equal m.repeated_string.to_a, orig_repeated_string.to_a
end
def test_slice!

4
ruby/compatibility_tests/v3.0.0/tests/stress.rb
Unescape View File

@ -30,8 +30,8 @@ module StressTest
100_000.times do
mnew = TestMessage.decode(data)
mnew = mnew.dup
assert_equal mnew.inspect, m.inspect
assert TestMessage.encode(mnew) == data
assert_equal m.inspect, mnew.inspect
assert_equal data, TestMessage.encode(mnew)
end
end
end

69
ruby/tests/BUILD.bazel
Unescape View File

@ -7,121 +7,123 @@ ruby_library(
)
filegroup(
name = "test_protos",
srcs = glob(["*.proto"]),
visibility = [
"//ruby:__subpackages__",
],
name = "test_protos",
srcs = glob(["*.proto"]),
visibility = [
"//ruby:__subpackages__",
],
)
ruby_test(
name = "basic",
srcs = ["basic.rb"],
deps = [
":common_tests",
"//ruby:protobuf",
"//ruby:test_ruby_protos",
"@protobuf_bundle//:test-unit"
"@protobuf_bundle//:test-unit",
],
srcs = ["basic.rb"],
)
ruby_test(
name = "basic_proto2",
srcs = ["basic_proto2.rb"],
deps = [
":common_tests",
"//ruby:protobuf",
"//ruby:test_ruby_protos",
"@protobuf_bundle//:test-unit"
"@protobuf_bundle//:test-unit",
],
srcs = ["basic_proto2.rb"],
)
ruby_test(
name = "encode_decode_test",
srcs = ["encode_decode_test.rb"],
deps = [
":common_tests",
"//ruby:protobuf",
"//ruby:test_ruby_protos",
"@protobuf_bundle//:test-unit"
"@protobuf_bundle//:test-unit",
],
srcs = ["encode_decode_test.rb"],
)
ruby_test(
name = "gc_test",
srcs = ["gc_test.rb"],
deps = [
":common_tests",
"//ruby:protobuf",
"//ruby:test_ruby_protos",
"@protobuf_bundle//:test-unit"
"@protobuf_bundle//:test-unit",
],
srcs = ["gc_test.rb"],
)
ruby_test(
name = "generated_code_test",
srcs = ["generated_code_test.rb"],
deps = [
":common_tests",
"//ruby:protobuf",
"//ruby:test_ruby_protos",
"@protobuf_bundle//:test-unit"
"@protobuf_bundle//:test-unit",
],
srcs = ["generated_code_test.rb"],
)
ruby_test(
name = "multi_level_nesting_test",
srcs = ["multi_level_nesting_test.rb"],
deps = [
":common_tests",
"//ruby:protobuf",
"//ruby:test_ruby_protos",
"@protobuf_bundle//:test-unit"
"@protobuf_bundle//:test-unit",
],
srcs = ["multi_level_nesting_test.rb"],
)
ruby_test(
name = "repeated_field_test",
srcs = ["repeated_field_test.rb"],
deps = [
":common_tests",
"//ruby:protobuf",
"//ruby:test_ruby_protos",
"@protobuf_bundle//:test-unit"
"@protobuf_bundle//:test-unit",
],
srcs = ["repeated_field_test.rb"],
)
ruby_test(
name = "ruby_version",
srcs = ["ruby_version.rb"],
deps = [
":common_tests",
"//ruby:protobuf",
"//ruby:test_ruby_protos",
"@protobuf_bundle//:test-unit"
"@protobuf_bundle//:test-unit",
],
srcs = ["ruby_version.rb"],
)
ruby_test(
name = "stress",
srcs = ["stress.rb"],
deps = [
":common_tests",
"//ruby:protobuf",
"//ruby:test_ruby_protos",
"@protobuf_bundle//:test-unit"
"@protobuf_bundle//:test-unit",
],
srcs = ["stress.rb"],
)
ruby_test(
name = "type_errors",
srcs = ["type_errors.rb"],
deps = [
":common_tests",
"//ruby:protobuf",
"//ruby:test_ruby_protos",
"@protobuf_bundle//:test-unit"
"@protobuf_bundle//:test-unit",
],
)
ruby_test(
name = "well_known_types_test",
srcs = ["well_known_types_test.rb"],
deps = [
"//ruby:protobuf",
"//ruby:test_ruby_protos",
"@protobuf_bundle//:test-unit",
],
srcs = ["type_errors.rb"],
)
pkg_files(
@ -135,4 +137,3 @@ pkg_files(
strip_prefix = strip_prefix.from_root(""),
visibility = ["//ruby:__pkg__"],
)

195
ruby/tests/basic.rb
Unescape View File

@ -56,7 +56,7 @@ module BasicTest
inners: []
)['inners'].to_s
assert_raise Google::Protobuf::TypeError do
assert_raises Google::Protobuf::TypeError do
outer.new(
inners: [nil]
).to_s
@ -112,46 +112,46 @@ module BasicTest
def test_has_field
m = TestSingularFields.new
assert !m.has_singular_msg?
refute m.has_singular_msg?
m.singular_msg = TestMessage2.new
assert m.has_singular_msg?
assert TestSingularFields.descriptor.lookup('singular_msg').has?(m)
m = OneofMessage.new
assert !m.has_my_oneof?
assert !m.has_a?
refute m.has_my_oneof?
refute m.has_a?
m.a = "foo"
assert m.has_my_oneof?
assert m.has_a?
assert_true OneofMessage.descriptor.lookup('a').has?(m)
m = TestSingularFields.new
assert_raise NoMethodError do
assert_raises NoMethodError do
m.has_singular_int32?
end
assert_raise ArgumentError do
assert_raises ArgumentError do
TestSingularFields.descriptor.lookup('singular_int32').has?(m)
end
assert_raise NoMethodError do
assert_raises NoMethodError do
m.has_singular_string?
end
assert_raise ArgumentError do
assert_raises ArgumentError do
TestSingularFields.descriptor.lookup('singular_string').has?(m)
end
assert_raise NoMethodError do
assert_raises NoMethodError do
m.has_singular_bool?
end
assert_raise ArgumentError do
assert_raises ArgumentError do
TestSingularFields.descriptor.lookup('singular_bool').has?(m)
end
m = TestMessage.new
assert_raise NoMethodError do
assert_raises NoMethodError do
m.has_repeated_msg?
end
assert_raise ArgumentError do
assert_raises ArgumentError do
TestMessage.descriptor.lookup('repeated_msg').has?(m)
end
end
@ -161,14 +161,12 @@ module BasicTest
# Explicitly setting to zero does not cause anything to be serialized.
m.singular_int32 = 0
assert_equal "", TestSingularFields.encode(m)
assert_empty TestSingularFields.encode(m)
# Explicitly setting to a non-zero value *does* cause serialization.
m.singular_int32 = 1
assert_not_equal "", TestSingularFields.encode(m)
refute_empty TestSingularFields.encode(m)
m.singular_int32 = 0
assert_equal "", TestSingularFields.encode(m)
assert_empty TestSingularFields.encode(m)
end
def test_set_clear_defaults
@ -187,35 +185,33 @@ module BasicTest
m.singular_string = "foo bar"
assert_equal "foo bar", m.singular_string
m.clear_singular_string
assert_equal "", m.singular_string
assert_empty m.singular_string
m.singular_string = "foo"
assert_equal "foo", m.singular_string
TestSingularFields.descriptor.lookup('singular_string').clear(m)
assert_equal "", m.singular_string
assert_empty m.singular_string
m.singular_msg = TestMessage2.new(:foo => 42)
assert_equal TestMessage2.new(:foo => 42), m.singular_msg
assert m.has_singular_msg?
m.clear_singular_msg
assert_equal nil, m.singular_msg
assert !m.has_singular_msg?
assert_nil m.singular_msg
refute m.has_singular_msg?
m.singular_msg = TestMessage2.new(:foo => 42)
assert_equal TestMessage2.new(:foo => 42), m.singular_msg
TestSingularFields.descriptor.lookup('singular_msg').clear(m)
assert_equal nil, m.singular_msg
assert_nil m.singular_msg
end
def test_import_proto2
m = TestMessage.new
assert !m.has_optional_proto2_submessage?
refute m.has_optional_proto2_submessage?
m.optional_proto2_submessage = ::FooBar::Proto2::TestImportedMessage.new
assert m.has_optional_proto2_submessage?
assert TestMessage.descriptor.lookup('optional_proto2_submessage').has?(m)
m.clear_optional_proto2_submessage
assert !m.has_optional_proto2_submessage?
refute m.has_optional_proto2_submessage?
end
def test_clear_repeated_fields
@ -224,96 +220,90 @@ module BasicTest
m.repeated_int32.push(1)
assert_equal [1], m.repeated_int32
m.clear_repeated_int32
assert_equal [], m.repeated_int32
assert_empty m.repeated_int32
m.repeated_int32.push(1)
assert_equal [1], m.repeated_int32
TestMessage.descriptor.lookup('repeated_int32').clear(m)
assert_equal [], m.repeated_int32
assert_empty m.repeated_int32
m = OneofMessage.new
m.a = "foo"
assert_equal "foo", m.a
assert m.has_my_oneof?
assert_equal :a, m.my_oneof
m.clear_a
assert !m.has_my_oneof?
refute m.has_my_oneof?
m.a = "foobar"
assert m.has_my_oneof?
m.clear_my_oneof
assert !m.has_my_oneof?
refute m.has_my_oneof?
m.a = "bar"
assert_equal "bar", m.a
assert m.has_my_oneof?
OneofMessage.descriptor.lookup('a').clear(m)
assert !m.has_my_oneof?
refute m.has_my_oneof?
end
def test_initialization_map_errors
e = assert_raise ArgumentError do
e = assert_raises ArgumentError do
TestMessage.new(:hello => "world")
end
assert_match(/hello/, e.message)
e = assert_raise ArgumentError do
e = assert_raises ArgumentError do
MapMessage.new(:map_string_int32 => "hello")
end
assert_equal e.message, "Expected Hash object as initializer value for map field 'map_string_int32' (given String)."
e = assert_raise ArgumentError do
assert_equal "Expected Hash object as initializer value for map field 'map_string_int32' (given String).", e.message
e = assert_raises ArgumentError do
TestMessage.new(:repeated_uint32 => "hello")
end
assert_equal e.message, "Expected array as initializer value for repeated field 'repeated_uint32' (given String)."
assert_equal "Expected array as initializer value for repeated field 'repeated_uint32' (given String).", e.message
end
def test_map_field
m = MapMessage.new
assert m.map_string_int32 == {}
assert m.map_string_msg == {}
assert_empty m.map_string_int32.to_h
assert_empty m.map_string_msg.to_h
m = MapMessage.new(
:map_string_int32 => {"a" => 1, "b" => 2},
:map_string_msg => {"a" => TestMessage2.new(:foo => 1),
"b" => TestMessage2.new(:foo => 2)},
:map_string_enum => {"a" => :A, "b" => :B})
assert m.map_string_int32.keys.sort == ["a", "b"]
assert m.map_string_int32["a"] == 1
assert m.map_string_msg["b"].foo == 2
assert m.map_string_enum["a"] == :A
assert_equal ["a", "b"], m.map_string_int32.keys.sort
assert_equal 1, m.map_string_int32["a"]
assert_equal 2, m.map_string_msg["b"].foo
assert_equal :A, m.map_string_enum["a"]
m.map_string_int32["c"] = 3
assert m.map_string_int32["c"] == 3
assert_equal 3, m.map_string_int32["c"]
m.map_string_msg["c"] = TestMessage2.new(:foo => 3)
assert m.map_string_msg["c"] == TestMessage2.new(:foo => 3)
assert_equal TestMessage2.new(:foo => 3), m.map_string_msg["c"]
m.map_string_msg.delete("b")
m.map_string_msg.delete("c")
assert m.map_string_msg == { "a" => TestMessage2.new(:foo => 1) }
assert_raise Google::Protobuf::TypeError do
assert_equal({ "a" => TestMessage2.new(:foo => 1).to_h }, m.map_string_msg.to_h)
assert_raises Google::Protobuf::TypeError do
m.map_string_msg["e"] = TestMessage.new # wrong value type
end
# ensure nothing was added by the above
assert m.map_string_msg == { "a" => TestMessage2.new(:foo => 1) }
assert_equal({ "a" => TestMessage2.new(:foo => 1).to_h }, m.map_string_msg.to_h)
m.map_string_int32 = Google::Protobuf::Map.new(:string, :int32)
assert_raise Google::Protobuf::TypeError do
assert_raises Google::Protobuf::TypeError do
m.map_string_int32 = Google::Protobuf::Map.new(:string, :int64)
end
assert_raise Google::Protobuf::TypeError do
assert_raises Google::Protobuf::TypeError do
m.map_string_int32 = {}
end
assert_raise Google::Protobuf::TypeError do
assert_raises Google::Protobuf::TypeError do
m = MapMessage.new(:map_string_int32 => { 1 => "I am not a number" })
end
end
def test_map_field_with_symbol
m = MapMessage.new
assert m.map_string_int32 == {}
assert m.map_string_msg == {}
assert_empty m.map_string_int32.to_h
assert_empty m.map_string_msg.to_h
m = MapMessage.new(
:map_string_int32 => {a: 1, "b" => 2},
@ -335,7 +325,7 @@ module BasicTest
expected_a = "<BasicTest::MapMessage: map_string_int32: {\"b\"=>2, \"a\"=>1}, map_string_msg: {\"b\"=><BasicTest::TestMessage2: foo: 2>, \"a\"=><BasicTest::TestMessage2: foo: 1>}, map_string_enum: {\"b\"=>:B, \"a\"=>:A}>"
expected_b = "<BasicTest::MapMessage: map_string_int32: {\"a\"=>1, \"b\"=>2}, map_string_msg: {\"a\"=><BasicTest::TestMessage2: foo: 1>, \"b\"=><BasicTest::TestMessage2: foo: 2>}, map_string_enum: {\"a\"=>:A, \"b\"=>:B}>"
inspect_result = m.inspect
assert expected_a == inspect_result || expected_b == inspect_result, "Incorrect inspect result: #{inspect_result}"
assert_includes [expected_a, expected_b], inspect_result
end
def test_map_corruption
@ -353,7 +343,7 @@ module BasicTest
assert_equal 4, m.map_int64[0].value
assert_equal 5, m.map_uint32[0].value
assert_equal 6, m.map_uint64[0].value
assert_equal true, m.map_bool[0].value
assert m.map_bool[0].value
assert_equal 'str', m.map_string[0].value
assert_equal 'fun', m.map_bytes[0].value
}
@ -395,9 +385,9 @@ module BasicTest
assert_equal 0, m.map_int64[0].value
assert_equal 0, m.map_uint32[0].value
assert_equal 0, m.map_uint64[0].value
assert_equal false, m.map_bool[0].value
assert_equal '', m.map_string[0].value
assert_equal '', m.map_bytes[0].value
refute m.map_bool[0].value
assert_empty m.map_string[0].value
assert_empty m.map_bytes[0].value
}
m = proto_module::Wrapper.new(
@ -437,9 +427,9 @@ module BasicTest
assert_equal 0, m.map_int64[0].value
assert_equal 0, m.map_uint32[0].value
assert_equal 0, m.map_uint64[0].value
assert_equal false, m.map_bool[0].value
assert_equal '', m.map_string[0].value
assert_equal '', m.map_bytes[0].value
refute m.map_bool[0].value
assert_empty m.map_string[0].value
assert_empty m.map_bytes[0].value
}
m = proto_module::Wrapper.new(
@ -489,19 +479,16 @@ module BasicTest
"b" => TestMessage2.new(:foo => 2)},
:map_string_enum => {"a" => :A, "b" => :B})
m2 = MapMessage.decode(MapMessage.encode(m))
assert m == m2
assert_equal m, m2
m3 = MapMessageWireEquiv.decode(MapMessage.encode(m))
assert m3.map_string_int32.length == 2
assert_equal 2, m3.map_string_int32.length
kv = {}
m3.map_string_int32.map { |msg| kv[msg.key] = msg.value }
assert kv == {"a" => 1, "b" => 2}
assert_equal({"a" => 1, "b" => 2}, kv)
kv = {}
m3.map_string_msg.map { |msg| kv[msg.key] = msg.value }
assert kv == {"a" => TestMessage2.new(:foo => 1),
"b" => TestMessage2.new(:foo => 2)}
assert_equal({"a" => TestMessage2.new(:foo => 1),
"b" => TestMessage2.new(:foo => 2)}, kv)
end
def test_protobuf_decode_json_ignore_unknown_fields
@ -510,8 +497,8 @@ module BasicTest
not_in_message: "some_value"
}.to_json, { ignore_unknown_fields: true })
assert_equal m.optional_string, "foo"
e = assert_raise Google::Protobuf::ParseError do
assert_equal "foo", m.optional_string
e = assert_raises Google::Protobuf::ParseError do
TestMessage.decode_json({ not_in_message: "some_value" }.to_json)
end
assert_match(/No such field: not_in_message/, e.message)
@ -573,10 +560,10 @@ module BasicTest
m = MapMessage.new(:map_string_int32 => {"a" => 1})
expected = {mapStringInt32: {a: 1}, mapStringMsg: {}, mapStringEnum: {}}
expected_preserve = {map_string_int32: {a: 1}, map_string_msg: {}, map_string_enum: {}}
assert_equal JSON.parse(MapMessage.encode_json(m, :emit_defaults=>true), :symbolize_names => true), expected
assert_equal expected, JSON.parse(MapMessage.encode_json(m, :emit_defaults=>true), :symbolize_names => true)
json = MapMessage.encode_json(m, :preserve_proto_fieldnames => true, :emit_defaults=>true)
assert_equal JSON.parse(json, :symbolize_names => true), expected_preserve
assert_equal expected_preserve, JSON.parse(json, :symbolize_names => true)
m2 = MapMessage.decode_json(MapMessage.encode_json(m))
assert_equal m, m2
@ -588,7 +575,7 @@ module BasicTest
actual = MapMessage.encode_json(m, :emit_defaults => true)
assert_equal JSON.parse(actual, :symbolize_names => true), expected
assert_equal expected, JSON.parse(actual, :symbolize_names => true)
end
def test_json_emit_defaults_submsg
@ -615,18 +602,18 @@ module BasicTest
def test_respond_to
msg = MapMessage.new
assert msg.respond_to?(:map_string_int32)
assert !msg.respond_to?(:bacon)
assert_respond_to msg, :map_string_int32
refute_respond_to msg, :bacon
end
def test_file_descriptor
file_descriptor = TestMessage.descriptor.file_descriptor
assert nil != file_descriptor
refute_nil file_descriptor
assert_equal "tests/basic_test.proto", file_descriptor.name
assert_equal :proto3, file_descriptor.syntax
file_descriptor = TestEnum.descriptor.file_descriptor
assert nil != file_descriptor
refute_nil file_descriptor
assert_equal "tests/basic_test.proto", file_descriptor.name
assert_equal :proto3, file_descriptor.syntax
end
@ -645,10 +632,10 @@ module BasicTest
assert m.map_string_int32.frozen?
assert m.map_string_msg.frozen?
assert_raise(FrozenErrorType) { m.map_string_int32['foo'] = 1 }
assert_raise(FrozenErrorType) { m.map_string_msg['bar'] = proto_module::TestMessage2.new }
assert_raise(FrozenErrorType) { m.map_string_int32.delete('a') }
assert_raise(FrozenErrorType) { m.map_string_int32.clear }
assert_raises(FrozenErrorType) { m.map_string_int32['foo'] = 1 }
assert_raises(FrozenErrorType) { m.map_string_msg['bar'] = proto_module::TestMessage2.new }
assert_raises(FrozenErrorType) { m.map_string_int32.delete('a') }
assert_raises(FrozenErrorType) { m.map_string_int32.clear }
end
def test_map_length
@ -691,23 +678,23 @@ module BasicTest
def test_map_fields_respond_to? # regression test for issue 9202
msg = proto_module::MapMessage.new
assert msg.respond_to?(:map_string_int32=)
assert_respond_to msg, :map_string_int32=
msg.map_string_int32 = Google::Protobuf::Map.new(:string, :int32)
assert msg.respond_to?(:map_string_int32)
assert_respond_to msg, :map_string_int32
assert_equal( Google::Protobuf::Map.new(:string, :int32), msg.map_string_int32 )
assert msg.respond_to?(:clear_map_string_int32)
assert_respond_to msg, :clear_map_string_int32
msg.clear_map_string_int32
assert !msg.respond_to?(:has_map_string_int32?)
assert_raise NoMethodError do
refute_respond_to msg, :has_map_string_int32?
assert_raises NoMethodError do
msg.has_map_string_int32?
end
assert !msg.respond_to?(:map_string_int32_as_value)
assert_raise NoMethodError do
refute_respond_to msg, :map_string_int32_as_value
assert_raises NoMethodError do
msg.map_string_int32_as_value
end
assert !msg.respond_to?(:map_string_int32_as_value=)
assert_raise NoMethodError do
refute_respond_to msg, :map_string_int32_as_value=
assert_raises NoMethodError do
msg.map_string_int32_as_value = :boom
end
end
@ -718,13 +705,13 @@ module BasicTest
# `has_` prefix + "?" suffix actions should work for oneofs fields and members.
assert msg.has_my_oneof?
assert msg.respond_to? :has_my_oneof?
assert msg.respond_to?( :has_a? )
assert !msg.has_a?
assert msg.respond_to?( :has_b? )
assert !msg.has_b?
assert msg.respond_to?( :has_c? )
assert !msg.has_c?
assert msg.respond_to?( :has_d? )
assert !msg.has_d?
assert_respond_to msg, :has_a?
refute msg.has_a?
assert_respond_to msg, :has_b?
refute msg.has_b?
assert_respond_to msg, :has_c?
refute msg.has_c?
assert_respond_to msg, :has_d?
refute msg.has_d?
end
end

143
ruby/tests/basic_proto2.rb
Unescape View File

@ -35,34 +35,34 @@ module BasicTestProto2
def test_has_field
m = TestMessage.new
assert !m.has_optional_int32?
assert !TestMessage.descriptor.lookup('optional_int32').has?(m)
assert !m.has_optional_int64?
assert !TestMessage.descriptor.lookup('optional_int64').has?(m)
assert !m.has_optional_uint32?
assert !TestMessage.descriptor.lookup('optional_uint32').has?(m)
assert !m.has_optional_uint64?
assert !TestMessage.descriptor.lookup('optional_uint64').has?(m)
assert !m.has_optional_bool?
assert !TestMessage.descriptor.lookup('optional_bool').has?(m)
assert !m.has_optional_float?
assert !TestMessage.descriptor.lookup('optional_float').has?(m)
assert !m.has_optional_double?
assert !TestMessage.descriptor.lookup('optional_double').has?(m)
assert !m.has_optional_string?
assert !TestMessage.descriptor.lookup('optional_string').has?(m)
assert !m.has_optional_bytes?
assert !TestMessage.descriptor.lookup('optional_bytes').has?(m)
assert !m.has_optional_enum?
assert !TestMessage.descriptor.lookup('optional_enum').has?(m)
refute m.has_optional_int32?
refute TestMessage.descriptor.lookup('optional_int32').has?(m)
refute m.has_optional_int64?
refute TestMessage.descriptor.lookup('optional_int64').has?(m)
refute m.has_optional_uint32?
refute TestMessage.descriptor.lookup('optional_uint32').has?(m)
refute m.has_optional_uint64?
refute TestMessage.descriptor.lookup('optional_uint64').has?(m)
refute m.has_optional_bool?
refute TestMessage.descriptor.lookup('optional_bool').has?(m)
refute m.has_optional_float?
refute TestMessage.descriptor.lookup('optional_float').has?(m)
refute m.has_optional_double?
refute TestMessage.descriptor.lookup('optional_double').has?(m)
refute m.has_optional_string?
refute TestMessage.descriptor.lookup('optional_string').has?(m)
refute m.has_optional_bytes?
refute TestMessage.descriptor.lookup('optional_bytes').has?(m)
refute m.has_optional_enum?
refute TestMessage.descriptor.lookup('optional_enum').has?(m)
m = TestMessage.new(:optional_int32 => nil)
assert !m.has_optional_int32?
refute m.has_optional_int32?
assert_raise NoMethodError do
assert_raises NoMethodError do
m.has_repeated_msg?
end
assert_raise ArgumentError do
assert_raises ArgumentError do
TestMessage.descriptor.lookup('repeated_msg').has?(m)
end
@ -71,46 +71,46 @@ module BasicTestProto2
assert TestMessage.descriptor.lookup('optional_msg').has?(m)
m = OneofMessage.new
assert !m.has_my_oneof?
refute m.has_my_oneof?
m.a = "foo"
assert m.has_my_oneof?
assert_equal :a, m.my_oneof
assert m.has_a?
assert OneofMessage.descriptor.lookup('a').has?(m)
assert_equal "foo", m.a
assert !m.has_b?
assert !OneofMessage.descriptor.lookup('b').has?(m)
assert !m.has_c?
assert !OneofMessage.descriptor.lookup('c').has?(m)
assert !m.has_d?
assert !OneofMessage.descriptor.lookup('d').has?(m)
refute m.has_b?
refute OneofMessage.descriptor.lookup('b').has?(m)
refute m.has_c?
refute OneofMessage.descriptor.lookup('c').has?(m)
refute m.has_d?
refute OneofMessage.descriptor.lookup('d').has?(m)
m = OneofMessage.new
m.b = 100
assert m.has_b?
assert_equal 100, m.b
assert m.has_my_oneof?
assert !m.has_a?
assert !m.has_c?
assert !m.has_d?
refute m.has_a?
refute m.has_c?
refute m.has_d?
m = OneofMessage.new
m.c = TestMessage2.new
assert m.has_c?
assert_equal TestMessage2.new, m.c
assert m.has_my_oneof?
assert !m.has_a?
assert !m.has_b?
assert !m.has_d?
refute m.has_a?
refute m.has_b?
refute m.has_d?
m = OneofMessage.new
m.d = :A
assert m.has_d?
assert_equal :A, m.d
assert m.has_my_oneof?
assert !m.has_a?
assert !m.has_b?
assert !m.has_c?
refute m.has_a?
refute m.has_b?
refute m.has_c?
end
def test_defined_defaults
@ -119,23 +119,23 @@ module BasicTestProto2
assert_equal 2, m.optional_int64
assert_equal 3, m.optional_uint32
assert_equal 4, m.optional_uint64
assert_equal true, m.optional_bool
assert m.optional_bool
assert_equal 6.0, m.optional_float
assert_equal 7.0, m.optional_double
assert_equal "Default Str", m.optional_string
assert_equal "\xCF\xA5s\xBD\xBA\xE6fubar".force_encoding("ASCII-8BIT"), m.optional_bytes
assert_equal :B2, m.optional_enum
assert !m.has_optional_int32?
assert !m.has_optional_int64?
assert !m.has_optional_uint32?
assert !m.has_optional_uint64?
assert !m.has_optional_bool?
assert !m.has_optional_float?
assert !m.has_optional_double?
assert !m.has_optional_string?
assert !m.has_optional_bytes?
assert !m.has_optional_enum?
refute m.has_optional_int32?
refute m.has_optional_int64?
refute m.has_optional_uint32?
refute m.has_optional_uint64?
refute m.has_optional_bool?
refute m.has_optional_float?
refute m.has_optional_double?
refute m.has_optional_string?
refute m.has_optional_bytes?
refute m.has_optional_enum?
end
def test_set_clear_defaults
@ -146,56 +146,55 @@ module BasicTestProto2
assert m.has_optional_int32?
m.clear_optional_int32
assert_equal 1, m.optional_int32
assert !m.has_optional_int32?
refute m.has_optional_int32?
m.optional_string = "foo bar"
assert_equal "foo bar", m.optional_string
assert m.has_optional_string?
m.clear_optional_string
assert_equal "Default Str", m.optional_string
assert !m.has_optional_string?
refute m.has_optional_string?
m.optional_msg = TestMessage2.new(:foo => 42)
assert_equal TestMessage2.new(:foo => 42), m.optional_msg
assert m.has_optional_msg?
m.clear_optional_msg
assert_equal nil, m.optional_msg
assert !m.has_optional_msg?
assert_nil m.optional_msg
refute m.has_optional_msg?
m.optional_msg = TestMessage2.new(:foo => 42)
assert_equal TestMessage2.new(:foo => 42), m.optional_msg
assert TestMessageDefaults.descriptor.lookup('optional_msg').has?(m)
TestMessageDefaults.descriptor.lookup('optional_msg').clear(m)
assert_equal nil, m.optional_msg
assert !TestMessageDefaults.descriptor.lookup('optional_msg').has?(m)
assert_nil m.optional_msg
refute TestMessageDefaults.descriptor.lookup('optional_msg').has?(m)
m = TestMessage.new
m.repeated_int32.push(1)
assert_equal [1], m.repeated_int32
m.clear_repeated_int32
assert_equal [], m.repeated_int32
assert_empty m.repeated_int32
m = OneofMessage.new
m.a = "foo"
assert_equal "foo", m.a
assert m.has_a?
m.clear_a
assert !m.has_a?
refute m.has_a?
m = OneofMessage.new
m.a = "foobar"
assert m.has_my_oneof?
m.clear_my_oneof
assert !m.has_my_oneof?
refute m.has_my_oneof?
m = OneofMessage.new
m.a = "bar"
assert_equal "bar", m.a
assert m.has_my_oneof?
OneofMessage.descriptor.lookup('a').clear(m)
assert !m.has_my_oneof?
refute m.has_my_oneof?
end
def test_assign_nil
@ -205,20 +204,20 @@ module BasicTestProto2
assert_equal TestMessage2.new(:foo => 42), m.optional_msg
assert m.has_optional_msg?
m.optional_msg = nil
assert_equal nil, m.optional_msg
assert !m.has_optional_msg?
assert_nil m.optional_msg
refute m.has_optional_msg?
end
def test_initialization_map_errors
e = assert_raise ArgumentError do
e = assert_raises ArgumentError do
TestMessage.new(:hello => "world")
end
assert_match(/hello/, e.message)
e = assert_raise ArgumentError do
e = assert_raises ArgumentError do
TestMessage.new(:repeated_uint32 => "hello")
end
assert_equal e.message, "Expected array as initializer value for repeated field 'repeated_uint32' (given String)."
assert_equal "Expected array as initializer value for repeated field 'repeated_uint32' (given String).", e.message
end
@ -241,17 +240,17 @@ module BasicTestProto2
# This test fails with JRuby 1.7.23, likely because of an old JRuby bug.
return if RUBY_PLATFORM == "java"
msg = TestMessage.new
assert !msg.respond_to?(:bacon)
refute_respond_to msg, :bacon
end
def test_file_descriptor
file_descriptor = TestMessage.descriptor.file_descriptor
assert nil != file_descriptor
refute_nil file_descriptor
assert_equal "tests/basic_test_proto2.proto", file_descriptor.name
assert_equal :proto2, file_descriptor.syntax
file_descriptor = TestEnum.descriptor.file_descriptor
assert nil != file_descriptor
refute_nil file_descriptor
assert_equal "tests/basic_test_proto2.proto", file_descriptor.name
assert_equal :proto2, file_descriptor.syntax
end
@ -264,11 +263,11 @@ module BasicTestProto2
assert msg.respond_to? :has_a?
assert msg.has_a?
assert msg.respond_to? :has_b?
assert !msg.has_b?
refute msg.has_b?
assert msg.respond_to? :has_c?
assert !msg.has_c?
refute msg.has_c?
assert msg.respond_to? :has_d?
assert !msg.has_d?
refute msg.has_d?
end
end
end

892
ruby/tests/common_tests.rb
View File

File diff suppressed because it is too large Load Diff

23
ruby/tests/encode_decode_test.rb
Unescape View File

@ -19,8 +19,7 @@ class EncodeDecodeTest < Test::Unit::TestCase
m = A::B::C::TestMessage.decode(from)
Google::Protobuf.discard_unknown(m)
to = A::B::C::TestMessage.encode(m)
assert_equal '', to
assert_empty to
# Test discard unknown for singular message field.
unknown_msg = A::B::C::TestUnknown.new(
:optional_unknown =>
@ -29,8 +28,7 @@ class EncodeDecodeTest < Test::Unit::TestCase
m = A::B::C::TestMessage.decode(from)
Google::Protobuf.discard_unknown(m)
to = A::B::C::TestMessage.encode(m.optional_msg)
assert_equal '', to
assert_empty to
# Test discard unknown for repeated message field.
unknown_msg = A::B::C::TestUnknown.new(
:repeated_unknown =>
@ -39,8 +37,7 @@ class EncodeDecodeTest < Test::Unit::TestCase
m = A::B::C::TestMessage.decode(from)
Google::Protobuf.discard_unknown(m)
to = A::B::C::TestMessage.encode(m.repeated_msg[0])
assert_equal '', to
assert_empty to
# Test discard unknown for map value message field.
unknown_msg = A::B::C::TestUnknown.new(
:map_unknown =>
@ -49,8 +46,7 @@ class EncodeDecodeTest < Test::Unit::TestCase
m = A::B::C::TestMessage.decode(from)
Google::Protobuf.discard_unknown(m)
to = A::B::C::TestMessage.encode(m.map_string_msg[''])
assert_equal '', to
assert_empty to
# Test discard unknown for oneof message field.
unknown_msg = A::B::C::TestUnknown.new(
:oneof_unknown =>
@ -59,7 +55,7 @@ class EncodeDecodeTest < Test::Unit::TestCase
m = A::B::C::TestMessage.decode(from)
Google::Protobuf.discard_unknown(m)
to = A::B::C::TestMessage.encode(m.oneof_msg)
assert_equal '', to
assert_empty to
end
def test_encode_json
@ -67,8 +63,7 @@ class EncodeDecodeTest < Test::Unit::TestCase
json = msg.to_json
to = A::B::C::TestMessage.decode_json(json)
assert_equal to.optional_int32, 22
assert_equal 22, to.optional_int32
msg = A::B::C::TestMessage.new({ optional_int32: 22 })
json = msg.to_json({ preserve_proto_fieldnames: true })
@ -115,7 +110,7 @@ class EncodeDecodeTest < Test::Unit::TestCase
end
def test_encode_wrong_msg
assert_raise ::ArgumentError do
assert_raises ::ArgumentError do
m = A::B::C::TestMessage.new(
:optional_int32 => 1,
)
@ -146,7 +141,7 @@ class EncodeDecodeTest < Test::Unit::TestCase
msg_out = A::B::C::TestMessage.decode(msg_encoded)
assert_match msg.to_json, msg_out.to_json
assert_raise Google::Protobuf::ParseError do
assert_raises Google::Protobuf::ParseError do
A::B::C::TestMessage.decode(msg_encoded, { recursion_limit: 4 })
end
@ -171,7 +166,7 @@ class EncodeDecodeTest < Test::Unit::TestCase
msg_out = A::B::C::TestMessage.decode(msg_encoded)
assert_match msg.to_json, msg_out.to_json
assert_raise RuntimeError do
assert_raises RuntimeError do
A::B::C::TestMessage.encode(msg, { recursion_limit: 5 })
end

32
ruby/tests/repeated_field_test.rb
Unescape View File

@ -8,7 +8,7 @@ class RepeatedFieldTest < Test::Unit::TestCase
def test_acts_like_enumerator
m = TestMessage.new
(Enumerable.instance_methods - TestMessage.new.repeated_string.methods).each do |method_name|
assert m.repeated_string.respond_to?(method_name) == true, "does not respond to #{method_name}"
assert_respond_to m.repeated_string, method_name
end
end
@ -23,7 +23,7 @@ class RepeatedFieldTest < Test::Unit::TestCase
arr_methods -= [:intersection, :deconstruct] # ruby 2.7 methods we can ignore
arr_methods -= [:intersect?] # ruby 3.1 methods we can ignore
arr_methods.each do |method_name|
assert m.repeated_string.respond_to?(method_name) == true, "does not respond to #{method_name}"
assert_respond_to m.repeated_string, method_name
end
end
@ -31,8 +31,8 @@ class RepeatedFieldTest < Test::Unit::TestCase
m = TestMessage.new
repeated_field_names(TestMessage).each do |field_name|
assert_nil m.send(field_name).first
assert_equal [], m.send(field_name).first(0)
assert_equal [], m.send(field_name).first(1)
assert_empty m.send(field_name).first(0)
assert_empty m.send(field_name).first(1)
end
fill_test_msg(m)
@ -40,7 +40,7 @@ class RepeatedFieldTest < Test::Unit::TestCase
assert_equal( -1_000_000, m.repeated_int64.first )
assert_equal 10, m.repeated_uint32.first
assert_equal 1_000_000, m.repeated_uint64.first
assert_equal true, m.repeated_bool.first
assert m.repeated_bool.first
assert_equal( -1.01, m.repeated_float.first.round(2) )
assert_equal( -1.0000000000001, m.repeated_double.first )
assert_equal 'foo', m.repeated_string.first
@ -52,7 +52,7 @@ class RepeatedFieldTest < Test::Unit::TestCase
m.repeated_int32.first(-1)
end
assert_equal "negative array size", err.message
assert_equal [], m.repeated_int32.first(0)
assert_empty m.repeated_int32.first(0)
assert_equal [-10], m.repeated_int32.first(1)
assert_equal [-10, -11], m.repeated_int32.first(2)
assert_equal [-10, -11], m.repeated_int32.first(3)
@ -69,7 +69,7 @@ class RepeatedFieldTest < Test::Unit::TestCase
assert_equal( -1_000_001, m.repeated_int64.last )
assert_equal 11, m.repeated_uint32.last
assert_equal 1_000_001, m.repeated_uint64.last
assert_equal false, m.repeated_bool.last
refute m.repeated_bool.last
assert_equal( -1.02, m.repeated_float.last.round(2) )
assert_equal( -1.0000000000002, m.repeated_double.last )
assert_equal 'bar', m.repeated_string.last
@ -81,7 +81,7 @@ class RepeatedFieldTest < Test::Unit::TestCase
m.repeated_int32.last(-1)
end
assert_equal "negative array size", err.message
assert_equal [], m.repeated_int32.last(0)
assert_empty m.repeated_int32.last(0)
assert_equal [-11], m.repeated_int32.last(1)
assert_equal [-10, -11], m.repeated_int32.last(2)
assert_equal [-10, -11], m.repeated_int32.last(3)
@ -103,8 +103,8 @@ class RepeatedFieldTest < Test::Unit::TestCase
assert_equal 10, m.repeated_uint32.pop
assert_equal 1_000_001, m.repeated_uint64.pop
assert_equal 1_000_000, m.repeated_uint64.pop
assert_equal false, m.repeated_bool.pop
assert_equal true, m.repeated_bool.pop
refute m.repeated_bool.pop
assert m.repeated_bool.pop
assert_equal( -1.02, m.repeated_float.pop.round(2) )
assert_equal( -1.01, m.repeated_float.pop.round(2) )
assert_equal( -1.0000000000002, m.repeated_double.pop )
@ -143,17 +143,17 @@ class RepeatedFieldTest < Test::Unit::TestCase
def test_empty?
m = TestMessage.new
assert_equal true, m.repeated_string.empty?
assert_empty m.repeated_string
m.repeated_string << 'foo'
assert_equal false, m.repeated_string.empty?
refute_empty m.repeated_string
m.repeated_string << 'bar'
assert_equal false, m.repeated_string.empty?
refute_empty m.repeated_string
end
def test_reassign
m = TestMessage.new
m.repeated_msg = Google::Protobuf::RepeatedField.new(:message, TestMessage2, [TestMessage2.new(:foo => 1)])
assert_equal m.repeated_msg.first, TestMessage2.new(:foo => 1)
assert_equal TestMessage2.new(:foo => 1), m.repeated_msg.first
end
def test_array_accessor
@ -323,7 +323,7 @@ class RepeatedFieldTest < Test::Unit::TestCase
m.repeated_string += reference_arr.clone
assert_equal reference_arr, m.repeated_string
reference_arr << 'fizz'
assert_not_equal reference_arr, m.repeated_string
refute_equal reference_arr, m.repeated_string
m.repeated_string << 'fizz'
assert_equal reference_arr, m.repeated_string
end
@ -337,7 +337,7 @@ class RepeatedFieldTest < Test::Unit::TestCase
hash = m.repeated_string.hash
assert_equal hash, m.repeated_string.hash
m.repeated_string << 'j'
assert_not_equal hash, m.repeated_string.hash
refute_equal hash, m.repeated_string.hash
end
def test_plus

2
ruby/tests/stress.rb
Unescape View File

@ -31,7 +31,7 @@ module StressTest
mnew = TestMessage.decode(data)
mnew = mnew.dup
assert_equal m.inspect, mnew.inspect
assert TestMessage.encode(mnew) == data
assert_equal data, TestMessage.encode(mnew)
end
end
end

75
ruby/tests/well_known_types_test.rb
Unescape View File

@ -65,18 +65,17 @@ class TestWellKnownTypes < Test::Unit::TestCase
struct["sublist"] = sublist
assert_equal 12345, struct["number"]
assert_equal true, struct["boolean-true"]
assert_equal false, struct["boolean-false"]
assert_equal nil, struct["null"]
assert struct["boolean-true"]
refute struct["boolean-false"]
assert_nil struct["null"]
assert_equal "abcdef", struct["string"]
assert_equal(Google::Protobuf::Struct.from_hash(substruct),
struct["substruct"])
assert_equal(Google::Protobuf::ListValue.from_a(sublist),
struct["sublist"])
assert_equal true, struct.has_key?("null")
assert_equal false, struct.has_key?("missing_key")
assert struct.has_key? "null"
refute struct.has_key? "missing_key"
should_equal = {
"number" => 12345,
"boolean-true" => true,
@ -91,48 +90,48 @@ class TestWellKnownTypes < Test::Unit::TestCase
}
list = struct["sublist"]
list.is_a?(Google::Protobuf::ListValue)
assert_instance_of Google::Protobuf::ListValue, list
assert_equal "abc", list[0]
assert_equal 123, list[1]
assert_equal({"deepkey" => "deepval"}, list[2].to_h)
# to_h returns a fully-flattened Ruby structure (Hash and Array).
assert_equal(should_equal, struct.to_h)
assert_equal should_equal, struct.to_h
# Test that we can safely access a missing key
assert_equal(nil, struct["missing_key"])
assert_nil struct["missing_key"]
# Test that we can assign Struct and ListValue directly.
struct["substruct"] = Google::Protobuf::Struct.from_hash(substruct)
struct["sublist"] = Google::Protobuf::ListValue.from_a(sublist)
assert_equal(should_equal, struct.to_h)
assert_equal should_equal, struct.to_h
struct["sublist"] << nil
should_equal["sublist"] << nil
assert_equal(should_equal, struct.to_h)
assert_equal(should_equal["sublist"].length, struct["sublist"].length)
assert_equal should_equal, struct.to_h
assert_equal should_equal["sublist"].length, struct["sublist"].length
assert_raise Google::Protobuf::UnexpectedStructType do
assert_raises Google::Protobuf::UnexpectedStructType do
struct[123] = 5
end
assert_raise Google::Protobuf::UnexpectedStructType do
assert_raises Google::Protobuf::UnexpectedStructType do
struct[5] = Time.new
end
assert_raise Google::Protobuf::UnexpectedStructType do
assert_raises Google::Protobuf::UnexpectedStructType do
struct[5] = [Time.new]
end
assert_raise Google::Protobuf::UnexpectedStructType do
assert_raises Google::Protobuf::UnexpectedStructType do
struct[5] = {123 => 456}
end
assert_raise Google::Protobuf::UnexpectedStructType do
struct = Google::Protobuf::Struct.new
struct.fields["foo"] = Google::Protobuf::Value.new
struct = Google::Protobuf::Struct.new
struct.fields["foo"] = Google::Protobuf::Value.new
assert_raises Google::Protobuf::UnexpectedStructType do
# Tries to return a Ruby value for a Value class whose type
# hasn't been filled in.
struct["foo"]
@ -184,10 +183,10 @@ class TestWellKnownTypes < Test::Unit::TestCase
assert_equal expected_b_x, s[:b][:x].values
assert_equal expected_b_x, s['b'][:x].values
assert_equal expected_b_x, s[:b]['x'].values
assert_equal true, s['b']['y']
assert_equal true, s[:b][:y]
assert_equal true, s[:b]['y']
assert_equal true, s['b'][:y]
assert s['b']['y']
assert s[:b][:y]
assert s[:b]['y']
assert s['b'][:y]
assert_equal Google::Protobuf::Struct.new, s['c']
assert_equal Google::Protobuf::Struct.new, s[:c]
@ -202,10 +201,10 @@ class TestWellKnownTypes < Test::Unit::TestCase
)
assert_equal 'Eh', s['a']
assert_equal 'Eh', s[:a]
assert_equal false, s['b']['y']
assert_equal false, s[:b][:y]
assert_equal false, s['b'][:y]
assert_equal false, s[:b]['y']
refute s['b']['y']
refute s[:b][:y]
refute s['b'][:y]
refute s[:b]['y']
end
def test_b8325
@ -218,30 +217,26 @@ class TestWellKnownTypes < Test::Unit::TestCase
def test_from_ruby
pb = Google::Protobuf::Value.from_ruby(nil)
assert_equal pb.null_value, :NULL_VALUE
assert_equal :NULL_VALUE, pb.null_value
pb = Google::Protobuf::Value.from_ruby(1.23)
assert_equal pb.number_value, 1.23
assert_equal 1.23, pb.number_value
pb = Google::Protobuf::Value.from_ruby('1.23')
assert_equal pb.string_value, '1.23'
assert_equal '1.23', pb.string_value
pb = Google::Protobuf::Value.from_ruby(true)
assert_equal pb.bool_value, true
assert pb.bool_value
pb = Google::Protobuf::Value.from_ruby(false)
assert_equal pb.bool_value, false
refute pb.bool_value
pb = Google::Protobuf::Value.from_ruby(Google::Protobuf::Struct.from_hash({ 'a' => 1, 'b' => '2', 'c' => [1, 2, 3], 'd' => nil, 'e' => true }))
assert_equal pb.struct_value, Google::Protobuf::Struct.from_hash({ 'a' => 1, 'b' => '2', 'c' => [1, 2, 3], 'd' => nil, 'e' => true })
assert_equal Google::Protobuf::Struct.from_hash({ 'a' => 1, 'b' => '2', 'c' => [1, 2, 3], 'd' => nil, 'e' => true }), pb.struct_value
pb = Google::Protobuf::Value.from_ruby({ 'a' => 1, 'b' => '2', 'c' => [1, 2, 3], 'd' => nil, 'e' => true })
assert_equal pb.struct_value, Google::Protobuf::Struct.from_hash({ 'a' => 1, 'b' => '2', 'c' => [1, 2, 3], 'd' => nil, 'e' => true })
assert_equal Google::Protobuf::Struct.from_hash({ 'a' => 1, 'b' => '2', 'c' => [1, 2, 3], 'd' => nil, 'e' => true }), pb.struct_value
pb = Google::Protobuf::Value.from_ruby(Google::Protobuf::ListValue.from_a([1, 2, 3]))
assert_equal pb.list_value, Google::Protobuf::ListValue.from_a([1, 2, 3])
assert_equal Google::Protobuf::ListValue.from_a([1, 2, 3]), pb.list_value
pb = Google::Protobuf::Value.from_ruby([1, 2, 3])
assert_equal pb.list_value, Google::Protobuf::ListValue.from_a([1, 2, 3])
assert_equal Google::Protobuf::ListValue.from_a([1, 2, 3]), pb.list_value
end
end

Write Preview
Loading…
Cancel
Save