protobuf 2.8.0.beta9 → 2.8.0

data/test/proto/types.proto

@@ -1,37 +0,0 @@
-package test.types;
-
-message TestTypes {
-  required double type1 = 1;
-  required float type2 = 2;
-  required int32 type3 = 3;
-  required int64 type4 = 4;
-  required uint32 type5 = 5;
-  required uint64 type6 = 6;
-  required sint32 type7 = 7;
-  required sint64 type8 = 8;
-  required fixed32 type9 = 9;
-  required fixed64 type10 = 10;
-  required bool type11 = 11;
-  required string type12 = 12;
-  required bytes type13 = 13;
-  required sfixed32 type14 = 14;
-  required sfixed64 type15 = 15;
-}
-
-message RepeatedTypes {
-  repeated double type1 = 1;
-  repeated float type2 = 2;
-  repeated int32 type3 = 3;
-  repeated int64 type4 = 4;
-  repeated uint32 type5 = 5;
-  repeated uint64 type6 = 6;
-  repeated sint32 type7 = 7;
-  repeated sint64 type8 = 8;
-  repeated fixed32 type9 = 9;
-  repeated fixed64 type10 = 10;
-  repeated bool type11 = 11;
-  repeated string type12 = 12;
-  repeated bytes type13 = 13;
-  repeated sfixed32 type14 = 14;
-  repeated sfixed64 type15 = 15;
-}

data/test/test_addressbook.rb

@@ -1,56 +0,0 @@
-require 'test/unit'
-require 'protobuf/message/message'
-require 'protobuf/enum'
-require 'test/proto/addressbook.pb'
-
-class AddressbookTest < Test::Unit::TestCase
-  def test_enum
-    phone_number = Tutorial::Person::PhoneNumber.new
-    assert_equal(Tutorial::Person::PhoneType::HOME, phone_number.type)
-    phone_number.type = Tutorial::Person::PhoneType::MOBILE
-    assert_equal(0, phone_number.type)
-    phone_number.type = Tutorial::Person::PhoneType::HOME
-    assert_equal(1, phone_number.type)
-    phone_number.type = Tutorial::Person::PhoneType::WORK
-    assert_equal(2, phone_number.type)
-    assert_raise(TypeError) do
-      phone_number.type = 3
-    end
-  end
-
-  def test_symbol_enum
-    phone_number = Tutorial::Person::PhoneNumber.new
-    assert_equal(Tutorial::Person::PhoneType::HOME, phone_number.type)
-    phone_number.type = :MOBILE
-    assert_equal(0, phone_number.type)
-    phone_number.type = :HOME
-    assert_equal(1, phone_number.type)
-    phone_number.type = :WORK
-    assert_equal(2, phone_number.type)
-    assert_raise(TypeError) do
-      phone_number.type = :UNKNOWN
-    end
-  end
-
-  def test_initial_value
-    person = Tutorial::Person.new
-    assert_nil(person.name)
-    assert_nil(person.id)
-    assert_equal([], person.phone)
-    assert_equal('', person.email)
-  end
-
-  def test_repeatable
-    address_book = Tutorial::AddressBook.new
-    assert_equal([], address_book.person)
-    assert_instance_of(Protobuf::Field::FieldArray, address_book.person)
-    address_book.person << Tutorial::Person.new
-    assert_equal(1, address_book.person.size)
-    assert_raise(TypeError) do
-      address_book.person << 1
-    end
-    assert_equal(1, address_book.person.size)
-    address_book.person << Tutorial::Person.new
-    assert_equal(2, address_book.person.size)
-  end
-end

data/test/test_enum_value.rb

@@ -1,41 +0,0 @@
-require 'test/unit'
-require 'protobuf/message/message'
-require 'protobuf/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

@@ -1,36 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,128 +0,0 @@
-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

@@ -1,103 +0,0 @@
-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

data/test/test_packed_field.rb

@@ -1,40 +0,0 @@
-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