ruby_protobuf 0.3.3 → 0.4.1

data/test/test_optional_field.rb

@@ -1,60 +1,60 @@
 require 'test/unit'
-require 'test/optional_field'
+require 'test/proto/optional_field.pb'
 
 class OptionalFieldTest < Test::Unit::TestCase
   def test_accessor
-    message = Test::Optional_field::Message.new
+    message = Test::OptionalField::Message.new
 
     # default values
-    assert !message.has_field?(:number)
-    assert_equal 20, message.number
+    assert(!message.has_field?(:number))
+    assert_equal(20, message.number)
 
-    assert !message.has_field?(:text)
-    assert_equal 'default string', message.text
+    assert(!message.has_field?(:text))
+    assert_equal('default string', message.text)
 
-    assert !message.has_field?(:enum)
-    assert_equal 2, message.enum
+    assert(!message.has_field?(:enum))
+    assert_equal(2, message.enum)
 
-    assert !message.has_field?(:signed)
+    assert(!message.has_field?(:signed))
     assert_equal(-100, message.signed)
 
     # assign values
     assert_nothing_raised { message.number = 100 }
-    assert message.has_field?(:number)
-    assert_equal 100, message.number
+    assert(message.has_field?(:number))
+    assert_equal(100, message.number)
 
     assert_nothing_raised { message.text = 'abc' }
-    assert message.has_field?(:text)
-    assert_equal 'abc', message.text
+    assert(message.has_field?(:text))
+    assert_equal('abc', message.text)
 
-    assert_nothing_raised { message.enum = Test::Optional_field::Message::Enum::A }
-    assert message.has_field?(:enum)
-    assert_equal 1, message.enum
+    assert_nothing_raised { message.enum = Test::OptionalField::Message::Enum::A }
+    assert(message.has_field?(:enum))
+    assert_equal(1, message.enum)
 
     assert_nothing_raised { message.signed = -20 }
-    assert message.has_field?(:signed)
+    assert(message.has_field?(:signed))
     assert_equal(-20, message.signed)
   end
 
   def test_serialize
-    message1 = Test::Optional_field::Message.new
-    message2 = Test::Optional_field::Message.new
+    message1 = Test::OptionalField::Message.new
+    message2 = Test::OptionalField::Message.new
 
     # all fields are empty
     serialized_string = message1.to_s
-    assert serialized_string.empty?
+    assert(serialized_string.empty?)
     message2.parse_from_string(serialized_string)
-    assert_equal message1.number, message2.number
-    assert_equal message1.text,   message2.text
-    assert_equal message1.enum,   message2.enum
-    assert_equal message1.signed, message2.signed
-    assert !message2.has_field?(:number)
-    assert !message2.has_field?(:text)
-    assert !message2.has_field?(:enum)
-    assert !message2.has_field?(:signed)
+    assert_equal(message1.number, message2.number)
+    assert_equal(message1.text,   message2.text)
+    assert_equal(message1.enum,   message2.enum)
+    assert_equal(message1.signed, message2.signed)
+    assert(!message2.has_field?(:number))
+    assert(!message2.has_field?(:text))
+    assert(!message2.has_field?(:enum))
+    assert(!message2.has_field?(:signed))
 
     # assign the value whith is equal to default value
-    message1 = Test::Optional_field::Message.new
+    message1 = Test::OptionalField::Message.new
     message1.number = message1.number
     message1.text   = message1.text
     message1.enum   = message1.enum
@@ -63,18 +63,41 @@ class OptionalFieldTest < Test::Unit::TestCase
     assert !serialized_string.empty?
 
     # set some fields
-    message1 = Test::Optional_field::Message.new
+    message1 = Test::OptionalField::Message.new
     message1.number = 100
     message1.text   = 'new text'
     serialized_string = message1.to_s
     message2.parse_from_string(serialized_string)
-    assert_equal message1.number, message2.number
-    assert_equal message1.text,   message2.text
-    assert_equal message1.enum,   message2.enum
-    assert_equal message1.signed, message2.signed
-    assert  message2.has_field?(:number)
-    assert  message2.has_field?(:text)
-    assert !message2.has_field?(:enum)
-    assert !message2.has_field?(:signed)
+    assert_equal(message1.number, message2.number)
+    assert_equal(message1.text,   message2.text)
+    assert_equal(message1.enum,   message2.enum)
+    assert_equal(message1.signed, message2.signed)
+    assert( message2.has_field?(:number))
+    assert( message2.has_field?(:text))
+    assert(!message2.has_field?(:enum))
+    assert(!message2.has_field?(:signed))
   end
+
+  def test_merge_optional_fields
+    src1 = Test::OptionalField::Message.new
+    src2 = Test::OptionalField::Message.new
+    dst  = Test::OptionalField::Message.new
+
+    src1.number = 100
+    src1.text   = 'old'
+    src2.text   = 'new'
+    src2.signed = 20
+
+    serialized_string = src1.to_s + src2.to_s
+    dst.parse_from_string(serialized_string)
+
+    assert_equal(100,   dst.number)
+    assert_equal('new', dst.text)
+    assert_equal(20,    dst.signed)
+    assert  dst.has_field?(:number)
+    assert  dst.has_field?(:text)
+    assert !dst.has_field?(:enum)
+    assert  dst.has_field?(:signed)
+  end
+
 end

data/test/test_packed_field.rb

@@ -0,0 +1,40 @@
+require 'test/unit'
+require 'test/proto/packed.pb'
+
+class PackedFieldTest < Test::Unit::TestCase
+
+  def test_packed_field
+    values = [1, 1_000, 10_000, 1_000_000, 1_000_000_000]
+
+    # encode
+    message = Test::PackedField::Message.new
+    message.a = values
+    message.b = values
+
+    expected = ''
+    serialized_string = nil
+    assert_nothing_raised { serialized_string = message.serialize_to_string }
+
+    value = values.map {|v| Protobuf::Field::VarintField.encode(v) }.join
+    expected << Protobuf::Field::VarintField.encode((1 << 3) | 2)  # tag=1, wire_type=2 (length-delimited)
+    expected << Protobuf::Field::VarintField.encode(value.size)
+    expected << value
+
+    value = values.pack('V*')
+    expected << Protobuf::Field::VarintField.encode((2 << 3) | 2)  # tag=2, wire_type=2 (length-delimited)
+    expected << Protobuf::Field::VarintField.encode(value.size)
+    expected << value
+
+    assert_equal(expected, serialized_string)
+
+    # decode
+    message2 = Test::PackedField::Message.new
+    assert_nothing_raised { message2.parse_from_string(serialized_string) }
+
+    values.each_with_index do |val, n|
+      assert_equal(val, message.a[n])
+      assert_equal(val, message.b[n])
+    end
+  end
+
+end

data/test/test_parse.rb

@@ -1,15 +1,15 @@
 require 'test/unit'
-require 'test/addressbook'
+require 'test/proto/addressbook.pb'
 
 class ParseTest < Test::Unit::TestCase
   def test_parse
     person = Tutorial::Person.new
-    person.parse_from_file 'test/data/data.bin'
-    assert_equal 1234, person.id
-    assert_equal 'John Doe', person.name
-    assert_equal 'jdoe@example.com', person.email
-    assert_equal 1, person.phone.size
-    assert_equal '555-4321', person.phone[0].number
-    assert_equal Tutorial::Person::PhoneType::HOME, person.phone[0].type
+    person.parse_from_file('test/data/data.bin')
+    assert_equal(1234, person.id)
+    assert_equal('John Doe', person.name)
+    assert_equal('jdoe@example.com', person.email)
+    assert_equal(1, person.phone.size)
+    assert_equal('555-4321', person.phone[0].number)
+    assert_equal(Tutorial::Person::PhoneType::HOME, person.phone[0].type)
   end
 end

data/test/test_repeated_types.rb

@@ -1,5 +1,5 @@
 require 'test/unit'
-require 'test/types'
+require 'test/proto/types.pb'
 
 class RepeatedTypesTest < Test::Unit::TestCase
   def test_serialize
@@ -10,9 +10,9 @@ class RepeatedTypesTest < Test::Unit::TestCase
     # has 1 member
     types = Test::Types::RepeatedTypes.new
     types.type1 << 0.01
-    types.type2 << 0.1 
+    types.type2 << 0.1
     types.type3 << 1
-    types.type4 << 10 
+    types.type4 << 10
     types.type5 << 100
     types.type6 << 1000
     types.type7 << -1
@@ -103,4 +103,30 @@ class RepeatedTypesTest < Test::Unit::TestCase
     assert_equal(-2_000_000_000, types2.type14[1])
     assert_equal(-8_000_000_000_000_000_000, types2.type15[1])
   end
+
+  def test_repeated_types
+    types = Test::Types::RepeatedTypes.new
+    # types.type3 is a repeated int32 field.
+    assert(types.type3.empty?)
+    types.type3 << 0
+    types.type3 << 1
+    assert_equal(0, types.type3[0])
+    assert_equal(1, types.type3[1])
+    assert_equal(2, types.type3.size)
+
+    assert_raise(TypeError) do
+      types.type3 << 'string'
+    end
+    
+    types.type3[1] = 10
+    assert_equal(0, types.type3[0])
+    assert_equal(10, types.type3[1])
+    assert_equal(2, types.type3.size)
+
+    types.type3.replace([10, 20, 30])
+    assert_equal(10, types.type3[0])
+    assert_equal(20, types.type3[1])
+    assert_equal(30, types.type3[2])
+    assert_equal(3, types.type3.size)
+  end
 end

data/test/test_serialize.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 require 'test/unit'
-require 'test/addressbook'
+require 'test/proto/addressbook.pb'
 
 class SerializeTest < Test::Unit::TestCase
   def test_serialize
@@ -17,13 +17,13 @@ class SerializeTest < Test::Unit::TestCase
 
     # parse the serialized string
     person2 = Tutorial::Person.new
-    person2.parse_from_string serialized_string
-    assert_equal 1234, person2.id
-    assert_equal 'John Doe', person2.name
-    assert_equal 'jdoe@example.com', person2.email
-    assert_equal 1, person2.phone.size
-    assert_equal '555-4321', person2.phone[0].number
-    assert_equal Tutorial::Person::PhoneType::HOME, person2.phone[0].type
+    person2.parse_from_string(serialized_string)
+    assert_equal(1234, person2.id)
+    assert_equal('John Doe', person2.name)
+    assert_equal('jdoe@example.com', person2.email)
+    assert_equal(1, person2.phone.size)
+    assert_equal('555-4321', person2.phone[0].number)
+    assert_equal(Tutorial::Person::PhoneType::HOME, person2.phone[0].type)
   end
 
   def test_serialize_utf8string
@@ -35,9 +35,9 @@ class SerializeTest < Test::Unit::TestCase
 
     # parse the serialized string
     person2 = Tutorial::Person.new
-    person2.parse_from_string serialized_string
-    assert_equal 1234, person2.id
-    assert_equal '山田 太郎', person2.name
+    person2.parse_from_string(serialized_string)
+    assert_equal(1234, person2.id)
+    assert_equal('山田 太郎', person2.name)
   end
 
   def test_unknown_field
@@ -54,7 +54,7 @@ class SerializeTest < Test::Unit::TestCase
 
     # decode
     person2 = Tutorial::Person.new
-    person2.parse_from_string serialized_string
+    person2.parse_from_string(serialized_string)
 
     assert_equal(person, person2)
   end

data/test/test_standard_message.rb

@@ -1,22 +1,23 @@
 require 'test/unit'
 require 'protobuf/message/message'
 require 'protobuf/message/enum'
-require 'test/addressbook'
+require 'test/proto/addressbook.pb'
 
 class StandardMessageTest < Test::Unit::TestCase
   def test_initialized
     person = Tutorial::Person.new
-    assert !person.initialized?
+    assert(!person.initialized?)
+    assert_raise(Protobuf::NotInitializedError) { person.to_s }
     person.name = 'name'
-    assert !person.initialized?
+    assert(!person.initialized?)
     person.id = 12
-    assert person.initialized?
+    assert( person.initialized?)
 
     # repeated field
     person.phone << Tutorial::Person::PhoneNumber.new
-    assert !person.initialized?
+    assert(!person.initialized?)
     person.phone.last.number = '123-456'
-    assert  person.initialized?
+    assert( person.initialized?)
   end
 
   def test_clear
@@ -27,14 +28,14 @@ class StandardMessageTest < Test::Unit::TestCase
     person.phone << Tutorial::Person::PhoneNumber.new
     person.clear!
 
-    assert_nil person.name
-    assert_nil person.id
-    assert_equal '', person.email
-    assert_equal 0, person.phone.size
+    assert_nil(person.name)
+    assert_nil(person.id)
+    assert_equal('', person.email)
+    assert_equal(0, person.phone.size)
 
-    assert !person.has_field?(:name)
-    assert !person.has_field?(:id)
-    assert !person.has_field?(:email)
+    assert(!person.has_field?(:name))
+    assert(!person.has_field?(:id))
+    assert(!person.has_field?(:email))
   end
 
   def test_dup
@@ -50,20 +51,20 @@ class StandardMessageTest < Test::Unit::TestCase
     person.phone.last.type = Tutorial::Person::PhoneType::WORK
 
     person2 = person.dup
-    assert person == person2
-    assert !person.eql?(person2)
-    assert_equal person.name, person2.name
-    assert_equal person.id, person2.id
-    assert_equal person.email, person2.email
-    assert_equal person.phone.size, person2.phone.size
-    assert person.phone.first == person2.phone.first
-    assert !person.phone.first.eql?(person2.phone.first)
-    assert_equal person.phone.first.number, person2.phone.first.number
-    assert_equal person.phone.first.type, person2.phone.first.type
-    assert person.phone.last == person2.phone.last
-    assert !person.phone.last.eql?(person2.phone.last)
-    assert_equal person.phone.last.number, person2.phone.last.number
-    assert_equal person.phone.last.type, person2.phone.last.type
+    assert(person == person2)
+    assert(!person.eql?(person2))
+    assert_equal(person.name, person2.name)
+    assert_equal(person.id, person2.id)
+    assert_equal(person.email, person2.email)
+    assert_equal(person.phone.size, person2.phone.size)
+    assert(person.phone.first == person2.phone.first)
+    assert(!person.phone.first.eql?(person2.phone.first))
+    assert_equal(person.phone.first.number, person2.phone.first.number)
+    assert_equal(person.phone.first.type, person2.phone.first.type)
+    assert(person.phone.last == person2.phone.last)
+    assert(!person.phone.last.eql?(person2.phone.last))
+    assert_equal(person.phone.last.number, person2.phone.last.number)
+    assert_equal(person.phone.last.type, person2.phone.last.type)
   end
 
   def test_inspect
@@ -78,7 +79,7 @@ class StandardMessageTest < Test::Unit::TestCase
     person.phone.last.number = '456-123'
     person.phone.last.type = Tutorial::Person::PhoneType::WORK
 
-    assert_equal <<-eos, person.inspect
+    assert_equal <<-EOS, person.inspect
 name: "name"
 id: 1234
 email: "abc@cde.fgh"
@@ -90,7 +91,6 @@ phone {
   number: "456-123"
   type: WORK
 }
-    eos
+    EOS
   end
 end
-