chrisk-protopuffs 0.2.0

data/test/message_base_test.rb

@@ -0,0 +1,98 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class MessageBaseTest < Test::Unit::TestCase
+
+  context ".define_message_class using 'Person' and two fields" do
+    should "create a Message::Person class" do
+      fields = [Protopuffs::MessageField.new("optional", "string", "name", 1),
+                Protopuffs::MessageField.new("optional", "string", "address", 2)]
+      Protopuffs::Message::Base.define_message_class("Person", fields)
+      Protopuffs::Message::Person
+    end
+
+    should "create a class with accessors for each field" do
+      fields = [Protopuffs::MessageField.new("optional", "string", "name", 1),
+                Protopuffs::MessageField.new("optional", "string", "address", 2)]
+      Protopuffs::Message::Base.define_message_class("Person", fields)
+      person = Protopuffs::Message::Person.new
+      person.name = "Chris"
+      person.address = "61 Carmelita St."
+      assert_equal person.name, "Chris"
+      assert_equal person.address, "61 Carmelita St."
+    end
+  end
+
+
+  context ".define_message_class with fields that have duplicate tags" do
+    should "raise a Protopuffs::ParseError" do
+      fields = [Protopuffs::MessageField.new("optional", "int32", "name", 1),
+                Protopuffs::MessageField.new("optional", "string", "address", 1)]
+      assert_raises Protopuffs::ParseError do
+        Protopuffs::Message::Base.define_message_class("Person", fields)
+      end
+    end
+  end
+
+
+  context ".define_message_class with fields that have invalid tags" do
+    should "raise a Protopuffs::ParseError when a tag is too large" do
+      fields = [Protopuffs::MessageField.new("optional", "int32", "name", 1),
+                Protopuffs::MessageField.new("optional", "string", "address", 536_870_912)]
+      assert_raises Protopuffs::ParseError do
+        Protopuffs::Message::Base.define_message_class("Person", fields)
+      end
+    end
+
+    should "raise a Protopuffs::ParseError when a tag is too small" do
+      fields = [Protopuffs::MessageField.new("optional", "int32", "name", 0),
+                Protopuffs::MessageField.new("optional", "string", "address", 1)]
+      assert_raises Protopuffs::ParseError do
+        Protopuffs::Message::Base.define_message_class("Person", fields)
+      end
+    end
+
+    should "raise a Protopuffs::ParseError when a tag is reserved" do
+      fields = [Protopuffs::MessageField.new("optional", "string", "name", 19050)]
+      assert_raises Protopuffs::ParseError do
+        Protopuffs::Message::Base.define_message_class("Person", fields)
+      end
+    end
+  end
+
+
+  should "not allow you to instantiate Message::Base directly" do
+    assert_raises RuntimeError do
+      Protopuffs::Message::Base.new
+    end
+  end
+
+
+  context "comparing messages with #==" do
+    should "return false when the messages have different types" do
+      Protopuffs::Message::Base.define_message_class("Dog", [])
+      Protopuffs::Message::Base.define_message_class("Cat", [])
+      assert_not_equal Protopuffs::Message::Dog.new, Protopuffs::Message::Cat.new
+    end
+
+    should "return false when the messages' fields have different values" do
+      fields = [Protopuffs::MessageField.new("optional", "string", "name", 1)]
+      Protopuffs::Message::Base.define_message_class("Person", fields)
+      alice = Protopuffs::Message::Person.new
+      alice.name = "Alice"
+      bob = Protopuffs::Message::Person.new
+      bob.name = "Bob"
+      assert_not_equal alice, bob
+    end
+
+    should "return true when messages of the same type have the same field values" do
+      fields = [Protopuffs::MessageField.new("optional", "string", "name", 1)]
+      Protopuffs::Message::Base.define_message_class("Sheep", fields)
+      sheep = Protopuffs::Message::Sheep.new
+      sheep.name = "Dolly"
+      sheep2 = Protopuffs::Message::Sheep.new
+      sheep2.name = "Dolly"
+      assert_equal sheep, sheep2
+    end
+  end
+
+end

data/test/message_field_test.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class MessageFieldTest < Test::Unit::TestCase
+
+  context "creating a MessageField" do
+    should "set a string's default to '' when a default isn't specified" do
+      field = Protopuffs::MessageField.new("optional", "string", "name", 1)
+      assert_equal "", field.default
+    end
+
+    should "set a numeric's default to 0 when a default isn't specified" do
+      numeric_types = %w(double float int32 int64 uint32 unit64 sint32 sint64
+                         fixed32 fixed64 sfixed32 sfixed64)
+      numeric_types.each do |type|
+        assert_equal 0, Protopuffs::MessageField.new("optional", type, "number", 1).default
+      end
+    end
+
+    should "set a bool's default to false when a default isn't specified" do
+      field = Protopuffs::MessageField.new("optional", "bool", "opt_in", 1)
+      assert_same false, field.default
+    end
+
+    should "set the default to 'Matz' when that default is specified" do
+      field = Protopuffs::MessageField.new("optional", "string", "name", 1, "Matz")
+      assert_equal "Matz", field.default
+    end
+  end
+
+  should_return_wire_type_for_fields_typed 0 => %w(int32 int64 uint32 uint64 bool),
+                                           1 => %w(double fixed64),
+                                           2 => %w(bytes string TestMessage),
+                                           5 => %w(float fixed32)
+end

data/test/parse_tree_test.rb

@@ -0,0 +1,206 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class ParseTreeTest < Test::Unit::TestCase
+
+  context "a protocol buffer descriptor" do
+    setup do
+      @parser = Protopuffs::Parser::ProtocolBufferDescriptor.new
+    end
+
+    context "with an empty Person message" do
+      setup do
+        @proto = @parser.parse("message Person {}")
+      end
+
+      should "have one message" do
+        assert_equal 1, @proto.messages.size
+      end
+
+      should "have a message named Person" do
+        assert_equal "Person", @proto.messages.first.name
+      end
+
+      should "have an empty body" do
+        assert @proto.messages.first.body.empty?
+      end
+    end
+
+    context "with two empty messages Apple and Orange" do
+      setup do
+        @descriptor = <<-proto
+          message Apple {}
+          message Orange {}
+        proto
+      end
+
+      should "have two messages" do
+        proto = @parser.parse(@descriptor)
+        assert_equal 2, proto.messages.size
+      end
+
+      should "have messages named Apple and Orange" do
+        proto = @parser.parse(@descriptor)
+        assert_equal %w(Apple Orange), proto.messages.map { |m| m.name }.sort
+      end
+
+      should "have messages with empty bodes" do
+        proto = @parser.parse(@descriptor)
+        assert proto.messages.all? { |m| m.body.empty? }
+      end
+    end
+
+    context "a proto with a Person message including a name field" do
+      setup do
+        @descriptor = <<-proto
+          message Person {
+            required string name = 1;
+          }
+        proto
+      end
+
+      should "have one message named person" do
+        proto = @parser.parse(@descriptor)
+        assert_equal 1, proto.messages.size
+        assert_equal "Person", proto.messages.first.name
+      end
+
+      should "have one required string field called name with tag 1" do
+        proto = @parser.parse(@descriptor)
+        fields = proto.messages.first.body.fields
+        assert_equal 1, fields.size
+        assert_equal "required", fields.first.modifier.text_value
+        assert_equal "string", fields.first.type.text_value
+        assert_equal "name", fields.first.identifier.text_value
+        assert_equal "1", fields.first.integer.text_value
+      end
+    end
+
+    context "with a Person message including three fields" do
+      setup do
+        @descriptor = <<-proto
+          message Person {
+            required string name = 1;
+            required int32 id = 2;
+            optional string email = 3;
+          }
+        proto
+      end
+
+      should "have one message named person" do
+        proto = @parser.parse(@descriptor)
+        assert_equal 1, proto.messages.size
+        assert_equal "Person", proto.messages.first.name
+      end
+
+      should "have three fields with correct components" do
+        proto = @parser.parse(@descriptor)
+        fields = proto.messages.first.body.fields
+        assert_equal 3, fields.size
+        actual = fields.map { |f| [f.modifier, f.type, f.identifier, f.integer].map { |el| el.text_value } }
+        expected = [ %w(required string name 1),
+                     %w(required int32 id 2),
+                     %w(optional string email 3) ]
+        assert_equal expected, actual
+      end
+    end
+
+    context "with a Person message including two fields with defaults and one without" do
+      setup do
+        @proto = @parser.parse(<<-proto)
+          message Person {
+            required string name = 1;
+            optional string language = 2 [default = "en"];
+            optional int32 account_code = 3 [default = 0];
+          }
+        proto
+      end
+
+      should "have one message named person" do
+        assert_equal 1, @proto.messages.size
+        assert_equal "Person", @proto.messages.first.name
+      end
+
+      should "have three fields with correct components" do
+        fields = @proto.messages.first.body.fields
+        assert_equal 3, fields.size
+        actual = fields.map { |f| [f.modifier, f.type, f.identifier, f.integer, f.default] }
+        actual.map! { |f| f.map! { |el| el.respond_to?(:text_value) ? el.text_value : el } }
+        expected = [ ["required", "string", "name", "1", nil],
+                     ["optional", "string", "language", "2", "en"],
+                     ["optional", "int32", "account_code", "3", 0] ]
+        assert_equal expected, actual
+      end
+    end
+
+    context "with a message including lots of comments" do
+      setup do
+        @proto = @parser.parse(<<-proto)
+          // test
+          //test
+          message Person { //test // test
+            // test
+            required string name = 1; // test
+            // optional string language = 2 [default = "en"];
+            optional int32 account_code = 3 [default = 0]; // test
+            // test
+          } // test
+          // test
+          //test
+        proto
+      end
+
+      should "parse" do
+        assert_not_nil @proto
+      end
+
+      should "have uncommented fields with correct components" do
+        fields = @proto.messages.first.body.fields
+        assert_equal 2, fields.size
+        actual = fields.map { |f| [f.modifier, f.type, f.identifier, f.integer, f.default] }
+        actual.map! { |f| f.map! { |el| el.respond_to?(:text_value) ? el.text_value : el } }
+        expected = [ ["required", "string", "name", "1", nil],
+                     ["optional", "int32", "account_code", "3", 0] ]
+        assert_equal expected, actual
+      end
+    end
+
+
+    context "with a message including a user-typed field" do
+      setup do
+        @proto = @parser.parse(<<-proto)
+          message Person {
+            required string name = 1;
+            repeated Address addresses = 2;
+          }
+        proto
+      end
+
+      should "parse" do
+        assert_not_nil @proto
+      end
+
+      should "have two fields with correct components" do
+        fields = @proto.messages.first.body.fields
+        assert_equal 2, fields.size
+        actual = fields.map { |f| [f.modifier, f.type, f.identifier, f.integer] }
+        actual.map! { |f| f.map! { |el| el.respond_to?(:text_value) ? el.text_value : el } }
+        expected = [ ["required", "string", "name", "1"],
+                     ["repeated", "Address", "addresses", "2"] ]
+        assert_equal expected, actual
+      end
+    end
+
+
+    should "raise a ParseError when parsing a message with a syntax error" do
+      assert_raises Protopuffs::ParseError do
+        @parser.parse(<<-proto)
+          message Person {
+            required name = 1
+          }
+        proto
+      end
+    end
+
+  end
+
+end

data/test/protopuffs_test.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class ProtopuffsTest < Test::Unit::TestCase
+
+  context ".proto_load_path accessors" do
+    setup { Protopuffs.proto_load_path = [] }
+
+    should "have an accessor for an array of load paths for .proto files" do
+      Protopuffs.proto_load_path << "proto_files" << "other_proto_files"
+      assert_equal ["proto_files", "other_proto_files"], Protopuffs.proto_load_path
+    end
+
+    should "have a mutator for directly assigning the load paths" do
+      Protopuffs.proto_load_path = ["my_proto_files"]
+      assert_equal ["my_proto_files"], Protopuffs.proto_load_path
+    end
+  end
+
+  should "have a ParseError class" do
+    Protopuffs::ParseError
+  end
+
+
+  context ".load_message_classes when a descriptor is in the load path with a Person message" do
+    setup { Protopuffs.proto_load_path = ["#{File.dirname(__FILE__)}/fixtures/proto"] }
+
+    should "create a Person message class with correct accessors" do
+      Protopuffs.load_message_classes
+      p = Protopuffs::Message::Person.new
+      p.name = "Chris"
+      p.id = 42
+      p.email = "chris@kampers.net"
+      assert_equal ["Chris", 42, "chris@kampers.net"], [p.name, p.id, p.email]
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,71 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+require 'treetop'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'protopuffs'
+
+class Test::Unit::TestCase
+
+  # helper for debugging
+  def print_bytes(string)
+    puts
+    string.each_byte do |byte|
+      printf("%1$08b (%1$02X)\n", byte)
+    end
+  end
+
+  # helper for generating test names
+  def self.inspect_bytes(bytes_array)
+    "[#{bytes_array.map { |b| sprintf("%02X", b) }.join(' ')}]"
+  end
+
+
+  def self.should_encode_wire_format_from_fields(expected_bytes, actual_fields)
+    should "encode the fields #{actual_fields.inspect} to the byte string #{inspect_bytes(expected_bytes)}" do
+      actual_fields.each_pair do |name, value|
+        value = value.call if value.respond_to?(:call)
+        @message.send("#{name}=", value)
+      end
+      actual_bytes = @message.to_wire_format.unpack('C*')
+      assert_equal expected_bytes, actual_bytes
+    end
+  end
+
+  def self.should_decode_wire_format_to_fields(actual_bytes, expected_fields)
+    should "decode the byte string #{inspect_bytes(actual_bytes)} to the fields #{expected_fields.inspect}" do
+      buffer = StringIO.new(actual_bytes.pack('C*'))
+      @message.from_wire_format(buffer)
+      actual_fields = @message.class.fields.inject({}) { |hash, field|
+        hash[field.identifier.to_sym] = @message.send(field.identifier)
+        hash
+      }
+
+      expected_fields.each_pair do |key, expected_value|
+        expected_value = expected_value.call if expected_value.respond_to?(:call)
+        if expected_value.is_a?(Float)
+          assert_in_delta(expected_value, actual_fields[key], Float::EPSILON)
+        else
+          assert_equal expected_value, actual_fields[key]
+        end
+      end
+
+      assert_equal expected_fields.size, actual_fields.size
+    end
+  end
+
+
+  def self.should_return_wire_type_for_fields_typed(wire_types)
+    wire_types.each_pair do |wire_type, names|
+      names.each do |name|
+        should "return wire type #{wire_type} for a field with type #{name}" do
+          assert_equal wire_type, Protopuffs::MessageField.new("required", name, "a", 1).wire_type
+        end
+      end
+    end
+  end
+
+end
+

data/test/wire_format_test.rb

@@ -0,0 +1,231 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class WireFormatTest < Test::Unit::TestCase
+
+  context "a message with one int32 field tagged #1" do
+    # from http://code.google.com/apis/protocolbuffers/docs/encoding.html#simple
+    setup do
+      fields = [Protopuffs::MessageField.new("required", "int32", "a", 1)]
+      Protopuffs::Message::Base.define_message_class("Test1", fields)
+      @message = Protopuffs::Message::Test1.new
+    end
+
+    should_encode_wire_format_from_fields [0x08, 0x96, 0x01], :a => 150
+    should_decode_wire_format_to_fields   [0x08, 0x96, 0x01], :a => 150
+
+    # should ignore unknown fields: this message also has an int32 tagged #2 with value 157,372
+    should_decode_wire_format_to_fields [0x08, 0x96, 0x01, 0x10, 0xBC, 0xCD, 0x09], :a => 150
+  end
+
+
+  context "a message with two int32 fields tagged #1 and #2" do
+    setup do
+      fields = [Protopuffs::MessageField.new("required", "int32", "a", 1),
+                Protopuffs::MessageField.new("required", "int32", "b", 2)]
+      Protopuffs::Message::Base.define_message_class("Test1", fields)
+      @message = Protopuffs::Message::Test1.new
+    end
+
+    should_encode_wire_format_from_fields [0x08, 0x96, 0x01, 0x10, 0xBC, 0xCD, 0x09],
+                                          :a => 150, :b => 157_372
+    should_decode_wire_format_to_fields   [0x08, 0x96, 0x01, 0x10, 0xBC, 0xCD, 0x09],
+                                          :a => 150, :b => 157_372
+  end
+
+
+  context "a message with one int64 field tagged #1" do
+    setup do
+      fields = [Protopuffs::MessageField.new("required", "int64", "a", 1)]
+      Protopuffs::Message::Base.define_message_class("Test1", fields)
+      @message = Protopuffs::Message::Test1.new
+    end
+
+    should_encode_wire_format_from_fields [0x08, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x02],
+                                          :a => 2**50
+    should_decode_wire_format_to_fields   [0x08, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x02],
+                                          :a => 2**50
+  end
+
+
+  context "a message with one uint32 field tagged #1 and one uint64 field tagged #2" do
+    setup do
+      fields = [Protopuffs::MessageField.new("required", "uint32", "a", 1),
+                Protopuffs::MessageField.new("required", "uint64", "b", 2)]
+      Protopuffs::Message::Base.define_message_class("Test1", fields)
+      @message = Protopuffs::Message::Test1.new
+    end
+
+    should_encode_wire_format_from_fields [0x08, 0x90, 0x07, 0x10, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x20],
+                                          :a => 912, :b => 2**54
+    should_decode_wire_format_to_fields   [0x08, 0x90, 0x07, 0x10, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x20],
+                                          :a => 912, :b => 2**54
+  end
+
+
+  context "a message with two bool fields tagged #1 and #2" do
+    setup do
+      fields = [Protopuffs::MessageField.new("required", "bool", "a", 1),
+                Protopuffs::MessageField.new("required", "bool", "b", 2)]
+      Protopuffs::Message::Base.define_message_class("Test1", fields)
+      @message = Protopuffs::Message::Test1.new
+    end
+
+    should_encode_wire_format_from_fields [0x08, 0x00, 0x10, 0x01],
+                                          :a => false, :b => true
+    should_decode_wire_format_to_fields   [0x08, 0x00, 0x10, 0x01],
+                                          :a => false, :b => true
+  end
+
+
+  context "a message with one string field tagged #2" do
+    setup do
+      # from http://code.google.com/apis/protocolbuffers/docs/encoding.html#types
+      fields = [Protopuffs::MessageField.new("required", "string", "b", 2)]
+      Protopuffs::Message::Base.define_message_class("Test2", fields)
+      @message = Protopuffs::Message::Test2.new
+    end
+
+    should_encode_wire_format_from_fields [0x12, 0x07, 0x74, 0x65, 0x73, 0x74, 0x69, 0x6E, 0x67],
+                                          :b => "testing"
+    should_decode_wire_format_to_fields   [0x12, 0x07, 0x74, 0x65, 0x73, 0x74, 0x69, 0x6E, 0x67],
+                                          :b => "testing"
+  end
+
+
+  context "a message with a bytes field tagged #1" do
+    setup do
+      fields = [Protopuffs::MessageField.new("required", "bytes", "a", 1)]
+      Protopuffs::Message::Base.define_message_class("Test1", fields)
+      @message = Protopuffs::Message::Test1.new
+    end
+
+    should_encode_wire_format_from_fields [0x0A, 0x04, 0xDE, 0xCA, 0xFB, 0xAD],
+                                          :a => [0xDE, 0xCA, 0xFB, 0xAD].pack('C*')
+    should_decode_wire_format_to_fields   [0x0A, 0x04, 0xDE, 0xCA, 0xFB, 0xAD],
+                                          :a => [0xDE, 0xCA, 0xFB, 0xAD].pack('C*')
+  end
+
+
+  context "a message with one float field tagged #1" do
+    setup do
+      fields = [Protopuffs::MessageField.new("required", "float", "a", 1)]
+      Protopuffs::Message::Base.define_message_class("Test1", fields)
+      @message = Protopuffs::Message::Test1.new
+    end
+
+    # 1.61803 gives you repeating binary digits when encoded, so the number
+    # you get from decoding is different (within Float::EPSILON)
+    should_encode_wire_format_from_fields [0x0D, 0x9B, 0x1B, 0xCF, 0x3F],
+                                          :a => 1.61803
+    should_decode_wire_format_to_fields   [0x0D, 0x9B, 0x1B, 0xCF, 0x3F],
+                                          :a => 1.6180299520492554
+  end
+
+
+  context "a message with one double field tagged #1" do
+    setup do
+      fields = [Protopuffs::MessageField.new("required", "double", "a", 1)]
+      Protopuffs::Message::Base.define_message_class("Test1", fields)
+      @message = Protopuffs::Message::Test1.new
+    end
+
+    # 64-bit doubles have enough precision to encode/decode 1.61803,
+    # unlike the 32-bit floats above
+    should_encode_wire_format_from_fields [0x09, 0x6C, 0x26, 0xDF, 0x6C, 0x73, 0xE3, 0xF9, 0x3F],
+                                          :a => 1.61803
+    should_decode_wire_format_to_fields   [0x09, 0x6C, 0x26, 0xDF, 0x6C, 0x73, 0xE3, 0xF9, 0x3F],
+                                          :a => 1.61803
+  end
+
+
+  context "a message with one fixed64 field tagged #1" do
+    setup do
+      fields = [Protopuffs::MessageField.new("required", "fixed64", "a", 1)]
+      Protopuffs::Message::Base.define_message_class("Test1", fields)
+      @message = Protopuffs::Message::Test1.new
+    end
+
+    should_encode_wire_format_from_fields [0x09, 0xF1, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F],
+                                          :a => 2**62 - 15
+    should_decode_wire_format_to_fields   [0x09, 0xF1, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F],
+                                          :a => 2**62 - 15
+
+  end
+
+
+  context "a message with one fixed32 field tagged #1" do
+    setup do
+      fields = [Protopuffs::MessageField.new("required", "fixed32", "a", 1)]
+      Protopuffs::Message::Base.define_message_class("Test1", fields)
+      @message = Protopuffs::Message::Test1.new
+    end
+
+    should_encode_wire_format_from_fields [0x0D, 0xFE, 0xFF, 0xFF, 0xFF],
+                                          :a => 2**32 - 2
+    should_decode_wire_format_to_fields   [0x0D, 0xFE, 0xFF, 0xFF, 0xFF],
+                                          :a => 2**32 - 2
+  end
+
+
+  context "a message with one repeating int32 field tagged #1" do
+    setup do
+      fields = [Protopuffs::MessageField.new("repeated", "int32", "a", 1)]
+      Protopuffs::Message::Base.define_message_class("Test1", fields)
+      @message = Protopuffs::Message::Test1.new
+    end
+
+    should_encode_wire_format_from_fields [0x08, 0x96, 0x01, 0x08, 0xBC, 0xCD, 0x09, 0x08, 0x3D],
+                                          :a => [150, 157_372, 61]
+    should_decode_wire_format_to_fields   [0x08, 0x96, 0x01, 0x08, 0xBC, 0xCD, 0x09, 0x08, 0x3D],
+                                          :a => [150, 157_372, 61]
+  end
+
+
+  context "a message with one embedded-message field Test1 tagged #3 (where Test1 has an int32 field tagged #1)" do
+    # from http://code.google.com/apis/protocolbuffers/docs/encoding.html#embedded
+    setup do
+      test1_fields = [Protopuffs::MessageField.new("required", "int32", "a", 1)]
+      Protopuffs::Message::Base.define_message_class("Test1", test1_fields)
+
+      test3_fields = [Protopuffs::MessageField.new("required", "Test1", "c", 3)]
+      Protopuffs::Message::Base.define_message_class("Test3", test3_fields)
+      @message = Protopuffs::Message::Test3.new
+    end
+
+    should_encode_wire_format_from_fields [0x1A, 0x03, 0x08, 0x96, 0x01],
+                                          :c => lambda { msg = Protopuffs::Message::Test1.new; msg.a = 150; msg }
+    should_decode_wire_format_to_fields   [0x1A, 0x03, 0x08, 0x96, 0x01],
+                                          :c => lambda { msg = Protopuffs::Message::Test1.new; msg.a = 150; msg }
+  end
+
+
+  context "a message with two int32 fields tagged #1 (optional, default=150) and #2 (required)" do
+    setup do
+      fields = [Protopuffs::MessageField.new("optional", "int32", "a", 1, 150),
+                Protopuffs::MessageField.new("required", "int32", "b", 2)]
+      Protopuffs::Message::Base.define_message_class("Test1", fields)
+      @message = Protopuffs::Message::Test1.new
+    end
+
+    should_encode_wire_format_from_fields [0x10, 0xBC, 0xCD, 0x09],
+                                          :b => 157_372
+    should_decode_wire_format_to_fields   [0x10, 0xBC, 0xCD, 0x09],
+                                          :a => 150, :b => 157_372
+  end
+
+
+  context "a message with two int32 fields tagged #1 (optional, no default) and #2 (required)" do
+    setup do
+      fields = [Protopuffs::MessageField.new("optional", "int32", "a", 1),
+                Protopuffs::MessageField.new("required", "int32", "b", 2)]
+      Protopuffs::Message::Base.define_message_class("Test1", fields)
+      @message = Protopuffs::Message::Test1.new
+    end
+
+    should_encode_wire_format_from_fields [0x10, 0xBC, 0xCD, 0x09],
+                                          :b => 157_372
+    should_decode_wire_format_to_fields   [0x10, 0xBC, 0xCD, 0x09],
+                                          :a => 0, :b => 157_372
+  end
+
+end