hexdump 0.3.0 → 1.0.1

data/spec/reader_spec.rb

@@ -0,0 +1,866 @@
+require 'spec_helper'
+require 'hexdump/reader'
+require 'hexdump/types'
+
+describe Hexdump::Reader do
+  describe "#initialize" do
+    let(:type)  { Hexdump::TYPES[:uint8] }
+
+    subject { described_class.new(type) }
+
+    it "must set #type" do
+      expect(subject.type).to eq(type)
+    end
+
+    it "must default #offset to nil" do
+      expect(subject.offset).to be(nil)
+    end
+
+    it "must default #length to nil" do
+      expect(subject.length).to be(nil)
+    end
+
+    it "must default #zero_pad? to false" do
+      expect(subject.zero_pad?).to be(false)
+    end
+
+    context "when offset: is given" do
+      let(:offset) { 2 }
+
+      subject { described_class.new(type, offset: offset) }
+
+      it "must set #offset" do
+        expect(subject.offset).to eq(offset)
+      end
+    end
+
+    context "when length: is given" do
+      let(:length) { 256 }
+
+      subject { described_class.new(type, length: length) }
+
+      it "must set #length" do
+        expect(subject.length).to eq(length)
+      end
+    end
+
+    context "when zero_pad: is true" do
+      subject { described_class.new(type, zero_pad: true) }
+
+      it "must enable #zero_pad?" do
+        expect(subject.zero_pad?).to be(true)
+      end
+    end
+  end
+
+  let(:type) { Hexdump::TYPES[:byte] }
+
+  subject { described_class.new(type) }
+
+  describe "#each_byte" do
+    let(:type)  { Hexdump::TYPES[:uint8] }
+
+    let(:chars) { %w[A B C D] }
+    let(:data)  { chars.join  }
+    let(:bytes) { data.bytes  }
+
+    it "must yield each byte from the given data" do
+      expect { |b|
+        subject.each_byte(data,&b)
+      }.to yield_successive_args(*bytes)
+    end
+
+    context "when #offset is > 0" do
+      let(:offset)  { 2 }
+      let(:bytes) { data.bytes[offset..-1] }
+
+      subject { described_class.new(type, offset: offset) }
+
+      it "must offset the first N bytes before yielding any bytes" do
+        expect { |b|
+          subject.each_byte(data,&b)
+        }.to yield_successive_args(*bytes)
+      end
+    end
+
+    context "when #length is set" do
+      let(:length) { 3 }
+      let(:bytes) { data.bytes[0,length] }
+
+      subject { described_class.new(type, length: length) }
+
+      it "must read at most N bytes" do
+        expect { |b|
+          subject.each_byte(data,&b)
+        }.to yield_successive_args(*bytes)
+      end
+    end
+
+    context "when no block is given" do
+      it "must return an Enumerator" do
+        expect(subject.each_byte(data)).to be_kind_of(Enumerator)
+      end
+    end
+  end
+
+  describe "#each_slice" do
+    context "when type has size of 1" do
+      let(:type)  { Hexdump::TYPES[:int8] }
+      let(:chars) { %w[A B C D]           }
+      let(:data)  { "ABCD"                }
+
+      it "must yield each consequetize character" do
+        expect { |b|
+          subject.each_slice(data,&b)
+        }.to yield_successive_args(*chars)
+      end
+
+      context "and when #offset is > 0" do
+        let(:offset)  { 2       }
+        let(:chars) { %w[C D] }
+
+        subject { described_class.new(type, offset: offset) }
+
+        it "must offset the first N bytes before reading each character" do
+          expect { |b|
+            subject.each_slice(data,&b)
+          }.to yield_successive_args(*chars)
+        end
+      end
+
+      context "and when #length is set" do
+        let(:length) { 3         }
+        let(:chars) { %w[A B C] }
+
+        subject { described_class.new(type, length: length) }
+
+        it "must read at most N bytes" do
+          expect { |b|
+            subject.each_slice(data,&b)
+          }.to yield_successive_args(*chars)
+        end
+      end
+    end
+
+    context "when type has size > 1" do
+      let(:type)   { Hexdump::TYPES[:int16] }
+      let(:slices) { %w[AA BB CC DD EE FF]  }
+      let(:data)   { "AABBCCDDEEFF"         }
+
+      it "must yield each slice of the String" do
+        expect { |b|
+          subject.each_slice(data,&b)
+        }.to yield_successive_args(*slices)
+      end
+
+      it "must yield a new String instance for each slice" do
+        yielded_object_ids = []
+
+        subject.each_slice(data) do |slice|
+          yielded_object_ids << slice.object_id
+        end
+
+        expect(yielded_object_ids.uniq).to eq(yielded_object_ids)
+      end
+
+      context "and when #offset is > 0" do
+        let(:offset)   { 3 }
+        let(:slices) { %w[BC CD DE EF F] }
+
+        subject { described_class.new(type, offset: offset) }
+
+        it "must offset the first N bytes before reading each slice" do
+          expect { |b|
+            subject.each_slice(data,&b)
+          }.to yield_successive_args(*slices)
+        end
+      end
+
+      context "and when #length is set" do
+        let(:length)  { 7 }
+        let(:slices) { %w[AA BB CC D] }
+
+        subject { described_class.new(type, length: length) }
+
+        it "must read at most N bytes" do
+          expect { |b|
+            subject.each_slice(data,&b)
+          }.to yield_successive_args(*slices)
+        end
+      end
+
+      context "when the given data is not evenly divisible by the type's size" do
+        let(:type)   { Hexdump::TYPES[:int32] }
+        let(:slices) { %w[AABB CCDD E]        }
+        let(:data)   { "AABBCCDDE"            }
+
+        it "must yield the reamining data" do
+          expect { |b|
+            subject.each_slice(data,&b)
+          }.to yield_successive_args('AABB', 'CCDD', "E")
+        end
+
+        context "but #zero_pad? is true" do
+          subject { described_class.new(type, zero_pad: true) }
+
+          it "must zero out the rest of the buffer" do
+            expect { |b|
+              subject.each_slice(data,&b)
+            }.to yield_successive_args('AABB', 'CCDD', "E\0\0\0")
+          end
+        end
+      end
+    end
+  end
+
+  describe "#each_uint" do
+    context "when the type has size of 1" do
+      let(:bytes) { [0x41, 0x42, 0x43, 0x44] }
+      let(:raw)   { bytes.map(&:chr) }
+      let(:data)  { raw.join }
+      let(:type)  { Hexdump::TYPES[:uint8] }
+
+      it "must yield each byte" do
+        expect { |b|
+          subject.each_uint(data,&b)
+        }.to yield_successive_args(*raw.zip(bytes))
+      end
+    end
+
+    context "when the type has size of 2" do
+      let(:uints) { [0xfa01, 0xfb02, 0xfc03, 0xfd04] }
+
+      context "when the type is little-endian" do
+        let(:type)  { Hexdump::TYPES[:uint16_le] }
+        let(:raw)   { uints.map { |uint| [uint].pack('S<') } }
+        let(:data)  { raw.join }
+
+        it "must decode the bytes in little-endian order" do
+          expect { |b|
+            subject.each_uint(data,&b)
+          }.to yield_successive_args(*raw.zip(uints))
+        end
+
+        context "but there is not enough bytes to decode a value" do
+          let(:data) { "\x11".encode(Encoding::BINARY) }
+
+          it "must yield remaining bytes and nil" do
+            expect { |b|
+              subject.each_uint(data,&b)
+            }.to yield_with_args(data,nil)
+          end
+
+          context "but #zero_pad? is true" do
+            subject { described_class.new(type, zero_pad: true) }
+
+            it "must yield the zero-padded data and partially decoded uint" do
+              expect { |b|
+                subject.each_uint(data,&b)
+              }.to yield_with_args("#{data}\x00",0x0011)
+            end
+          end
+        end
+      end
+
+      context "when the type is big-endian" do
+        let(:type)  { Hexdump::TYPES[:uint16_be] }
+        let(:raw)   { uints.map { |uint| [uint].pack('S>') } }
+        let(:data)  { raw.join }
+
+        it "must decode the bytes in big-endian order" do
+          expect { |b|
+            subject.each_uint(data,&b)
+          }.to yield_successive_args(*raw.zip(uints))
+        end
+
+        context "but there is not enough bytes to decode a value" do
+          let(:data) { "\x11".encode(Encoding::BINARY) }
+
+          it "must yield remaining bytes and nil" do
+            expect { |b|
+              subject.each_uint(data,&b)
+            }.to yield_with_args(data,nil)
+          end
+
+          context "but #zero_pad? is true" do
+            subject { described_class.new(type, zero_pad: true) }
+
+            it "must yield the zero-padded data and partially decoded uint" do
+              expect { |b|
+                subject.each_uint(data,&b)
+              }.to yield_with_args("#{data}\x00",0x1100)
+            end
+          end
+        end
+      end
+    end
+
+    context "when the type has size of 4" do
+      let(:uints) { [0xffeedd01, 0xffccbb02, 0xffaa9903, 0xff887704] }
+
+      context "when the type is little-endian" do
+        let(:type)  { Hexdump::TYPES[:uint32_le] }
+        let(:raw)   { uints.map { |uint| [uint].pack('L<') } }
+        let(:data)  { raw.join }
+
+        it "must decode the bytes in little-endian order" do
+          expect { |b|
+            subject.each_uint(data,&b)
+          }.to yield_successive_args(*raw.zip(uints))
+        end
+
+        context "but there is not enough bytes to decode a value" do
+          let(:data) { "\x11\x22\x33".encode(Encoding::BINARY) }
+
+          it "must yield nil and the remaining bytes" do
+            expect { |b|
+              subject.each_uint(data,&b)
+            }.to yield_with_args(data,nil)
+          end
+
+          context "but #zero_pad? is true" do
+            subject { described_class.new(type, zero_pad: true) }
+
+            it "must yield the zero-padded data and partially decoded uint" do
+              expect { |b|
+                subject.each_uint(data,&b)
+              }.to yield_with_args("#{data}\x00",0x00332211)
+            end
+          end
+        end
+      end
+
+      context "when the type is big-endian" do
+        let(:type)  { Hexdump::TYPES[:uint32_be] }
+        let(:raw)   { uints.map { |uint| [uint].pack('L>') } }
+        let(:data)  { raw.join }
+
+        it "must decode the bytes in big-endian order" do
+          expect { |b|
+            subject.each_uint(data,&b)
+          }.to yield_successive_args(*raw.zip(uints))
+        end
+
+        context "but there is not enough bytes to decode a value" do
+          let(:data) { "\x11\x22\x33".encode(Encoding::BINARY) }
+
+          it "must yield the remaining bytes and nil" do
+            expect { |b|
+              subject.each_uint(data,&b)
+            }.to yield_with_args(data,nil)
+          end
+
+          context "but #zero_pad? is true" do
+            subject { described_class.new(type, zero_pad: true) }
+
+            it "must yield the zero-padded data and partially decoded uint" do
+              expect { |b|
+                subject.each_uint(data,&b)
+              }.to yield_with_args("#{data}\x00",0x11223300)
+            end
+          end
+        end
+      end
+    end
+
+    context "when the type has size of 8" do
+      let(:uints) { [0xffffffff11223344, 0xffffffff55667788, 0xffffffff99aabbcc, 0xffffffffddeeff00] }
+
+      context "when the type is little-endian" do
+        let(:type)  { Hexdump::TYPES[:uint64_le] }
+        let(:raw)   { uints.map { |uint| [uint].pack('Q<') } }
+        let(:data)  { raw.join }
+
+        it "must decode the bytes in little-endian order" do
+          expect { |b|
+            subject.each_uint(data,&b)
+          }.to yield_successive_args(*raw.zip(uints))
+        end
+
+        context "but there is not enough bytes to decode a value" do
+          let(:data) { "\x11\x22\x33\x44\x55\x66\x77".encode(Encoding::BINARY) }
+
+          it "must yield the remaining bytes and nil" do
+            expect { |b|
+              subject.each_uint(data,&b)
+            }.to yield_with_args(data,nil)
+          end
+
+          context "but #zero_pad? is true" do
+            subject { described_class.new(type, zero_pad: true) }
+
+            it "must yield the zero-padded data and partially decoded uint" do
+              expect { |b|
+                subject.each_uint(data,&b)
+              }.to yield_with_args("#{data}\x00",0x0077665544332211)
+            end
+          end
+        end
+      end
+
+      context "when the type is big-endian" do
+        let(:type)  { Hexdump::TYPES[:uint64_be] }
+        let(:raw)   { uints.map { |uint| [uint].pack('Q>') } }
+        let(:data)  { raw.join }
+
+        it "must decode the bytes in big-endian order" do
+          expect { |b|
+            subject.each_uint(data,&b)
+          }.to yield_successive_args(*raw.zip(uints))
+        end
+
+        context "but there is not enough bytes to decode a value" do
+          let(:data) { "\x11\x22\x33\x44\x55\x66\x77".encode(Encoding::BINARY) }
+
+          it "must yield the remaining bytes and nil" do
+            expect { |b|
+              subject.each_uint(data,&b)
+            }.to yield_with_args(data,nil)
+          end
+
+          context "but #zero_pad? is true" do
+            subject { described_class.new(type, zero_pad: true) }
+
+            it "must yield the zero-padded data and partially decoded uint" do
+              expect { |b|
+                subject.each_uint(data,&b)
+              }.to yield_with_args("#{data}\x00",0x1122334455667700)
+            end
+          end
+        end
+      end
+    end
+
+    context "when the given data does not define #each_byte" do
+      it do
+        expect {
+          subject.each_uint(Object.new).to_a
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe "#each_int" do
+    context "when the type has size of 1" do
+      let(:ints) { [0x01, -0x02, 0x03, -0x04] }
+      let(:type)  { Hexdump::TYPES[:int8] }
+      let(:raw)   { ints.map { |int| [int].pack('c') } }
+      let(:data)  { raw.join }
+
+      it "must decode the bytes" do
+        expect { |b|
+          subject.each_int(data,&b)
+        }.to yield_successive_args(*raw.zip(ints))
+      end
+    end
+
+    context "when the type has size of 2" do
+      let(:ints) { [0x0001, -0x0002, 0x0003, -0x0004] }
+
+      context "when the type is little-endian" do
+        let(:type)  { Hexdump::TYPES[:int16_le] }
+        let(:raw)   { ints.map { |int| [int].pack('s<') } }
+        let(:data)  { raw.join }
+
+        it "must decode the bytes in little-endian order" do
+          expect { |b|
+            subject.each_int(data,&b)
+          }.to yield_successive_args(*raw.zip(ints))
+        end
+
+        context "but there is not enough bytes to decode a value" do
+          let(:data) { "\x11".encode(Encoding::BINARY) }
+
+          it "must yield the remaining bytes and nil" do
+            expect { |b|
+              subject.each_int(data,&b)
+            }.to yield_with_args(data, nil)
+          end
+
+          context "but #zero_pad? is true" do
+            subject { described_class.new(type, zero_pad: true) }
+
+            it "must yield the zero-padded data and partially decoded int" do
+              expect { |b|
+                subject.each_int(data,&b)
+              }.to yield_with_args("#{data}\x00",0x11)
+            end
+          end
+        end
+      end
+
+      context "when the type is big-endian" do
+        let(:type)  { Hexdump::TYPES[:int16_be] }
+        let(:raw)   { ints.map { |int| [int].pack('s>') } }
+        let(:data)  { raw.join }
+
+        it "must decode the bytes in big-endian order" do
+          expect { |b|
+            subject.each_int(data,&b)
+          }.to yield_successive_args(*raw.zip(ints))
+        end
+
+        context "but there is not enough bytes to decode a value" do
+          let(:data) { "\x11".encode(Encoding::BINARY) }
+
+          it "must yield the remaining bytes and nil" do
+            expect { |b|
+              subject.each_int(data,&b)
+            }.to yield_with_args(data, nil)
+          end
+
+          context "but #zero_pad? is true" do
+            subject { described_class.new(type, zero_pad: true) }
+
+            it "must yield the zero-padded data and partially decoded int" do
+              expect { |b|
+                subject.each_int(data,&b)
+              }.to yield_with_args("#{data}\x00",0x1100)
+            end
+          end
+        end
+      end
+    end
+
+    context "when the type has size of 4" do
+      let(:ints) { [0x00aa0001, -0x00bb0002, 0x00cc0003, -0x00dd0004] }
+
+      context "when the type is little-endian" do
+        let(:type)  { Hexdump::TYPES[:int32_le] }
+        let(:raw)   { ints.map { |int| [int].pack('l<') } }
+        let(:data)  { raw.join }
+
+        it "must decode the bytes in little-endian order" do
+          expect { |b|
+            subject.each_int(data,&b)
+          }.to yield_successive_args(*raw.zip(ints))
+        end
+
+        context "but there is not enough bytes to decode a value" do
+          let(:data) { "\x11\x22\x33".encode(Encoding::BINARY) }
+
+          it "must yield the remaining bytes and nil" do
+            expect { |b|
+              subject.each_int(data,&b)
+            }.to yield_with_args(data, nil)
+          end
+
+          context "but #zero_pad? is true" do
+            subject { described_class.new(type, zero_pad: true) }
+
+            it "must yield the zero-padded data and partially decoded int" do
+              expect { |b|
+                subject.each_int(data,&b)
+              }.to yield_with_args("#{data}\x00",0x00332211)
+            end
+          end
+        end
+      end
+
+      context "when the type is big-endian" do
+        let(:type)  { Hexdump::TYPES[:int32_be] }
+        let(:raw)   { ints.map { |int| [int].pack('l>') } }
+        let(:data)  { raw.join }
+
+        it "must decode the bytes in big-endian order" do
+          expect { |b|
+            subject.each_int(data,&b)
+          }.to yield_successive_args(*raw.zip(ints))
+        end
+
+        context "but there is not enough bytes to decode a value" do
+          let(:data) { "\x11\x22\x33".encode(Encoding::BINARY) }
+
+          it "must yield the remaining bytes and nil" do
+            expect { |b|
+              subject.each_int(data,&b)
+            }.to yield_with_args(data, nil)
+          end
+
+          context "but #zero_pad? is true" do
+            subject { described_class.new(type, zero_pad: true) }
+
+            it "must yield the zero-padded data and partially decoded int" do
+              expect { |b|
+                subject.each_int(data,&b)
+              }.to yield_with_args("#{data}\x00",0x11223300)
+            end
+          end
+        end
+      end
+    end
+
+    context "when the type has size of 8" do
+      let(:ints) { [0x1122334400aa0001, -0x1122334400bb0002, 0x1122334400cc0003, -0x1122334400dd0004] }
+
+      context "when the type is little-endian" do
+        let(:type)  { Hexdump::TYPES[:int64_le] }
+        let(:raw)   { ints.map { |int| [int].pack('q<') } }
+        let(:data)  { raw.join }
+
+        it "must decode the bytes in little-endian order" do
+          expect { |b|
+            subject.each_int(data,&b)
+          }.to yield_successive_args(*raw.zip(ints))
+        end
+
+        context "but there is not enough bytes to decode a value" do
+          let(:data) { "\x11\x22\x33\x44\x55\x66\x77".encode(Encoding::BINARY) }
+
+          it "must yield the remaining bytes and nil" do
+            expect { |b|
+              subject.each_int(data,&b)
+            }.to yield_with_args(data, nil)
+          end
+
+          context "but #zero_pad? is true" do
+            subject { described_class.new(type, zero_pad: true) }
+
+            it "must yield the zero-padded data and partially decoded int" do
+              expect { |b|
+                subject.each_int(data,&b)
+              }.to yield_with_args("#{data}\x00",0x0077665544332211)
+            end
+          end
+        end
+      end
+
+      context "when the type is big-endian" do
+        let(:type)  { Hexdump::TYPES[:int64_be] }
+        let(:raw)   { ints.map { |int| [int].pack('q>') } }
+        let(:data)  { raw.join }
+
+        it "must decode the bytes in big-endian order" do
+          expect { |b|
+            subject.each_int(data,&b)
+          }.to yield_successive_args(*raw.zip(ints))
+        end
+
+        context "but there is not enough bytes to decode a value" do
+          let(:data) { "\x11\x22\x33\x44\x55\x66\x77".encode(Encoding::BINARY) }
+
+          it "must yield nil and the remaining bytes" do
+            expect { |b|
+              subject.each_int(data,&b)
+            }.to yield_with_args(data, nil)
+          end
+
+          context "but #zero_pad? is true" do
+            subject { described_class.new(type, zero_pad: true) }
+
+            it "must yield the zero-padded data and partially decoded int" do
+              expect { |b|
+                subject.each_int(data,&b)
+              }.to yield_with_args("#{data}\x00",0x1122334455667700)
+            end
+          end
+        end
+      end
+    end
+
+    context "when the given data does not define #each_byte" do
+      it do
+        expect {
+          subject.each_int(Object.new).to_a
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe "#each_float" do
+    let(:type)  { Hexdump::TYPES[:float] }
+
+    context "when the type has size of 4" do
+      let(:floats) { [1.0, -3.0, 5.0, -7.0, 9.0] }
+
+      context "when the type is little-endian" do
+        let(:type)  { Hexdump::TYPES[:float_le] }
+        let(:raw)   { floats.map { |float| [float].pack('e') } }
+        let(:data)  { raw.join }
+
+        it "must decode the bytes in little-endian order" do
+          expect { |b|
+            subject.each_float(data,&b)
+          }.to yield_successive_args(*raw.zip(floats))
+        end
+
+        context "but there is not enough bytes to decode a value" do
+          let(:data) { "\x01\x02\x03".encode(Encoding::BINARY) }
+
+          it "must yield the remaining bytes and nil" do
+            expect { |b|
+              subject.each_float(data,&b)
+            }.to yield_with_args(data, nil)
+          end
+
+          context "but #zero_pad? is true" do
+            subject { described_class.new(type, zero_pad: true) }
+
+            it "must yield the zero-padded data and partially decoded float" do
+              expect { |b|
+                subject.each_float(data,&b)
+              }.to yield_with_args("#{data}\x00",2.7622535458617227e-40)
+            end
+          end
+        end
+      end
+
+      context "when the type is big-endian" do
+        let(:type)  { Hexdump::TYPES[:float_be] }
+        let(:raw)   { floats.map { |float| [float].pack('g') } }
+        let(:data)  { raw.join }
+
+        it "must decode the bytes in big-endian order" do
+          expect { |b|
+            subject.each_float(data,&b)
+          }.to yield_successive_args(*raw.zip(floats))
+        end
+
+        context "but there is not enough bytes to decode a value" do
+          let(:data) { "\x01\x02\x03".encode(Encoding::BINARY) }
+
+          it "must yield the remaining bytes and nil" do
+            expect { |b|
+              subject.each_float(data,&b)
+            }.to yield_with_args(data, nil)
+          end
+
+          context "but #zero_pad? is true" do
+            subject { described_class.new(type, zero_pad: true) }
+
+            it "must yield the zero-padded data and partially decoded float" do
+              expect { |b|
+                subject.each_float(data,&b)
+              }.to yield_with_args("#{data}\x00",2.387938139551892e-38)
+            end
+          end
+        end
+      end
+    end
+
+    context "when the type has size of 8" do
+      let(:floats) { [1.2, -3.4, 5.6, -7.8, 9.0] }
+
+      context "when the type is little-endian" do
+        let(:type)  { Hexdump::TYPES[:double_le] }
+        let(:raw)   { floats.map { |float| [float].pack('E') } }
+        let(:data)  { raw.join }
+
+        it "must decode the bytes in little-endian order" do
+          expect { |b|
+            subject.each_float(data,&b)
+          }.to yield_successive_args(*raw.zip(floats))
+        end
+
+        context "but there is not enough bytes to decode a value" do
+          let(:data) { "\x01\x02\x03\x04\x05\x06\x07".encode(Encoding::BINARY) }
+
+          it "must yield the remaining bytes and nil" do
+            expect { |b|
+              subject.each_float(data,&b)
+            }.to yield_with_args(data, nil)
+          end
+
+          context "but #zero_pad? is true" do
+            subject { described_class.new(type, zero_pad: true) }
+
+            it "must yield the zero-padded data and partially decoded float" do
+              expect { |b|
+                subject.each_float(data,&b)
+              }.to yield_with_args("#{data}\x00",9.76739841864353e-309)
+            end
+          end
+        end
+      end
+
+      context "when the type is big-endian" do
+        let(:type)  { Hexdump::TYPES[:double_be] }
+        let(:raw)   { floats.map { |float| [float].pack('G') } }
+        let(:data)  { raw.join }
+
+        it "must decode the bytes in big-endian order" do
+          expect { |b|
+            subject.each_float(data,&b)
+          }.to yield_successive_args(*raw.zip(floats))
+        end
+
+        context "but there is not enough bytes to decode a value" do
+          let(:data) { "\x01\x02\x03\x04\x05\x06\x07".encode(Encoding::BINARY) }
+
+          it "must yield the remaining bytes and nil" do
+            expect { |b|
+              subject.each_float(data,&b)
+            }.to yield_with_args(data, nil)
+          end
+
+          context "but #zero_pad? is true" do
+            subject { described_class.new(type, zero_pad: true) }
+
+            it "must yield the zero-padded data and partially decoded float" do
+              expect { |b|
+                subject.each_float(data,&b)
+              }.to yield_with_args("#{data}\x00",8.207880399131826e-304)
+            end
+          end
+        end
+      end
+    end
+
+    context "when the given data does not define #each_byte" do
+      it do
+        expect {
+          subject.each_float(Object.new).to_a
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe "#each" do
+    context "when #type is a UInt" do
+      let(:type)  { Hexdump::TYPES[:uint32] }
+      let(:uints) { [1, 2, 3] }
+      let(:raw)   { uints.map { |uint| [uint].pack('L') } }
+      let(:data)  { raw.join }
+
+      it "must yield decoded integers" do
+        expect { |b|
+          subject.each(data,&b)
+        }.to yield_successive_args(*raw.zip(uints))
+      end
+    end
+
+    context "when #type is a Int" do
+      let(:type) { Hexdump::TYPES[:int32] }
+      let(:ints) { [1, 2, 3] }
+      let(:raw)  { ints.map { |int| [int].pack('l') } }
+      let(:data) { raw.join }
+
+      it "must yield decoded integers" do
+        expect { |b|
+          subject.each(data,&b)
+        }.to yield_successive_args(*raw.zip(ints))
+      end
+    end
+
+    context "when #type is a Float" do
+      let(:type)   { Hexdump::TYPES[:float] }
+      let(:floats) { [1.0, 2.0, 3.0] }
+      let(:raw)    { floats.map { |float| [float].pack('e') } }
+      let(:data)   { raw.join }
+
+      it "must yield decoded integers" do
+        expect { |b|
+          subject.each(data,&b)
+        }.to yield_successive_args(*raw.zip(floats))
+      end
+    end
+
+    context "when the given data does not define #each_byte" do
+      it do
+        expect {
+          subject.each(Object.new).to_a
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end