dep-protobuf/ruby/tests/basic.rb

#!/usr/bin/ruby

# basic_test_pb.rb is in the same directory as this test.
$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__)))

require 'basic_test_features_pb'
require 'basic_test_pb'
require 'common_tests'
require 'google/protobuf'
require 'json'
require 'test/unit'

module BasicTest
  TestMessage = BasicTest::TestMessage
  Outer = BasicTest::Outer

  class MessageContainerTest < Test::Unit::TestCase
    # Required by CommonTests module to resolve proto3 proto classes used in tests.
    def proto_module
      ::BasicTest
    end
    include CommonTests

    def test_issue_8311_crash
      BasicTest::Outer8311.new(
          inners: []
      )['inners'].to_s

      assert_raises Google::Protobuf::TypeError do
        BasicTest::Outer8311.new(
            inners: [nil]
        ).to_s
      end
    end

    def test_issue_8559_crash
      msg = TestMessage.new
      msg.repeated_int32 = ::Google::Protobuf::RepeatedField.new(:int32, [1, 2, 3])

      # https://github.com/jruby/jruby/issues/6818 was fixed in JRuby 9.3.0.0
      if cruby_or_jruby_9_3_or_higher?
        GC.start(full_mark: true, immediate_sweep: true)
      end
      TestMessage.encode(msg)
    end

    def test_issue_9440
      msg = HelloRequest.new
      msg.id = 8
      assert_equal 8, msg.id
      msg.version = '1'
      assert_equal 8, msg.id
    end

    def test_issue_9507
      m = BasicTest::NpeMessage.new(
        other: "foo"      # must be set, but can be blank
      )

      begin
        encoded = BasicTest::NpeMessage.encode(m)
      rescue java.lang.NullPointerException
        flunk "NPE rescued"
      end
      decoded = BasicTest::NpeMessage.decode(encoded)
      decoded.inspect
      decoded.to_proto
    end

    def test_has_field
      m = TestSingularFields.new
      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
      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_raises NoMethodError do
        m.has_singular_int32?
      end
      assert_raises ArgumentError do
        TestSingularFields.descriptor.lookup('singular_int32').has?(m)
      end

      assert_raises NoMethodError do
        m.has_singular_string?
      end
      assert_raises ArgumentError do
        TestSingularFields.descriptor.lookup('singular_string').has?(m)
      end

      assert_raises NoMethodError do
        m.has_singular_bool?
      end
      assert_raises ArgumentError do
        TestSingularFields.descriptor.lookup('singular_bool').has?(m)
      end

      m = TestMessage.new
      assert_raises NoMethodError do
        m.has_repeated_msg?
      end
      assert_raises ArgumentError do
        TestMessage.descriptor.lookup('repeated_msg').has?(m)
      end
    end

    def test_no_presence
      m = TestSingularFields.new

      # Explicitly setting to zero does not cause anything to be serialized.
      m.singular_int32 = 0
      assert_empty TestSingularFields.encode(m)
      # Explicitly setting to a non-zero value *does* cause serialization.
      m.singular_int32 = 1
      refute_empty TestSingularFields.encode(m)
      m.singular_int32 = 0
      assert_empty TestSingularFields.encode(m)
    end

    def test_set_clear_defaults
      m = TestSingularFields.new

      m.singular_int32 = -42
      assert_equal( -42, m.singular_int32 )
      m.clear_singular_int32
      assert_equal 0, m.singular_int32

      m.singular_int32 = 50
      assert_equal 50, m.singular_int32
      TestSingularFields.descriptor.lookup('singular_int32').clear(m)
      assert_equal 0, m.singular_int32

      m.singular_string = "foo bar"
      assert_equal "foo bar", m.singular_string
      m.clear_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_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_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_nil m.singular_msg
    end

    def test_import_proto2
      m = TestMessage.new
      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
      refute m.has_optional_proto2_submessage?
    end

    def test_clear_repeated_fields
      m = TestMessage.new

      m.repeated_int32.push(1)
      assert_equal [1], m.repeated_int32
      m.clear_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_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
      refute m.has_my_oneof?

      m.a = "foobar"
      assert m.has_my_oneof?
      m.clear_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)
      refute m.has_my_oneof?
    end

    def test_initialization_map_errors
      e = assert_raises ArgumentError do
        TestMessage.new(:hello => "world")
      end
      assert_match(/hello/, e.message)

      e = assert_raises ArgumentError do
        MapMessage.new(:map_string_int32 => "hello")
      end
      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 "Expected array as initializer value for repeated field 'repeated_uint32' (given String).", e.message
    end

    def test_map_field
      m = MapMessage.new
      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_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_equal 3, m.map_string_int32["c"]
      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_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_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_raises Google::Protobuf::TypeError do
        m.map_string_int32 = Google::Protobuf::Map.new(:string, :int64)
      end
      assert_raises Google::Protobuf::TypeError do
        m.map_string_int32 = {}
      end

      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_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 => 10)})
      assert_equal 1, m.map_string_int32[:a]
      assert_equal 2, m.map_string_int32[:b]
      assert_equal 10, m.map_string_msg[:b].foo
    end

    def test_map_inspect
      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})

      # JRuby doesn't keep consistent ordering so check for either version
      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_includes [expected_a, expected_b], inspect_result
    end

    def test_map_corruption
      # This pattern led to a crash in a previous version of upb/protobuf.
      m = MapMessage.new(map_string_int32: { "aaa" => 1 })
      m.map_string_int32['podid'] = 2
      m.map_string_int32['aaa'] = 3
    end

    def test_map_wrappers
      run_asserts = ->(m) {
        assert_equal 2.0, m.map_double[0].value
        assert_equal 4.0, m.map_float[0].value
        assert_equal 3, m.map_int32[0].value
        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 m.map_bool[0].value
        assert_equal 'str', m.map_string[0].value
        assert_equal 'fun', m.map_bytes[0].value
      }

      m = proto_module::Wrapper.new(
        map_double: {0 => Google::Protobuf::DoubleValue.new(value: 2.0)},
        map_float: {0 => Google::Protobuf::FloatValue.new(value: 4.0)},
        map_int32: {0 => Google::Protobuf::Int32Value.new(value: 3)},
        map_int64: {0 => Google::Protobuf::Int64Value.new(value: 4)},
        map_uint32: {0 => Google::Protobuf::UInt32Value.new(value: 5)},
        map_uint64: {0 => Google::Protobuf::UInt64Value.new(value: 6)},
        map_bool: {0 => Google::Protobuf::BoolValue.new(value: true)},
        map_string: {0 => Google::Protobuf::StringValue.new(value: 'str')},
        map_bytes: {0 => 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
    end

    def test_map_wrappers_with_default_values
      run_asserts = ->(m) {
        assert_equal 0.0, m.map_double[0].value
        assert_equal 0.0, m.map_float[0].value
        assert_equal 0, m.map_int32[0].value
        assert_equal 0, m.map_int64[0].value
        assert_equal 0, m.map_uint32[0].value
        assert_equal 0, m.map_uint64[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(
        map_double: {0 => Google::Protobuf::DoubleValue.new(value: 0.0)},
        map_float: {0 => Google::Protobuf::FloatValue.new(value: 0.0)},
        map_int32: {0 => Google::Protobuf::Int32Value.new(value: 0)},
        map_int64: {0 => Google::Protobuf::Int64Value.new(value: 0)},
        map_uint32: {0 => Google::Protobuf::UInt32Value.new(value: 0)},
        map_uint64: {0 => Google::Protobuf::UInt64Value.new(value: 0)},
        map_bool: {0 => Google::Protobuf::BoolValue.new(value: false)},
        map_string: {0 => Google::Protobuf::StringValue.new(value: '')},
        map_bytes: {0 => Google::Protobuf::BytesValue.new(value: '')},
      )

      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
    end

    def test_map_wrappers_with_no_value
      run_asserts = ->(m) {
        assert_equal 0.0, m.map_double[0].value
        assert_equal 0.0, m.map_float[0].value
        assert_equal 0, m.map_int32[0].value
        assert_equal 0, m.map_int64[0].value
        assert_equal 0, m.map_uint32[0].value
        assert_equal 0, m.map_uint64[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(
        map_double: {0 => Google::Protobuf::DoubleValue.new()},
        map_float: {0 => Google::Protobuf::FloatValue.new()},
        map_int32: {0 => Google::Protobuf::Int32Value.new()},
        map_int64: {0 => Google::Protobuf::Int64Value.new()},
        map_uint32: {0 => Google::Protobuf::UInt32Value.new()},
        map_uint64: {0 => Google::Protobuf::UInt64Value.new()},
        map_bool: {0 => Google::Protobuf::BoolValue.new()},
        map_string: {0 => Google::Protobuf::StringValue.new()},
        map_bytes: {0 => Google::Protobuf::BytesValue.new()},
      )
      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)
    end

    def test_concurrent_decoding
      o = Outer.new
      o.items[0] = Inner.new
      raw = Outer.encode(o)

      thds = 2.times.map do
        Thread.new do
          100000.times do
            assert_equal o, Outer.decode(raw)
          end
        end
      end
      thds.map(&:join)
    end

    def test_map_encode_decode
      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})
      m2 = MapMessage.decode(MapMessage.encode(m))
      assert_equal m, m2
      m3 = MapMessageWireEquiv.decode(MapMessage.encode(m))
      assert_equal 2, m3.map_string_int32.length
      kv = {}
      m3.map_string_int32.map { |msg| kv[msg.key] = msg.value }
      assert_equal({"a" => 1, "b" => 2}, kv)
      kv = {}
      m3.map_string_msg.map { |msg| kv[msg.key] = msg.value }
      assert_equal({"a" => TestMessage2.new(:foo => 1),
                    "b" => TestMessage2.new(:foo => 2)}, kv)
    end

    def test_protobuf_decode_json_ignore_unknown_fields
      m = TestMessage.decode_json({
        optional_string: "foo",
        not_in_message: "some_value"
      }.to_json, { ignore_unknown_fields: true })

      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)
    end

    #def test_json_quoted_string
    #  m = TestMessage.decode_json(%q(
    #    "optionalInt64": "1",,
    #  }))
    #  puts(m)
    #  assert_equal 1, m.optional_int32
    #end

    def test_to_h
      m = TestMessage.new(
        :optional_bool => true,
        :optional_double => -10.100001,
        :optional_string => 'foo',
        :repeated_string => ['bar1', 'bar2'],
        :repeated_msg => [TestMessage2.new(:foo => 100)]
      )
      expected_result = {
        :optional_bool=>true,
        :optional_double=>-10.100001,
        :optional_string=>"foo",
        :repeated_string=>["bar1", "bar2"],
        :repeated_msg=>[{:foo => 100}],
      }
      assert_equal expected_result, m.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})
      expected_result = {
        :map_string_int32 => {"a" => 1, "b" => 2},
        :map_string_msg => {"a" => {:foo => 1}, "b" => {:foo => 2}},
        :map_string_enum => {"a" => :A, "b" => :B}
      }
      assert_equal expected_result, m.to_h
    end


    def test_json_maps
      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 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 expected_preserve, JSON.parse(json, :symbolize_names => true)

      m2 = MapMessage.decode_json(MapMessage.encode_json(m))
      assert_equal m, m2
    end

    def test_json_maps_emit_defaults_submsg
      m = MapMessage.new(:map_string_msg => {"a" => TestMessage2.new(foo: 0)})
      expected = {mapStringInt32: {}, mapStringMsg: {a: {foo: 0}}, mapStringEnum: {}}

      actual = MapMessage.encode_json(m, :emit_defaults => true)

      assert_equal expected, JSON.parse(actual, :symbolize_names => true)
    end

    def test_json_emit_defaults_submsg
      m = TestSingularFields.new(singular_msg: proto_module::TestMessage2.new)

      expected = {
        singularInt32: 0,
        singularInt64: "0",
        singularUint32: 0,
        singularUint64: "0",
        singularBool: false,
        singularFloat: 0,
        singularDouble: 0,
        singularString: "",
        singularBytes: "",
        singularMsg: {},
        singularEnum: "Default",
      }

      actual = proto_module::TestMessage.encode_json(m, :emit_defaults => true)

      assert_equal expected, JSON.parse(actual, :symbolize_names => true)
    end

    def test_respond_to
      msg = MapMessage.new
      assert_respond_to msg, :map_string_int32
      refute_respond_to msg, :bacon
    end

    def test_file_descriptor
      file_descriptor = TestMessage.descriptor.file_descriptor
      refute_nil file_descriptor
      assert_equal "basic_test.proto", file_descriptor.name

      file_descriptor = TestEnum.descriptor.file_descriptor
      refute_nil file_descriptor
      assert_equal "basic_test.proto", file_descriptor.name
    end

    def test_map_freeze
      m = proto_module::MapMessage.new
      m.map_string_int32['a'] = 5
      m.map_string_msg['b'] = proto_module::TestMessage2.new

      m.map_string_int32.freeze
      m.map_string_msg.freeze

      assert m.map_string_int32.frozen?
      assert m.map_string_msg.frozen?

      assert_raises(FrozenError) { m.map_string_int32['foo'] = 1 }
      assert_raises(FrozenError) { m.map_string_msg['bar'] = proto_module::TestMessage2.new }
      assert_raises(FrozenError) { m.map_string_int32.delete('a') }
      assert_raises(FrozenError) { m.map_string_int32.clear }
    end

    def test_map_length
      m = proto_module::MapMessage.new
      assert_equal 0, m.map_string_int32.length
      assert_equal 0, m.map_string_msg.length
      assert_equal 0, m.map_string_int32.size
      assert_equal 0, m.map_string_msg.size

      m.map_string_int32['a'] = 1
      m.map_string_int32['b'] = 2
      m.map_string_msg['a'] = proto_module::TestMessage2.new
      assert_equal 2, m.map_string_int32.length
      assert_equal 1, m.map_string_msg.length
      assert_equal 2, m.map_string_int32.size
      assert_equal 1, m.map_string_msg.size
    end

    def test_string_with_singleton_class_enabled
      str = 'foobar'
      # NOTE: Accessing a singleton class of an object changes its low level class representation
      #       as far as the C API's CLASS_OF() method concerned, exposing the issue
      str.singleton_class
      m = proto_module::TestMessage.new(
        optional_string: str,
        optional_bytes: str
      )

      assert_equal str, m.optional_string
      assert_equal str, m.optional_bytes
    end

    def test_utf8
      m = proto_module::TestMessage.new(
        optional_string: "µpb",
      )
      m2 = proto_module::TestMessage.decode(proto_module::TestMessage.encode(m))
      assert_equal m2, m
    end

    def test_map_fields_respond_to? # regression test for issue 9202
      msg = proto_module::MapMessage.new
      assert_respond_to msg, :map_string_int32=
      msg.map_string_int32 = Google::Protobuf::Map.new(:string, :int32)
      assert_respond_to msg, :map_string_int32
      assert_equal( Google::Protobuf::Map.new(:string, :int32), msg.map_string_int32 )
      assert_respond_to msg, :clear_map_string_int32
      msg.clear_map_string_int32

      refute_respond_to msg, :has_map_string_int32?
      assert_raises NoMethodError do
        msg.has_map_string_int32?
      end
      refute_respond_to msg, :map_string_int32_as_value
      assert_raises NoMethodError do
        msg.map_string_int32_as_value
      end
      refute_respond_to msg, :map_string_int32_as_value=
      assert_raises NoMethodError do
        msg.map_string_int32_as_value = :boom
      end
    end

    def test_has_presence
      assert_true TestMessage.descriptor.lookup("optional_int32").has_presence?
      assert_false TestMessage.descriptor.lookup("repeated_int32").has_presence?
      assert_false TestSingularFields.descriptor.lookup("singular_int32").has_presence?
    end

    def test_is_packed
      assert_false TestMessage.descriptor.lookup("optional_int32").is_packed?
      assert_true TestMessage.descriptor.lookup("repeated_int32").is_packed?
    end

    def test_file_descriptor_options
      file_descriptor = TestMessage.descriptor.file_descriptor

      assert_instance_of Google::Protobuf::FileOptions, file_descriptor.options
      assert file_descriptor.options.deprecated
    end

    def test_field_descriptor_options
      field_descriptor = TestDeprecatedMessage.descriptor.lookup("foo")

      assert_instance_of Google::Protobuf::FieldOptions, field_descriptor.options
      assert field_descriptor.options.deprecated
    end

    def test_descriptor_options
      descriptor = TestDeprecatedMessage.descriptor

      assert_instance_of Google::Protobuf::MessageOptions, descriptor.options
      assert descriptor.options.deprecated
    end

    def test_enum_descriptor_options
      enum_descriptor = TestDeprecatedEnum.descriptor

      assert_instance_of Google::Protobuf::EnumOptions, enum_descriptor.options
      assert enum_descriptor.options.deprecated
    end

    def test_oneof_descriptor_options
      descriptor = TestDeprecatedMessage.descriptor
      oneof_descriptor = descriptor.lookup_oneof("test_deprecated_message_oneof")

      assert_instance_of Google::Protobuf::OneofOptions, oneof_descriptor.options
      test_top_level_option = Google::Protobuf::DescriptorPool.generated_pool.lookup 'basic_test.test_top_level_option'
      assert_instance_of Google::Protobuf::FieldDescriptor, test_top_level_option
      assert_equal "Custom option value", test_top_level_option.get(oneof_descriptor.options)
    end

    def test_nested_extension
      descriptor = TestDeprecatedMessage.descriptor
      oneof_descriptor = descriptor.lookup_oneof("test_deprecated_message_oneof")

      assert_instance_of Google::Protobuf::OneofOptions, oneof_descriptor.options
      test_nested_option = Google::Protobuf::DescriptorPool.generated_pool.lookup 'basic_test.TestDeprecatedMessage.test_nested_option'
      assert_instance_of Google::Protobuf::FieldDescriptor, test_nested_option
      assert_equal "Another custom option value", test_nested_option.get(oneof_descriptor.options)
    end

    def test_options_deep_freeze
      descriptor = TestDeprecatedMessage.descriptor

      assert_raise FrozenError do
        descriptor.options.uninterpreted_option.push \
          Google::Protobuf::UninterpretedOption.new
      end
    end

    def test_message_freeze
      message = TestDeprecatedMessage.new
      nested_message_2 = TestMessage2.new

      message.map_string_msg["message"] = TestMessage2.new
      message.repeated_msg.push(TestMessage2.new)

      message.freeze

      assert_raise FrozenError do
        message.map_string_msg["message"].foo = nested_message_2
      end

      assert_raise FrozenError do
        message.repeated_msg[0].foo = nested_message_2
      end
    end

    def test_oneof_fields_respond_to? # regression test for issue 9202
      msg = proto_module::OneofMessage.new
      # `has_` prefix + "?" suffix actions should work for oneofs fields and members.
      assert_false msg.has_my_oneof?
      assert msg.respond_to? :has_my_oneof?
      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

    def test_string_subclass
      str = "hello"
      myString = Class.new(String)

      m = proto_module::TestMessage.new(
        optional_string: myString.new(str),
      )

      assert_equal str, m.optional_string
    end

    def test_proto3_explicit_presence
      descriptor = TestMessage.descriptor.lookup("optional_int32")
      assert_true descriptor.has_presence?
      assert_false descriptor.options.has_features?
    end

    def test_proto3_implicit_presence
      descriptor = TestSingularFields.descriptor.lookup("singular_int32")
      assert_false descriptor.has_presence?
      assert_false descriptor.options.has_features?
    end

    def test_proto3_packed_encoding
      descriptor = TestMessage.descriptor.lookup("repeated_int32")
      assert_true descriptor.is_packed?
      assert_false descriptor.options.has_features?
    end

    def test_proto3_expanded_encoding
      descriptor = TestUnpackedMessage.descriptor.lookup("repeated_int32")
      assert_false descriptor.is_packed?
      assert_false descriptor.options.has_features?
    end

    def test_proto3_expanded_encoding_unpackable
      descriptor = TestMessage.descriptor.lookup("optional_msg")
      assert_false descriptor.is_packed?
      assert_false descriptor.options.has_features?
    end

    def test_editions_explicit_presence
      descriptor = TestFeaturesMessage.descriptor.lookup("explicit")
      assert_true descriptor.has_presence?
      assert_false descriptor.options.has_features?
    end

    def test_editions_implicit_presence
      descriptor = TestFeaturesMessage.descriptor.lookup("implicit")
      assert_false descriptor.has_presence?
      assert_false descriptor.options.has_features?
    end

    def test_editions_required_presence
      descriptor = TestFeaturesMessage.descriptor.lookup("legacy_required")
      assert_equal :required, descriptor.label
      assert_false descriptor.options.has_features?
    end

    def test_editions_packed_encoding
      descriptor = TestFeaturesMessage.descriptor.lookup("packed")
      assert_true descriptor.is_packed?
      assert_false descriptor.options.has_features?
    end

    def test_editions_expanded_encoding
      descriptor = TestFeaturesMessage.descriptor.lookup("expanded")
      assert_false descriptor.is_packed?
      assert_false descriptor.options.has_features?
    end

    def test_editions_expanded_encoding_unpackable
      descriptor = TestFeaturesMessage.descriptor.lookup("unpackable")
      assert_false descriptor.is_packed?
      assert_false descriptor.options.has_features?
    end

    def test_field_delimited_encoding
      descriptor = TestFeaturesMessage.descriptor.lookup("delimited")
      assert_equal :group, descriptor.type
      assert_false descriptor.options.has_features?
    end

    def test_field_length_prefixed_encoding
      descriptor = TestFeaturesMessage.descriptor.lookup("length_prefixed")
      assert_equal :message, descriptor.type
      assert_false descriptor.options.has_features?
    end

  end
end