da_funk 3.31.0 → 3.34.1

data/lib/iso8583/bitmap.rb

@@ -14,16 +14,51 @@ module ISO8583
   # transparently by the Message class.
   class Bitmap
     include DaFunk::Helper
+
+    class << self
+      # Parse the bytes in string and return the Bitmap and bytes remaining in `str`
+      # after the bitmap is taken away.
+      def parse(str, hex_bitmap = false, bitmap_size = 64)
+        bmp  = Bitmap.new(str, hex_bitmap, bitmap_size)
+
+        rest = if bmp.hex_bitmap?
+                 str[bmp.size_in_bytes_hex, str.length]
+               else
+                 str[bmp.size_in_bytes, str.length]
+               end
+
+        [ bmp, rest ]
+      end
+    end
+
+    # bitmap_size defines the size in bits of bitmap. It has to be multiple of 8 (a byte of 8 bits)
+    attr_reader :bitmap_size
+
+    # additional_bitmap defines if the bit 1 (left to right) indicates the presence of another
+    # bitmap just after the current one
+    attr_reader :additional_bitmap
+
+    attr_reader :bitmaps
+
     # create a new Bitmap object. In case an iso message
     # is passed in, that messages bitmap will be parsed. If
     # not, this initializes and empty bitmap.
-    def initialize(message = nil, hex_bitmap=false)
-      @bmp        = Array.new(128, false)
-      @hex_bitmap = hex_bitmap
+    def initialize(message = nil, hex_bitmap=false, bitmap_size = 64, additional_bitmap = true)
+      raise ISO8583Exception.new "wrong bitmap_size: #{bitmap_size}" if bitmap_size % 8 != 0
+
+      @bitmap_size           = bitmap_size
+      @bmp                   = Array.new(bitmap_size, false)
+      @hex_bitmap            = hex_bitmap
+      @additional_bitmap = additional_bitmap
+      @bitmaps               = 1
 
       message ? initialize_from_message(message) : nil
     end
 
+    def additional_bitmap?
+      !!@additional_bitmap
+    end
+
     def hex_bitmap?
       !!@hex_bitmap
     end
@@ -38,22 +73,40 @@ module ISO8583
       @bmp[i-1]
     end
 
-    # Set the bit to the indicated value. Only `true` sets the
-    # bit, any other value unsets it.
-    def []=(i, value)
-      if i > 128
-        raise ISO8583Exception.new("Bits > 128 are not permitted.")
-      elsif i < 2
-        raise ISO8583Exception.new("Bits < 2 are not permitted (continutation bit is set automatically)")
-      end
-      @bmp[i-1] = (value == true)
-    end
-
     # Sets bit #i
     def set(i)
+      if additional_bitmap?
+        raise ISO8583Exception, "field #{i} shouldn't be set (continuation bit is set automatically)" if i % bitmap_size == 1
+      end
+
+      if i > bitmap_size
+        raise ISO8583Exception, "can't set field #{i}, bitmap_size == #{bitmap_size}" unless additional_bitmap?
+
+        quo = i / bitmap_size
+        rem = i % bitmap_size
+        @bitmaps = rem > 0 ? quo + 1 : quo
+        new_bmp = Array.new(@bitmaps * bitmap_size, false)
+        @bmp.each_with_index { |v, idx| new_bmp[idx] = v }
+        0.upto(@bitmaps - 2) do |pos|
+          new_bmp[pos * bitmap_size] = true
+        end
+        @bmp = new_bmp
+      end
       self[i] = true
     end
 
+    def size_in_bits
+      bitmaps * bitmap_size
+    end
+
+    def size_in_bytes
+      size_in_bits / 8
+    end
+
+    def size_in_bytes_hex
+      size_in_bytes * 2
+    end
+
     # Unsets bit #i
     def unset(i)
       self[i] = false
@@ -64,13 +117,13 @@ module ISO8583
       if RUBY_ENGINE == 'mruby'
         # Convert binary to hex, by slicing the binary in 4 bytes chuncks
         bitmap_hex = ""
-        str = ""
+        str = String.new("", encoding: 'ASCII-8BIT')
         self.to_s.chars.reverse.each_with_index do |ch, i|
           str << ch
           next if i == 0
           if (i+1) % 4 == 0
             bitmap_hex << str.reverse.to_i(2).to_s(16)
-            str = ""
+            str = String.new("", encoding: 'ASCII-8BIT')
           end
         end
         unless str.empty?
@@ -78,29 +131,20 @@ module ISO8583
         end
         bitmap_hex.reverse.upcase
       else
-        [to_s].pack("B*").force_encoding('UTF-8')
+        [to_s].pack("B*")
       end
     end
     alias_method :to_b, :to_bytes
 
     def to_hex
-      value = self.to_s.to_i(2).to_s(16).upcase
-      if value.respond_to? :force_encoding
-        value.force_encoding('UTF-8')
-      else
-        value
-      end
+      self.to_s.to_i(2).to_s(16).upcase.ljust(size_in_bytes_hex, '0')
     end
 
     # Generate a String representation of this bitmap in the form:
     #	01001100110000011010110110010100100110011000001101011011001010
     def to_s
-      #check whether any `high` bits are set
-      ret           = (65..128).find {|bit| !!self[bit]}
-      high, @bmp[0] = ret ? [128, true] : [64, false]
-
-      str = ""
-      1.upto(high) do|i|
+      str = String.new("", encoding: "ASCII-8BIT")
+      1.upto(size_in_bits) do |i|
         str << (self[i] ? '1' : '0')
       end
 
@@ -110,6 +154,12 @@ module ISO8583
 
     private
 
+    # Set the bit to the indicated value. Only `true` sets the
+    # bit, any other value unsets it.
+    def []=(i, value)
+      @bmp[i-1] = (value == true)
+    end
+
     def convert_hex_to_binary(str)
       str.chars.reverse.inject("") do |string, ch|
         string + ch.to_i(16).to_s(2).rjust(4, "0").reverse
@@ -118,40 +168,30 @@ module ISO8583
 
     def initialize_from_message(message)
       bmp = if hex_bitmap?
-              rjust(convert_hex_to_binary(message[0..15]), 64, '0')
+              slice_range = (bitmap_size * 2) / 8 - 1
+              rjust(convert_hex_to_binary(message[0..slice_range]), bitmap_size, '0')
             else
-              message.unpack("B64")[0]
+              message.unpack("B#{bitmap_size}")[0]
             end
 
-      if bmp[0,1] == "1"
-        bmp = if hex_bitmap?
-                rjust(convert_hex_to_binary(message[0..31]), 128, '0')
-              else
-                message.unpack("B128")[0]
-              end
+      if additional_bitmap?
+        has_next_bitmap = bmp[0] == "1"
+        while has_next_bitmap
+          @bitmaps += 1
+          bmp = if hex_bitmap?
+                  slice_range = (bitmap_size * bitmaps * 2) / 8 - 1
+                  rjust(convert_hex_to_binary(message[0..slice_range]), bitmap_size * bitmaps, '0')
+                else
+                  message.unpack("B#{bitmap_size * bitmaps}")[0]
+                end
+          has_next_bitmap = bmp[bitmap_size * (bitmaps - 1)] == "1"
+        end
       end
 
       0.upto(bmp.length-1) do |i|
         @bmp[i] = (bmp[i,1] == "1")
       end
     end
-
-    class << self
-      # Parse the bytes in string and return the Bitmap and bytes remaining in `str`
-      # after the bitmap is taken away.
-      def parse(str, hex_bitmap = false)
-        bmp  = Bitmap.new(str, hex_bitmap)
-
-        rest = if bmp.hex_bitmap?
-                 bmp[1] ? str[32, str.length] : str[16, str.length]
-               else
-                 bmp[1] ? str[16, str.length] : str[8, str.length]
-               end
-
-        [ bmp, rest ]
-      end
-    end
-
   end
 end
 

data/lib/iso8583/codec.rb

@@ -106,11 +106,11 @@ module ISO8583
   Packed_Number.encoder = lambda { |val|
     val = val.to_s
     val = val.length % 2 == 0 ? val : "0"+val
-    raise ISO8583Exception.new("Invalid value: #{val} must be numeric!") unless val =~ /^[0-9]*$/
-    [val].pack("H*")
+    raise ISO8583Exception.new("Invalid value: #{val} must be numeric!") unless val =~ /^[0-9A-Fa-f]*$/
+    String.new([val].pack("H*"), encoding: "ASCII-8BIT")
   }
   Packed_Number.decoder = lambda{|encoded|
-    d = encoded.unpack("H*")[0].to_i
+    encoded.unpack("H*")[0].to_i
   }
 
   A_Codec = Codec.new

data/lib/iso8583/field.rb

@@ -39,7 +39,7 @@ module ISO8583
       begin
         real_value = codec.decode(raw_value)
       rescue => e
-        ContextLog.exception e, e.backtrace if Object.defined?(:ContextLog)
+        ContextLog.exception e, e.backtrace if Object.const_defined?(:ContextLog)
         raise ISO8583ParseException.new(e.message+" (#{name})")
       end
 
@@ -72,7 +72,7 @@ module ISO8583
                 when Integer
                   raise ISO8583Exception.new("Too long: #{value} (#{name})! length=#{length}")  if encoded_value.length > length
                   raise ISO8583Exception.new("Too short: #{value} (#{name})! length=#{length}") if encoded_value.length < length
-                  "" 
+                  String.new("", encoding: 'ASCII-8BIT')
                 when Field
                   raise ISO8583Exception.new("Max lenth exceeded: #{value}, max: #{max}") if max && encoded_value.length > max
                   length.encode(encoded_value.length)
@@ -85,11 +85,55 @@ module ISO8583
   end
 
   class BCDField < Field
+    attr_accessor :data_length
+    attr_accessor :byte_length
     # This corrects the length for BCD fields, as their encoded length is half (+ parity) of the
     # content length. E.g. 123 (length = 3) encodes to "\x01\x23" (length 2)
     def length
-      _length = super
-      (_length % 2) != 0 ? (_length / 2) + 1 : _length / 2
+      if @length.respond_to?(:odd?)
+        @data_length = @length
+        if @data_length.odd?
+          @byte_length = (@data_length + 1) / 2
+        else
+          @byte_length = @data_length / 2
+        end
+        return @byte_length
+      end
+      @length
+    end
+
+    def encode(value)
+      begin
+        encoded_value = codec.encode(value)
+        @data_length = value.size
+        @byte_length = encoded_value.bytes.size
+      rescue ISO8583Exception => e
+        ContextLog.exception(e, e.backtrace, "#{e.message} (#{name})") if Object.const_defined?(:ContextLog)
+        raise ISO8583Exception.new(e.message+" (#{name})")
+      end
+
+      if padding
+        if padding.arity == 1
+          encoded_value = padding.call(encoded_value)
+        elsif padding.arity == 2
+          encoded_value = padding.call(encoded_value, length)
+        end
+      end
+
+      len_str = case length
+                when Integer
+                  raise ISO8583Exception.new("Too long: #{value} (#{name})! length=#{length}")  if encoded_value.length > length
+                  raise ISO8583Exception.new("Too short: #{value} (#{name})! length=#{length}") if encoded_value.length < length
+                  String.new("", encoding: 'ASCII-8BIT')
+                when Field
+                  raise ISO8583Exception.new("Max length exceeded: #{value}, max: #{max}") if max && @byte_length > max
+                  length.encode(@data_length)
+                else
+                  raise ISO8583Exception.new("Invalid length (#{length}) for '#{name}' field")
+                end
+
+      len_str + encoded_value
+
     end
   end
 

data/lib/iso8583/fields.rb

@@ -4,6 +4,8 @@
 # this distribution
 #++
 
+require_relative '../da_funk/helper'
+
 module ISO8583
   include DaFunk::Helper
 
@@ -16,7 +18,7 @@ module ISO8583
   # The following fields are available:
   #
   # [+LL+]           special form to de/encode variable length indicators, two bytes ASCII numerals
-  # [+LLL+]          special form to de/encode variable length indicators, two bytes ASCII numerals
+  # [+LLL+]          special form to de/encode variable length indicators, three bytes ASCII numerals
   # [+LL_BCD+]       special form to de/encode variable length indicators, two BCD digits
   # [+LLVAR_N+]      two byte variable length ASCII numeral, payload ASCII numerals
   # [+LLLVAR_N+]     three byte variable length ASCII numeral, payload ASCII numerals

data/lib/iso8583/message.rb

@@ -117,9 +117,16 @@ module ISO8583
     # ISO8583 allows hex or binary bitmap, so it should be configurable
     attr_reader :use_hex_bitmap
 
+    # ignore_mti allow use of Message without mti. Useful for fields with variable subfields
+    attr_reader :ignore_mti
+
+    # bitmap_size define the size of bitmap to be used, in number of bits.
+    # It should be a multiple of 8 (a byte of 8 bits)
+    attr_reader :bitmap_size
+
     # Instantiate a new instance of this type of Message
     # optionally specifying an mti.
-    def initialize(mti = nil, use_hex_bitmap = false)
+    def initialize(mti = nil, use_hex_bitmap = false, ignore_mti = false, bitmap_size = 64)
       # values is an internal field used to collect all the
       # bmp number | bmp name | field en/decoders | values
       # which are set in this message.
@@ -127,7 +134,8 @@ module ISO8583
 
       self.mti = mti if mti
       @use_hex_bitmap = use_hex_bitmap
-
+      @ignore_mti = ignore_mti
+      @bitmap_size = bitmap_size
     end
 
     # Set the mti of the Message using either the actual value
@@ -143,7 +151,9 @@ module ISO8583
     #    mes = MyMessage.new
     #    mes.mti = 1100 # or mes.mti = "Authorization Request Acquirer Gateway"
     def mti=(value)
-      num, name = _get_mti_definition(value)
+      raise ISO8583Exception.new "can't set MTI when `ignore_mti` is set" if ignore_mti
+
+      num, _ = _get_mti_definition(value)
       @mti = num
     end
 
@@ -180,9 +190,12 @@ module ISO8583
 
     # Retrieve the byte representation of the bitmap.
     def to_b
-      raise ISO8583Exception.new "no MTI set!" unless mti
-      mti_enc = self.class._mti_format.encode(mti).force_encoding('UTF-8')
-      mti_enc << _body.join.force_encoding('UTF-8')
+      raise ISO8583Exception.new "no MTI set!" if !(ignore_mti || mti)
+
+      return _body.join if ignore_mti
+
+      mti_enc = self.class._mti_format.encode(mti)
+      mti_enc << _body.join
     end
 
     # Returns a nicely formatted representation of this
@@ -209,12 +222,12 @@ module ISO8583
     # Returns an array of two byte arrays:
     # [bitmap_bytes, message_bytes]
     def _body
-      bitmap  = Bitmap.new
-      message = ""
+      bitmap  = Bitmap.new(nil, use_hex_bitmap, bitmap_size)
+      message = String.new("", encoding: 'ASCII-8BIT')
       @values.keys.sort.each do |bmp_num|
         bitmap.set(bmp_num)
         enc_value = @values[bmp_num].encode
-        message << enc_value.force_encoding('UTF-8')
+        message << enc_value
       end
 
       if use_hex_bitmap
@@ -356,12 +369,12 @@ module ISO8583
       end
 
       # Parse the bytes `str` returning a message of the defined type.
-      def parse(str, use_hex_bitmap = false)
-        message = self.new(nil, use_hex_bitmap)
+      def parse(str, use_hex_bitmap = false, bitmap_size = 64)
+        message = self.new(nil, use_hex_bitmap, false, bitmap_size)
 
         message.mti, rest = _mti_format.parse(str)
 
-        bmp, rest = Bitmap.parse(rest, use_hex_bitmap)
+        bmp, rest = Bitmap.parse(rest, use_hex_bitmap, bitmap_size)
 
         bmp.each {|bit|
           bmp_def      = _definitions[bit]

data/lib/iso8583/util.rb

@@ -30,7 +30,7 @@ module ISO8583
   end
 
   def _conv(str, mapping)
-    _str = ""
+    _str = String.new("", encoding: "ASCII-8BIT")
     str.each_byte{|byte|
       _str << mapping[byte]
     }

data/test/iso8583/bitmap_test.rb

@@ -0,0 +1,277 @@
+require_relative 'minitest_helper'
+
+module ISO8583
+  class TestBitmap < Minitest::Test
+    def test_parse_with_hex_bitmap_without_additional_bitmap
+      message = "7020000000008000165432123456789876000000000000001500986"
+      hex_bitmap = true
+      bitmap_size = 64
+
+      bitmap, _ = Bitmap.parse(message, hex_bitmap, bitmap_size)
+
+      expect = "7020000000008000"
+      assert_equal(expect, bitmap.to_hex)
+    end
+
+    def test_parse_with_bin_bitmap_without_additional_bitmap
+      message = String.new("\x70\x20\x00\x00\x00\x00\x80\x00165432123456789876000000000000001500986", encoding: "ASCII-8BIT")
+      hex_bitmap = false
+      bitmap_size = 64
+
+      bitmap, _ = Bitmap.parse(message, hex_bitmap, bitmap_size)
+
+      expect = String.new("\x70\x20\x00\x00\x00\x00\x80\x00", encoding: "ASCII-8BIT")
+      assert_equal(expect, bitmap.to_bytes)
+    end
+
+    def test_parse_with_hex_bitmap_having_one_additional_bitmap
+      message = "F02000000000800000000000000000021654321234567898760000000000000015009860a53ec23-8f0b-4328-a51f-b9202dad7b8b"
+      hex_bitmap = true
+      bitmap_size = 64
+
+      bitmap, _ = Bitmap.parse(message, hex_bitmap, bitmap_size)
+
+      expect = "F0200000000080000000000000000002"
+      assert_equal(expect, bitmap.to_hex)
+    end
+
+    def test_parse_with_bin_bitmap_having_one_additional_bitmap
+      message = String.new("\xF0\x20\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x021654321234567898760000000000000015009860a53ec23-8f0b-4328-a51f-b9202dad7b8b", encoding: 'ASCII-8BIT')
+      hex_bitmap = false
+      bitmap_size = 64
+
+      bitmap, _ = Bitmap.parse(message, hex_bitmap, bitmap_size)
+
+      expect = String.new("\xF0\x20\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x02", encoding: "ASCII-8BIT")
+      assert_equal(expect, bitmap.to_bytes)
+    end
+
+    def test_parse_with_hex_bitmap_having_more_additionals_bitmap
+      message = "808002blablabla"
+      hex_bitmap = true
+      bitmap_size = 8
+
+      bitmap, _ = Bitmap.parse(message, hex_bitmap, bitmap_size)
+
+      expect = "808002"
+      assert_equal(expect, bitmap.to_hex)
+      assert_equal(true, bitmap[23])
+    end
+
+    def test_parse_returning_remainder_of_message_small_bitmap_size
+      message = "40blablabla"
+      hex_bitmap = true
+      bitmap_size = 8
+
+      _, rest = Bitmap.parse(message, hex_bitmap, bitmap_size)
+
+      expect = "blablabla"
+      assert_equal(expect, rest)
+    end
+
+    def test_parse_returning_remainder_of_message_usual_bitmap_size
+      message = "4000000000000000foobarbaz"
+      hex_bitmap = true
+      bitmap_size = 64
+
+      _, rest = Bitmap.parse(message, hex_bitmap, bitmap_size)
+
+      expect = "foobarbaz"
+      assert_equal(expect, rest)
+    end
+
+    def test_parse_returning_remainder_of_message_big_bitmap_size
+      message = "40000000000000000000000000000000bazbarfoo"
+      hex_bitmap = true
+      bitmap_size = 128
+
+      _, rest = Bitmap.parse(message, hex_bitmap, bitmap_size)
+
+      expect = "bazbarfoo"
+      assert_equal(expect, rest)
+    end
+
+    def test_raises_on_wrong_bitmap_size
+      e = assert_raises { Bitmap.new(nil, false, 1) }
+      assert_equal(ISO8583Exception, e.class)
+      assert_equal('wrong bitmap_size: 1', e.message)
+    end
+
+    def test_set_and_get_value
+      bitmap = Bitmap.new(nil, false, 8)
+      bitmap.set(2)
+      assert_equal(true, bitmap[2])
+      assert_equal(false, bitmap[1])
+    end
+
+    def test_avoid_set_bit_greater_than_size
+      bitmap = Bitmap.new(nil, false, 8,  false)
+      e = assert_raises { bitmap.set(9) }
+      assert_equal(ISO8583Exception, e.class)
+      assert_equal("can't set field 9, bitmap_size == 8", e.message)
+    end
+
+    def test_allow_set_bit_1_when_no_has_additional_bitmap
+      bitmap = Bitmap.new(nil, false, 8,  false)
+      bitmap.set(1)
+      assert_equal(true, bitmap[1])
+    end
+
+    def test_avoid_set_bit_1_when_has_additional_bitmap
+      bitmap = Bitmap.new(nil, false, 8,  true)
+      e = assert_raises { bitmap.set(1) }
+      assert_equal(ISO8583Exception, e.class)
+      assert_equal("field 1 shouldn't be set (continuation bit is set automatically)", e.message)
+    end
+
+    def test_set_continuation_bit
+      bitmap = Bitmap.new(nil, false, 8,  true)
+      bitmap.set(20)
+      assert_equal(true, bitmap[1])
+      assert_equal(true, bitmap[9])
+      assert_equal(false, bitmap[17])
+      assert_equal(true, bitmap[20])
+    end
+
+    def test_set_continuation_bit_with_bitmap_size_of_64
+      bitmap = Bitmap.new(nil, false, 64,  true)
+      bitmap.set(180)
+      assert_equal(true, bitmap[1])
+      assert_equal(true, bitmap[65])
+      assert_equal(false, bitmap[129])
+      assert_equal(true, bitmap[180])
+    end
+
+    def test_unset_field
+      bitmap = Bitmap.new(nil, false, 8,  false)
+      assert_equal(false, bitmap[1])
+      bitmap.set(1)
+      assert_equal(true, bitmap[1])
+      bitmap.unset(1)
+      assert_equal(false, bitmap[1])
+    end
+
+    def test_to_s_bitmap_size_8_bits
+      bitmap = Bitmap.new(nil, false, 8,  false)
+      bitmap.set(2)
+      bitmap.set(7)
+
+      assert_equal('01000010', bitmap.to_s)
+    end
+
+    def test_to_s_bitmap_size_8_bits_having_additional_bitmap
+      bitmap = Bitmap.new(nil, false, 8,  true)
+      bitmap.set(2)
+      bitmap.set(10)
+
+      assert_equal('1100000001000000', bitmap.to_s)
+    end
+
+    def test_to_s_bitmap_size_64_bits
+      bitmap = Bitmap.new(nil, false, 64,  true)
+      bitmap.set(2)
+      bitmap.set(3)
+      bitmap.set(7)
+      bitmap.set(11)
+      bitmap.set(39)
+
+      assert_equal('0110001000100000000000000000000000000010000000000000000000000000', bitmap.to_s)
+    end
+
+    def test_to_s_bitmap_size_64_bits_having_additional_bitmap
+      bitmap = Bitmap.new(nil, false, 64,  true)
+      bitmap.set(2)
+      bitmap.set(3)
+      bitmap.set(7)
+      bitmap.set(11)
+      bitmap.set(39)
+      bitmap.set(127)
+
+      assert_equal('11100010001000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000010', bitmap.to_s)
+    end
+
+    def test_to_hex_without_fields
+      bitmap = Bitmap.new(nil, true, 8,  true)
+
+      expected = "00"
+      assert_equal(expected, bitmap.to_hex)
+    end
+
+    def test_to_hex_with_many_fields
+      bitmap = Bitmap.new(nil, true, 64,  true)
+      bitmap.set(2)
+      bitmap.set(3)
+      bitmap.set(4)
+      bitmap.set(5)
+      bitmap.set(6)
+      bitmap.set(7)
+      bitmap.set(8)
+      bitmap.set(66)
+
+      expected = "FF000000000000004000000000000000"
+
+      assert_equal(expected, bitmap.to_hex)
+    end
+
+    def test_to_b_bitmap_size_8
+      bitmap = Bitmap.new(nil, false, 8,  false)
+      bitmap.set(2)
+      bitmap.set(3)
+      bitmap.set(4)
+      bitmap.set(5)
+      bitmap.set(6)
+      bitmap.set(7)
+
+      expected = String.new("\x7E", encoding: 'ASCII-8BIT')
+
+      assert_equal(expected, bitmap.to_b)
+    end
+
+    def test_to_b_bitmap_size_8_having_additional_bitmap
+      bitmap = Bitmap.new(nil, false, 8,  true)
+      bitmap.set(2)
+      bitmap.set(3)
+      bitmap.set(4)
+      bitmap.set(5)
+      bitmap.set(6)
+      bitmap.set(7)
+      bitmap.set(11)
+
+      expected = String.new("\xFE\x20", encoding: 'ASCII-8BIT')
+
+      assert_equal(expected, bitmap.to_b)
+    end
+
+    def test_to_b_bitmap_size_64
+      bitmap = Bitmap.new(nil, false, 64,  false)
+      bitmap.set(2)
+      bitmap.set(3)
+      bitmap.set(4)
+      bitmap.set(5)
+      bitmap.set(6)
+      bitmap.set(7)
+      bitmap.set(8)
+      bitmap.set(64)
+
+      expected = String.new("\x7F\x00\x00\x00\x00\x00\x00\x01", encoding: 'ASCII-8BIT')
+
+      assert_equal(expected, bitmap.to_b)
+    end
+
+    def test_to_b_bitmap_size_64_having_additional_bitmap
+      bitmap = Bitmap.new(nil, false, 64,  true)
+      bitmap.set(2)
+      bitmap.set(3)
+      bitmap.set(4)
+      bitmap.set(5)
+      bitmap.set(6)
+      bitmap.set(7)
+      bitmap.set(8)
+      bitmap.set(66)
+
+      expected = String.new("\xFF\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00", encoding: 'ASCII-8BIT')
+
+      assert_equal(expected, bitmap.to_b)
+    end
+  end
+end