beefcake-spanx 0.3.4.1

data/lib/beefcake/version.rb

@@ -0,0 +1,3 @@
+module Beefcake
+  VERSION = "0.3.4.1"
+end

data/test/buffer_decode_test.rb

@@ -0,0 +1,114 @@
+require 'beefcake/buffer'
+
+class BufferDecodeTest < Test::Unit::TestCase
+
+  B = Beefcake::Buffer
+
+  def setup
+    @buf = B.new
+  end
+
+  def test_read_info
+    @buf.append_info(1, 2)
+    assert_equal [1, 2], @buf.read_info
+
+    @buf.append_info(2, 5)
+    assert_equal [2, 5], @buf.read_info
+  end
+
+  def test_read_string
+    @buf.append_string("testing")
+    assert_equal "testing", @buf.read_string
+  end
+
+  def test_read_fixed32
+    @buf.append_fixed32(123)
+    assert_equal 123, @buf.read_fixed32
+  end
+
+  def test_read_fixed64
+    @buf.append_fixed64(456)
+    assert_equal 456, @buf.read_fixed64
+  end
+
+  def test_read_uint32
+    @buf.append_uint32(1)
+    assert_equal 1, @buf.read_uint32
+  end
+
+  def test_read_int32
+    @buf.append_int32(999)
+    assert_equal 999, @buf.read_int32
+
+    @buf.append_int32(-999)
+    assert_equal -999, @buf.read_int32
+  end
+
+  def test_read_int64
+    @buf.append_int64(999)
+    assert_equal 999, @buf.read_int64
+
+    @buf.append_int64(-999)
+    assert_equal -999, @buf.read_int64
+  end
+
+  def test_read_uint64
+    @buf.append_uint64(1)
+    assert_equal 1, @buf.read_uint64
+  end
+
+  def test_read_float
+    @buf.append_float(0.5)
+    assert_equal 0.5, @buf.read_float
+  end
+
+  def test_read_double
+    @buf.append_double(Math::PI)
+    assert_equal Math::PI, @buf.read_double
+  end
+
+  def test_read_bool
+    @buf.append_bool(true)
+    assert_equal true, @buf.read_bool
+
+    @buf.append_bool(false)
+    assert_equal false, @buf.read_bool
+  end
+
+  def test_read_sint32
+    @buf.append_sint32(B::MinInt32)
+    assert_equal B::MinInt32, @buf.read_sint32
+
+    @buf.buf = ""
+    @buf.append_sint32(B::MaxInt32)
+    assert_equal B::MaxInt32, @buf.read_sint32
+  end
+
+  def test_read_sfixed32
+    @buf.append_sfixed32(B::MinInt32)
+    assert_equal B::MinInt32, @buf.read_sfixed32
+
+    @buf.buf = ""
+    @buf.append_sfixed32(B::MaxInt32)
+    assert_equal B::MaxInt32, @buf.read_sfixed32
+  end
+
+  def test_read_sint64
+    @buf.append_sint64(B::MinInt64)
+    assert_equal B::MinInt64, @buf.read_sint64
+
+    @buf.buf = ""
+    @buf.append_sint64(B::MaxInt64)
+    assert_equal B::MaxInt64, @buf.read_sint64
+  end
+
+  def test_read_sfixed64
+    @buf.append_sfixed64(B::MinInt64)
+    assert_equal B::MinInt64, @buf.read_sfixed64
+
+    @buf.buf = ""
+    @buf.append_sfixed64(B::MaxInt64)
+    assert_equal B::MaxInt64, @buf.read_sfixed64
+  end
+
+end

data/test/buffer_encode_test.rb

@@ -0,0 +1,222 @@
+require 'beefcake/buffer/encode'
+
+class BufferEncodeTest < Test::Unit::TestCase
+
+  B = Beefcake::Buffer
+
+  def setup
+    @buf = B.new
+  end
+
+  def test_append_info
+    @buf.append_info(1, 0)
+    assert_equal "\010", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_info(2, 1)
+    assert_equal "\021", @buf.to_s
+  end
+
+  def test_append_string
+    @buf.append_string("testing")
+    assert_equal "\007testing", @buf.to_s
+  end
+
+  def test_append_fixed32
+    @buf.append_fixed32(1)
+    assert_equal "\001\0\0\0", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_fixed32(B::MinUint32)
+    assert_equal "\0\0\0\0", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_fixed32(B::MaxUint32)
+    assert_equal "\377\377\377\377", @buf.to_s
+
+    assert_raises B::OutOfRangeError do
+      @buf.append_fixed32(B::MinUint32 - 1)
+    end
+
+    assert_raises B::OutOfRangeError do
+      @buf.append_fixed32(B::MaxUint32 + 1)
+    end
+  end
+
+  def test_append_fixed64
+    @buf.append_fixed64(1)
+    assert_equal "\001\0\0\0\0\0\0\0", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_fixed64(B::MinUint64)
+    assert_equal "\000\0\0\0\0\0\0\0", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_fixed64(B::MaxUint64)
+    assert_equal "\377\377\377\377\377\377\377\377", @buf.to_s
+
+    assert_raises B::OutOfRangeError do
+      @buf.append_fixed64(B::MinUint64 - 1)
+    end
+
+    assert_raises B::OutOfRangeError do
+      @buf.append_fixed64(B::MaxUint64 + 1)
+    end
+  end
+
+  def test_append_uint32
+    @buf.append_uint32(1)
+    assert_equal "\001", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_uint32(B::MinUint32)
+    assert_equal "\000", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_uint32(B::MaxUint32)
+    assert_equal "\377\377\377\377\017", @buf.to_s
+
+    assert_raises B::OutOfRangeError do
+      @buf.append_uint32(B::MinUint32 - 1)
+    end
+
+    assert_raises B::OutOfRangeError do
+      @buf.append_uint32(B::MaxUint32 + 1)
+    end
+  end
+
+  def test_append_int32
+    @buf.append_int32(1)
+    assert_equal "\001", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_int32(-1)
+    assert_equal "\377\377\377\377\377\377\377\377\377\001", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_int32(B::MinInt32)
+    assert_equal "\200\200\200\200\370\377\377\377\377\001", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_int32(B::MaxInt32)
+    assert_equal "\377\377\377\377\007", @buf.to_s
+
+    assert_raises B::OutOfRangeError do
+      @buf.append_int32(B::MinInt32 - 1)
+    end
+
+    assert_raises B::OutOfRangeError do
+      @buf.append_int32(B::MaxInt32 + 1)
+    end
+  end
+
+  def test_append_int64
+    @buf.append_int64(1)
+    assert_equal "\001", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_int64(-1)
+    assert_equal "\377\377\377\377\377\377\377\377\377\001", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_int64(B::MinInt64)
+    assert_equal "\200\200\200\200\200\200\200\200\200\001", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_int64(B::MaxInt64)
+    assert_equal "\377\377\377\377\377\377\377\377\177", @buf.to_s
+
+    assert_raises B::OutOfRangeError do
+      @buf.append_int64(B::MinInt64 - 1)
+    end
+
+    assert_raises B::OutOfRangeError do
+      @buf.append_int64(B::MaxInt64 + 1)
+    end
+  end
+
+  def test_append_uint64
+    @buf.append_uint64(1)
+    assert_equal "\001", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_uint64(B::MinUint64)
+    assert_equal "\000", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_uint64(B::MaxUint64)
+    assert_equal "\377\377\377\377\377\377\377\377\377\001", @buf.to_s
+
+    assert_raises B::OutOfRangeError do
+      @buf.append_uint64(B::MinUint64 - 1)
+    end
+
+    assert_raises B::OutOfRangeError do
+      @buf.append_uint64(B::MaxUint64 + 1)
+    end
+  end
+
+  def test_append_float
+    @buf.append_float(3.14)
+    assert_equal "\303\365H@", @buf.to_s
+  end
+
+  def test_append_double
+    @buf.buf = ""
+    @buf.append_float(Math::PI)
+    assert_equal "\333\017I@", @buf.to_s
+  end
+
+  def test_append_bool
+    @buf.append_bool(true)
+    @buf.append_bool(false)
+    assert_equal "\001\000", @buf.to_s
+  end
+
+  def test_append_sint32
+    @buf.append_sint32(-2)
+    assert_equal "\003", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_sint32(B::MaxInt32)
+    assert_equal "\376\377\377\377\017", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_sint32(B::MinInt32)
+    assert_equal "\377\377\377\377\017", @buf.to_s
+  end
+
+  def test_append_sfixed32
+    @buf.append_sfixed32(-2)
+    assert_equal "\003\000\000\000", @buf.to_s
+  end
+
+  def test_append_sint64
+    @buf.append_sint64(-2)
+    assert_equal "\003", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_sint64(B::MaxInt64)
+    assert_equal "\376\377\377\377\377\377\377\377\377\001", @buf.to_s
+
+    @buf.buf = ""
+    @buf.append_sint64(B::MinInt64)
+    assert_equal "\377\377\377\377\377\377\377\377\377\001", @buf.to_s
+  end
+
+  def test_append_sfixed64
+    @buf.append_sfixed64(B::MaxInt64)
+    assert_equal "\376\377\377\377\377\377\377\377", @buf.to_s
+  end
+
+  def test_append_string
+    @buf.append_string("testing")
+    assert_equal "\007testing", @buf.to_s
+  end
+
+  def test_append_bytes
+    @buf.append_bytes("testing")
+    assert_equal "\007testing", @buf.to_s
+  end
+
+end

data/test/buffer_test.rb

@@ -0,0 +1,44 @@
+require 'beefcake/buffer'
+
+class BufferTest < Test::Unit::TestCase
+
+  def setup
+    @buf = Beefcake::Buffer.new
+  end
+
+  def test_simple
+    assert_equal "", @buf.to_s
+
+    @buf << "asdf"
+    assert_equal "asdf", @buf.to_s
+    assert_equal "asdf", @buf.to_str
+
+    @buf.buf = ""
+    assert_equal "", @buf.to_s
+  end
+
+  def test_wire_for
+    assert_equal 0, Beefcake::Buffer.wire_for(:int32)
+    assert_equal 0, Beefcake::Buffer.wire_for(:uint32)
+    assert_equal 0, Beefcake::Buffer.wire_for(:sint32)
+    assert_equal 0, Beefcake::Buffer.wire_for(:int64)
+    assert_equal 0, Beefcake::Buffer.wire_for(:uint64)
+    assert_equal 0, Beefcake::Buffer.wire_for(:sint64)
+
+    assert_equal 1, Beefcake::Buffer.wire_for(:fixed64)
+    assert_equal 1, Beefcake::Buffer.wire_for(:sfixed64)
+    assert_equal 1, Beefcake::Buffer.wire_for(:double)
+
+    assert_equal 2, Beefcake::Buffer.wire_for(:string)
+    assert_equal 2, Beefcake::Buffer.wire_for(:bytes)
+
+    assert_equal 5, Beefcake::Buffer.wire_for(:fixed32)
+    assert_equal 5, Beefcake::Buffer.wire_for(:sfixed32)
+    assert_equal 5, Beefcake::Buffer.wire_for(:float)
+
+    assert_raises Beefcake::Buffer::UnknownType do
+      Beefcake::Buffer.wire_for(:asdf)
+    end
+  end
+
+end

data/test/generator_test.rb

@@ -0,0 +1,51 @@
+require 'beefcake/generator'
+
+class GeneratorTest < Test::Unit::TestCase
+
+  def setup
+    # Load up the generator request for the addressbook.proto example
+    dat = File.dirname(__FILE__) + "/../dat/code_generator_request.dat"
+    mock_request = File.read(dat)
+    @req = CodeGeneratorRequest.decode(mock_request)
+  end
+
+  if "".respond_to?(:encoding)
+    def test_request_has_filenames_as_binary
+      @req.proto_file.each do |file|
+        assert_equal Encoding.find("ASCII-8BIT"), file.name.encoding
+      end
+    end
+  end
+
+  def test_generate_empty_namespace
+    @res = Beefcake::Generator.compile([], @req)
+    assert_equal(CodeGeneratorResponse, @res.class)
+  end
+
+  def test_generate_top_namespace
+    @res = Beefcake::Generator.compile(["Top"], @req)
+    assert_equal(CodeGeneratorResponse, @res.class)
+    assert_match(/module Top/, @res.file.first.content)
+  end
+
+  def test_generate_two_level_namespace
+    @res = Beefcake::Generator.compile(["Top", "Bottom"], @req)
+    assert_equal(CodeGeneratorResponse, @res.class)
+    assert_match(/module Top\s*\n\s*module Bottom/m, @res.file.first.content)
+  end
+
+  # Covers the regression of encoding a CodeGeneratorResponse under 1.9.2-p136 raising
+  # Encoding::CompatibilityError: incompatible character encodings: ASCII-8BIT and US-ASCII
+  def test_encode_decode_generated_response
+    @res = Beefcake::Generator.compile([], @req)
+    assert_nothing_raised { @res.encode }
+  end
+
+  def test_encode_decode_generated_response
+    @res = Beefcake::Generator.compile([], @req)
+    assert_equal(CodeGeneratorResponse, @res.class)
+
+    round_trip = CodeGeneratorResponse.decode(@res.encode)
+    assert_equal round_trip, @res
+  end
+end

data/test/message_test.rb

@@ -0,0 +1,371 @@
+require 'beefcake'
+
+class NumericsMessage
+  include Beefcake::Message
+
+  required :int32,    :int32,    1
+  required :uint32,   :uint32,   2
+  required :sint32,   :sint32,   3
+  required :fixed32,  :fixed32,  4
+  required :sfixed32, :sfixed32, 5
+
+  required :int64,    :int64,    6
+  required :uint64,   :uint64,   7
+  required :sint64,   :sint64,   8
+  required :fixed64,  :fixed64,  9
+  required :sfixed64, :sfixed64, 10
+end
+
+
+class LendelsMessage
+  include Beefcake::Message
+
+  required :string, :string, 1
+  required :bytes,  :bytes,  2
+end
+
+
+class SimpleMessage
+  include Beefcake::Message
+
+  optional :a, :int32,  1
+  optional :b, :string, 2
+end
+
+
+class CompositeMessage
+  include Beefcake::Message
+
+  required :encodable, SimpleMessage, 1
+end
+
+
+class EnumsMessage
+  include Beefcake::Message
+
+  module X
+    A = 1
+  end
+
+  required :a, X, 1
+end
+
+
+class EnumsDefaultMessage
+  include Beefcake::Message
+
+  module X
+    A = 1
+    B = 2
+  end
+
+  optional :a, X, 1, :default => X::B
+end
+
+
+class RepeatedMessage
+  include Beefcake::Message
+
+  repeated :a, :int32, 1
+end
+
+
+class PackedRepeatedMessage
+  include Beefcake::Message
+
+  repeated :a, :int32, 1, :packed => true
+end
+
+class RepeatedNestedMessage
+  include Beefcake::Message
+
+  repeated :simple, SimpleMessage, 1
+end
+
+class BoolMessage
+  include Beefcake::Message
+
+  required :bool, :bool, 1
+end
+
+class LargeFieldNumberMessage
+  include Beefcake::Message
+
+  required :field_1, :string, 1
+  required :field_2, :string, 100
+end
+
+class MessageTest < Test::Unit::TestCase
+  B = Beefcake::Buffer
+
+  ## Encoding
+  def test_encode_numerics
+    buf = Beefcake::Buffer.new
+
+    buf.append(:int32, B::MaxInt32, 1)
+    buf.append(:uint32, B::MaxUint32, 2)
+    buf.append(:sint32, B::MinInt32, 3)
+    buf.append(:fixed32, B::MaxInt32, 4)
+    buf.append(:sfixed32, B::MinInt32, 5)
+    buf.append(:int64, B::MaxInt64, 6)
+    buf.append(:uint64, B::MaxUint64, 7)
+    buf.append(:sint64, B::MinInt64, 8)
+    buf.append(:fixed64, B::MaxInt64, 9)
+    buf.append(:sfixed64, B::MinInt64, 10)
+
+    msg = NumericsMessage.new({
+      :int32     => B::MaxInt32,
+      :uint32    => B::MaxUint32,
+      :sint32    => B::MinInt32,
+      :fixed32   => B::MaxInt32,
+      :sfixed32  => B::MinInt32,
+
+      :int64     => B::MaxInt64,
+      :uint64    => B::MaxUint64,
+      :sint64    => B::MinInt64,
+      :fixed64   => B::MaxInt64,
+      :sfixed64  => B::MinInt64
+    })
+
+    assert_equal buf.to_s, msg.encode.to_s
+  end
+
+  def test_encode_strings
+    buf = Beefcake::Buffer.new
+
+    buf.append(:string, "test\ning", 1)
+    buf.append(:bytes, "unixisawesome", 2)
+
+    msg = LendelsMessage.new({
+      :string => "test\ning",
+      :bytes  => "unixisawesome"
+    })
+
+    assert_equal buf.to_s, msg.encode.to_s
+  end
+
+  def test_encode_string_composite
+    buf1 = Beefcake::Buffer.new
+    buf1.append(:int32, 123, 1)
+
+    buf2 = Beefcake::Buffer.new
+    buf2.append(:string, buf1, 1)
+
+    msg = CompositeMessage.new(
+      :encodable => SimpleMessage.new(:a => 123)
+    )
+
+    assert_equal buf2.to_s, msg.encode.to_s
+  end
+
+  def test_encode_to_string
+    msg = SimpleMessage.new :a => 123
+    str = ""
+    msg.encode(str)
+    assert_equal "\b{", str
+  end
+
+  def test_encode_enum
+    buf = Beefcake::Buffer.new
+    buf.append(:int32, 2, 1)
+
+    msg = EnumsMessage.new :a => EnumsMessage::X::A
+    assert_equal "\b\001", msg.encode.to_s
+  end
+
+  def test_encode_invalid_enum_value
+    assert_raises Beefcake::Message::InvalidValueError do
+      EnumsMessage.new(:a => 99).encode
+    end
+  end
+
+  def test_encode_unset_required_field
+    assert_raises Beefcake::Message::RequiredFieldNotSetError do
+      NumericsMessage.new.encode
+    end
+  end
+
+  def test_decode_required_bool
+    msg = BoolMessage.new :bool => false
+    enc = msg.encode
+    dec = BoolMessage.decode(enc)
+    assert_equal false, dec.bool
+  end
+
+  def test_encode_repeated_field
+    buf = Beefcake::Buffer.new
+
+    buf.append(:int32, 1, 1)
+    buf.append(:int32, 2, 1)
+    buf.append(:int32, 3, 1)
+    buf.append(:int32, 4, 1)
+    buf.append(:int32, 5, 1)
+
+    msg = RepeatedMessage.new :a => [1, 2, 3, 4, 5]
+
+    assert_equal buf.to_s, msg.encode.to_s
+  end
+
+  def test_encode_packed_repeated_field
+    buf = Beefcake::Buffer.new
+
+    # Varint
+    buf.append_info(1, 0)
+
+    # Give size in bytes
+    buf.append_uint64 5
+
+    # Values
+    buf.append_int32 1
+    buf.append_int32 2
+    buf.append_int32 3
+    buf.append_int32 4
+    buf.append_int32 5
+
+    msg = PackedRepeatedMessage.new :a => [1, 2, 3, 4, 5]
+
+    assert_equal buf.to_s, msg.encode.to_s
+  end
+
+  def test_encode_large_field_number
+    buf = Beefcake::Buffer.new
+    buf.append(:string, "abc", 1)
+    buf.append(:string, "123", 100)
+
+    msg = LargeFieldNumberMessage.new
+    msg.field_1 = "abc"
+    msg.field_2 = "123"
+
+    assert_equal buf.to_s, msg.encode.to_s
+  end
+
+  ## Decoding
+  def test_decode_numerics
+    msg = NumericsMessage.new({
+      :int32     => B::MaxInt32,
+      :uint32    => B::MaxUint32,
+      :sint32    => B::MinInt32,
+      :fixed32   => B::MaxInt32,
+      :sfixed32  => B::MinInt32,
+
+      :int64     => B::MaxInt64,
+      :uint64    => B::MaxUint64,
+      :sint64    => B::MinInt64,
+      :fixed64   => B::MaxInt64,
+      :sfixed64  => B::MinInt64
+    })
+
+    got = NumericsMessage.decode(msg.encode)
+
+    msg.fields.values.each do |fld|
+      assert_equal msg[fld.name], got[fld.name], fld.name
+    end
+  end
+
+  def test_wire_does_not_match_decoded_info
+    buf = Beefcake::Buffer.new
+    buf.append(:string, "testing", 1)
+
+    assert_raises Beefcake::Message::WrongTypeError do
+      SimpleMessage.decode(buf)
+    end
+  end
+
+  def test_decode_unknown_field_number
+    buf = Beefcake::Buffer.new
+    buf.append(:string, "testing", 2)
+
+    msg = SimpleMessage.decode(buf)
+
+    assert_equal nil, msg.a
+  end
+
+  def test_decode_repeated_field
+    msg = RepeatedMessage.new :a => [1, 2, 3, 4, 5]
+    got = RepeatedMessage.decode(msg.encode)
+
+    assert_equal msg.a, got.a
+  end
+
+  def test_decode_packed_repeated_field
+    msg = PackedRepeatedMessage.new :a => [1, 2, 3, 4, 5]
+    got = PackedRepeatedMessage.decode(msg.encode)
+
+    assert_equal msg.a, got.a
+  end
+
+  def test_decode_merge
+    a = SimpleMessage.new :a => 1
+    b = SimpleMessage.new :a => 2
+
+    x = SimpleMessage.decode(a.encode)
+    SimpleMessage.decode(b.encode, x)
+
+    assert_equal b.a, x.a
+  end
+
+  def test_decode_default
+    got = EnumsDefaultMessage.decode("")
+    assert_equal EnumsDefaultMessage.fields[1].opts[:default], got.a
+  end
+
+  def test_decode_unset_required_fields
+    assert_raises Beefcake::Message::RequiredFieldNotSetError do
+      NumericsMessage.decode("")
+    end
+  end
+
+  def test_decode_enum
+    msg = EnumsMessage.new(:a => 1).encode
+    got = EnumsMessage.decode(msg)
+    assert_equal 1, got.a
+  end
+
+  def test_decode_repeated_nested
+    simple = [
+      SimpleMessage.new(:a => 1),
+      SimpleMessage.new(:b => "hello")
+    ]
+    msg = RepeatedNestedMessage.new(:simple => simple).encode
+    got = RepeatedNestedMessage.decode(msg)
+    assert_equal 2, got.simple.size
+    assert_equal 1, got.simple[0].a
+    assert_equal "hello", got.simple[1].b
+  end
+
+  def test_equality
+    a = SimpleMessage.new :a => 1
+    b = SimpleMessage.new :a => 1
+    assert_equal a, b
+    c = SimpleMessage.new :a => 2
+    assert_not_equal b, c
+  end
+
+  def test_inspect
+    msg = SimpleMessage.new :a => 1
+    assert_equal "<SimpleMessage a: 1>", msg.inspect
+    msg.b = "testing"
+    assert_equal "<SimpleMessage a: 1, b: \"testing\">", msg.inspect
+    msg.a = nil
+    assert_equal "<SimpleMessage b: \"testing\">", msg.inspect
+  end
+
+  def test_inspect_enums
+    msg = EnumsMessage.new :a => 1
+    assert_equal "<EnumsMessage a: A(1)>", msg.inspect
+    msg.a = 2
+    assert_equal "<EnumsMessage a: -NA-(2)>", msg.inspect
+  end
+
+  def test_inspect_nested_types
+    msg = CompositeMessage.new(:encodable => SimpleMessage.new(:a => 1))
+    assert_equal "<CompositeMessage encodable: <SimpleMessage a: 1>>", msg.inspect
+  end
+
+  def test_to_hash
+    msg =  SimpleMessage.new :a => 1
+    exp = { :a => 1 }
+    assert_equal(exp, msg.to_hash)
+  end
+
+end