codec 0.0.12 → 1.0.0

data/test/lib/codec/prefix_test.rb

@@ -2,71 +2,43 @@ require_relative '../../test_helper'
 
 describe Codec::Prefixedlength do
   before do
-    @length = Codec::Numasc.new('length',3)
-    @content = Codec::String.new('content',0)
+    @length = Codec::Numasc.new(3)
+    @content = Codec::String.new(0)
     @field = Codec::Field.new
     @field.set_value("0012AB")
+    @f = Codec::Field.new
     @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
+  subject { Codec::Prefixedlength.new(@length,@content) }
   
   it "must generate a field with computed value" do
-    subject.decode(@buffer).first.get_value.must_equal("0012AB")
+    subject.decode(@buffer,@f)
+    @f.get_value.must_equal("0012AB")
   end
   
-  it "must also return remaining data" do
-    subject.decode(@buffer).last.must_equal("")
+  it "remaining buffer must be empty" do
+    subject.decode(@buffer,@f)
+    @buffer.must_be_empty
   end
 
   it "must encode value prefixed with length" do
-    subject.encode(@field).must_equal("0060012AB")
+    buffer = ""
+    subject.encode(buffer, @field)
+    buffer.must_equal("0060012AB")
   end
 end
 
-describe Codec::Prefixedlength do
-  before do
-    @length = Codec::Numasc.new('length',3)
-    @content = Codec::Strpck.new('content',0)
-    @field = Codec::Field.new
-    @field.set_value("0012AB")
-    @buffer = "006" +["0012AB"].pack("H*")
-  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.upcase.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(@buffer)
-  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')
+    tag = Codec::Binary.new(1)
+    length = Codec::Numbin.new(1)
+    value = Codec::Numbin.new(0)
+    tlv = Codec::Tlv.new(length,tag,value)
+    @header = Codec::BaseComposed.new
     @header.add_sub_codec('H_TAG',tag)
-    @header.add_sub_codec('H_TLV',Codec::Prefixedlength.new('*',length,tlv))
-    @content = Codec::String.new('CONTENT',0)
+    @header.add_sub_codec('H_TLV',Codec::Prefixedlength.new(length,tlv))
+    @content = Codec::String.new(0)
     len = 6
     field_head = ['HEADER', [['H_TAG','AA'],['H_TLV',[['01',25],['02',len]]]]]
     field_content = ['CONTENT','STRING']
@@ -79,28 +51,31 @@ describe Codec::Headerlength do
     field_array = [field_content]
     @field_without_head = Codec::Field.from_array('Test_Headerlength',field_array)
     @buffer = ["AA06010119020106","STRING"].pack("H*A*")
+    @working_field = Codec::Field.new('Test_Headerlength')
   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
+  subject { Codec::Headerlength.new(@header, 'HEADER',@content,'CONTENT','.H_TLV.02') }
   
   it "must decode a field with computed value" do
-    subject.decode(@buffer).first.must_equal(@field_with_length)
+    subject.decode(@buffer,@working_field)
+    @working_field.must_equal(@field_with_length)
   end
   
   it "must also return remaining data" do
-    subject.decode(@buffer + "REMAIN").last.must_equal("REMAIN")
+    buffer = @buffer + "REMAIN"
+    subject.decode(buffer, @working_field)
+    buffer.must_equal("REMAIN")
   end
 
   it "must encode buffer with composed field [header,content]" do
-    subject.encode(@field_without_length).must_equal(@buffer)
+    buffer = ""
+    subject.encode(buffer, @field_without_length)
+    buffer.must_equal(@buffer)
   end
   
   it "must raise EncodingException if missing header field" do
-    proc { subject.encode(@field_without_head)}.must_raise(Codec::EncodingException)
+    buf =""
+    proc { subject.encode(buf, @field_without_head)}.must_raise(Codec::EncodingException)
   end
   
 end
@@ -111,31 +86,34 @@ describe Codec::Tagged do
     @field2 = Codec::Field.new('02','ABC')
     @buffer1 = "01012"
     @buffer2 = "02ABC"
+    @working_field = Codec::Field.new
   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))
+  subject { c = Codec::Tagged.new(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)
+    subject.decode(@buffer1,@working_field)
+    @working_field.must_equal(@field1)
   end
   
   it "must generate a field with computed value" do
-    subject.decode(@buffer2).first.must_equal(@field2)
+    subject.decode(@buffer2,@working_field)
+    @working_field.must_equal(@field2)
   end  
 
   it "must encode value prefixed with length" do
-    subject.encode(@field1).must_equal(@buffer1)
+    buffer = ""
+    subject.encode(buffer, @field1)
+    buffer.must_equal(@buffer1)
   end
 
   it "must encode value prefixed with length" do
-    subject.encode(@field2).must_equal(@buffer2)
+    buffer =""
+    subject.encode(buffer, @field2)
+    buffer.must_equal(@buffer2)
   end
 end

data/test/lib/codec/tlv_test.rb

@@ -1,37 +1,38 @@
 require_relative '../../test_helper'
- 
+
 describe Codec::Tlv do
-  subject { Codec::Tlv.new('Tlv', Codec::Numbin.new('*',1), 
-              Codec::Binary.new('*',1), Codec::Binary.new('*',0))
+  subject { Codec::Tlv.new(Codec::Numbin.new(1), 
+              Codec::Binary.new(1), 
+              Codec::Binary.new(0))
           }
   
   before do
     @buffer = ["950580000000009C0100"].pack("H*")
     @field = Codec::Field.from_array('Tlv',[['95','8000000000'],['9C','00']])
-  end
-
-  it "must be a Tlv codec" do
-    subject.must_be_instance_of(Codec::Tlv)
+    @wf = Codec::Field.new('Tlv')
   end
   
   it "must generate composed field from buffer" do
-    subject.decode(@buffer).first.
-      must_equal(@field)
+    subject.decode(@buffer,@wf)
+    @wf.must_equal(@field)
   end
 
   it "must generate buffer from composed field" do
-    subject.encode(@field).must_equal(@buffer)
+    buff = ""
+    subject.encode(buff, @field)
+    buff.must_equal(@buffer)
   end  
 end
 
 describe Codec::Tlv do
-  subject { Codec::Tlv.new('Tlv', Codec::Numbin.new('*',1), 
-              Codec::Binary.new('*',1), Codec::Binary.new('*',0))
+  subject { Codec::Tlv.new( Codec::Numbin.new(1), 
+              Codec::Binary.new(1),
+              Codec::Binary.new(0))
           }
   
   before do
-    tvr_codec = Codec::BaseComposed.new("Tvr")
-    one_byte_codec = Codec::Binary.new("*",1)
+    tvr_codec = Codec::BaseComposed.new()
+    one_byte_codec = Codec::Binary.new(1)
     (1..5).each do |i|
       tvr_codec.add_sub_codec("BIT#{i}",one_byte_codec)
     end
@@ -41,63 +42,67 @@ describe Codec::Tlv do
     @field = Codec::Field.from_array('Tlv',
       [['95',[['BIT1','80'],['BIT2','00'],['BIT3','00'],
        ['BIT4','00'],['BIT5','00']]],['9C','00']])
+    @wf = Codec::Field.new('Tlv')
   end
 
-  it "must be a Tlv codec" do
-    subject.must_be_instance_of(Codec::Tlv)
-  end
-  
   it "must generate composed field from buffer" do
-    subject.decode(@buffer).first.
-      must_equal(@field)
+    Codec::Logger.debug {"====== start failing test =========\n"}
+    subject.decode(@buffer,@wf)
+    @wf.must_equal(@field)
+    Codec::Logger.debug {"====== end failing test =========\n"}
   end
 
   it "must generate buffer from composed field" do
-    subject.encode(@field).must_equal(@buffer)
+    buff = ""
+    subject.encode(buff, @field)
+    buff.must_equal(@buffer)
   end  
 end
 
 
 describe Codec::Tlv do
   subject {
-    tag = Codec::Binary.new('T',1)
-    length = Codec::Numbin.new('L',1)
-    value = Codec::Numbin.new('V',0)
-    Codec::Tlv.new('TAG',length,tag,value) }
+    tag = Codec::Binary.new(1)
+    length = Codec::Numbin.new(1)
+    value = Codec::Numbin.new(0)
+    Codec::Tlv.new(length,tag,value) }
     before do
       @buffer = ["9501009C010181020200"].pack("H*")
       @field = Codec::Field.from_array('TAG',
-        [['95',0],['9C',1],['81',512]])          
+        [['95',0],['9C',1],['81',512]])
+      @wf = Codec::Field.new('TAG')
     end
     
     it "must decode TLV buffer to field" do
-      subject.decode(@buffer).first.must_equal(@field)
+      subject.decode(@buffer,@wf)
+      @wf.must_equal(@field)
     end
     
     it "must encode TLV field to buffer" do
-      subject.encode(@field).must_equal(@buffer)
+      buff = ""
+      subject.encode(buff, @field)
+      buff.must_equal(@buffer)
     end
 end
     
 describe Codec::Bertlv do
-  subject { Codec::Bertlv.new('Bertlv') }
+  subject { Codec::Bertlv.new }
   
   before do
+    @wf = Codec::Field.new('Bertlv')
     @tlv_buf = ["9F100A0102030405060708091095058000000000"].pack("H*")
     @field = Codec::Field.from_array('Bertlv',
               [['9F10','01020304050607080910'],['95','8000000000']])
   end
 
-  it "must be a Tlv codec" do
-    subject.must_be_instance_of(Codec::Bertlv)
-  end
-  
   it "must generate composed field from buffer" do
-    subject.decode(@tlv_buf).first.
-      must_equal(@field)
+    subject.decode(@tlv_buf,@wf)
+    @wf.must_equal(@field)
   end
   
   it "must generate buffer from composed field" do
-    subject.encode(@field).must_equal(@tlv_buf)
+    buff = ""
+    subject.encode(buff, @field)
+    buff.must_equal(@tlv_buf)
   end
 end

data/test/test_helper.rb

@@ -1,4 +1,7 @@
 require 'minitest/spec'
 require 'minitest/autorun'
 require 'minitest/pride'
+
 require File.expand_path('../../lib/codec.rb', __FILE__)
+
+Codec::Logger.outputters=Log4r::FileOutputter.new("Codec", {:filename => "rake_test.log"})

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: codec
 version: !ruby/object:Gem::Version
-  version: 0.0.12
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,42 +9,42 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-15 00:00:00.000000000 Z
+date: 2014-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: log4r
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: '1.3'
-  type: :development
+        version: '0'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.3'
 - !ruby/object:Gem::Dependency
-  name: log4r
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements: