protopuffs 0.3.0

data/test/message_field_test.rb

@@ -0,0 +1,78 @@
+# encoding: UTF-8
+
+require File.dirname(__FILE__) + '/test_helper'
+
+class MessageFieldTest < Test::Unit::TestCase
+
+  context "creating a MessageField" do
+    should "not allow you to instantiate MessageField directly" do
+      assert_raises RuntimeError do
+        Protopuffs::MessageField.new "_", "_", "_", "_"
+      end
+    end
+
+    should "complain if an invalid modifier is specified" do
+      ["optional", "required", "repeated"].each do |modifier|
+        assert_nothing_raised {Protopuffs::Int32.new(modifier, 'identitifer', 1)}
+      end
+      assert_raises(ArgumentError) {Protopuffs::Int32.new("invalid_modifier", "identifier", 1)}
+    end
+
+    should "instantiate the right class, given a type string" do
+      [[ "int32",    Protopuffs::Int32],
+       [ "int64",    Protopuffs::Int64],
+       [ "uint32",   Protopuffs::UInt32],
+       [ "uint64",   Protopuffs::UInt64],
+       [ "bool",     Protopuffs::Bool],
+       [ "double",   Protopuffs::Double],
+       [ "fixed64",  Protopuffs::Fixed64],
+       [ "string",   Protopuffs::String],
+       [ "bytes",    Protopuffs::Bytes],
+       [ "float",    Protopuffs::Float],
+       [ "fixed32",  Protopuffs::Fixed32],
+       [ "sfixed32", Protopuffs::SFixed32],
+       [ "embedded", Protopuffs::Embedded],
+      ].each do |type, klass|
+        assert_kind_of klass, Protopuffs::MessageField.factory(type, "optional", "a_string", 1, 2)
+      end
+    end
+
+    should "set a string's default to '' when a default isn't specified" do
+      field = Protopuffs::String.new("optional", "name", 1)
+      assert_equal "", field.default
+    end
+
+    should "set a string's default to '' when a default is specified as nil" do
+      field = Protopuffs::String.new("optional", "name", 1, nil)
+      assert_equal "", field.default
+    end
+
+    should "set a numeric's default to 0 when a default isn't specified or is specified as nil" do
+      numeric_types = [Protopuffs::Double, Protopuffs::Float,
+                       Protopuffs::Int32, Protopuffs::Int64,
+                       Protopuffs::UInt32, Protopuffs::UInt64,
+                       Protopuffs::Fixed32, Protopuffs::Fixed64,
+                       Protopuffs::SFixed32]
+      numeric_types.each do |type|
+        assert_equal 0, type.new("optional", "number", 1).default
+        assert_equal 0, type.new("optional", "number", 1, nil).default
+      end
+    end
+
+    should "set a bool's default to false when a default isn't specified" do
+      field = Protopuffs::Bool.new("optional", "opt_in", 1)
+      assert_same false, field.default
+    end
+
+    should "set a bool's default to false when a default is specified as nil" do
+      field = Protopuffs::Bool.new("optional", "opt_in", 1, nil)
+      assert_same false, field.default
+    end
+
+    should "set the default to 'Matz' when that default is specified" do
+      field = Protopuffs::String.new("optional", "name", 1, "Matz")
+      assert_equal "Matz", field.default
+    end
+  end
+
+end

data/test/parse_tree_test.rb

@@ -0,0 +1,208 @@
+# encoding: UTF-8
+
+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,38 @@
+# encoding: UTF-8
+
+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,90 @@
+# encoding: UTF-8
+
+require 'rubygems'
+require 'test/unit'
+
+gem "polyglot", "=0.2.9"
+gem "treetop", "=1.4.2"
+
+gem "thoughtbot-shoulda", "=2.10.2"
+require 'shoulda'
+
+gem "mocha", "=0.9.8"
+require 'mocha'
+
+$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*'))
+      buffer.set_encoding("BINARY") if buffer.respond_to?(:set_encoding)
+      @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_encode_and_decode_wire_format_and_fields(bytes, fields)
+    self.should_encode_wire_format_from_fields(bytes, fields)
+    self.should_decode_wire_format_to_fields(bytes, fields)
+  end
+
+  def self.should_losslessly_encode_and_decode_a_random_sample(fields)
+    raise ArgumentError if fields.size > 1
+    name, range = fields.shift
+    should "get the same value back after encoding and decoding a random sample of the values #{range.inspect} for field #{name.inspect}" do
+      size = range.last - range.first
+      size -= 1 if range.exclude_end?
+      values_to_test = [range.first, range.first + size]
+      250.times { values_to_test << range.first + rand(size) }
+      values_to_test.each do |value|
+        @message.send("#{name}=", value)
+        @message.from_wire_format(@message.to_wire_format)
+        assert_equal value, @message.send(name)
+      end
+    end
+  end
+
+end
+

data/test/text_format_test.rb

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+
+require File.dirname(__FILE__) + '/test_helper'
+
+class TextFormatTest < Test::Unit::TestCase
+
+  context "a message called Test1 with one int32 field" do
+    # from http://code.google.com/apis/protocolbuffers/docs/overview.html#whynotxml
+    setup do
+      fields = [Protopuffs::String.new("required", "name", 1),
+                Protopuffs::String.new("required", "email", 2)]
+      Protopuffs::Message::Base.define_message_class("Person", fields)
+      @message = Protopuffs::Message::Person.new
+      @message.name = "John Doe"
+      @message.email = "jdoe@example.com"
+    end
+
+    should "return the correct text format from #inspect" do
+      assert_equal %Q(person {\n  name: "John Doe"\n  email: "jdoe@example.com"\n}), @message.inspect
+    end
+  end
+
+end

data/test/wire_format_test.rb

@@ -0,0 +1,293 @@
+# encoding: UTF-8
+
+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::Int32.new("required", "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
+
+    should "return itself from #from_wire_format" do
+      wire_message = StringIO.new([0x08, 0x96, 0x01].pack('C*'))
+      assert_same @message, @message.from_wire_format(wire_message)
+    end
+
+    should "accept a string as an argument to #from_wire_format" do
+      wire_message = [0x08, 0x96, 0x01].pack('C*')
+      @message.from_wire_format(wire_message)
+      assert_equal 150, @message.a
+    end
+  end
+
+
+  context "a message with two int32 fields tagged #1 and #2" do
+    setup do
+      fields = [Protopuffs::Int32.new("required", "a", 1),
+                Protopuffs::Int32.new("required", "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::Int64.new("required", "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::UInt32.new("required", "a", 1),
+                Protopuffs::UInt64.new("required", "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::Bool.new("required", "a", 1),
+                Protopuffs::Bool.new("required", "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::String.new("required", "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"
+
+    should_encode_wire_format_from_fields [0x12, 0x01, 0x32], :b => 2
+    should_decode_wire_format_to_fields   [0x12, 0x01, 0x32], :b => "2"
+
+    should_encode_wire_format_from_fields [0x12, 0x0C, 0xE3, 0x81, 0x93, 0xE3, 0x81, 0xAB, 0xE3, 0x81, 0xA1, 0xE3, 0x82, 0x8F],
+                                          :b => "こにちわ"
+    should_decode_wire_format_to_fields   [0x12, 0x0C, 0xE3, 0x81, 0x93, 0xE3, 0x81, 0xAB, 0xE3, 0x81, 0xA1, 0xE3, 0x82, 0x8F],
+                                          :b => "こにちわ"
+
+    should_encode_wire_format_from_fields [0x12, 0x05, 0xD2, 0x90, 0x41, 0xC3, 0x9C],
+                                          :b => "ҐAÜ"
+    should_decode_wire_format_to_fields   [0x12, 0x05, 0xD2, 0x90, 0x41, 0xC3, 0x9C],
+                                          :b => "ҐAÜ"
+  end
+
+
+  context "a message with a bytes field tagged #1" do
+    setup do
+      fields = [Protopuffs::Bytes.new("required", "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::Float.new("required", "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::Double.new("required", "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::Fixed64.new("required", "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::Fixed32.new("required", "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 sfixed32 field tagged #1" do
+    setup do
+      fields = [Protopuffs::SFixed32.new("required", "a", 1)]
+      Protopuffs::Message::Base.define_message_class("Test1", fields)
+      @message = Protopuffs::Message::Test1.new
+    end
+
+    should_encode_and_decode_wire_format_and_fields [0x0D, 0x05, 0x00, 0x00, 0x80],
+                                                    :a => -2**31 + 5
+    should_encode_and_decode_wire_format_and_fields [0x0D, 0x05, 0x80, 0x00, 0x00],
+                                                    :a => 2**15 + 5
+    should_losslessly_encode_and_decode_a_random_sample :a => -2**31...2**31
+  end
+
+
+  context "a message with one repeating int32 field tagged #1" do
+    setup do
+      fields = [Protopuffs::Int32.new("repeated", "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::Int32.new("required", "a", 1)]
+      Protopuffs::Message::Base.define_message_class("Test1", test1_fields)
+
+      test3_fields = [Protopuffs::Embedded.new("Test1", "required", "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::Int32.new("optional", "a", 1, 150),
+                Protopuffs::Int32.new("required", "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::Int32.new("optional", "a", 1),
+                Protopuffs::Int32.new("required", "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
+
+
+  context "a message with two int32 fields tagged #1 and #2, defined with #2 first" do
+    setup do
+      fields = [Protopuffs::Int32.new("required", "b", 2),
+                Protopuffs::Int32.new("required", "a", 1)]
+      Protopuffs::Message::Base.define_message_class("Test1", fields)
+      @message = Protopuffs::Message::Test1.new
+    end
+
+    # should always encode with fields ordered by tag number, to take
+    # advantage of decoders that optimize for this case
+    should_encode_wire_format_from_fields [0x08, 0x14, 0x10, 0xBC, 0xCD, 0x09],
+                                          :a => 20, :b => 157_372
+
+    # the decoder should still support any field order, though
+    should_decode_wire_format_to_fields   [0x08, 0x14, 0x10, 0xBC, 0xCD, 0x09],
+                                          :a => 20, :b => 157_372
+    should_decode_wire_format_to_fields   [0x10, 0xBC, 0xCD, 0x09, 0x08, 0x14],
+                                          :a => 20, :b => 157_372
+  end
+
+end