binary_finery 0.0.1

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011 Michelangelo Altamore
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of 
+this software and associated documentation files (the "Software"), to deal in 
+the Software without restriction, including without limitation the rights to 
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of 
+the Software, and to permit persons to whom the Software is furnished to do so, 
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all 
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README

@@ -0,0 +1,61 @@
+Binary Finary
+=============
+
+Mixes in a _fluent interface_ to any IO entity for reading and
+writing binary data. It handles (de)serialization of:
+
+  - Integer numbers
+  - Null terminated strings
+  - Fixed size strings
+
+
+Requirements
+------------
+
+Binary Finary assumes that the stream where
+is mixed in, provides the following methods:
+
+	- read or read_nonblock
+	- write or write_nonblock
+
+
+It will run under Ruby version 1.8.7 or newer.
+
+
+Examples
+--------
+
+	File.open(my_file.bin) do |f|
+		f.extend(BinaryFinary)
+	  version = f.read_uint16_big
+		length  = f.read_uint32_little
+	end
+
+
+Install
+-------
+
+    $ gem install binary_finary
+
+
+Contributing
+------------
+
+If you'd like to hack on, please follow these instructions.
+To get all of the dependencies, install the gem first.
+
+1. Fork the project and clone down your fork
+2. Create a branch with a descriptive name to contain your change
+4. Hack away
+5. Add tests and make sure everything still passes by running rake
+6. Do not change the version number, I will do that on my end
+7. If necessary, rebase your commits into logical chunks, without errors
+8. Push the branch up to GitHub
+9. Send me (altamic) a pull request for your branch
+
+
+Copyright
+=========
+
+© Copyright 2011 Michelangelo Altamore. See LICENSE for details.
+

data/README.md

@@ -0,0 +1,61 @@
+Binary Finary
+=============
+
+Mixes in a _fluent interface_ to any IO entity for reading and
+writing binary data. It handles (de)serialization of:
+
+  - Integer numbers
+  - Null terminated strings
+  - Fixed size strings
+
+
+Requirements
+------------
+
+Binary Finary assumes that the stream where
+is mixed in, provides the following methods:
+
+	- read or read_nonblock
+	- write or write_nonblock
+
+
+It will run under Ruby version 1.8.7 or newer.
+
+
+Examples
+--------
+
+	File.open(my_file.bin) do |f|
+		f.extend(BinaryFinary)
+	  version = f.read_uint16_big
+		length  = f.read_uint32_little
+	end
+
+
+Install
+-------
+
+    $ gem install binary_finary
+
+
+Contributing
+------------
+
+If you'd like to hack on, please follow these instructions.
+To get all of the dependencies, install the gem first.
+
+1. Fork the project and clone down your fork
+2. Create a branch with a descriptive name to contain your change
+4. Hack away
+5. Add tests and make sure everything still passes by running rake
+6. Do not change the version number, I will do that on my end
+7. If necessary, rebase your commits into logical chunks, without errors
+8. Push the branch up to GitHub
+9. Send me (altamic) a pull request for your branch
+
+
+Copyright
+=========
+
+© Copyright 2011 Michelangelo Altamore. See LICENSE for details.
+

data/Rakefile

@@ -0,0 +1,19 @@
+# -*- ruby -*-
+
+$LOAD_PATH.unshift('lib')
+
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "irb -rubygems -r ./lib/binary_finery.rb"
+end
+
+task :default => :test
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.pattern = 'test/**/{helper,test_*}.rb'
+  test.warning = true
+  test.verbose = true
+end
+
+

data/lib/binary_finery.rb

@@ -0,0 +1,348 @@
+##
+# BinaryFinery mixin is meant to be used as a
+# fluent interface to any IO entity for reading
+# or writing binary data.
+# This module assumes that read(n) and write(str)
+# methods are available where this module is mixed in.
+# It handles (de)serialization of:
+#
+#   - Integer numbers ✓
+#   - Null terminated strings ✓
+#   - Fixed size strings ✓
+#
+
+# In order to be plaftorm agnostic, Binary inspects
+# at load time machine's capabilities and adjust its
+# own operations accordingly.
+#
+# BinaryFinary performs operations accepted by the
+# following grammar:
+#
+#  operation     ::= 'read' | 'write'
+#  integer_type  ::= 'uint' | 'int'
+#  bits          ::= '8' | '16' | '32' | '64' | '128' | '256'
+#  endianness    ::= 'native' | 'little' | 'big' | 'network'
+#  OP_INT ::= operation '_' integer_type bits ('_' endianness)?
+#
+#  str_padding      ::= 'null_padded' | 'c_'
+#  string_flavor    ::= 'string' | 'fixed_string' | 'binary_string'
+#  str_preposition  ::= '_of_'
+#  integer          ::= [0-9]+
+#  str_size         ::= 'bytes'
+#  OP_STR ::= operation '_' (str_padding '_')?
+#             string_flavor '_' str_preposition integer '_' str_size
+#
+module BinaryFinery
+  OP_RE     = /(read|write)_/
+  INT_RE    = /(uint|int)(8|16|32|64)_?(native|little|big|network)?/
+  STR_RE    = /(null_padded|c_)?((binary_|fixed_)?string)(_of_)[0-9]+(bytes)/
+  OP_INT_RE = Regexp::compile(OP_RE.source + INT_RE.source)
+  OP_STR_RE = Regexp::compile(OP_RE.source + STR_RE.source)
+
+  KNOWN_RE  = Regexp::compile(OP_INT_RE.source + OP_STR_RE.source)
+
+  NUL = 0.chr
+
+  # Returns the number of bytes used to encode an integer number
+  INTEGER_SIZE_IN_BYTES = module_eval { 1.size }
+  def integer_size_in_bytes() INTEGER_SIZE_IN_BYTES end
+  alias :word_size_in_bytes :integer_size_in_bytes
+
+  def little_endian_byte_order() :little end
+  def big_endian_byte_order()    :big end
+  alias :network_byte_order :big_endian_byte_order
+
+  # A machine architecture is said to be little endian if puts first the
+  # LSB. We evaluate the first byte of the number 1 packed as an integer.
+  # While first_byte is a Fixnum in Ruby 1.8.x, it is a string in 1.9.x;
+  # in latter case we employ the ord method to obtain the ordinal number
+  # associated,if is the case. Underlying machine is l.e. if the LSB is 1.
+
+  NATIVE_BYTE_ORDER = module_eval do
+    first_byte = [1].pack('i')[0]
+    first_byte = first_byte.ord if RUBY_VERSION =~ /^1\.9/
+    first_byte == 1 ? :little : :big
+  end
+
+  def native_byte_order() NATIVE_BYTE_ORDER end
+
+  def little_endian_platform?() native_byte_order.equal? :little end
+  def big_endian_platform?()    native_byte_order.equal? :big end
+  alias :network_endian_platform? :big_endian_platform?
+
+  @@pack_mappings = {
+    1 => { :uint => { :native => 'C' },
+           :int  => { :native => 'c' } },
+    2 => { :uint => { :native => 'S', :little => 'v', :big => 'n' },
+           :int  => { :native => 's', :little => 'v', :big => 'n' } },
+    4 => { :uint => { :native => 'L', :little => 'V', :big => 'N' },
+           :int  => { :native => 'l', :little => 'V', :big => 'N' } },
+    8 => { :uint => { :native => 'Q' },
+           :int  => { :native => 'q' } } }
+
+  BIT_MASK = {  4 => 0xF, 8 => 0xFF, 16 => 0xFFFFF,
+               32 => 0xFFFFFFFF, 64 => 0xFFFFFFFFFFFFFFFF,
+              128 => 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF }
+
+  DEFAULT_BIT_MASK = module_eval { (1.size >> 1) * 8 }
+
+  def msb(num, bits=DEFAULT_BIT_MASK) (num & BIT_MASK[bits]) end
+  def lsb(num, bits=DEFAULT_BIT_MASK) ((num >> bits) & BIT_MASK[bits]) end
+
+  def split_msb_lsb(num, bits)
+    [msb(num, bits), lsb(num,bits) ]
+  end
+
+  def concat(msb, lsb, bits)
+    lsb + (msb << bits)
+  end
+
+  def read_uint256_little
+    lsb  = read_uint128_little
+    msb  = read_uint128_little
+    concat(msb, lsb, 128)
+  end
+
+  def read_int256_little
+    val = read_uint256_little
+    val > (2**256 - 1) ? val : -val
+  end
+
+  def read_uint256_big
+    msb = read_uint64_big
+    lsb = read_uint64_big
+    concat(msb, lsb, 128)
+  end
+  alias :read_uint256_network :read_uint256_big
+
+  def read_uint256_native
+    little_endian_platform? ? read_uint256_little : read_uint256_big
+  end
+  alias :read_uint256 :read_uint256_native
+
+  def write_uint256_little(n)
+    msb, lsb = split_msb_lsb(n, 128)
+    write_uint128_little(msb)
+    write_uint128_little(lsb)
+  end
+
+  def write_int256_little(n)
+    n = 2**256 - n
+    write_uint256_little(n)
+  end
+
+  def write_uint256_big(n)
+    lsb, msb = split_msb_lsb(n, 128)
+    write_uint128_big(msb)
+    write_uint128_big(lsb)
+  end
+
+  def write_uint256_native(n)
+    little_endian_platform? ? write_uint256_little(n) : write_uint256_big(n)
+  end
+  alias :write_uint256 :write_uint256_native
+
+  def read_uint128_little
+    lsb = read_uint64_little
+    msb = read_uint64_little
+    concat(msb, lsb, 64)
+  end
+
+  def read_int128_little
+    val = read_uint128_little
+    val > (2**128 - 1) ? val : -val
+  end
+
+  def read_uint128_big
+    msb = read_uint64_big
+    lsb = read_uint64_big
+    concat(msb, lsb, 64)
+  end
+  alias :read_uint128_network :read_uint128_big
+
+  def read_uint128_native
+    little_endian_platform? ? read_uint128_little : read_uint128_big
+  end
+  alias :read_uint128 :read_uint128_native
+
+  def write_uint128_little(n)
+    lsb, msb = split_msb_lsb(n, 64)
+    write_uint64_little(lsb)
+    write_uint64_little(msb)
+  end
+
+  def write_int128_little(n)
+    n = 2**128 - n
+    write_uint128_little(n)
+  end
+
+  def write_uint128_big(n)
+    lsb, msb = split_msb_lsb(n, 64)
+    write_uint64_big(msb)
+    write_uint64_big(lsb)
+  end
+
+  def write_uint128_native(n)
+    little_endian_platform? ? write_uint128_little(n) : write_uint128_big(n)
+  end
+  alias :write_uint128 :write_uint128_native
+
+  def read_uint64_little
+    lsb = readn_unpack(4, 'L', :little)
+    msb = readn_unpack(4, 'L', :little)
+    concat(msb, lsb, 32)
+  end
+
+  def read_uint64_big
+    msb = readn_unpack(4, 'L', :big)
+    lsb = readn_unpack(4, 'L', :big)
+    concat(msb, lsb, 32)
+  end
+  alias :read_uint64_network :read_uint64_big
+
+  def read_uint64_native
+    little_endian_platform? ? read_uint64_little : read_uint64_big
+  end
+  alias :read_uint64 :read_uint64_native
+
+  def write_uint64_little(n)
+    lsb, msb = split_msb_lsb(n,32)
+    write_pack(lsb, 'L', :little)
+    write_pack(msb, 'L', :little)
+  end
+
+  def write_uint64_big(n)
+    lsb, msb = split_msb_lsb(n,32)
+    write_pack(msb, 'L', :big)
+    write_pack(lsb, 'L', :big)
+  end
+
+  def write_uint64_native(n)
+    little_endian_platform? ? write_uint64_little(n) : write_uint64_big(n)
+  end
+  alias :write_uint64 :write_uint64_native
+
+  # obtains the correct pack format for the arguments
+  def format(byte_size, type, byte_order)
+    byte_order = :native if byte_order.nil?
+    byte_order = :big if byte_order.equal?(:network)
+    @@pack_mappings[byte_size][type][byte_order]
+  end
+
+  # read n bytes and unpack, swapping bytes as per endianness
+  def readn_unpack(size, template, byte_order=NATIVE_BYTE_ORDER)
+    str = readn(size)
+    str.reverse! if not native_byte_order.equal? byte_order # spotted problem in pack
+    str.unpack(template).first
+  end
+
+  # read exactly n characters from the buffer, otherwise raise an exception.
+  def readn(n)
+    str = read(n)
+    raise "couldn't read #{n} characters." if str.nil? or str.size != n
+    str
+  end
+
+  def read_null_padded_string(size)
+    str = readn(size)
+    str.split(/NUL/).first or str
+  end
+
+  def read_c_string
+    readline(sep_string = NUL)
+  end
+
+  def read_string(opt={:size => nil, :padding => NUL})
+    if opt[:size]
+      read_fixed_size_string(opt[:size], opt[:padding])
+    else
+      read_c_string
+    end
+  end
+
+  # writes a number and pack it, swapping bytes as per endianness
+  def write_pack(number, template, byte_order=NATIVE_BYTE_ORDER)
+    str = [number].pack(template)
+    str.reverse! if not native_byte_order.equal? byte_order # blame Array#pack
+    write(str)
+  end
+
+  # writes the string and appends NUL
+  def write_c_string(str)
+    #TODO: improve input validation
+    raise ArgumentError, "Invalid Ruby string" if str.include?(NUL)
+    write(str)
+    write(NUL)
+  end
+
+  def write_string(content, opt = {:padding  => nil, :size => content.size})
+    return if not (opt[:size].kind_of? Integer)
+    output_string = content[0..opt[:size]]
+    output_string = output_string.ljust(opt[:size], opt[:padding]) if opt[:padding]
+    write(output_string)
+  end
+
+  def write_fixed_size_string(content="")
+    write_string(content, :size => content.size)
+  end
+
+  def write_null_padded_string(str, opt = {:size  => str.size})
+    write_string(str, padding => "\000", :size => str.size)
+  end
+
+  def method_missing(method_name, *args, &block)
+    if method_name.to_s =~ OP_INT_RE
+      op, type, bits, byte_order = Regexp.last_match[1..4]
+      # string → sym
+      op, type, byte_order = [op, type].map!(&:to_sym)
+      # adjust bits to bytes
+      byte_size = (bits.to_i / 8)
+      # normalize endianness
+      byte_order = byte_order.to_sym unless byte_order.nil?
+      byte_order = :big if byte_order == 'network'
+
+      fmt = format(byte_size,type,byte_order)
+
+      case op
+      when :read
+        self.class.send :define_method, method_name do
+          readn_unpack(byte_size, fmt, byte_order)
+        end
+        self.send method_name
+      when :write
+        if (args.first.kind_of? Integer) && (args.size == 1)
+          self.class.send :define_method, method_name do |value|
+            write_pack(value, fmt, byte_order)
+          end
+          self.send method_name, args.first
+        end
+      end
+    elsif method_name.to_s =~ OP_STR_RE
+      op, string_flavor = Regexp.last_match[1..2]
+      case op
+      when :read
+        options = args.first.indexes(:size, :padding)
+        self.send :read_string, options
+      when :write
+        str, options = args.shift, args
+        self.send :write_string, str, options
+      end
+    else
+      super
+    end
+  end
+
+  # Tells the byte size required for the method passed as argument.
+  # When recognized.
+  def size_of(type, object=nil)
+    case
+    when type.to_s =~ INT_RE then Regexp.last_match[2].to_i / 8
+    when type.to_s =~ STR_RE then Regexp.last_match[-2].to_i
+    end
+  end
+
+  def recognize?(type)
+    type.to_s =~ Regexp.union(INT_RE,STR_RE)
+  end
+end
+

data/test/helper.rb

@@ -0,0 +1,75 @@
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__))
+
+# TODO: resort to test_unit where minitest
+# is not available and don't require
+# anything
+begin; gem 'minitest' if RUBY_VERSION =~ /^1\.9/; rescue Gem::LoadError; end
+
+begin
+  require 'minitest/autorun'
+rescue LoadError
+  require 'rubygems'
+  require 'minitest/autorun'
+end
+
+require 'binary_finery'
+
+module BinaryFinery
+  class TestCase < MiniTest::Unit::TestCase
+    #
+    # Test::Unit backwards compatibility
+    #
+    begin
+      alias :assert_no_match   :refute_match
+      alias :assert_not_nil    :refute_nil
+      alias :assert_raise      :assert_raises
+      alias :assert_not_equal  :refute_equal
+    end if RUBY_VERSION =~ /^1\.9/
+
+    def fixture_path
+      File.join(File.dirname(__FILE__), 'fixtures')
+    end
+
+    def lib_path
+      File.join(File.dirname(__FILE__), '../lib')
+    end
+
+    def random_string(length)
+      (0...length).inject("") { |m,n| m  << (?A + rand(25)).chr }
+    end
+
+    def random_integer(bits, type=:uint)
+      (type.equal? :int) ? -1*rand(2**(bits-1)) : rand(2**bits)
+    end
+
+    def pack_integer(integer, opt={:bytes => 4, :type => :uint, :endian => nil})
+      bytes, type, endian = opt[:bytes], opt[:type], opt[:endian]
+      endian = :big if endian == :network
+      endian = :native if endian == nil
+
+      pack_mapping = {
+          1 => { :uint => { :native => 'C' },
+                 :int  => { :native => 'c' } },
+          2 => { :uint => { :native => 'S', :little => 'v', :big => 'n' },
+                 :int  => { :native => 's', :little => 'v', :big => 'n' } },
+          4 => { :uint => { :native => 'L', :little => 'V', :big => 'N' },
+                 :int  => { :native => 'l', :little => 'V', :big => 'N' } },
+          8 => { :uint => { :native => 'Q' },
+                 :int  => { :native => 'q' } } }
+
+      if bytes == 8 && (endian == :little || endian == :big)
+        bytes  = 4
+        format = pack_mapping[bytes][type][endian]
+        msb, lsb = (integer & 0xFFFFFFFF), (integer >> 16 & 0xFFFFFFFF)
+        array = [msb, lsb]
+        array.reverse! if [1,"\x01"].include?([1].pack('i')[0]) # little endian
+        array.pack(format*2)
+      else
+        format = pack_mapping[bytes][type][endian]
+        [integer].pack(format)
+      end
+
+    end
+
+  end
+end

data/test/test_binary_finery.rb

@@ -0,0 +1,303 @@
+require 'helper'
+require 'stringio'
+
+def StringIO.of_size(size, &block)
+  if (not size.kind_of?(Integer)) || (size < 0)
+    raise ArgumentError, 'positive integer required'
+  end
+  new(0.chr * size, &block)
+end
+
+class TestBinaryFinery < BinaryFinery::TestCase
+  def setup
+    @mockup = StringIO.new.extend(BinaryFinery)
+  end
+
+  def host_endianness
+    first_byte = [1].pack('i')[0]
+    [1,"\x01"].include?(first_byte) ? :little : :big
+  end
+
+  def test_detect_platform_endianness
+    assert_equal BinaryFinery::NATIVE_BYTE_ORDER, host_endianness
+  end
+
+  def test_detect_platform_integer_size
+    assert_equal BinaryFinery::INTEGER_SIZE_IN_BYTES, 1.size
+  end
+
+  def test_buffer_includes_binary
+    assert(@mockup.class.included_modules & [BinaryFinery])
+  end
+
+  def test_read_correctly_1_byte
+    buf = StringIO.of_size(2).extend(BinaryFinery)
+    buf.rewind
+    buf.write_uint8(0x55)
+    buf.rewind
+
+    assert_equal 0x55, buf.read_uint8
+  end
+
+  def test_does_not_care_about_overflow
+    overflow = 0xFF + 1
+    buf = StringIO.of_size(1).extend(BinaryFinery)
+    buf.rewind
+    buf.write_uint8(overflow)
+    buf.rewind
+
+    assert_equal 0, buf.read_uint8
+  end
+
+  def test_read_correctly_2_bytes
+    buf = StringIO.of_size(2).extend(BinaryFinery)
+    buf.rewind
+    buf.write_uint16_little(0x55)
+    buf.rewind
+
+    assert_equal 0x55, buf.read_uint16_little
+  end
+
+  def test_does_not_care_about_overflow_for_uint32
+    overflow = 0xFFFFFFFF + 1
+    buf = StringIO.of_size(4).extend(BinaryFinery)
+    buf.rewind
+    buf.write_uint32(overflow)
+    buf.rewind
+
+    assert_equal 0, buf.read_uint32
+  end
+
+  def test_read_correctly_4_bytes
+    v2 = [0x32, 0x24, 0x00, 0x00]
+    v2.reverse! if host_endianness.equal? :little
+    packed = v2.pack("C" * v2.size)
+    buf = StringIO.new(packed).extend(BinaryFinery)
+
+    buf.size.times do |i|
+      assert_equal v2[i], buf.read_uint8
+    end
+  end
+
+  def test_write_fixed_size_string
+    content = 'new blips are arbitrarily created in the electronic transaction system of the Federal Reserve (known as FedWire), no outside detection is possible whatsoever because there is no outside system that verifies (or even can verify) the total quantity of FedWire deposits'
+    buf = StringIO.of_size(content.size).extend(BinaryFinery)
+    buf.rewind
+    buf.write_fixed_size_string(content)
+    buf.rewind
+
+    assert_equal content, buf.gets.chomp
+  end
+
+  def test_find_bytesize_for_int16_little
+    buf = StringIO.new('').extend(BinaryFinery)
+    assert_equal 2, buf.size_of('read_int16_little')
+  end
+
+  def test_write_uint64_native
+    n = 0xB70A4625F1A224CF # Big endian
+    bytes = [0xB7, 0x0A, 0x46, 0x25, 0xF1, 0xA2, 0x24, 0xCF]
+    bytes.reverse! if BinaryFinery::NATIVE_BYTE_ORDER.equal? :little
+    
+    buf = StringIO.of_size(8).extend(BinaryFinery)
+
+    buf.rewind
+    buf.write_uint64(n)
+    buf.rewind
+
+    bytes.each_with_index do |byte, i|
+      buf.pos = i
+      assert_equal byte, buf.read_uint8
+    end
+    buf.rewind
+    expected = bytes.pack("C"*bytes.size)
+    assert_equal n, buf.read_uint64
+  end
+
+  def test_write_uint64_little
+  #    write_uint64_little(1)                 # services
+    n = 1
+    buf = StringIO.of_size(8).extend(BinaryFinery)
+    buf.write_uint64_little(n)
+    buf.rewind
+  
+    assert_equal n, buf.read_uint64_little
+  end
+
+  def test_write_uint128_little
+   # write_uint128_network(0xFFFF00000000)  # ip_address
+    n = 0xFFFF00000000
+    buf = StringIO.of_size(16).extend(BinaryFinery)
+    buf.write_uint128_little(n)
+    buf.rewind
+
+    assert_equal n, buf.read_uint128_little
+  end
+
+  def test_write_uint128_big
+    n = 0xFFFF00000000
+    buf = StringIO.of_size(16).extend(BinaryFinery)
+    buf.write_uint128_big(n)
+    buf.rewind
+
+    assert_equal n, buf.read_uint128_big
+  end
+
+  def test_read_uint128_little
+    n = rand(2**128)
+    assert_equal 16, n.size
+    buf = StringIO.of_size(16).extend(BinaryFinery)
+    buf.write_uint128_little(n)
+    buf.rewind
+
+    assert_equal n, buf.read_uint128_little
+  end
+
+  def test_read_uint256_little
+    n = rand(2**256)
+    assert_equal 32, n.size
+    buf = StringIO.of_size(32).extend(BinaryFinery)
+    buf.write_uint256_little(n)
+    buf.rewind
+
+    assert_equal n, buf.read_uint256_little
+  end
+
+  def test_read_int128_little
+    n = rand(2**64)
+    buf = StringIO.of_size(16).extend(BinaryFinery)
+    buf.write_int128_little(n)
+    buf.rewind
+
+    assert_equal n, buf.read_int128_little
+  end
+
+  def test_read_int128_little
+    n = -rand(2**64)
+    buf = StringIO.of_size(16).extend(BinaryFinery)
+    buf.write_int128_little(n)
+    buf.rewind
+
+    assert_equal n, buf.read_int128_little
+  end
+
+  def test_read_int256_little
+    n = rand(2**128)
+    buf = StringIO.of_size(32).extend(BinaryFinery)
+    buf.write_int256_little(n)
+    buf.rewind
+
+    assert_equal n, buf.read_int256_little
+  end
+
+  def test_read_int256_little
+    n = -rand(2**128)
+    buf = StringIO.of_size(32).extend(BinaryFinery)
+    buf.write_int256_little(n)
+    buf.rewind
+
+    assert_equal n, buf.read_int256_little
+  end
+
+  def test_write_null_padded_string
+    str = "ciao\000\000\000\000"
+    buf = StringIO.of_size(32).extend(BinaryFinery)
+
+    buf.write_string("ciao", :padding => "\000", :size => str.size)
+    buf.rewind
+
+    assert_equal str, buf.readn(str.size)
+  end
+
+  def test_write_c_string
+    str = "ciao\000"
+    buf = StringIO.of_size(32).extend(BinaryFinery)
+
+    buf.write_c_string("ciao")
+    buf.rewind
+
+    assert_equal str, buf.read_c_string
+  end
+
+  def test_read_null_padded_string
+    str = "ciao\000\000\000\000"
+    buf = StringIO.of_size(32).extend(BinaryFinery)
+
+    buf.write_string("ciao", :padding => "\000", :size => str.size)
+    buf.rewind
+
+    assert_equal str, buf.read_null_padded_string(8)
+  end
+
+end
+
+# test read
+bytes_ary = [1,2,4,8]
+
+bytes_ary.each do |bytes|
+  [:int, :uint].each do |type|
+    [:native, :little, :big, :network].each do |mapped_endian|
+      next if bytes.equal? 1
+      TestBinaryFinery.class_eval do
+        bits    = bytes * 8
+        packing = { :bytes => bytes, :type => type, :endian => mapped_endian }
+
+        # read
+        read_method = "read_#{type}#{bits}_#{mapped_endian}"
+        define_method "test_#{read_method}" do
+          number = random_integer(bits, type)
+          packed_number = pack_integer(number, packing)
+          buf = StringIO.new(packed_number).extend(BinaryFinery)
+
+          assert number, buf.send(read_method)
+        end
+
+        # write
+        write_method = "write_#{type}#{bits}_#{mapped_endian}"
+        define_method "test_#{write_method}" do
+          number = random_integer(bits, type)
+          buf = StringIO.of_size(bytes).extend(BinaryFinery)
+          buf.send(write_method, number)
+          buf.rewind
+          
+          assert number, buf.send(read_method)
+        end
+
+        #size
+        define_method "test_#{type}#{bits}_length_is_#{bytes}_bytes" do
+          assert bytes, StringIO.new('').extend(BinaryFinery).size_of(read_method)
+          assert bytes, StringIO.new('').extend(BinaryFinery).size_of(write_method)
+        end
+      end
+    end
+    [nil].each do |no_endian_specified|
+      bits = bytes * 8
+      packing = { :bytes  => bytes,
+                  :type   => type,
+                  :endian => no_endian_specified }
+
+      TestBinaryFinery.class_eval do
+        read_method = "read_#{type}#{bits}"
+        define_method "test_#{read_method}" do
+          number = random_integer(bits, type)
+          packed = pack_integer(number, packing)
+          buf = StringIO.new(packed).extend(BinaryFinery)
+
+          assert number, buf.send(read_method)
+        end
+
+        write_method = "write_#{type}#{bits}"
+        define_method "test_#{write_method}" do
+          number = random_integer(bits, type)
+          buf = StringIO.of_size(bytes).extend(BinaryFinery)
+          buf.rewind
+          buf.send(write_method, number)
+          buf.rewind
+          
+          assert number, buf.send(read_method)
+        end
+      end
+    end
+  end
+end
+    

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: binary_finery
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Michelangelo Altamore
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-10-07 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 2
+        - 1
+        - 0
+        version: 2.1.0
+  type: :development
+  version_requirements: *id001
+description: |-
+  BinaryFinery mixes in a fluent interface to any
+                       IO entity for reading or writing binary data.
+email: michelangelo@altamore.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- README.md
+- LICENSE
+- Rakefile
+- lib/binary_finery.rb
+- test/helper.rb
+- test/test_binary_finery.rb
+homepage: https://github.com/altamic/binary_finary
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A fluent interface for reading or writing binary data
+test_files: []
+