bitstream 0.0.1

data/lib/types/string-utils.rb

@@ -0,0 +1,37 @@
+# Author:: Natsuki Kawai (natsuki.kawai@gmail.com)
+# Copyright:: Copyright 2011 Natsuki Kawai
+# License:: 2-clause BSDL or Ruby's
+
+
+module BitStream
+
+  module Utils
+
+    def self.bit_lshift(s, bit)
+      if bit != 0
+        last_byte = nil
+        (s.size - 1).times do |i|
+          dbyte = s[i..(i + 1)].unpack('n')[0]
+          c = dbyte >> (8 - bit)
+          s[i] = (c & 0xff).chr
+        end
+      end
+    end
+    
+    def self.bit_rshift(s, bit)
+      if bit != 0
+        s << "\0"
+        first_byte = nil
+        (s.size - 1).downto 1 do |i|
+          dbyte = s[(i - 1)..i].unpack('n')[0]
+          c = dbyte >> bit
+          s[i] = (c & 0xff).chr
+          first_byte = c >> 8
+        end
+        s[0] = first_byte.chr
+      end
+    end
+
+  end
+
+end

data/lib/types/string.rb

@@ -0,0 +1,52 @@
+# Author:: Natsuki Kawai (natsuki.kawai@gmail.com)
+# Copyright:: Copyright 2011 Natsuki Kawai
+# License:: 2-clause BSDL or Ruby's
+
+
+require 'types/string-utils'
+
+module BitStream
+
+  class String
+
+    def self.instance(props, byte_len)
+      new byte_len
+    end
+
+    def initialize(byte_len)
+      @byte_len = byte_len
+    end
+
+    def length
+      @byte_len * 8
+    end
+
+    def read(s, offset)
+      bitoffset = offset % 8
+      head = offset / 8
+      tail = (offset + @byte_len * 8 + 7) / 8
+      val = s[head...tail]
+      Utils.bit_lshift(val, bitoffset)
+      val.slice!(val.size - 1) if bitoffset != 0
+
+      [val, @byte_len * 8]
+    end
+
+    def write(s, offset, data)
+      head = offset / 8
+      tail = (offset + @byte_len * 8 + 7) / 8
+      if offset % 8 != 0
+        bitoffset = offset % 8
+        Utils.bit_rshift(data, bitoffset)
+        s[head] = ((data[0].ord & 0xff >> bitoffset) | (s[head].ord & 0xff << (8 - bitoffset))).chr
+        s[tail - 1] = (data[data.size - 1].ord & 0xff << (8 - bitoffset)).chr
+        s[(head + 1)..(tail - 2)] = data[1..(data.size - 2)]
+      else
+        s[head...tail] = data
+      end
+      return @byte_len * 8
+    end
+
+  end
+
+end

data/sample/gzip-viewer.rb

@@ -0,0 +1,12 @@
+require_relative 'gzip'
+
+gzip = nil
+File.open(ARGV[0], "rb") do |file|
+  gzip = Gzip.create(file.read)
+end
+
+if gzip.respond_to? :original_file_name
+  puts "original_file_name:#{gzip.original_file_name}"
+else
+  puts "The gzip does not contain its original file name."
+end

data/sample/gzip.rb

@@ -0,0 +1,38 @@
+require 'bitstream'
+
+class Gzip
+  
+  include BitStream
+  byte_order :little_endian
+
+  FHCRC    = 1 << 1
+  FEXTRA   = 1 << 2
+  FNAME    = 1 << 3
+  FCOMMENT = 1 << 4
+
+  fields do
+    unsigned :id1,   8
+    unsigned :id2,   8
+    unsigned :cm,    8
+    unsigned :flg,   8
+    unsigned :mtime, 32
+    unsigned :xfl,   8
+    unsigned :os,    8
+    if (flg & FEXTRA) != 0
+      unsigned :xlen, 16
+      string   :extra_field, xlen
+    end
+    if (flg & FNAME) != 0
+      # cstring means a NULL-terminated string.
+      cstring :original_file_name
+    end
+    if (flg & FCOMMENT) != 0
+      # cstring means a NULL-terminated string.
+      cstring :file_comment
+    end
+    if (flg & FHCRC) != 0
+      unsigned :crc16, 16
+    end
+  end
+
+end

data/sample/tar-viewer.rb

@@ -0,0 +1,15 @@
+require 'bitstream'
+
+class Tar
+
+  include BitStream
+  byte_order :big_endian
+
+  fields do
+    cstring :name
+    string :padding1, 99 - file_name.size
+    string :mode, 8
+    string :uid, 8
+    string :gid, 8
+    string
+  end

data/test/test-array.rb

@@ -0,0 +1,33 @@
+# Author:: Natsuki Kawai (natsuki.kawai@gmail.com)
+# Copyright:: Copyright 2011 Natsuki Kawai
+# License:: 2-clause BSDL or Ruby's
+
+
+require 'test/unit'
+require 'bitstream'
+
+class ArraySample
+
+  include BitStream
+
+  fields do
+    array :a1, 5, :unsigned_int, 16
+  end
+
+end
+
+class TestArray < Test::Unit::TestCase
+
+  def setup
+    @spec = ArraySample.create "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a"
+  end
+
+  def test_a1
+    assert_equal(0x0102, @spec.a1[0])
+    assert_equal(0x0304, @spec.a1[1])
+    assert_equal(0x0506, @spec.a1[2])
+    assert_equal(0x0708, @spec.a1[3])
+    assert_equal(0x090a, @spec.a1[4])
+  end
+
+end

data/test/test-condition.rb

@@ -0,0 +1,50 @@
+# Author:: Natsuki Kawai (natsuki.kawai@gmail.com)
+# Copyright:: Copyright 2011 Natsuki Kawai
+# License:: 2-clause BSDL or Ruby's
+
+
+require 'test/unit'
+require 'bitstream'
+
+class ConditionSample
+
+  include BitStream
+
+  fields {
+    unsigned_int :u1, 32
+    if u1 == 0
+      unsigned_int :u2, 32
+    end
+  }
+
+end
+
+class TestCondition < Test::Unit::TestCase
+
+  def setup
+  end
+
+  def test_condition_true
+    spec = ConditionSample.create "\x00\x00\x00\x00\x00\x00\x00\x01"
+    assert_equal(0, spec.u1)
+    assert_equal(1, spec.u2)
+  end
+
+  def test_condition_false
+    spec = ConditionSample.create "\x00\x00\x00\x01\x00\x00\x00\x01"
+    assert_equal(1, spec.u1)
+    assert_raise(NoMethodError) do
+      spec.u2
+    end
+  end
+
+  def test_condition_false_with_dummy
+    ConditionSample.create "\x00\x00\x00\x00\x00\x00\x00\x01" # dummy
+    spec = ConditionSample.create "\x00\x00\x00\x01\x00\x00\x00\x01"
+    assert_equal(1, spec.u1)
+    assert_raise(NoMethodError) do
+      spec.u2
+    end
+  end
+
+end

data/test/test-dynarray.rb

@@ -0,0 +1,34 @@
+# Author:: Natsuki Kawai (natsuki.kawai@gmail.com)
+# Copyright:: Copyright 2011 Natsuki Kawai
+# License:: 2-clause BSDL or Ruby's
+
+
+require 'test/unit'
+require 'bitstream'
+
+class DynArraySample
+
+  include BitStream
+
+  fields {
+    dyn_array :a1, :char
+    while a1.last != "\0"
+      dyn_array :a1, :char
+    end
+  }
+
+end
+
+
+class TestDynArray < Test::Unit::TestCase
+
+  def setup
+    @spec = DynArraySample.create "foobar\0"
+  end
+
+  def test_a1
+    assert_equal("foobar\0", @spec.a1.join)
+  end
+
+end
+

data/test/test-nesting.rb

@@ -0,0 +1,64 @@
+# Author:: Natsuki Kawai (natsuki.kawai@gmail.com)
+# Copyright:: Copyright 2011 Natsuki Kawai
+# License:: 2-clause BSDL or Ruby's
+
+
+require 'test/unit'
+require 'bitstream'
+
+class Nested
+
+  include BitStream
+
+  fields do
+    unsigned_int "u1", 8
+    unsigned_int :u2, 8
+  end
+
+end
+
+class Nesting
+
+  include BitStream
+
+  add_type Nested, :nested
+
+  fields do
+    unsigned_int "u1", 8
+    nested       "n"
+    unsigned_int :u2, 8
+  end
+
+end
+
+class TestNesting < Test::Unit::TestCase
+
+  def setup
+    @spec = Nesting.create "\x01\x02\x03\x04"
+  end
+
+  def test_nesting_u1
+    assert_equal(0x01, @spec.u1)
+  end
+
+  def test_nesting_u2
+    assert_equal(0x04, @spec.u2)
+  end
+
+  def test_nesting
+    assert_equal(32, @spec.length)
+  end
+
+  def test_nested_u1
+    assert_equal(0x02, @spec.n.u1)
+  end
+
+  def test_nested_u2
+    assert_equal(0x03, @spec.n.u2)
+  end
+
+  def test_nested
+    assert_equal(16, @spec.n.length)
+  end
+
+end

data/test/test-primitives.rb

@@ -0,0 +1,92 @@
+# Author:: Natsuki Kawai (natsuki.kawai@gmail.com)
+# Copyright:: Copyright 2011 Natsuki Kawai
+# License:: 2-clause BSDL or Ruby's
+
+
+require 'test/unit'
+require 'bitstream'
+
+class SimpleIntBe
+
+  include BitStream
+
+  byte_order :big_endian
+
+  fields {
+    unsigned_int "u1", 32
+    unsigned_int :u2, 32
+    cstring      "cs1"
+    unsigned_int "u3", 1
+    unsigned_int "u4", 7
+    string       :s1, 3
+  }
+
+end
+
+class SimpleIntLe
+
+  include BitStream
+
+  byte_order :little_endian
+
+  fields {
+    unsigned_int "u1", 32
+    unsigned_int :u2, 32
+    cstring      "cs1"
+    unsigned_int "u3", 1
+    unsigned_int "u4", 7
+    string       :s1, 3
+  }
+
+end
+
+class TestSimpleInt < Test::Unit::TestCase
+
+  def setup
+    @spec = SimpleIntBe.create "\x10\x20\x30\x40\x50\x60\x70\x80foobar\00\xfebazdummy"
+
+    # dummy
+    dummy = SimpleIntBe.create "\x10\x20\x30\x40\x50\x60\x70\x80foobar\00\xfebazdummy"
+
+    @spec_le = SimpleIntLe.create "\x10\x20\x30\x40\x50\x60\x70\x80foobar\00\xfebazdummy"
+  end
+
+  def test_u1
+    assert_equal(0x10203040.to_s(16), @spec.u1.to_s(16))
+  end
+  def test_u1le
+    assert_equal(0x40302010.to_s(16), @spec_le.u1.to_s(16))
+  end
+
+  def test_u2
+    assert_equal(0x50607080.to_s(16), @spec.u2.to_s(16))
+  end
+  def test_u2le
+    assert_equal(0x80706050.to_s(16), @spec_le.u2.to_s(16))
+  end
+
+  def test_u3
+    assert_equal(1, @spec.u3)
+  end
+  def test_u3le
+    assert_equal(1, @spec_le.u3)
+  end
+
+  def test_u4
+    assert_equal(0x7e, @spec.u4)
+  end
+  def test_u4le
+    assert_equal(0x7e, @spec_le.u4)
+  end
+
+  def test_cs1
+    assert_equal("foobar", @spec.cs1)
+    assert_equal("foobar", @spec_le.cs1)
+  end
+
+  def test_s1
+    assert_equal("baz", @spec.s1)
+    assert_equal("baz", @spec_le.s1)
+  end
+
+end

data/test/test-simple-properties.rb

@@ -0,0 +1,34 @@
+# Author:: Natsuki Kawai (natsuki.kawai@gmail.com)
+# Copyright:: Copyright 2011 Natsuki Kawai
+# License:: 2-clause BSDL or Ruby's
+
+
+require 'test/unit'
+require 'bitstream'
+
+class HavingProps
+
+  include BitStream
+
+  fields do
+    unsigned_int :u1, props[:lengths][0]
+    unsigned_int :u2, props[:lengths][1]
+  end
+
+end
+
+class TestSimpleProperties < Test::Unit::TestCase
+
+  def setup
+    @spec = HavingProps.create "\x01\x02\x03\x04", lengths: [24, 8]
+  end
+
+  def test_u1
+    assert_equal(0x010203, @spec.u1)
+  end
+
+  def test_u2
+    assert_equal(0x04, @spec.u2)
+  end
+
+end

data/test/test-suite.rb

@@ -0,0 +1,14 @@
+# Author:: Natsuki Kawai (natsuki.kawai@gmail.com)
+# Copyright:: Copyright 2011 Natsuki Kawai
+# License:: 2-clause BSDL or Ruby's
+
+
+require 'test/test-primitives'
+require 'test/test-array'
+require 'test/test-dynarray'
+require 'test/test-nesting'
+require 'test/test-simple-properties'
+require 'test/types/test-character'
+require 'test/types/test-integer'
+require 'test/types/test-string'
+require 'test/types/test-cstring'

data/test/types/test-character.rb

@@ -0,0 +1,19 @@
+# Author:: Natsuki Kawai (natsuki.kawai@gmail.com)
+# Copyright:: Copyright 2011 Natsuki Kawai
+# License:: 2-clause BSDL or Ruby's
+
+
+require 'test/unit'
+require 'types/character'
+
+class TestUint < Test::Unit::TestCase
+
+  def test_char_nooffset_read
+    type = BitStream::Char.instance({})
+    val, len = type.read("abcd", 8)
+    assert_equal("b", val)
+    assert_equal(8, len)
+  end
+  
+end
+

data/test/types/test-cstring.rb

@@ -0,0 +1,18 @@
+# Author:: Natsuki Kawai (natsuki.kawai@gmail.com)
+# Copyright:: Copyright 2011 Natsuki Kawai
+# License:: 2-clause BSDL or Ruby's
+
+
+require 'test/unit'
+require 'types/cstring'
+
+class TestCstring < Test::Unit::TestCase
+
+  def test_aligned_read
+    type = BitStream::Cstring.instance({})
+    val, len = type.read("foobar\0baz", 16)
+    assert_equal("obar", val)
+    assert_equal(8 * "obar\0".size, len)
+  end
+
+end

data/test/types/test-integer.rb

@@ -0,0 +1,98 @@
+# Author:: Natsuki Kawai (natsuki.kawai@gmail.com)
+# Copyright:: Copyright 2011 Natsuki Kawai
+# License:: 2-clause BSDL or Ruby's
+
+
+require 'test/unit'
+require 'types/integer'
+
+class TestUint < Test::Unit::TestCase
+
+  BE_PROP = { :byte_order => :big_endian }
+  LE_PROP = { :byte_order => :little_endian }
+
+  def test_uint32be_nooffset_read
+    type = BitStream::Unsigned.instance(BE_PROP,32)
+    val, len = type.read("\x01\x02\x03\x04", 0)
+    assert_equal(0x01020304, val)
+    assert_equal(32, len)
+  end
+
+  def test_uint32le_nooffset_read
+    type = BitStream::Unsigned.instance(LE_PROP,32)
+    val, len = type.read("\x01\x02\x03\x04", 0)
+    assert_equal(0x04030201, val)
+    assert_equal(32, len)
+  end
+
+  def test_sint32be_nooffset_read
+    type = BitStream::Signed.instance(BE_PROP,32)
+    val, len = type.read("\xfe\xfd\xfc\xfb", 0)
+    assert_equal(-0x01020304 - 1, val)
+    assert_equal(32, len)
+  end
+
+  def test_sint32le_nooffset_read
+    type = BitStream::Signed.instance(LE_PROP,32)
+    val, len = type.read("\xfe\xfd\xfc\xfb", 0)
+    assert_equal(-0x04030201 - 1, val)
+    assert_equal(32, len)
+  end
+
+  def test_uint32_nooffset_write
+    type = BitStream::Unsigned.instance(BE_PROP, 32)
+    val = "\xff\x00"
+    type.write(val, 8, 0x01020304)
+    assert_equal("\xff\x01\x02\x03\x04", val)
+  end
+
+  def test_uint32be_offset4_read
+    type = BitStream::Unsigned.instance(BE_PROP, 32)
+    val, len = type.read("\xf1\x02\x03\x04\x05", 4)
+    assert_equal(0x10203040.to_s(16), val.to_s(16))
+    assert_equal(32, len)
+  end
+
+  def test_uint32be_offset1_read
+    type = BitStream::Unsigned.instance(BE_PROP, 32)
+    val, len = type.read("\x12\x23\x34\x45\x56", 1)
+    assert_equal(0x2446688a.to_s(16), val.to_s(16))
+    assert_equal(32, len)
+  end
+
+  def test_uint32le_offset4_read
+    type = BitStream::Unsigned.instance(LE_PROP, 32)
+    val, len = type.read("\xf1\x02\x03\x04\x05", 4)
+    assert_equal(0x5040302f.to_s(16), val.to_s(16))
+    assert_equal(32, len)
+  end
+
+  def test_uint32le_offset1_read
+    type = BitStream::Unsigned.instance(LE_PROP, 32)
+    val, len = type.read("\x80\x23\x34\x45\x56", 1)
+    assert_equal(0xac8a6847.to_s(16), val.to_s(16))
+    assert_equal(32, len)
+  end
+
+  def test_uint1be_read
+    type = BitStream::Unsigned.instance(BE_PROP, 1)
+    val, len = type.read("\x40", 1)
+    assert_equal(1, val)
+    assert_equal(1, len)
+
+    val, len = type.read("\xfd", 6)
+    assert_equal(0, val)
+    assert_equal(1, len)
+  end
+
+  def test_uint1le_read
+    type = BitStream::Unsigned.instance(LE_PROP, 1)
+    val, len = type.read("\x40", 1)
+    assert_equal(1, val)
+    assert_equal(1, len)
+
+    val, len = type.read("\xfd", 6)
+    assert_equal(0, val)
+    assert_equal(1, len)
+  end
+end

data/test/types/test-string.rb

@@ -0,0 +1,41 @@
+# Author:: Natsuki Kawai (natsuki.kawai@gmail.com)
+# Copyright:: Copyright 2011 Natsuki Kawai
+# License:: 2-clause BSDL or Ruby's
+
+
+require 'test/unit'
+require 'types/string'
+
+class TestString < Test::Unit::TestCase
+
+  def test_aligned_read
+    type = BitStream::String.instance({}, 3)
+    val, len = type.read("foobarbaz", 16)
+    assert_equal("oba", val)
+    assert_equal(3 * 8, len)
+  end
+
+  def test_aligned_write
+    type = BitStream::String.instance({}, 3)
+    val = "foobarbaz"
+    ret = type.write(val, 24, "qux")
+    assert_equal("fooquxbaz", val)
+  end
+
+  def test_unaligned_read
+    type = BitStream::String.instance({}, 2)
+    val, len = type.read([0x12345678].pack('N'), 1)
+    assert_equal("\x24\x68", val)
+    assert_equal(2 * 8, len)
+  end
+
+  def test_unaligned_write
+    type = BitStream::String.instance({}, 2)
+    val = "\x12\x34"
+    ret = type.write(val, 7, "\xcd\xef")
+
+    assert_equal("\x13\x9b", val[0..1])
+    assert(val[2].ord & 0xfe == 0xde)
+  end
+
+end