binary_parser 1.0.0

data/unit_test/test_stream_template_base.rb

@@ -0,0 +1,232 @@
+# -*- coding: utf-8 -*-
+$LIBRARY_ROOT_PATH = File.dirname(File.expand_path(File.dirname(__FILE__)))
+
+module BinaryParser
+  module UnitTest
+    require 'test/unit'
+
+    # load testing target
+    require $LIBRARY_ROOT_PATH + '/lib/binary_parser.rb'
+    
+    class TemplateStreamBaseTest < Test::Unit::TestCase
+      require 'stringio'
+
+      class TestingStreamTemplate < StreamTemplateBase
+        MyInt = Class.new(TemplateBase)
+        MyBin = Class.new(TemplateBase)
+
+        def_stream(3) do
+          data :id,   MyInt, 8
+          data :flag, MyInt, 8
+          data :char, MyBin, 8
+        end
+      end
+
+      def test_get_next_SIMPLE_USE
+        st = gen_stream(1, 0, 0x41,
+                        2, 1, 0x42)
+
+        d1 = st.get_next
+        assert_equal(1,   d1.id.to_i)
+        assert_equal(0,   d1.flag.to_i)
+        assert_equal("A", d1.char.to_s)
+
+        d2 = st.get_next
+        assert_equal(2,   d2.id.to_i)
+        assert_equal(1,   d2.flag.to_i)
+        assert_equal("B", d2.char.to_s)
+
+        assert_not(st.rest?)
+        assert_equal(nil, st.get_next)
+      end
+
+      def test_get_next_BINARY_SHORTAGE_ERROR
+        st = gen_stream(1, 0, 0x41, 0)
+
+        st.get_next
+        assert_raise(ParsingError) do
+          st.get_next
+        end
+      end
+
+      def test_filter_AND_get_next
+        st = gen_stream(1, 0, 0,
+                        2, 1, 0,
+                        3, 0, 0,
+                        4, 1, 0)
+
+        d1 = st.filter{|a| a.flag.to_i == 1}.get_next
+        assert_equal(2, d1.id.to_i)
+        
+        d2 = st.get_next
+        assert_equal(3, d2.id.to_i)
+
+        d3 = st.filter{|a| a.flag.to_i == 0}.get_next
+        assert_equal(nil, d3)
+
+        assert_not(st.rest?)
+
+        d4 = st.get_next
+        assert_equal(nil, d4)
+      end
+      
+      def test_seek_top_POPULAR_CASE
+        st = gen_stream(1, 0, 0,
+                        2, 0, 0,
+                        3, 1, 0,
+                        4, 0, 0)
+
+        abandoned = st.seek_top{|a| a.flag.to_i == 1}
+        assert_equal(2, abandoned.size)
+        assert_equal(1, abandoned[0].id.to_i)
+        assert_equal(2, abandoned[1].id.to_i)
+
+        assert_equal(3, st.get_next.id.to_i)
+      end
+
+      def test_seek_top_SPECIAL_CASE1
+        st = gen_stream(1, 1, 0,
+                        2, 0, 0)
+        
+        abandoned = st.seek_top{|a| a.flag.to_i == 1}
+        assert_equal(0, abandoned.size)
+        assert_equal(1, st.get_next.id.to_i)
+      end
+
+      def test_seek_top_SPECIAL_CASE2
+        st = gen_stream(1, 0, 0,
+                        2, 0, 0)
+        
+        abandoned = st.seek_top{|a| a.flag.to_i == 1}
+        assert_equal(2, abandoned.size)
+        assert_not(st.rest?)
+        assert_equal(nil, st.get_next)
+      end
+
+      def test_seek_top_SPECIAL_CASE3
+        st = gen_stream()
+        
+        abandoned = st.seek_top{|a| a.flag.to_i == 1}
+        assert_equal(0, abandoned.size)
+        assert_not(st.rest?)
+        assert_equal(nil, st.get_next)
+      end
+
+      def test_get_sequence_POPULAR_CASE
+        st = gen_stream(1, 0, 0,
+                        2, 1, 0,
+                        3, 0, 0,
+                        4, 0, 0,
+                        5, 1, 0)
+
+        seq = st.get_sequence{|a| a.flag.to_i == 1}
+        assert_equal(3, seq.size)
+        assert_equal(2, seq[0].id.to_i)
+        assert_equal(3, seq[1].id.to_i)
+        assert_equal(4, seq[2].id.to_i)
+
+        assert(st.rest?)
+        assert_equal(5, st.get_next.id.to_i)
+      end
+      
+      def test_get_sequence_SPECIAL_CASE1
+        st = gen_stream(1, 1, 0,
+                        2, 0, 0,
+                        3, 1, 0)
+        
+        seq = st.get_sequence{|a| a.flag.to_i == 1}
+        assert_equal(2, seq.size)
+
+        assert_equal(3, st.get_next.id.to_i)
+      end
+
+      def test_get_sequence_SPECIAL_CASE2
+        st = gen_stream(1, 1, 0,
+                        2, 1, 0,
+                        3, 0, 0)
+        
+        seq = st.get_sequence{|a| a.flag.to_i == 1}
+        assert_equal(1, seq.size)
+
+        assert_equal(2, st.get_next.id.to_i)
+      end
+
+      def test_get_sequence_SPECIAL_CASE3_A
+        st = gen_stream(1, 1, 0,
+                        2, 0, 0)
+        
+        seq = st.get_sequence{|a| a.flag.to_i == 1}
+        assert_equal(0, seq.size)
+
+        assert_not(st.rest?)
+      end
+
+      def test_get_sequence_SPECIAL_CASE3_B
+        st = gen_stream(1, 1, 0,
+                        2, 0, 0)
+        
+        seq = st.get_sequence(true){|a| a.flag.to_i == 1}
+        assert_equal(2, seq.size)
+
+        assert_not(st.rest?)
+      end
+
+      def test_get_sequence_SPECIAL_CASE4
+        st = gen_stream(1, 0, 0,
+                        2, 0, 0)
+        
+        seq = st.get_sequence{|a| a.flag.to_i == 1}
+        assert_equal(0, seq.size)
+
+        assert_not(st.rest?)
+      end
+
+      def test_get_sequence_SPECIAL_CASE5
+        st = gen_stream()
+        
+        seq = st.get_sequence{|a| a.flag.to_i == 1}
+        assert_equal(0, seq.size)
+
+        assert_not(st.rest?)
+      end
+
+      def test_accumulate_POPULAR_CASE
+        st = gen_stream(1, 0, 0,
+                        2, 0, 0,
+                        3, 0, 0,
+                        4, 0, 0,
+                        5, 0, 0)
+        
+        reduced_list = st.accumulate(0, 6){|acc, a| acc + a.id.to_i}
+        assert_equal(3, reduced_list.size)
+
+        assert_equal(4, st.get_next.id.to_i)
+      end
+
+      def test_accumulate_SPECIAL_CASE
+        st = gen_stream(1, 0, 0,
+                        2, 0, 0,
+                        3, 0, 0)
+
+        reduced_list = st.accumulate(0, 7){|acc, a| acc + a.id.to_i}
+        assert_equal(nil, reduced_list)
+
+        assert_not(st.rest?)
+      end
+
+      # helpers
+      def gen_bin(*chars)
+        return chars.pack("C*")
+      end
+
+      def gen_stream(*args)
+        binary_stream = StringIO.new(gen_bin(*args))
+        return TestingStreamTemplate.new(binary_stream)
+      end
+
+      def assert_not(object)
+        assert(!object)
+      end
+    end
+  end
+end

data/unit_test/test_structure_definition.rb

@@ -0,0 +1,115 @@
+# -*- coding: utf-8 -*-
+$LIBRARY_ROOT_PATH = File.dirname(File.expand_path(File.dirname(__FILE__)))
+
+module BinaryParser
+  module UnitTest
+    require 'test/unit'
+
+    # load testing target
+    require $LIBRARY_ROOT_PATH + '/lib/binary_parser.rb'
+
+    class StructureDefinitionTest < Test::Unit::TestCase
+
+      C1 = Class.new(TemplateBase)
+      C2 = Class.new(TemplateBase)
+      C3 = Class.new(TemplateBase)
+        
+      def test_data
+        st = StructureDefinition.new do
+          data :a, C1, 3
+          data :b, C2, var(:a) * 8
+          data :c, C3, 4
+        end
+
+        assert_equal(C1, st[:a].klass)
+        assert_equal(0,  st[:a].bit_position.eval{})
+        assert_equal(3,  st[:a].bit_length.eval{})
+        assert_equal([], st[:a].conditions)
+
+        assert_equal(C2, st[:b].klass)
+        assert_equal(3,  st[:b].bit_position.eval{})
+        assert_equal(24, st[:b].bit_length.eval{|name| {:a => 3}[name]})
+        assert_equal([], st[:b].conditions)
+
+        assert_equal(C3, st[:c].klass)
+        assert_equal(27, st[:c].bit_position.eval{|name| {:b => 24}[name]})
+        assert_equal(4,  st[:c].bit_length.eval{})
+        assert_equal([], st[:c].conditions)
+      end
+
+      def test_SPEND
+        st = StructureDefinition.new do
+          SPEND 48, :lp do
+            data :dat1, C1, 8
+            data :dat2, C2, 16
+          end
+          data :dat3, C3, 8
+        end
+        
+        assert_equal(8,  st[:lp].structure[:dat1].bit_length.eval{})
+        assert_equal(16, st[:lp].structure[:dat2].bit_length.eval{})
+        assert_equal(48, st[:dat3].bit_position.eval{})
+      end
+
+      def test_TIMES
+        st = StructureDefinition.new do
+          data :outer, C1, 8
+          TIMES 4, :list do
+            data :inner, C1, var(:outer)
+          end
+          data :foot, C1, 8
+        end
+        
+        assert_equal(8,  st[:list].bit_position.eval{})
+        assert_equal(12, st[:list].bit_length.eval{|name| {:outer => 3}[name]})
+        assert_equal(20, st[:foot].bit_position.eval{|name| {:list => 12}[name]})
+      end
+
+      def test_IF
+        st = StructureDefinition.new do
+          data :dat1, C1, 3
+          IF cond(:dat1){|v| v == 1} do
+            data :dat2, C2, var(:dat1) * 8
+            IF cond(:dat2){|v| v == 1} do
+              data :dat3, C3, var(:dat2) * 8
+            end
+          end
+          data :dat4, C1, 1
+        end
+      
+        assert_equal(0, st[:dat1].conditions.size)
+        assert_equal(1, st[:dat2].conditions.size)
+        assert_equal(2, st[:dat3].conditions.size)
+        assert_equal(0, st[:dat4].conditions.size)
+      end
+
+      def test_VARIABLE_REFERENCE_ERROR
+        assert_raise(DefinitionError) do
+          st = StructureDefinition.new do
+            data :d1, C1, var(:d2) * 8
+            data :d2, C2, 8
+          end
+        end
+      end
+
+      def test_TIMES_WITH_NONFIXED_LENGTH
+         assert_nothing_raised do
+          st = StructureDefinition.new do
+            data :length, C1,   8
+            TIMES 1, :list do
+              data :dat, C2, var(:length) * 8
+            end
+          end
+        end
+         assert_raise(DefinitionError) do
+          st = StructureDefinition.new do
+            TIMES 1, :list do
+              data :length, C1,   8
+              data :dat,    C2, var(:length) * 8
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/unit_test/test_template_base.rb

@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+$LIBRARY_ROOT_PATH = File.dirname(File.expand_path(File.dirname(__FILE__)))
+
+module BinaryParser
+  module UnitTest
+    require 'test/unit'
+
+    # load testing target
+    require $LIBRARY_ROOT_PATH + '/lib/binary_parser.rb'
+    
+    class TemplateBaseTest < Test::Unit::TestCase
+      
+      class TestingTemplate < TemplateBase
+        def_structure do
+          data :number, UInt,   7
+          data :flag,   Flag,   1
+          data :bytes,  Binary, 32
+        end
+      end
+
+      def test_initialize_FROM_ABSTRACT_BINARY
+        bin_seq = [0b10000001, 0x41, 0x42, 0x43, 0x44]
+        t = TestingTemplate.new(AbstractBinary.new(bin_seq.pack("C*")))
+        
+        assert_equal(0b1000000, t.number.to_i)
+        assert(t.flag.on?)
+        assert_equal("ABCD", t.bytes.to_s)
+      end
+
+      def test_initialize_FROM_BINARY_STRING
+        bin_seq = [0b10000001, 0x41, 0x42, 0x43, 0x44]
+        t = TestingTemplate.new(bin_seq.pack("C*"))
+        
+        assert_equal(0b1000000, t.number.to_i)
+        assert(t.flag.on?)
+        assert_equal("ABCD", t.bytes.to_s)
+      end
+        
+      def test_to_char
+        bin_seq = [0x01, 0x02, 0x3, 0x04, 0x05]
+        t = gen(*bin_seq)
+        
+        assert_equal(bin_seq, t.to_chars)
+      end
+
+      def test_binary_bit_length
+        t = gen(0x01, 0x02, 0x3, 0x04, 0x05, 0x06)
+        assert_equal(6 * 8, t.binary_bit_length)
+      end
+
+      def test_structure_bit_length
+        t = gen(0x01, 0x02, 0x3, 0x04, 0x05, 0x06)
+        assert_equal(40, t.structure_bit_length)
+      end
+
+      # helper for generating binary
+      def gen(*chars)
+        return TestingTemplate.new(chars.pack("C*"))
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: binary_parser
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- rokugats(u)
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: "This library can parse all kind of binary-data structures including
+  non-fixed length of structures and nested structures.\nFor generic parsing, loop
+  and condition(if) statement to define structures is provided in this library.\nOf
+  course, values of neighbor binary-data can be used as the other binary-data's specification
+  of length.\n\nFurthermore, this library handles all binary-data under the lazy evaluation.\nSo
+  you can read required parts of a binary-data very quickly even if whole of the binary-data
+  is too big, \n"
+email:
+- sasasawada@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- binary_parser.gemspec
+- lib/binary_parser.rb
+- lib/binary_parser/version.rb
+- lib/built_in_template/binary.rb
+- lib/built_in_template/flag.rb
+- lib/built_in_template/uint.rb
+- lib/error.rb
+- lib/general_class/abstract_binary.rb
+- lib/general_class/bit_position.rb
+- lib/general_class/condition.rb
+- lib/general_class/expression.rb
+- lib/loop_list.rb
+- lib/nameless_template.rb
+- lib/scope.rb
+- lib/stream_template_base.rb
+- lib/structure_definition.rb
+- lib/template_base.rb
+- unit_test/general_class/test_abstract_binary.rb
+- unit_test/general_class/test_bit_position.rb
+- unit_test/general_class/test_condition.rb
+- unit_test/general_class/test_expression.rb
+- unit_test/test_scope.rb
+- unit_test/test_stream_template_base.rb
+- unit_test/test_structure_definition.rb
+- unit_test/test_template_base.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: An elegant DSL library for parsing binary-data.
+test_files: []