codec 0.0.2 → 0.0.4

data/lib/codec/tlv.rb

@@ -0,0 +1,176 @@
+module Codec
+  class Tlv < Prefixedlength
+    def initialize(id,length,header,content)
+      super(id,length,content)
+      @tag_codec = header
+      @subCodecs = {}
+    end
+    
+    def decode_with_length(buf,length)
+      l = eval_length(buf,length)
+      f,r = decode(buf[0,l])
+      Logger.warn("Remain data in a tlv buffer :[#{r.unpack("H*").first}]") if r.length > 0
+      return f,buf[l,buf.length]
+    end
+    
+    def encode(field)
+      out = ""
+      fields = field.get_value
+      fields.each do |id,sf|
+        out += @tag_codec.encode(Field.new(id,id))
+        if @subCodecs[id]
+          content = @subCodecs[id].encode(sf)
+          length_buffer = @length_codec.encode(Field.new('*',content.length))
+          out += length_buffer + content
+        else
+          out += super(sf)
+        end
+      end
+      return out
+    end
+  
+    def decode(buffer)
+      msg = Field.new(@id)
+      while(buffer.length > 0)
+        begin
+          tag,buffer = @tag_codec.decode(buffer)
+        rescue 
+          val = Field.new("ERR")
+          val.set_value("Error on parsing tag for TLV with following data [#{buffer.unpack("H*").first}]")
+          msg.add_sub_field(val)
+          return msg
+        end
+        begin
+          if @subCodecs[tag.get_value.to_s].nil?
+            val,buffer = super(buffer)
+          else
+            l,buf = @length_codec.decode(buffer)
+            val,buffer = @subCodecs[tag.get_value.to_s].decode_with_length(buf,l.get_value.to_i)
+          end
+        rescue BufferUnderflow => e
+          val = Field.new
+          val.set_value("Buffer underflow when parsing this tag : #{e.message} [#{buffer.unpack("H*").first}]")
+          buffer = ""
+        rescue 
+          val = Field.new
+          val.set_value("Parsing error [#{buffer.unpack("H*").first}]")
+          buffer = ""
+        end
+        
+        val.set_id(tag.get_value.to_s)
+        msg.add_sub_field(val)
+      end
+      return msg,buffer
+    end
+  end
+  
+  class Bertlv < Base
+    def initialize(id)
+      @id = id
+      @length = 0
+    end
+    
+    def tag_decode(buffer)
+      buf = buffer.dup
+      # removing trailling bytes
+      begin ; b = buf.slice!(0).getbyte(0) ; end while (b == 0 || b == 255)
+      tag = b.chr
+      if (b & 0x1F == 0x1F) 
+        begin 
+          nb = buf.slice!(0).getbyte(0)
+    	    tag += nb.chr
+    	  end while nb & 0x80 == 0x80
+      end
+      return tag.unpack("H*").first.upcase, buf
+    end
+
+    def tag_encode(tag)
+      buf = [tag].pack("H*")
+      check_tag, remain = tag_decode(buf)
+      if tag != check_tag || remain != ""
+        raise EncodingException, "Invalid BER tag [#{tag}]"
+      end
+      return buf
+    end
+    
+    def length_decode(buffer)
+     buf = buffer.dup
+     b = buf.slice!(0).getbyte(0)
+     if b & 0x80 == 0x80
+       # Compute lenght of encoding length sample if first byte is 83 then lenth is encode 
+       # on 3 bytes
+       loencl = b & 0x7F 
+       lb = buf[0,loencl]
+       buf = buf[loencl,buf.length]
+       length = 0
+       while(lb.length > 0)
+         length *= 256
+    	   length += lb.slice!(0).getbyte(0)
+       end
+       return length,buf
+     else
+       return b,buf
+     end
+    end
+
+    def length_encode(length)
+      out = Numbin.numbin(length,0)
+      if out.length > 127
+       raise EncodingException,"Invalid length for BER Tlv #{length}"
+      elsif out.length > 1
+        out = (128 + out.length).chr + out
+      end
+      return out
+    end
+    
+    def value_decode(buf,length)
+      if length > buf.length
+        raise ErrorBufferUnderflow,"Not enough data for parsing BER TLV 
+           #{@id} length value #{length} remaining only #{buf.length}"
+      end
+      value = buf[0,length]
+      buf = buf[length,buf.length]
+      return value.unpack("H*").first.upcase,buf
+    end
+  
+    def value_encode(unpack_buffer)
+      [unpack_buffer].pack("H*")
+    end
+    
+    def build_field(buf,length)
+      msg = Field.new(@id)
+      buffer = buf[0,length]
+      while buffer.length > 0
+        tag,buffer = tag_decode(buffer)
+        f = Field.new(tag)
+        value_length,buffer = length_decode(buffer)
+        value, buffer = value_decode(buffer,value_length)
+    	  f.set_value(value)
+    	  msg.add_sub_field(f)
+      end
+      return msg
+    end
+  
+    def decode(buffer)
+      return build_field(buffer,buffer.length),""
+    end
+    
+    def encode(field)
+      out = ""
+      subfields = field.get_value
+      unless subfields.kind_of?(Array)
+        raise EncodingException, "Invalid field #{field.to_yaml} for BER Tlv encoding"
+      end
+      
+      while subfields.size > 0
+        subfield = subfields.shift
+        out += tag_encode(subfield.first)
+        # TODO : Handle value that is not String
+        value = value_encode(subfield.last.get_value)
+        out += length_encode(value.length)
+        out += value
+      end
+      return out
+    end
+  end
+end

data/lib/codec/version.rb

@@ -1,3 +1,3 @@
 module Codec
-  VERSION = "0.0.2"
+  VERSION = "0.0.4"
 end

data/lib/codec.rb

@@ -4,10 +4,11 @@ require 'codec/field'
 require 'codec/exceptions'
 require 'codec/base'
 require 'codec/fix'
-# require 'codec/packed'
-# require 'codec/prefixed'
-# require 'codec/composed'
-
+require 'codec/packed'
+require 'codec/prefix'
+require 'codec/composed'
+require 'codec/bitmap'
+require 'codec/tlv'
 
 module Codec
   

data/test/lib/codec/bitmap_test.rb

@@ -0,0 +1,71 @@
+require_relative '../../test_helper'
+ 
+describe Codec::Bitmap do
+  
+  subject { Codec::Bitmap.new('Bitmap',2) }
+  
+  before do
+    subject.add_sub_codec('1',Codec::Numasc.new('*',3))
+    subject.add_sub_codec('2', Codec::String.new('*',5))
+    subject.add_sub_codec('3', Codec::String.new('*',3))
+    subject.add_sub_codec('15', Codec::Numbin.new('*',2))
+    @buffer = ["1100000000000010","012ABCDE","0012"].pack("B*A*H*")
+  end
+
+  it "must be a BaseComposed codec" do
+    subject.must_be_instance_of(Codec::Bitmap)
+  end
+  
+  it "must generate composed field from buffer" do
+    subject.decode(@buffer).first.
+      get_value.collect{ |id,f| 
+        [id,f.get_value]
+      }.must_equal([['1',12],['2',"ABCDE"],['15',18]])
+  end
+
+end
+
+describe Codec::Bitmap do
+  
+  subject { Codec::Bitmap.new('MultipleBitmap',2) }
+  
+  before do
+    subject.add_extended_bitmap('1')
+    subject.add_sub_codec('2',Codec::Numasc.new('*',3))
+    subject.add_sub_codec('3', Codec::String.new('*',5))
+    subject.add_sub_codec('4', Codec::String.new('*',3))
+    subject.add_sub_codec('18', Codec::Numbin.new('*',2))
+    subject.add_sub_codec('21', Codec::String.new('*',5))
+    @buffer_1 = ["11000000000000000100100000000000","012","0012","ABCDE"].pack("B*A*H*A*")
+    @buffer2 = ["0110000000000000","012","ABCDE"].pack("B*A3A5")
+    @field_1 = Codec::Field.from_array('MultipleBitmap',[['2',12],['18',18],['21',"ABCDE"]])
+    @field_2 = Codec::Field.from_array('MultipleBitmap',[['2',12],['41',18],['21',"ABCDE"]])
+  end
+
+  it "must be a Bitmap codec" do
+    subject.must_be_instance_of(Codec::Bitmap)
+  end
+  
+  it "must generate composed field from buffer with extended bitmap" do
+    subject.decode(@buffer_1).first.
+      get_value.collect{ |id,f| 
+        [id,f.get_value]
+      }.must_equal([['2',12],['18',18],['21',"ABCDE"]])
+  end
+
+  it "must generate composed field from buffer without extended bitmap" do
+    subject.decode(@buffer2).first.
+      get_value.collect{ |id,f| 
+        [id,f.get_value]
+      }.must_equal([['2',12],['3',"ABCDE"]])
+  end
+  
+  it "must generate buffer from composed field" do
+    subject.encode(@field_1).must_equal(@buffer_1)
+  end
+
+  it "must raise Encoding exception if subfield is unknown" do
+    proc { subject.encode(@field_2) }.must_raise(Codec::EncodingException)
+  end  
+  
+end

data/test/lib/codec/composed_test.rb

@@ -0,0 +1,79 @@
+require_relative '../../test_helper'
+ 
+describe Codec::BaseComposed do
+  subject { Codec::BaseComposed.new('BaseComposed') }
+
+  before do
+    subject.add_sub_codec('CHP1', Codec::Numasc.new('CHP1',3))
+    subject.add_sub_codec('CHP2', Codec::String.new('CHP2',5))
+    subject.add_sub_codec('CHP3', Codec::String.new('CHP3',4))
+    subject.add_sub_codec('CHP4', Codec::Numasc.new('CH4',4))
+    field_array = [['CHP1',12],['CHP2','ABCDE'],['CHP3','WXYZ'],['CHP4',23]]
+    @buffer_test1 = "012ABCDEWXYZ0023"
+    @field_test1 = Codec::Field.from_array('BaseComposed', field_array)
+    @buffer_test2 = "012ABCDEWXYZ"
+    @field_test2 = Codec::Field.from_array('BaseComposed', field_array[0,3])
+  end
+  
+  it "must be a BaseComposed codec" do
+    subject.must_be_instance_of(Codec::BaseComposed)
+  end
+  
+  it "must generate a field with computed value" do
+    subject.decode(@buffer_test1).first.must_equal(@field_test1)
+  end
+
+  it "must encode buffer with composed field" do
+    subject.encode(@field_test1).must_equal(@buffer_test1)
+  end
+  
+  it "must encode buffer with composed field without codec's last field " do
+    subject.encode(@field_test2).must_equal(@buffer_test2)
+  end  
+  
+  it "must handle remaining data" do
+    subject.decode("012ABCDEWXYZ0023123").last.must_equal("123")
+  end
+end
+
+describe Codec::CompleteComposed do
+  subject { Codec::CompleteComposed.new('CompleteComposed') }
+
+  before do
+    test_1 = [['CHP1',Codec::Numasc.new('*',3),12],
+      ['CHP2',Codec::String.new('*',5),"ABCDE"],
+      ['CHP3',Codec::String.new('*',4),"WXYZ"]]
+    field_array = test_1.collect{|id,codec,value| [id,value]}
+    @field_1 = Codec::Field.from_array('CompleteComposed',field_array)
+    test_1.each { |id,codec,value| subject.add_sub_codec(id,codec) }
+    @buffer_1 = "012ABCDEWXYZ123"
+    @buffer_2 = "012ABCDEWXYZ"
+    @buffer_3 = "012ABCDE"
+    @field_2 = Codec::Field.from_array('CompleteComposed',field_array[0,2])
+  end
+ 
+  it "must be a CompleteComposed codec" do
+    subject.must_be_instance_of(Codec::CompleteComposed)
+  end
+  
+  it "must generate a field with computed value" do
+    subject.decode(@buffer_1).first.must_equal(@field_1)
+  end
+  
+  it "must handle remaining data" do
+    subject.decode(@buffer_1).last.must_equal("123")
+  end
+ 
+  it "must raise BufferUnderflow if missing field" do
+    proc { subject.decode(@buffer_3)}.must_raise(Codec::BufferUnderflow)
+  end
+  
+  it "must encode expected buffer" do
+    subject.encode(@field_1).must_equal(@buffer_2)
+  end 
+
+  it "must raise EncodingException if missing field" do
+    proc { subject.encode(@field_2)}.must_raise(Codec::EncodingException)
+  end
+
+end

data/test/lib/codec/field_test.rb

@@ -0,0 +1,60 @@
+require_relative '../../test_helper'
+ 
+describe Codec::Field do
+  subject { f = Codec::Field.new('Test')
+    sf1 = Codec::Field.new('SF1')
+    sf1.set_value("123")
+    f.add_sub_field(sf1)
+    sf2 = Codec::Field.new('SF2')
+    sf2.set_value("321")
+    f.add_sub_field(sf2)
+    f
+  }
+  
+  it "must be a Field" do
+    subject.must_be_instance_of(Codec::Field)
+  end
+  
+  it "must respond to set_value" do
+    subject.must_respond_to :set_value
+  end
+  
+  it "must equal field create with from_array builder" do
+    subject.must_equal(Codec::Field.from_array('Test',[['SF1',"123"],['SF2',"321"]]))
+  end
+
+end
+
+describe Codec::Field do
+  subject { f = Codec::Field.new('Test')
+    sf1 = Codec::Field.new('SF1')
+    sf1.set_value("123")
+    f.add_sub_field(sf1)
+    sf2 = Codec::Field.new('SF2')
+    sf2.set_value("321")
+    f.add_sub_field(sf2)
+    sf3 = Codec::Field.new('SF3')
+    sf31 = Codec::Field.new('SF31')
+    sf31.set_value("456")
+    sf3.add_sub_field(sf31)
+    sf32 = Codec::Field.new('SF32')
+    sf32.set_value("789")
+    sf3.add_sub_field(sf32)
+    f.add_sub_field(sf3)
+    f
+  }
+  
+  it "must be a Field" do
+    subject.must_be_instance_of(Codec::Field)
+  end
+  
+  it "must respond to set_value" do
+    subject.must_respond_to :set_value
+  end
+  
+  it "must equal field create with from_array builder" do
+    subject.must_equal(Codec::Field.from_array('Test',
+    [['SF1',"123"],['SF2',"321"],['SF3',[['SF31',"456"],['SF32','789']]]]))
+  end
+
+end

data/test/lib/codec/fix_test.rb

@@ -2,6 +2,11 @@ require_relative '../../test_helper'
  
 describe Codec::Numbin do
   subject { Codec::Numbin.new('Test',4) }
+
+  before do
+    @f256 = Codec::Field.new
+    @f256.set_value(256)
+  end
   
   it "must be a codec" do
     subject.must_be_instance_of(Codec::Numbin)
@@ -10,7 +15,87 @@ describe Codec::Numbin do
   it "must generate a field with computed value" do
     subject.decode(["00000100"].pack("H*")).first.get_value.to_i.must_equal(256)
   end
+  
   it "must generate a field with computed value" do
     subject.decode(["00000100"].pack("H*")).last.size.must_equal(0)
-   end
+  end
+
+  it "must generate a field with computed value" do
+    subject.encode(@f256).must_equal(["00000100"].pack("H*"))
+  end
+end
+
+describe Codec::Numasc do
+  subject { Codec::Numasc.new('Test',4) }
+  
+  before do
+    @f12 = Codec::Field.new
+    @f12.set_value(12)
+  end
+  
+  it "must be a codec" do
+    subject.must_be_instance_of(Codec::Numasc)
+  end
+  
+  it "must generate a field with computed value" do
+    subject.decode("0012").first.get_value.to_i.must_equal(12)
+  end
+  
+  it "must generate a field with computed value" do
+    subject.decode("0012").last.size.must_equal(0)
+  end
+
+  it "must generate a field with computed value" do
+    subject.encode(@f12).must_equal("0012")
+  end
+end
+
+describe Codec::String do
+  subject { Codec::String.new('Test',10) }
+  before do
+    @fstring = Codec::Field.new
+    @fstring.set_value("TEST")
+  end
+  
+  it "must be a codec" do
+    subject.must_be_instance_of(Codec::String)
+  end
+  
+  it "must generate a field with computed value" do
+    subject.decode("Testing string").first.get_value.must_equal("Testing st")
+  end
+  
+  it "must also return remaining data" do
+    subject.decode("Testing string").last.must_equal("ring")
+  end
+
+  it "must generate a buffer with corresponding value padded with space" do
+    subject.encode(@fstring).must_equal("TEST      ")
+  end
+end
+
+describe Codec::Binary do
+  subject { Codec::Binary.new('Test',8) }
+  before do
+    @unpack_buffer = "ABCDEF0123456789"
+    @bin_buffer = [@unpack_buffer].pack("H*")
+    @fbin = Codec::Field.new
+    @fbin.set_value(@unpack_buffer)
+  end
+  
+  it "must be a codec" do
+    subject.must_be_instance_of(Codec::Binary)
+  end
+  
+  it "must generate a field with computed value" do
+    subject.decode(@bin_buffer).first.get_value.must_equal(@unpack_buffer)
+  end
+  
+  it "must return no remaining data" do
+    subject.decode(@bin_buffer).last.must_equal("")
+  end
+
+  it "must regenerate corresponding buffer" do
+    subject.encode(@fbin).must_equal(@bin_buffer)
+  end
 end

data/test/lib/codec/pckd_test.rb

@@ -0,0 +1,71 @@
+require_relative '../../test_helper'
+ 
+describe Codec::Packed do
+  subject { Codec::Packed.new('Test',6) }
+
+  before do
+    @f_pck = Codec::Field.new
+    @f_pck.set_value("123")
+  end
+  
+  it "must be a codec" do
+    subject.must_be_instance_of(Codec::Packed)
+  end
+  
+  it "must retrieve field length" do
+    subject.eval_pck_length(@f_pck).must_equal(6)
+  end
+
+end
+
+describe Codec::Numpck do
+  subject { Codec::Numpck.new('Test',5) }
+  
+  before do
+    @f12 = Codec::Field.new
+    @f12.set_value(12)
+    @pck_buff = ["000012"].pack("H*")
+  end
+  
+  it "must be a codec" do
+    subject.must_be_instance_of(Codec::Numpck)
+  end
+  
+  it "must generate a field with computed value" do
+    subject.decode(@pck_buff).first.get_value.to_i.must_equal(12)
+  end
+  
+  it "must not remain data" do
+    subject.decode(@pck_buff).last.size.must_equal(0)
+  end
+
+  it "must generate a field with computed value" do
+    subject.encode(@f12).must_equal(@pck_buff)
+  end
+end
+
+describe Codec::Strpck do
+  subject { Codec::Strpck.new('Test',11) }
+  before do
+    @unpack_buffer = "497011D9010"
+    @bin_buffer = [@unpack_buffer + "F"].pack("H*")
+    @fbin = Codec::Field.new
+    @fbin.set_value(@unpack_buffer)
+  end
+  
+  it "must be a codec" do
+    subject.must_be_instance_of(Codec::Strpck)
+  end
+  
+  it "must generate a field with computed value" do
+    subject.decode(@bin_buffer).first.get_value.upcase.must_equal(@unpack_buffer)
+  end
+  
+  it "must return no remaining data" do
+    subject.decode(@bin_buffer).last.must_equal("")
+  end
+
+  it "must regenerate corresponding buffer" do
+    subject.encode(@fbin).must_equal(@bin_buffer)
+  end
+end

data/test/lib/codec/prefix_test.rb

@@ -0,0 +1,104 @@
+require_relative '../../test_helper'
+
+describe Codec::Prefixedlength do
+  before do
+    @length = Codec::Numasc.new('length',3)
+    @content = Codec::String.new('content',0)
+    @field = Codec::Field.new
+    @field.set_value("0012AB")
+    @buffer = "0060012AB"
+  end
+
+  subject { Codec::Prefixedlength.new('Test_lvar',@length,@content) }
+  
+  it "must be a Prefixedlength codec" do
+    subject.must_be_instance_of(Codec::Prefixedlength)
+  end
+  
+  it "must generate a field with computed value" do
+    subject.decode(@buffer).first.get_value.must_equal("0012AB")
+  end
+  
+  it "must also return remaining data" do
+    subject.decode(@buffer).last.must_equal("")
+  end
+
+  it "must encode value prefixed with length" do
+    subject.encode(@field).must_equal("0060012AB")
+  end
+end
+
+describe Codec::Headerlength do
+  before do
+    tag = Codec::Binary.new('T',1)
+    length = Codec::Numbin.new('L',1)
+    value = Codec::Numbin.new('V',0)
+    tlv = Codec::Tlv.new('TAG',length,tag,value)
+    @header = Codec::BaseComposed.new('HEADER')
+    @header.add_sub_codec('H_TAG',tag)
+    @header.add_sub_codec('H_TLV',Codec::Prefixedlength.new('*',length,tlv))
+    @content = Codec::String.new('CONTENT',0)
+    len = 6
+    field_array = [['HEADER', [['H_TAG','AA'],['H_TLV',[['01',25],['02',len]]]]],
+      ['CONTENT','STRING']]
+    @field_with_length = Codec::Field.from_array('Test_Headerlength',field_array)
+    len = 0
+    field_array = [['HEADER', [['H_TAG','AA'],['H_TLV',[['01',25],['02',len]]]]],
+      ['CONTENT','STRING']]
+    @field_without_length = Codec::Field.from_array('Test_Headerlength',field_array)
+    @buffer = ["AA06010119020106","STRING"].pack("H*A*")
+  end
+
+  subject { Codec::Headerlength.new('Test_Headerlength',@header,@content,'.H_TLV.02') }
+  
+  it "must be a Headerlength codec" do
+    subject.must_be_instance_of(Codec::Headerlength)
+  end
+  
+  it "must decode a field with computed value" do
+    subject.decode(@buffer).first.must_equal(@field_with_length)
+  end
+  
+  it "must also return remaining data" do
+    subject.decode(@buffer + "REMAIN").last.must_equal("REMAIN")
+  end
+
+  it "must encode buffer with composed field [header,content]" do
+    subject.encode(@field_without_length).must_equal(@buffer)
+  end
+end
+
+describe Codec::Tagged do
+  before do
+    @field1 = Codec::Field.new('01',12)
+    @field2 = Codec::Field.new('02','ABC')
+    @buffer1 = "01012"
+    @buffer2 = "02ABC"
+  end
+
+  subject { c = Codec::Tagged.new('Test_tagged',Codec::String.new('*',2)) 
+            c.add_sub_codec('01',Codec::Numasc.new('*',3))
+            c.add_sub_codec('02',Codec::String.new('*',3))
+            c
+          }
+  
+  it "must be a Tagged codec" do
+    subject.must_be_instance_of(Codec::Tagged)
+  end
+  
+  it "must generate a field with computed value" do
+    subject.decode(@buffer1).first.must_equal(@field1)
+  end
+  
+  it "must generate a field with computed value" do
+    subject.decode(@buffer2).first.must_equal(@field2)
+  end  
+
+  it "must encode value prefixed with length" do
+    subject.encode(@field1).must_equal(@buffer1)
+  end
+
+  it "must encode value prefixed with length" do
+    subject.encode(@field2).must_equal(@buffer2)
+  end
+end