protobuf 1.0.0

data/test/test_descriptor.rb

@@ -0,0 +1,122 @@
+require 'test/unit'
+require 'test/proto/addressbook.pb'
+require 'protobuf/descriptor/descriptor_builder'
+require 'protobuf/descriptor/descriptor_proto'
+
+class DescriptorTest < Test::Unit::TestCase
+  include Google::Protobuf
+  def test_build
+    tutorial_proto = FileDescriptorProto.new
+    tutorial_proto.package = 'Build::Tutorial'
+
+    person_proto = DescriptorProto.new
+    tutorial_proto.message_type << person_proto
+    person_proto.name = 'Person'
+
+    person_name_proto = FieldDescriptorProto.new
+    person_proto.field << person_name_proto
+    person_name_proto.label = FieldDescriptorProto::Label::LABEL_REQUIRED
+    person_name_proto.type = FieldDescriptorProto::Type::TYPE_STRING
+    person_name_proto.name = 'name'
+    person_name_proto.number = 1
+
+    person_id_proto = FieldDescriptorProto.new
+    person_proto.field << person_id_proto
+    person_id_proto.label = FieldDescriptorProto::Label::LABEL_REQUIRED
+    person_id_proto.type = FieldDescriptorProto::Type::TYPE_INT32
+    person_id_proto.name = 'id'
+    person_id_proto.number = 2
+
+    person_email_proto = FieldDescriptorProto.new
+    person_proto.field << person_email_proto
+    person_email_proto.label = FieldDescriptorProto::Label::LABEL_OPTIONAL
+    person_email_proto.type = FieldDescriptorProto::Type::TYPE_STRING
+    person_email_proto.name = 'email'
+    person_email_proto.number = 3
+
+    person_phone_type_proto = EnumDescriptorProto.new
+    person_proto.enum_type << person_phone_type_proto
+    person_phone_type_proto.name = 'PhoneType'
+
+    person_phone_type_mobile_proto = EnumValueDescriptorProto.new
+    person_phone_type_proto.value << person_phone_type_mobile_proto
+    person_phone_type_mobile_proto.name = 'MOBILE'
+    person_phone_type_mobile_proto.number = 0
+
+    person_phone_type_home_proto = EnumValueDescriptorProto.new
+    person_phone_type_proto.value << person_phone_type_home_proto
+    person_phone_type_home_proto.name = 'HOME'
+    person_phone_type_home_proto.number = 1
+
+    person_phone_type_work_proto = EnumValueDescriptorProto.new
+    person_phone_type_proto.value << person_phone_type_work_proto
+    person_phone_type_work_proto.name = 'WORK'
+    person_phone_type_work_proto.number = 2
+
+    person_phone_number_proto = DescriptorProto.new
+    person_proto.nested_type << person_phone_number_proto
+    person_phone_number_proto.name = 'PhoneNumber'
+
+    person_phone_number_number_proto = FieldDescriptorProto.new
+    person_phone_number_proto.field << person_phone_number_number_proto
+    person_phone_number_number_proto.label = FieldDescriptorProto::Label::LABEL_REQUIRED
+    person_phone_number_number_proto.type = FieldDescriptorProto::Type::TYPE_STRING
+    person_phone_number_number_proto.name = 'number'
+    person_phone_number_number_proto.number = 1
+
+    person_phone_number_type_proto = FieldDescriptorProto.new
+    person_phone_number_proto.field << person_phone_number_type_proto
+    person_phone_number_type_proto.label = FieldDescriptorProto::Label::LABEL_OPTIONAL
+    person_phone_number_type_proto.type = FieldDescriptorProto::Type::TYPE_ENUM
+    person_phone_number_type_proto.type_name = 'PhoneType'
+    person_phone_number_type_proto.name = 'type'
+    person_phone_number_type_proto.number = 2
+    person_phone_number_type_proto.default_value = 'HOME'
+
+    person_phone_phone_number_proto = FieldDescriptorProto.new
+    person_proto.field << person_phone_phone_number_proto
+    person_phone_phone_number_proto.label = FieldDescriptorProto::Label::LABEL_REPEATED
+    person_phone_phone_number_proto.type = FieldDescriptorProto::Type::TYPE_MESSAGE
+    person_phone_phone_number_proto.type_name = 'PhoneNumber'
+    person_phone_phone_number_proto.name = 'phone'
+    person_phone_phone_number_proto.number = 4
+
+    address_book_proto = DescriptorProto.new
+    tutorial_proto.message_type << address_book_proto
+    address_book_proto.name = 'AddressBook'
+
+    address_book_person_proto = FieldDescriptorProto.new
+    address_book_proto.field << address_book_person_proto
+    address_book_person_proto.label = FieldDescriptorProto::Label::LABEL_REPEATED
+    address_book_person_proto.type = FieldDescriptorProto::Type::TYPE_MESSAGE
+    address_book_person_proto.type_name = 'Person'
+    address_book_person_proto.name = 'person'
+    address_book_person_proto.number = 1
+
+    Protobuf::Descriptor::DescriptorBuilder.build(tutorial_proto)
+
+    assert_nothing_raised {Build::Tutorial::Person}
+    assert_nothing_raised {Build::Tutorial::Person.new}
+    assert_equal(['email', 'id', 'name', 'phone'],
+      Build::Tutorial::Person.fields.map{|tag, field| field.name}.sort)
+
+    assert_nothing_raised {Build::Tutorial::Person::PhoneNumber}
+    assert_nothing_raised {Build::Tutorial::Person::PhoneNumber.new}
+    assert_equal(['number', 'type'],
+      Build::Tutorial::Person::PhoneNumber.fields.map{|tag, field| field.name}.sort)
+
+    assert_nothing_raised {Build::Tutorial::Person::PhoneType}
+    assert_equal(0, Build::Tutorial::Person::PhoneType::MOBILE)
+    assert_equal(1, Build::Tutorial::Person::PhoneType::HOME)
+    assert_equal(2, Build::Tutorial::Person::PhoneType::WORK)
+
+    assert_nothing_raised {Build::Tutorial::AddressBook}
+  end
+
+  def test_unbuild
+    proto = Protobuf::Descriptor::FileDescriptor.unbuild(Tutorial::Person)
+    proto.serialize_to_file('person.bin')
+    puts
+    puts "run `test/check_unbuild.rb'"
+  end
+end

data/test/test_enum_value.rb

@@ -0,0 +1,41 @@
+require 'test/unit'
+require 'protobuf/message/message'
+require 'protobuf/message/enum'
+require 'test/proto/addressbook.pb'
+require 'test/proto/addressbook_base.pb'
+
+class EnumValueTest < Test::Unit::TestCase
+  def test_enum_value
+    e = Protobuf::EnumValue.new(Object, :name, 100)
+    assert_kind_of(Protobuf::EnumValue, e)
+    assert_equal(:name, e.name)
+    assert_equal(100, e.value)
+    assert_equal('name', e.to_s)
+    assert_equal('name', "#{e}")
+    assert(e == 100)
+    assert(100 == e)
+    assert(101, e + 1)
+    assert(101, 1 + e)
+  end
+
+  def test_enum_field_and_enum_value
+    phone_number = Tutorial::Person::PhoneNumber.new
+
+    assert_kind_of(Protobuf::EnumValue, phone_number.type)
+    assert_equal(Tutorial::Person::PhoneType::HOME, phone_number.type)
+
+    phone_number.type = 1
+    assert_kind_of(Protobuf::EnumValue, phone_number.type)
+    assert_equal(Tutorial::Person::PhoneType::HOME, phone_number.type)
+    assert_equal(1, phone_number.type)
+
+    phone_number.type = :HOME
+    assert_kind_of(Protobuf::EnumValue, phone_number.type)
+    assert_equal(Tutorial::Person::PhoneType::HOME, phone_number.type)
+    assert_equal(1, phone_number.type)
+
+    assert_raise(TypeError) do
+      phone_number.type = TutorialExt::Person::PhoneType::HOME
+    end
+  end
+end

data/test/test_extension.rb

@@ -0,0 +1,36 @@
+require 'test/unit'
+require 'test/proto/addressbook_ext.pb'
+
+class ExtensionTest < Test::Unit::TestCase
+  def test_accessor
+    assert(TutorialExt::Person.extension_fields.to_a.map{|t, f| f.name}.include?(:age))
+    person = TutorialExt::Person.new
+    assert_nothing_raised {person.age = 100}
+    assert_equal(100, person.age)
+  end
+
+  def test_serialize
+    # serialize to string
+    person = TutorialExt::Person.new
+    person.id = 1234
+    person.age = 70
+    person.name = 'John Doe'
+    person.email = 'jdoe@example.com'
+    phone = TutorialExt::Person::PhoneNumber.new
+    phone.number = '555-4321'
+    phone.type = TutorialExt::Person::PhoneType::HOME
+    person.phone << phone
+    serialized_string = person.serialize_to_string
+
+    # parse the serialized string
+    person2 = TutorialExt::Person.new
+    person2.parse_from_string serialized_string
+    assert_equal(1234, person2.id)
+    assert_equal(70, person2.age)
+    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(TutorialExt::Person::PhoneType::HOME, person2.phone[0].type)
+  end
+end

data/test/test_lowercase.rb

@@ -0,0 +1,11 @@
+require 'test/unit'
+require 'test/proto/lowercase.pb'
+
+class LowercaseTest < Test::Unit::TestCase
+  def test_lowercase
+    message = nil
+    assert_nothing_raised { message = Test::Lowercase::Baaz.new }
+    assert_nothing_raised { message.x = Test::Lowercase::Foo::Bar.new }
+    assert_equal(Test::Lowercase::Foo::Bar, message.get_field_by_name(:x).type)
+  end
+end

data/test/test_message.rb

@@ -0,0 +1,128 @@
+require 'protobuf/message/message'
+require 'test/proto/addressbook.pb'
+require 'test/proto/merge.pb'
+require 'test/unit'
+
+# It should not conflict with Test::InnerMessage1 which is included in merge.proto
+class InnerMessage1; end
+
+class MessageTest < Test::Unit::TestCase
+  def test_equality
+    person1 = Tutorial::Person.new :name => 'ando'
+    person2 = Tutorial::Person.new :name => 'ando'
+    person3 = Tutorial::Person.new :name => 'Ando'
+    assert(person1 == person2)
+    assert(person1 != person3)
+    assert(person1 != 'ando')
+  end
+
+  def test_bracketed_access
+    person = Tutorial::Person.new
+    name_tag = 1
+    person[name_tag] = 'Ichiro'
+    assert_equal('Ichiro', person.name)
+    assert_equal('Ichiro', person[name_tag])
+
+    person[:id] = 100
+    assert_equal(100, person.id)
+    person['id'] = 200
+    assert_equal(200, person.id)
+    assert_equal(200, person[:id])
+    assert_equal(200, person['id'])
+  end
+
+  def test_initialize_with_hash
+    person = Tutorial::Person.new(:name => 'Jiro', :id => 300, :email => 'jiro@ema.il')
+    assert_equal('Jiro', person.name)
+    assert_equal(300, person.id)
+    assert_equal('jiro@ema.il', person.email)
+
+    # initialize with array of hash
+    person = Tutorial::Person.new(:phone => [{:number => 'phone1'}, {:number => 'phone2'}])
+    assert_equal('phone1', person.phone[0].number)
+    assert_equal('phone2', person.phone[1].number)
+
+    # initalize with hash in hash
+    message = Test::MergeMessage.new(:require_message => { :name => 'name1', :repeate_message => [{:name => 'name2'}] })
+    assert_equal('name1', message.require_message.name)
+    assert_equal('name2', message.require_message.repeate_message[0].name)
+
+    message.require_message = { :name => 'name21' }
+    message.require_message.repeate_message = [ {:name => 'name22'} ]
+    assert_equal('name21', message.require_message.name)
+    assert_equal('name22', message.require_message.repeate_message[0].name)
+    assert_equal(1,        message.require_message.repeate_message.size)
+  end
+
+  def test_defined_filenames
+    assert(Tutorial::Person.defined_filenames)
+    assert_equal(1, Tutorial::Person.defined_filenames.size)
+    assert_match(%r{/.*/proto/addressbook\.pb\.rb}, Tutorial::Person.defined_filenames.first)
+  end
+
+  def test_proto_filenames
+    assert(Tutorial::Person.proto_filenames)
+    assert_equal(1, Tutorial::Person.proto_filenames.size)
+    assert_equal('test/proto/addressbook.proto', Tutorial::Person.proto_filenames.first)
+  end
+
+  def test_proto_contents
+    assert_equal(<<-EOS.strip, Tutorial::Person.proto_contents.values.first.strip)
+package tutorial;
+
+message Person {
+  required string name = 1;
+  required int32 id = 2;
+  optional string email = 3;
+
+  enum PhoneType {
+    MOBILE = 0;
+    HOME = 1;
+    WORK = 2;
+  }
+
+  message PhoneNumber {
+    required string number = 1;
+    optional PhoneType type = 2 [default = HOME];
+  }
+
+  repeated PhoneNumber phone = 4;
+  optional uint32 age = 5 [default = 20];
+
+  extensions 100 to 200;
+}
+
+/*
+extend Person {
+  optional int32 age = 100;
+}
+*/
+
+message AddressBook {
+  repeated Person person = 1;
+}
+    EOS
+  end
+
+  def test_merge_field
+    inner_message1_2 = Test::MergeMessage::InnerMessage2.new(:name => 'name12')
+    inner_message1_2.repeate_message << Test::MergeMessage::InnerMessage1.new(:name => 'name121')
+    message1 = Test::MergeMessage.new(:name => 'name1', :require_message => inner_message1_2)
+    message1.repeate_message << Test::MergeMessage::InnerMessage1.new(:name => 'name11')
+
+    inner_message2_2 = Test::MergeMessage::InnerMessage2.new(:name => 'name22')
+    inner_message2_2.repeate_message << Test::MergeMessage::InnerMessage1.new(:name => 'name221')
+    message2 = Test::MergeMessage.new(:name => 'name2', :require_message => inner_message2_2)
+    message2.repeate_message << Test::MergeMessage::InnerMessage1.new(:name => 'name21')
+
+    message1.merge_from(message2)
+    assert_equal('name2', message1.name)
+    assert_equal(2, message1.repeate_message.size)
+    assert_equal('name11', message1.repeate_message[0].name)
+    assert_equal('name21', message1.repeate_message[1].name)
+    assert_equal('name22', message1.require_message.name)
+    assert_equal(2, message1.require_message.repeate_message.size)
+    assert_equal('name121', message1.require_message.repeate_message[0].name)
+    assert_equal('name221', message1.require_message.repeate_message[1].name)
+  end
+end

data/test/test_optional_field.rb

@@ -0,0 +1,103 @@
+require 'test/unit'
+require 'test/proto/optional_field.pb'
+
+class OptionalFieldTest < Test::Unit::TestCase
+  def test_accessor
+    message = Test::OptionalField::Message.new
+
+    # default values
+    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?(:enum))
+    assert_equal(2, message.enum)
+
+    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_nothing_raised { message.text = 'abc' }
+    assert(message.has_field?(:text))
+    assert_equal('abc', message.text)
+
+    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_equal(-20, message.signed)
+  end
+
+  def test_serialize
+    message1 = Test::OptionalField::Message.new
+    message2 = Test::OptionalField::Message.new
+
+    # all fields are empty
+    serialized_string = message1.to_s
+    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))
+
+    # assign the value whith is equal to default value
+    message1 = Test::OptionalField::Message.new
+    message1.number = message1.number
+    message1.text   = message1.text
+    message1.enum   = message1.enum
+    message1.signed = message1.signed
+    serialized_string = message1.to_s
+    assert !serialized_string.empty?
+
+    # set some fields
+    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))
+  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