prepor-beefcake 1.0.0

data/lib/beefcake/version.rb

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

data/test/benchmark_test.rb

@@ -0,0 +1,42 @@
+require 'minitest/autorun'
+require 'minitest/benchmark'
+require 'beefcake'
+
+class Inner
+  include Beefcake::Message
+
+  required :content, :string, 1
+end
+
+class Outer
+  include Beefcake::Message
+
+  repeated :inner, Inner, 1
+end
+
+class BenchmarkTest < Minitest::Benchmark
+  def setup
+    @buf = Beefcake::Buffer.new
+  end
+
+  def bench_read_string
+    assert_performance_linear 0.75 do |n|
+      candidate = 'x' * (n * 1_000)
+      @buf.append_string candidate
+      assert_equal candidate, @buf.read_string
+    end
+  end
+
+  def bench_decode
+    assert_performance_linear 0.75 do |n|
+      inners = n.times.map{ Inner.new :content => 'x' * 100 }
+      outer = Outer.new :inner => inners
+
+      encoded = outer.encode.to_s
+
+      decoded = Outer.decode encoded
+
+      assert_equal n, decoded.inner.length
+    end
+  end
+end

data/test/buffer_decode_test.rb

@@ -0,0 +1,117 @@
+require 'minitest/autorun'
+require 'beefcake/buffer'
+
+class BufferDecodeTest < Minitest::Test
+
+  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")
+    decoded = @buf.read_string
+    assert_equal "testing", decoded
+    assert_equal Encoding.find('utf-8'), decoded.encoding
+  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,234 @@
+# encoding: ASCII-8BIT
+require 'minitest/autorun'
+require 'beefcake/buffer/encode'
+
+class BufferEncodeTest < Minitest::Test
+
+  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_unicode_string
+    ingest = "\u{1f63a}" * 5
+    assert_equal 5, ingest.chars.to_a.length
+    expected = ingest.bytes.to_a.length.chr + ingest
+    @buf.append_string(ingest)
+    actual = @buf.to_s
+    assert_equal expected.bytes.to_a.length, actual.bytes.to_a.length
+    assert_equal expected.bytes.to_a, actual.bytes.to_a
+  end
+
+  def test_append_bytes
+    @buf.append_bytes("testing")
+    assert_equal "\007testing", @buf.to_s
+  end
+
+  def test_append_frozen_string
+    @buf.append_string "testing".freeze
+    assert_equal "\007testing", @buf.to_s
+  end
+
+end

data/test/buffer_test.rb

@@ -0,0 +1,45 @@
+require 'minitest/autorun'
+require 'beefcake/buffer'
+
+class BufferTest < Minitest::Test
+
+  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,46 @@
+require 'minitest/autorun'
+require 'beefcake/generator'
+
+class GeneratorTest < Minitest::Test
+
+  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
+
+  def test_request_has_filenames_as_string
+    @req.proto_file.each do |file|
+      assert_equal Encoding.find("UTF-8"), file.name.encoding
+    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_equal(CodeGeneratorResponse, @res.class)
+
+    round_trip = CodeGeneratorResponse.decode(@res.encode)
+    assert_equal round_trip, @res
+  end
+end