third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/ruby/tests/basic.rb

 #!/usr/bin/ruby
 
 require 'google/protobuf'
 require 'test/unit'
 
 # ------------- generated code --------------
 
 module BasicTest
   pool = Google::Protobuf::DescriptorPool.new
   pool.build do
@@ skipping 165 matching lines @@
       m = TestMessage.new(:optional_int32 => -42,
                           :optional_enum => :A,
                           :optional_msg => TestMessage2.new,
                           :repeated_string => ["hello", "there", "world"])
       expected = '<BasicTest::TestMessage: optional_int32: -42, optional_int64: 0, optional_uint32: 0, optional_uint64: 0, optional_bool: false, optional_float: 0.0, optional_double: 0.0, optional_string: "", optional_bytes: "", optional_msg: <BasicTest::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
     end
 
     def test_hash
       m1 = TestMessage.new(:optional_int32 => 42)
-      m2 = TestMessage.new(:optional_int32 => 102)
+      m2 = TestMessage.new(:optional_int32 => 102, repeated_string: ['please', 'work', 'ok?'])
+      m3 = 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
         TestMessage.new.hello
       end
       assert_match(/hello/, e.message)
 
       e = assert_raise NoMethodError do
         TestMessage.new.hello = "world"
@@ skipping 46 matching lines @@
 
       assert_raise TypeError do
         m.repeated_msg.push TestMessage.new
       end
     end
 
     def test_string_encoding
       m = TestMessage.new
 
       # Assigning a normal (ASCII or UTF8) string to a bytes field, or
-      # ASCII-8BIT to a string field, raises an error.
-      assert_raise TypeError do
-        m.optional_bytes = "Test string ASCII".encode!('ASCII')
-      end
-      assert_raise TypeError do
+      # 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 TypeError do
+
+      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 mutable so we can do this, but serialize should catch it.
+      # strings are immutable so we can't do this, but serialize should catch it.
       m.optional_string = "asdf".encode!('UTF-8')
-      m.optional_string.encode!('ASCII-8BIT')
-      assert_raise TypeError do
-        data = TestMessage.encode(m)
+      assert_raise RuntimeError do
+        m.optional_string.encode!('ASCII-8BIT')
       end
     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]
@@ skipping 171 matching lines @@
       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 m == m2
+      assert_equal m, m2
       assert m.hash != 0
-      assert m.hash == m2.hash
+      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")
 
@@ skipping 69 matching lines @@
       end
       assert_raise TypeError do
         m["asdf"] = 1
       end
 
       m = Google::Protobuf::Map.new(:string, :int32)
       m["asdf"] = 1
       assert_raise TypeError do
         m[1] = 1
       end
-      assert_raise TypeError do
+      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
-      assert_raise TypeError do
-        m["asdf"] = 1
-      end
+      # Allowed -- we will automatically convert to ASCII-8BIT.
+      m["asdf"] = 1
       assert_raise TypeError do
         m[1] = 1
       end
     end
 
     def test_map_msg_enum_valuetypes
       m = Google::Protobuf::Map.new(:string, :message, TestMessage)
       m["asdf"] = TestMessage.new
       assert_raise TypeError do
         m["jkl;"] = TestMessage2.new
@@ skipping 114 matching lines @@
         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 = OneofMessage.new
-      assert d.a == nil
-      assert d.b == nil
+      assert d.a == ""
+      assert d.b == 0
       assert d.c == nil
-      assert d.d == nil
+      assert d.d == :Default
       assert d.my_oneof == nil
 
       d.a = "hi"
       assert d.a == "hi"
-      assert d.b == nil
+      assert d.b == 0
       assert d.c == nil
-      assert d.d == nil
+      assert d.d == :Default
       assert d.my_oneof == :a
 
       d.b = 42
-      assert d.a == nil
+      assert d.a == ""
       assert d.b == 42
       assert d.c == nil
-      assert d.d == nil
+      assert d.d == :Default
       assert d.my_oneof == :b
 
       d.c = TestMessage2.new(:foo => 100)
-      assert d.a == nil
-      assert d.b == nil
+      assert d.a == ""
+      assert d.b == 0
       assert d.c.foo == 100
-      assert d.d == nil
+      assert d.d == :Default
       assert d.my_oneof == :c
 
       d.d = :C
-      assert d.a == nil
-      assert d.b == nil
+      assert d.a == ""
+      assert d.b == 0
       assert d.c == nil
       assert d.d == :C
       assert d.my_oneof == :d
 
       d2 = OneofMessage.decode(OneofMessage.encode(d))
       assert d2 == d
 
       encoded_field_a = OneofMessage.encode(OneofMessage.new(:a => "string"))
       encoded_field_b = OneofMessage.encode(OneofMessage.new(:b => 1000))
       encoded_field_c = OneofMessage.encode(
         OneofMessage.new(:c => TestMessage2.new(:foo => 1)))
       encoded_field_d = OneofMessage.encode(OneofMessage.new(:d => :B))
 
       d3 = OneofMessage.decode(
         encoded_field_c + encoded_field_a + encoded_field_d)
-      assert d3.a == nil
-      assert d3.b == nil
+      assert d3.a == ""
+      assert d3.b == 0
       assert d3.c == nil
       assert d3.d == :B
 
       d4 = OneofMessage.decode(
         encoded_field_c + encoded_field_a + encoded_field_d +
         encoded_field_c)
-      assert d4.a == nil
-      assert d4.b == nil
+      assert d4.a == ""
+      assert d4.b == 0
       assert d4.c.foo == 1
-      assert d4.d == nil
+      assert d4.d == :Default
 
       d5 = OneofMessage.new(:a => "hello")
-      assert d5.a != nil
+      assert d5.a == "hello"
       d5.a = nil
-      assert d5.a == nil
+      assert d5.a == ""
       assert OneofMessage.encode(d5) == ''
       assert d5.my_oneof == nil
     end
 
     def test_enum_field
       m = TestMessage.new
       assert m.optional_enum == :Default
       m.optional_enum = :A
       assert m.optional_enum == :A
       assert_raise RangeError do
@@ skipping 68 matching lines @@
       m2 = TestMessage.decode data
       assert m == m2
 
       data = Google::Protobuf.encode m
       m2 = Google::Protobuf.decode(TestMessage, data)
       assert m == m2
     end
 
     def test_encode_decode_helpers
       m = 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 = TestMessage.decode_json(json)
-      assert m2.optional_string == 'foo'
-      assert m2.repeated_string == ['bar1', 'bar2']
+      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 = TestMessage.decode(proto)
-      assert m2.optional_string == 'foo'
-      assert m2.repeated_string == ['bar1', 'bar2']
+      assert_equal 'foo', m2.optional_string
+      assert_equal ['bar1', 'bar2'], m2.repeated_string
     end
 
     def test_protobuf_encode_decode_helpers
       m = 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(TestMessage, encoded_msg)
       assert_equal TestMessage.decode(m.to_proto), decoded_msg
     end
@@ skipping 288 matching lines @@
       expected = '{"mapStringInt32":{"a":1},"mapStringMsg":{}}'
       expected_preserve = '{"map_string_int32":{"a":1},"map_string_msg":{}}'
       assert MapMessage.encode_json(m) == expected
 
       json = MapMessage.encode_json(m, :preserve_proto_fieldnames => true)
       assert json == expected_preserve
 
       m2 = MapMessage.decode_json(MapMessage.encode_json(m))
       assert m == m2
     end
+
+    def test_comparison_with_arbitrary_object
+      assert MapMessage.new != nil
+    end
+
+    def test_respond_to
+      # This test fails with JRuby 1.7.23, likely because of an old JRuby bug.
+      return if RUBY_PLATFORM == "java"
+      msg = MapMessage.new
+      assert msg.respond_to?(:map_string_int32)
+      assert !msg.respond_to?(:bacon)
+    end
   end
 end