hexdump 0.3.0 → 1.0.0

data/lib/hexdump/types.rb

@@ -0,0 +1,108 @@
+require 'hexdump/type'
+
+module Hexdump
+  #
+  # @api private
+  #
+  # @since 1.0.0
+  #
+  TYPES = {
+    char:  Type::Char.new,
+    uchar: Type::UChar.new,
+
+    int8:  Type::Int8.new,
+    uint8: Type::UInt8.new,
+
+    int16:     Type::Int16.new,
+    int16_le:  Type::Int16.new(endian: :little),
+    int16_be:  Type::Int16.new(endian: :big),
+    int16_ne:  Type::Int16.new(endian: :big),
+
+    uint16:    Type::UInt16.new,
+    uint16_le: Type::UInt16.new(endian: :little),
+    uint16_be: Type::UInt16.new(endian: :big),
+    uint16_ne: Type::UInt16.new(endian: :big),
+
+    int32:     Type::Int32.new,
+    int32_le:  Type::Int32.new(endian: :little),
+    int32_be:  Type::Int32.new(endian: :big),
+    int32_ne:  Type::Int32.new(endian: :big),
+
+    uint32:    Type::UInt32.new,
+    uint32_le: Type::UInt32.new(endian: :little),
+    uint32_be: Type::UInt32.new(endian: :big),
+    uint32_ne: Type::UInt32.new(endian: :big),
+
+    int64:        Type::Int64.new,
+    int64_le:     Type::Int64.new(endian: :little),
+    int64_be:     Type::Int64.new(endian: :big),
+    int64_ne:     Type::Int64.new(endian: :big),
+
+    uint64:       Type::UInt64.new,
+    uint64_le:    Type::UInt64.new(endian: :little),
+    uint64_be:    Type::UInt64.new(endian: :big),
+    uint64_ne:    Type::UInt64.new(endian: :big),
+
+    float32:    Type::Float32.new,
+    float32_le: Type::Float32.new(endian: :little),
+    float32_be: Type::Float32.new(endian: :big),
+    float32_ne: Type::Float32.new(endian: :big),
+
+    float64:    Type::Float64.new,
+    float64_le: Type::Float64.new(endian: :little),
+    float64_be: Type::Float64.new(endian: :big),
+    float64_ne: Type::Float64.new(endian: :big),
+  }
+
+  TYPES[:byte]   = TYPES[:uint8]
+
+  TYPES[:short]    = TYPES[:int16]
+  TYPES[:short_le] = TYPES[:int16_le]
+  TYPES[:short_be] = TYPES[:int16_be]
+  TYPES[:short_ne] = TYPES[:int16_ne]
+
+  TYPES[:ushort]    = TYPES[:uint16]
+  TYPES[:ushort_le] = TYPES[:uint16_le]
+  TYPES[:ushort_be] = TYPES[:uint16_be]
+  TYPES[:ushort_ne] = TYPES[:uint16_ne]
+
+  TYPES[:int]    = TYPES[:int32]
+  TYPES[:int_le] = TYPES[:int32_le]
+  TYPES[:int_be] = TYPES[:int32_be]
+  TYPES[:int_ne] = TYPES[:int32_ne]
+
+  TYPES[:uint]    = TYPES[:uint32]
+  TYPES[:uint_le] = TYPES[:uint32_le]
+  TYPES[:uint_be] = TYPES[:uint32_be]
+  TYPES[:uint_ne] = TYPES[:uint32_ne]
+
+  TYPES[:long]    = TYPES[:int32]
+  TYPES[:long_le] = TYPES[:int32_le]
+  TYPES[:long_be] = TYPES[:int32_be]
+  TYPES[:long_ne] = TYPES[:int32_ne]
+
+  TYPES[:ulong]    = TYPES[:uint32]
+  TYPES[:ulong_le] = TYPES[:uint32_le]
+  TYPES[:ulong_be] = TYPES[:uint32_be]
+  TYPES[:ulong_ne] = TYPES[:uint32_ne]
+
+  TYPES[:long_long]    = TYPES[:int64]
+  TYPES[:long_long_le] = TYPES[:int64_le]
+  TYPES[:long_long_be] = TYPES[:int64_be]
+  TYPES[:long_long_ne] = TYPES[:int64_ne]
+
+  TYPES[:ulong_long]    = TYPES[:uint64]
+  TYPES[:ulong_long_le] = TYPES[:uint64_le]
+  TYPES[:ulong_long_be] = TYPES[:uint64_be]
+  TYPES[:ulong_long_ne] = TYPES[:uint64_ne]
+
+  TYPES[:float]    = TYPES[:float32]
+  TYPES[:float_le] = TYPES[:float32_le]
+  TYPES[:float_be] = TYPES[:float32_be]
+  TYPES[:float_ne] = TYPES[:float32_ne]
+
+  TYPES[:double]    = TYPES[:float64]
+  TYPES[:double_le] = TYPES[:float64_le]
+  TYPES[:double_be] = TYPES[:float64_be]
+  TYPES[:double_ne] = TYPES[:float64_ne]
+end

data/lib/hexdump/version.rb

@@ -1,4 +1,4 @@
 module Hexdump
   # hexdump version
-  VERSION = '0.3.0'
+  VERSION = '1.0.0'
 end

data/lib/hexdump.rb

@@ -1,3 +1,14 @@
-require 'hexdump/hexdump'
+require 'hexdump/module_methods'
 require 'hexdump/core_ext'
 require 'hexdump/version'
+
+module Hexdump
+  extend ModuleMethods
+
+  #
+  # @see hexdump
+  #
+  def self.dump(data,**kwargs)
+    hexdump(data,**kwargs)
+  end
+end

data/spec/chars_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+require 'hexdump/chars'
+
+describe Hexdump::Chars do
+  describe "#initialize" do
+    it "must default #encoding to nil" do
+      expect(subject.encoding).to be(nil)
+    end
+
+    context "when given nil" do
+      subject { described_class.new(nil) }
+
+      it "must set #encoding to nil" do
+        expect(subject.encoding).to be(nil)
+      end
+    end
+
+    context "when given an Encoding object" do
+      let(:encoding) { Encoding::UTF_8 }
+
+      subject { described_class.new(encoding) }
+
+      it "must set #encoding to the Encoding object" do
+        expect(subject.encoding).to be(encoding)
+      end
+    end
+  end
+
+  describe "#scrub" do
+    context "when the string only contains printable ASCII characters" do
+      let(:string)   { "hello" }
+
+      it "must return the string unchanged" do
+        expect(subject.scrub(string)).to eq(string)
+      end
+    end
+
+    context "when the string contains unprintable ASCII characters" do
+      let(:ascii) { (0..255).map(&:chr).join }
+
+      it "must replace non-printable ASCII characters with a '.'" do
+        expect(subject.scrub(ascii)).to eq(ascii.gsub(/[^\x20-\x7e]/,'.'))
+      end
+    end
+
+    context "#encoding is set" do
+      let(:encoding) { Encoding::UTF_8 }
+      let(:string)   { "hello"         }
+
+      subject { described_class.new(encoding) }
+
+      it "must convert the string to the #encoding" do
+        expect((subject.scrub(string)).encoding).to eq(encoding)
+      end
+
+      context "when the string contains an invalid byte-sequence" do
+        let(:invalid_bytes) { "\x80\x81"           }
+        let(:string)        { "A#{invalid_bytes}B" }
+
+        it "must replace any invalid byte sequencnes with a '.'" do
+          expect(subject.scrub(string)).to eq("A..B")
+        end
+      end
+
+      context "when the string contains unprintable characters" do
+        let(:codepoint) { 888                     }
+        let(:char)      { codepoint.chr(encoding) }
+        let(:string)    { "A#{char}B"             }
+
+        it "must replace unprintable characters with a '.'" do
+          expect(subject.scrub(string)).to eq("A.B")
+        end
+      end
+    end
+  end
+end

data/spec/core_ext_spec.rb

@@ -2,19 +2,23 @@ require 'spec_helper'
 require 'hexdump/core_ext'
 
 describe "Hexdump core_ext" do
-  it "should include Hexdump into String" do
-    expect(String).to include(Hexdump)
+  it "should include Hexdump::Mixin into String" do
+    expect(String).to include(Hexdump::Mixin)
   end
 
-  it "should include Hexdump into StringIO" do
-    expect(StringIO).to include(Hexdump)
+  it "should include Hexdump::Mixin into StringIO" do
+    expect(StringIO).to include(Hexdump::Mixin)
   end
 
-  it "should include Hexdump into IO" do
-    expect(IO).to include(Hexdump)
+  it "should include Hexdump::Mixin into IO" do
+    expect(IO).to include(Hexdump::Mixin)
   end
 
   it "should define File.hexdump" do
     expect(File).to respond_to(:hexdump)
   end
+
+  it "should include Hexdump::ModuleMethods into ::Kernel" do
+    expect(::Kernel).to include(Hexdump::ModuleMethods)
+  end
 end

data/spec/hexdump_class_spec.rb

@@ -0,0 +1,1708 @@
+require 'spec_helper'
+require 'hexdump/hexdump'
+
+describe Hexdump::Hexdump do
+  describe "#initialize" do
+    it "must default type to :byte" do
+      expect(subject.type).to be(Hexdump::TYPES[:byte])
+    end
+
+    it "must default #columns to 16" do
+      expect(subject.columns).to eq(16)
+    end
+
+    it "must default #group_columns to nil" do
+      expect(subject.group_columns).to be(nil)
+    end
+
+    it "must default #base to 16" do
+      expect(subject.base).to eq(16)
+    end
+
+    it "must initialize #index to Hexdump::Numeric::Hexdecimal by default" do
+      expect(subject.index).to be_kind_of(Hexdump::Numeric::Hexadecimal)
+    end
+
+    it "must default #index_offset to nil" do
+      expect(subject.index_offset).to be(nil)
+    end
+
+    it "must initialize #numeric to a Hexdump::Numeric::Hexadecimal" do
+      expect(subject.numeric).to be_kind_of(Hexdump::Numeric::Hexadecimal)
+    end
+
+    it "must initialize the #reader with zero-padding disabled by default" do
+      expect(subject.reader.zero_pad?).to be(false)
+    end
+
+    it "must initialize #chars by default" do
+      expect(subject.chars).to be_kind_of(Hexdump::Chars)
+    end
+
+    context "when given the chars_column: true" do
+      subject { described_class.new(chars_column: true) }
+
+      it "must set #chars_column to true" do
+        expect(subject.chars_column).to be(true)
+      end
+
+      it "must initialize #chars with #encoding" do
+        expect(subject.chars).to be_kind_of(Hexdump::Chars)
+      end
+
+      context "and encoding: keyword" do
+        let(:encoding) { :utf8 }
+
+        subject { described_class.new(chars_column: true, encoding: encoding) }
+
+        it "must set #chars.encoding to the given encoding: value" do
+          expect(subject.chars.encoding).to be(subject.encoding)
+        end
+      end
+    end
+
+    context "when given chars_column: false" do
+      subject { described_class.new(chars_column: false) }
+
+      it "must set #chars_column to false" do
+        expect(subject.chars_column).to be(false)
+      end
+
+      it "must set #chars to nil" do
+        expect(subject.chars).to be(nil)
+      end
+    end
+
+    context "when given the encoding: keyword" do
+      subject { described_class.new(encoding: :utf8) }
+
+      it "must set #encoding" do
+        expect(subject.encoding).to eq(Encoding::UTF_8)
+      end
+    end
+
+    context "when given the offset: keyword" do
+      let(:offset) { 4 }
+
+      subject { described_class.new(offset: offset) }
+
+      it "must initialize the #reader with the offset: keyword" do
+        expect(subject.reader.offset).to eq(offset)
+      end
+
+      it "must also set #index_offset" do
+        expect(subject.index_offset).to eq(offset)
+      end
+    end
+
+    context "when given the length: keyword" do
+      let(:length) { 1024 }
+
+      subject { described_class.new(length: length) }
+
+      it "must initialize the #reader with the length: keyword" do
+        expect(subject.reader.length).to eq(length)
+      end
+    end
+
+    context "when given zero_pad: true" do
+      subject { described_class.new(zero_pad: true) }
+
+      it "must initialize the #reader with zero-padding enabled" do
+        expect(subject.reader.zero_pad?).to be(true)
+      end
+    end
+
+    context "when given a type: keyword" do
+      let(:type) { :uint16_le }
+
+      subject { described_class.new(type: type) }
+
+      it "must look up the given type in Hexdump::TYPES" do
+        expect(subject.type).to be(Hexdump::TYPES[type])
+      end
+
+      it "must divide the number of columns by the size of the type" do
+        expect(subject.columns).to eq(16 / Hexdump::TYPES[type].size)
+      end
+
+      context "when initialized with a type: :char" do
+        subject { described_class.new(type: :char) }
+
+        it "must set #type to Hexdump::Type::Char" do
+          expect(subject.type).to be_kind_of(Hexdump::Type::Char)
+        end
+
+        it "must initialize #numeric to Hexdump::Numeric::CharOrInt" do
+          expect(subject.numeric).to be_kind_of(Hexdump::Numeric::CharOrInt)
+        end
+
+        it "must disable #chars" do
+          expect(subject.chars).to be(nil)
+        end
+      end
+
+      context "when with type: is :uchar" do
+        let(:type) { :uchar }
+
+        it "must initialize #numeric to Hexdump::Numeric::CharOrInt" do
+          expect(subject.numeric).to be_kind_of(Hexdump::Numeric::CharOrInt)
+        end
+      end
+
+      context "when the type: is :byte" do
+        let(:type) { :byte }
+
+        it "must set #type to Hexdump::Type::UInt8" do
+          expect(subject.type).to be_kind_of(Hexdump::Type::UInt8)
+        end
+      end
+
+      context "when the type: is :uint8" do
+        let(:type) { :uint8 }
+
+        it "must set #type to Hexdump::Type::UInt8" do
+          expect(subject.type).to be_kind_of(Hexdump::Type::UInt8)
+        end
+      end
+
+      context "when the type: is :int8" do
+        let(:type) { :int8 }
+
+        it "must set #type to Hexdump::Type::Int8" do
+          expect(subject.type).to be_kind_of(Hexdump::Type::Int8)
+        end
+      end
+
+      context "when the type: is :uint16" do
+        let(:type) { :uint16 }
+
+        it "must set #type to Hexdump::Type::UInt16" do
+          expect(subject.type).to be_kind_of(Hexdump::Type::UInt16)
+        end
+      end
+
+      context "when the type: is :int16" do
+        let(:type) { :int16 }
+
+        it "must set #type to Hexdump::Type::Int16" do
+          expect(subject.type).to be_kind_of(Hexdump::Type::Int16)
+        end
+      end
+
+      context "when the type: is :uint32" do
+        let(:type) { :uint32 }
+
+        it "must set #type to Hexdump::Type::UInt32" do
+          expect(subject.type).to be_kind_of(Hexdump::Type::UInt32)
+        end
+      end
+
+      context "when the type: is :int32" do
+        let(:type) { :int32 }
+
+        it "must set #type to Hexdump::Type::Int32" do
+          expect(subject.type).to be_kind_of(Hexdump::Type::Int32)
+        end
+      end
+
+      context "when the type: is :uint64" do
+        let(:type) { :uint64 }
+
+        it "must set #type to Hexdump::Type::UInt64" do
+          expect(subject.type).to be_kind_of(Hexdump::Type::UInt64)
+        end
+      end
+
+      context "when the type: is :int64" do
+        let(:type) { :int64 }
+
+        it "must set #type to Hexdump::Type::Int64" do
+          expect(subject.type).to be_kind_of(Hexdump::Type::Int64)
+        end
+      end
+
+      context "and the type is :float, :float32, :float64, or :double" do
+        let(:type) { :float }
+
+        it "must set #type to Hexdump::Type::Float" do
+          expect(subject.type).to be_kind_of(Hexdump::Type::Float)
+        end
+
+        it "must default the #base to 10" do
+          expect(subject.base).to eq(10)
+        end
+
+        context "but the base: value isn't 10 or 16" do
+          it do
+            expect {
+              described_class.new(type: type, base: 8)
+            }.to raise_error(Hexdump::Numeric::IncompatibleTypeError)
+          end
+        end
+      end
+
+      context "when given an unsupported type" do
+        it do
+          expect {
+            described_class.new(type: :foo)
+          }.to raise_error(ArgumentError,"unsupported type: :foo")
+        end
+      end
+    end
+
+    context "when given base: keyword" do
+      subject { described_class.new(base: base) }
+
+      context "when the base: is 16" do
+        let(:base) { 16 }
+
+        it "must initialize #numeric to Hexdump::Numeric::Hexdecimal" do
+          expect(subject.numeric).to be_kind_of(Hexdump::Numeric::Hexadecimal)
+        end
+      end
+
+      context "when the base: is 10" do
+        let(:base) { 10 }
+
+        it "must initialize #numeric to Hexdump::Numeric::Decimal" do
+          expect(subject.numeric).to be_kind_of(Hexdump::Numeric::Decimal)
+        end
+      end
+
+      context "when given base: 8" do
+        let(:base) { 8 }
+
+        it "must initialize #numeric to Hexdump::Numeric::Octal" do
+          expect(subject.numeric).to be_kind_of(Hexdump::Numeric::Octal)
+        end
+      end
+
+      context "when given base: 2" do
+        let(:base) { 2 }
+
+        it "must initialize #numeric to Hexdump::Numeric::Binary" do
+          expect(subject.numeric).to be_kind_of(Hexdump::Numeric::Binary)
+        end
+      end
+    end
+
+    context "when given index_base: keyword" do
+      subject { described_class.new(index_base: index_base) }
+
+      context "when the index: is 16" do
+        let(:index_base) { 16 }
+
+        it "must initialize #index to Hexdump::Numeric::Hexdecimal" do
+          expect(subject.index).to be_kind_of(Hexdump::Numeric::Hexadecimal)
+        end
+      end
+
+      context "when the index: is 10" do
+        let(:index_base) { 10 }
+
+        it "must initialize #index to Hexdump::Numeric::Decimal" do
+          expect(subject.index).to be_kind_of(Hexdump::Numeric::Decimal)
+        end
+      end
+
+      context "when given index: 8" do
+        let(:index_base) { 8 }
+
+        it "must initialize #index to Hexdump::Numeric::Octal" do
+          expect(subject.index).to be_kind_of(Hexdump::Numeric::Octal)
+        end
+      end
+
+      context "when given index: 2" do
+        let(:index_base) { 2 }
+
+        it "must initialize #index to Hexdump::Numeric::Binary" do
+          expect(subject.index).to be_kind_of(Hexdump::Numeric::Binary)
+        end
+      end
+    end
+
+    context "when given the index_offset: keyword" do
+      let(:index_offset) { 1024 }
+
+      subject { described_class.new(index_offset: index_offset) }
+
+      it "must set #index_offset" do
+        expect(subject.index_offset).to eq(index_offset)
+      end
+
+      context "but the offset: keyword is also given" do
+        let(:offset) { 4 }
+
+        subject do
+          described_class.new(
+            offset:       offset,
+            index_offset: index_offset
+          )
+        end
+
+        it "must set #index_offset to the index_offset: value" do
+          expect(subject.index_offset).to eq(index_offset)
+        end
+      end
+    end
+
+    context "when given the columns: keyword" do
+      let(:columns) { 7 }
+
+      subject { described_class.new(columns: columns) }
+
+      it "must set #columns" do
+        expect(subject.columns).to eq(columns)
+      end
+    end
+
+    context "when given the group_columns: keyword" do
+      let(:group_columns) { 4 }
+
+      subject { described_class.new(group_columns: group_columns) }
+
+      it "must set #group_columns" do
+        expect(subject.group_columns).to eq(group_columns)
+      end
+    end
+
+    context "when given the group_chars: keyword" do
+      let(:group_chars) { 4 }
+
+      subject { described_class.new(group_chars: group_chars) }
+
+      it "must set #group_chars" do
+        expect(subject.group_chars).to eq(group_chars)
+      end
+
+      context "when group_chars: :type is given" do
+        let(:type) { :uint16 }
+
+        subject { described_class.new(type: type, group_chars: :type) }
+
+        it "must set #group_chars to #type.size" do
+          expect(subject.group_chars).to eq(subject.type.size)
+        end
+      end
+    end
+
+    context "when given an unsupported base: value" do
+      it do
+        expect {
+          described_class.new(base: 3)
+        }.to raise_error(ArgumentError,"unsupported base: 3")
+      end
+    end
+
+    it "must default #theme to nil" do
+      expect(subject.theme).to be(nil)
+    end
+
+    context "when given the style: keyword" do
+      context "and is a Hash" do
+        let(:index_style)   { :white }
+        let(:numeric_style) { :cyan  }
+        let(:chars_style)   { :blue  }
+
+        subject do
+          described_class.new(
+            style: {
+              index:   index_style,
+              numeric: numeric_style,
+              chars:   chars_style
+            }
+          )
+        end
+
+        it "must initialize #style" do
+          expect(subject.theme).to be_kind_of(Hexdump::Theme)
+        end
+
+        it "must initialize #style.index" do
+          expect(subject.theme.index).to be_kind_of(Hexdump::Theme::Rule)
+        end
+
+        it "must populate #style.index.theme" do
+          expect(subject.theme.index.style.parameters).to eq(index_style)
+        end
+
+        it "must initialize #style.numeric" do
+          expect(subject.theme.numeric).to be_kind_of(Hexdump::Theme::Rule)
+        end
+
+        it "must populate #style.numeric.theme" do
+          expect(subject.theme.numeric.style.parameters).to eq(numeric_style)
+        end
+
+        it "must initialize #style.chars" do
+          expect(subject.theme.chars).to be_kind_of(Hexdump::Theme::Rule)
+        end
+
+        it "must populate #style.chars.theme" do
+          expect(subject.theme.chars.style.parameters).to eq(chars_style)
+        end
+      end
+    end
+
+    context "when given the highlights: keyword" do
+      context "and is a Hash" do
+        let(:index_pattern)      { /00$/ }
+        let(:index_highlight)    { :white }
+        let(:index_highlights)   { {index_pattern => index_highlight} }
+
+        let(:numeric_pattern)    { '00'    }
+        let(:numeric_highlight)  { :faint  }
+        let(:numeric_highlights) { {numeric_pattern => numeric_highlight}  }
+
+        let(:chars_pattern)    { /A-Z/  }
+        let(:chars_highlight)  { :bold  }
+        let(:chars_highlights) { {chars_pattern => chars_highlight}  }
+
+        subject do
+          described_class.new(
+            highlights: {
+              index: index_highlights,
+              numeric: numeric_highlights,
+              chars:   chars_highlights
+            }
+          )
+        end
+
+        it "must initialize #style" do
+          expect(subject.theme).to be_kind_of(Hexdump::Theme)
+        end
+
+        it "must initialize #style.index" do
+          expect(subject.theme.index).to be_kind_of(Hexdump::Theme::Rule)
+        end
+
+        it "must populate #style.index.highlights" do
+          expect(subject.theme.index.highlights[index_pattern].parameters).to eq(index_highlight)
+        end
+
+        it "must initialize #style.numeric" do
+          expect(subject.theme.numeric).to be_kind_of(Hexdump::Theme::Rule)
+        end
+
+        it "must populate #style.numeric.highlights" do
+          expect(subject.theme.numeric.highlights[numeric_pattern].parameters).to eq(numeric_highlight)
+        end
+
+        it "must initialize #style.chars" do
+          expect(subject.theme.chars).to be_kind_of(Hexdump::Theme::Rule)
+        end
+
+        it "must populate #style.chars.highlights" do
+          expect(subject.theme.chars.highlights[chars_pattern].parameters).to eq(chars_highlight)
+        end
+      end
+    end
+
+    context "when a block is given" do
+      it "must yield the newly initialized hexdump object" do
+        yielded_hexdump = nil
+
+        described_class.new  do |hexdump|
+          yielded_hexdump = hexdump
+        end
+
+        expect(yielded_hexdump).to be_kind_of(described_class)
+      end
+    end
+  end
+
+  describe "#type=" do
+    context "when given a type name" do
+      let(:type_name) { :uint32_le }
+
+      before { subject.type = type_name }
+
+      it "must set the #type to a Type object" do
+        expect(subject.type).to eq(Hexdump::TYPES.fetch(type_name))
+      end
+    end
+  end
+
+  describe "#base=" do
+    context "when given 16" do
+      let(:base) { 16 }
+
+      before { subject.base = base }
+
+      it "must set #base" do
+        expect(subject.base).to eq(base)
+      end
+    end
+
+    context "when given 10" do
+      let(:base) { 10 }
+
+      before { subject.base = base }
+
+      it "must set #base" do
+        expect(subject.base).to eq(base)
+      end
+    end
+
+    context "when given 8" do
+      let(:base) { 8 }
+
+      before { subject.base = base }
+
+      it "must set #base" do
+        expect(subject.base).to eq(base)
+      end
+    end
+
+    context "when given 2" do
+      let(:base) { 2 }
+
+      before { subject.base = base }
+
+      it "must set #base" do
+        expect(subject.base).to eq(base)
+      end
+    end
+  end
+
+  describe "#index_base=" do
+    context "when given 16" do
+      let(:value) { 16 }
+
+      before { subject.index_base = value }
+
+      it "must set #index_base" do
+        expect(subject.index_base).to eq(value)
+      end
+    end
+
+    context "when given 10" do
+      let(:value) { 10 }
+
+      before { subject.index_base = value }
+
+      it "must set #index_base" do
+        expect(subject.index_base).to eq(value)
+      end
+    end
+
+    context "when given 8" do
+      let(:value) { 8 }
+
+      before { subject.index_base = value }
+
+      it "must set #index_base" do
+        expect(subject.index_base).to eq(value)
+      end
+    end
+
+    context "when given 2" do
+      let(:value) { 2 }
+
+      before { subject.index_base = value }
+
+      it "must set #index_base" do
+        expect(subject.index_base).to eq(value)
+      end
+    end
+  end
+
+  describe "#group_chars=" do
+    context "when given an Integer" do
+      let(:value) { 4 }
+
+      before { subject.group_chars = value }
+
+      it "must set #group_chars" do
+        expect(subject.group_chars).to eq(value)
+      end
+    end
+
+    context "when given :type" do
+      subject { described_class.new(type: :uint16) }
+
+      before { subject.group_chars = :type }
+
+      it "must set #group_chars to #type.size" do
+        expect(subject.group_chars).to eq(subject.type.size)
+      end
+    end
+  end
+
+  describe "#encoding=" do
+    context "when given nil" do
+      before { subject.encoding = nil }
+
+      it "must set #encoding to nil" do
+        expect(subject.encoding).to be(nil)
+      end
+    end
+
+    context "when given :ascii" do
+      before { subject.encoding = :ascii }
+
+      it "must set #encoding to nil" do
+        expect(subject.encoding).to be(nil)
+      end
+    end
+
+    context "when given :utf8" do
+      before { subject.encoding = :utf8 }
+
+      it "must set #encoding to Encoding::UTF_8" do
+        expect(subject.encoding).to eq(Encoding::UTF_8)
+      end
+    end
+
+    context "when given an Encoding object" do
+      let(:encoding) { Encoding::UTF_7 }
+
+      before { subject.encoding = encoding }
+
+      it "must set #encoding" do
+        expect(subject.encoding).to eq(encoding)
+      end
+    end
+  end
+
+  describe "#theme" do
+    context "when a block is given" do
+      context "when not initialized with style: or highlights: keywords" do
+        it "must yield a new Theme object" do
+          yielded_theme = nil
+
+          subject.theme { |theme| yielded_theme = theme }
+
+          initialized_theme = subject.instance_variable_get("@theme")
+
+          expect(yielded_theme).to be(initialized_theme)
+        end
+
+        context "when called multiple times" do
+          it "must yield the same Theme object" do
+            theme_id1 = nil
+            theme_id2 = nil
+
+            subject.theme { |theme| theme_id1 = theme.object_id }
+            subject.theme { |theme| theme_id2 = theme.object_id }
+
+            expect(theme_id1).to eq(theme_id2)
+          end
+        end
+      end
+
+      context "when initialized with style: or highlights: keywords" do
+        subject do
+          described_class.new(
+            style:      {},
+            highlights: {}
+          )
+        end
+
+        it "must yield the initialized theme object" do
+          initialized_theme = subject.instance_variable_get("@theme")
+
+          yielded_theme = nil
+
+          subject.theme { |theme| yielded_theme = theme }
+
+          expect(yielded_theme).to be(initialized_theme)
+        end
+      end
+    end
+
+    context "when no block is given" do
+      context "when not initialized with style: or highlights: keywords" do
+        it "must return nil" do
+          expect(subject.theme).to be(nil)
+        end
+      end
+
+      context "when initialized with style: or highlights: keywords" do
+        subject do
+          described_class.new(
+            style:      {},
+            highlights: {}
+          )
+        end
+
+        it "must return the initialized theme object" do
+          initialized_theme = subject.instance_variable_get("@theme")
+
+          expect(subject.theme).to be(initialized_theme)
+        end
+      end
+    end
+  end
+
+  let(:data) do
+    'A' * subject.columns + \
+    'B' * subject.columns + \
+    'C' * subject.columns
+  end
+
+  let(:columns) { subject.columns }
+
+  describe "#each_row" do
+    let(:rows) do
+      [
+        [columns * 0, [0x41] * columns, ['A'] * columns],
+        [columns * 1, [0x42] * columns, ['B'] * columns],
+        [columns * 2, [0x43] * columns, ['C'] * columns],
+      ]
+    end
+
+    it "must yield each row of index, numeric values, and raw characters" do
+      yielded_rows = []
+
+      subject.each_row(data) do |*args|
+        yielded_rows << args
+      end
+
+      expect(yielded_rows).to eq(rows)
+    end
+
+    it "must return the total number of bytes read" do
+      index = subject.each_row(data) do |*args|
+      end
+
+      expect(index).to eq(data.length)
+    end
+
+    context "when #reader.offset is > 0" do
+      let(:offset) { 8 }
+
+      subject { described_class.new(offset: offset) }
+
+      let(:indexes) do
+        [
+          offset + (columns * 0),
+          offset + (columns * 1),
+          offset + (columns * 2),
+        ]
+      end
+
+      it "must start the index at #offset" do
+        yielded_indexes = []
+
+        subject.each_row(data) do |index,*args|
+          yielded_indexes << index
+        end
+
+        expect(yielded_indexes).to eq(indexes)
+      end
+
+      context "and #index_offset is > 0" do
+        let(:index_offset) { 0 }
+
+        subject do
+          described_class.new(
+            offset:       offset,
+            index_offset: index_offset
+          )
+        end
+
+        let(:indexes) do
+          [
+            index_offset + (columns * 0),
+            index_offset + (columns * 1),
+            index_offset + (columns * 2),
+          ]
+        end
+
+        it "must override :index and start the index at #index_offset" do
+          yielded_indexes = []
+
+          subject.each_row(data) do |index,*args|
+            yielded_indexes << index
+          end
+
+          expect(yielded_indexes).to eq(indexes)
+        end
+      end
+    end
+
+    context "when the data's length is not evenly divisble by the columns" do
+      let(:rows) do
+        [
+          [columns * 0, [0x41] * columns,       ['A'] * columns      ],
+          [columns * 1, [0x42] * columns,       ['B'] * columns      ],
+          [columns * 2, [0x43] * (columns / 2), ['C'] * (columns / 2)]
+        ]
+      end
+
+      let(:data) do
+        'A' * columns + \
+        'B' * columns + \
+        'C' * (columns / 2)
+      end
+
+      it "must yield a partial row of read values last" do
+        yielded_rows = []
+
+        subject.each_row(data) do |*args|
+          yielded_rows << args
+        end
+
+        expect(yielded_rows).to eq(rows)
+      end
+    end
+
+    context "when #columns is not 16" do
+      let(:columns) { 7 }
+
+      subject { described_class.new(columns: columns) }
+
+      it "must yield rows with the same number of columns" do
+        yielded_row_lengths = []
+
+        subject.each_row(data) do |index,numeric,chars|
+          yielded_row_lengths << numeric.length
+        end
+
+        expect(yielded_row_lengths).to all(eq(columns))
+      end
+    end
+
+    context "when there are not enough bytes to decode the last value" do
+      subject { described_class.new(type: :uint32) }
+
+      let(:size) { subject.type.size }
+
+      let(:data) do
+        "\x41\x41\x41\x41" * columns + \
+        "ABC"
+      end
+
+      let(:rows) do
+        [
+          [size * columns * 0, [0x41414141] * columns, ["AAAA"] * columns],
+          [size * columns * 1, [nil], ["ABC"]]
+        ]
+      end
+
+      it "must yield the read characters, but not the partially decoded value" do
+        yielded_rows = []
+
+        subject.each_row(data) do |*row|
+          yielded_rows << row
+        end
+
+        expect(yielded_rows).to eq(rows)
+      end
+    end
+
+    context "when no block is given" do
+      it "must return an Enumerator" do
+        expect(subject.each_row(data)).to be_kind_of(Enumerator)
+      end
+    end
+  end
+
+  describe "#each_non_repeating_row" do
+    let(:rows) do
+      [
+        [columns * 0, [0x41] * columns, ['A'] * columns],
+        [columns * 1, [0x42] * columns, ['B'] * columns],
+        ['*'],
+        [columns * 4, [0x43] * columns, ['C'] * columns]
+      ]
+    end
+
+    let(:data) do
+      'A' * subject.columns + \
+      'B' * subject.columns + \
+      'B' * subject.columns + \
+      'B' * subject.columns + \
+      'C' * subject.columns
+    end
+
+    it "must omit repeating rows, instead yielding an index of '*'" do
+      yielded_rows = []
+
+      subject.each_non_repeating_row(data) do |*args|
+        yielded_rows << args
+      end
+
+      expect(yielded_rows).to eq(rows)
+    end
+
+    it "must return the total number of bytes read" do
+      index = subject.each_non_repeating_row(data) do |*args|
+      end
+
+      expect(index).to eq(data.length)
+    end
+
+    context "when the repeating rows is at the end of the data" do
+      let(:rows) do
+        [
+          [columns * 0, [0x41] * columns, ['A'] * columns],
+          [columns * 1, [0x42] * columns, ['B'] * columns],
+          [columns * 2, [0x43] * columns, ['C'] * columns],
+          ['*']
+        ]
+      end
+
+      let(:data) do
+        'A' * columns + \
+        'B' * columns + \
+        'C' * columns + \
+        'C' * columns + \
+        'C' * columns
+      end
+
+      it "must yield an index of '*' at the end" do
+        yielded_rows = []
+
+        subject.each_non_repeating_row(data) do |*args|
+          yielded_rows << args
+        end
+
+        expect(yielded_rows).to eq(rows)
+      end
+    end
+
+    context "when no block is given" do
+      it "must return an Enumerator" do
+        expect(subject.each_non_repeating_row(data)).to be_kind_of(Enumerator)
+      end
+    end
+  end
+
+  describe "#each_formatted_row" do
+    let(:formatted_rows) do
+      [
+        ["%.8x" % (columns * 0), ["41"] * columns, "A" * columns],
+        ["%.8x" % (columns * 1), ["42"] * columns, "B" * columns],
+        ["%.8x" % (columns * 2), ["43"] * columns, "C" * columns],
+      ]
+    end
+
+    it "should yield the formatted rows to the given block" do
+      yielded_rows = []
+
+      subject.each_formatted_row(data) do |*row|
+        yielded_rows << row
+      end
+
+      expect(yielded_rows).to eq(formatted_rows)
+    end
+
+    it "must return the formatted total number of bytes read" do
+      index = subject.each_formatted_row(data) do |*row|
+      end
+
+      expect(index).to eq(subject.index % data.length)
+    end
+
+    [*(0x00..0x1f), *(0x7f..0xff)].each do |byte|
+      context "when the row contains an ASCII #{byte.chr.dump} characters" do
+        let(:data) { "ABC#{byte.chr}" }
+
+        let(:formatted_rows) do
+          [
+            ["00000000", ["41", "42", "43", "%.2x" % byte], "ABC."]
+          ]
+        end
+
+        it "must replace unprintable characters with a '.'" do
+          yielded_rows = []
+
+          subject.each_formatted_row(data) do |*row|
+            yielded_rows << row
+          end
+
+          expect(yielded_rows).to eq(formatted_rows)
+        end
+      end
+    end
+
+    context "when the data's length is not evenly divisble by the columns" do
+      let(:data) do
+        'A' * columns + \
+        'B' * columns + \
+        'C' * (columns / 2)
+      end
+
+      let(:formatted_rows) do
+        [
+          ["%.8x" % (columns * 0), ["41"] * columns, "A" * columns],
+          ["%.8x" % (columns * 1), ["42"] * columns, "B" * columns],
+          [
+            "%.8x" % (columns * 2), ["43"] * (columns / 2), "C" * (columns / 2)
+          ]
+        ]
+      end
+
+      it "must yield the last formatted partial row" do
+        yielded_rows = []
+
+        subject.each_formatted_row(data) do |*row|
+          yielded_rows << row
+        end
+
+        expect(yielded_rows).to eq(formatted_rows)
+      end
+    end
+
+    context "when there are not enough bytes to decode the last value" do
+      subject { described_class.new(type: :uint32) }
+
+      let(:size) { subject.type.size }
+
+      let(:data) do
+        "\x41\x41\x41\x41" * columns + \
+        "ABC"
+      end
+
+      let(:formatted_rows) do
+        [
+          [
+            "%.8x" % (size * columns * 0),
+            ["41414141"] * columns,
+            "AAAA" * columns
+          ],
+
+          [
+            "%.8x" % (size * columns * 1),
+            ["        "],
+            "ABC"
+          ]
+        ]
+      end
+
+      it "must yield the read characters and a place-holder blank String" do
+        yielded_rows = []
+
+        subject.each_formatted_row(data) do |*row|
+          yielded_rows << row
+        end
+
+        expect(yielded_rows).to eq(formatted_rows)
+      end
+    end
+
+    context "when there is repeating rows of data" do
+      let(:data) do
+        'A' * columns + \
+        'B' * columns + \
+        'B' * columns + \
+        'B' * columns + \
+        'C' * columns
+      end
+
+      let(:formatted_rows) do
+        [
+          ["%.8x" % (columns * 0), ["41"] * columns, "A" * columns],
+          ["%.8x" % (columns * 1), ["42"] * columns, "B" * columns],
+          ["*"],
+          ["%.8x" % (columns * 4), ["43"] * columns, "C" * columns]
+        ]
+      end
+
+      it "must yield the formatted rows and a '*' row to denote the beginning of repeating rows" do
+        yielded_rows = []
+
+        subject.each_formatted_row(data) do |*row|
+          yielded_rows << row
+        end
+
+        expect(yielded_rows).to eq(formatted_rows)
+      end
+
+      context "and #repeating is true" do
+        subject { described_class.new(repeating: true) }
+
+        let(:formatted_rows) do
+          [
+            ["%.8x" % (columns * 0), ["41"] * columns, 'A' * columns],
+            ["%.8x" % (columns * 1), ["42"] * columns, 'B' * columns],
+            ["%.8x" % (columns * 2), ["42"] * columns, 'B' * columns],
+            ["%.8x" % (columns * 3), ["42"] * columns, 'B' * columns],
+            ["%.8x" % (columns * 4), ["43"] * columns, 'C' * columns]
+          ]
+        end
+
+        it "must yield the formatted repeating rows" do
+          yielded_rows = []
+
+          subject.each_formatted_row(data) do |*row|
+            yielded_rows << row
+          end
+
+          expect(yielded_rows).to eq(formatted_rows)
+        end
+      end
+    end
+
+    context "when #columns is not 16" do
+      let(:columns) { 7 }
+
+      subject { described_class.new(columns: columns) }
+
+      it "must yield rows with the same number of formatted columns" do
+        yielded_numeric_lengths = []
+        yielded_chars_lengths   = []
+
+        subject.each_formatted_row(data) do |index,numeric,chars|
+          yielded_numeric_lengths << numeric.length
+          yielded_chars_lengths   << chars.length
+        end
+
+        expect(yielded_numeric_lengths).to all(eq(columns))
+        expect(yielded_chars_lengths).to   all(eq(columns))
+      end
+    end
+
+    context "when #chars.encoding is set" do
+      let(:encoding) { Encoding::UTF_8 }
+
+      subject { described_class.new(encoding: encoding) }
+
+      it "must encode the characters to the given Encoding" do
+        yielded_char_encodings = []
+
+        subject.each_formatted_row(data) do |index,numeric,chars|
+          yielded_char_encodings << chars.encoding
+        end
+
+        expect(yielded_char_encodings).to all(eq(encoding))
+      end
+
+      context "and the data contains unprintable characters" do
+        let(:codepoint) { 888 }
+        let(:char) { codepoint.chr(encoding) }
+        let(:data) { "A#{char}B" }
+        let(:bytes) { data.bytes }
+
+        let(:formatted_rows) do
+          [
+            [subject.index % 0, bytes.map { |b| subject.numeric % b }, "A.B"]
+          ]
+        end
+
+        it "must replace any unprintable characters with a '.'" do
+          yielded_rows = []
+
+          subject.each_formatted_row(data) do |*row|
+            yielded_rows << row
+          end
+
+          expect(yielded_rows).to eq(formatted_rows)
+        end
+      end
+
+      context "and the data contains invalid byte sequences" do
+        let(:invalid_bytes) { "\x80\x81" }
+        let(:data) { "A#{invalid_bytes}B" }
+        let(:bytes) { data.bytes }
+
+        let(:formatted_rows) do
+          [
+            [subject.index % 0, bytes.map { |b| subject.numeric % b }, "A..B"]
+          ]
+        end
+
+        it "must replace any invalid byte sequences with a '.'" do
+          yielded_rows = []
+
+          subject.each_formatted_row(data) do |*row|
+            yielded_rows << row
+          end
+
+          expect(yielded_rows).to eq(formatted_rows)
+        end
+      end
+    end
+
+    context "when #theme is initialized" do
+      let(:ansi_reset) { Hexdump::Theme::ANSI::RESET }
+      let(:ansi_green) { Hexdump::Theme::ANSI::PARAMETERS[:green] }
+      let(:ansi_blue)  { Hexdump::Theme::ANSI::PARAMETERS[:blue]  }
+
+      let(:ansi_reset) { Hexdump::Theme::ANSI::RESET }
+
+      context "and #style.index.theme is set" do
+        subject { described_class.new(style: {index: :cyan}) }
+
+        let(:ansi_style)  { Hexdump::Theme::ANSI::PARAMETERS[:cyan] }
+
+        let(:index_format) { "#{ansi_style}%.8x#{ansi_reset}" }
+        let(:formatted_rows) do
+          [
+            [index_format % (columns * 0), ["41"] * columns, "A" * columns],
+            [index_format % (columns * 1), ["42"] * columns, "B" * columns],
+            [index_format % (columns * 2), ["43"] * columns, "C" * columns],
+          ]
+        end
+
+        it "must apply ANSI control sequences around the index column" do
+          yielded_rows = []
+
+          subject.each_formatted_row(data) do |*row|
+            yielded_rows << row
+          end
+
+          expect(yielded_rows).to eq(formatted_rows)
+        end
+
+        let(:formatted_index)  do
+          "#{ansi_style}%.8x#{ansi_reset}" % data.length
+        end
+
+        it "must apply ANSI control sequences around the returned index" do
+          index = subject.each_formatted_row(data) do |*row|
+          end
+
+          expect(index).to eq(formatted_index)
+        end
+      end
+
+      context "and #style.index.highlights is populated" do
+        subject do
+          described_class.new(
+            highlights: {
+              index: {/00$/ => :bold}
+            }
+          )
+        end
+
+        let(:ansi_style)  { Hexdump::Theme::ANSI::PARAMETERS[:bold] }
+
+        let(:highlighted_index) { "000000#{ansi_style}00#{ansi_reset}" }
+        let(:formatted_rows) do
+          [
+            [highlighted_index,      ["41"] * columns, "A" * columns],
+            ["%.8x" % (columns * 1), ["42"] * columns, "B" * columns],
+            ["%.8x" % (columns * 2), ["43"] * columns, "C" * columns],
+          ]
+        end
+
+        it "must selectively insert ANSI control sequences to the index column" do
+          yielded_rows = []
+
+          subject.each_formatted_row(data) do |*row|
+            yielded_rows << row
+          end
+
+          expect(yielded_rows).to eq(formatted_rows)
+        end
+      end
+
+      context "and #style.numeric.theme is set" do
+        subject { described_class.new(style: {numeric: :blue}) }
+
+        let(:ansi_style)  { Hexdump::Theme::ANSI::PARAMETERS[:blue] }
+
+        let(:formatted_rows) do
+          [
+            ["%.8x" % (columns * 0), ["#{ansi_style}41#{ansi_reset}"] * columns, "A" * columns],
+            ["%.8x" % (columns * 1), ["#{ansi_style}42#{ansi_reset}"] * columns, "B" * columns],
+            ["%.8x" % (columns * 2), ["#{ansi_style}43#{ansi_reset}"] * columns, "C" * columns],
+          ]
+        end
+
+        it "must apply ANSI control sequences around each numeric column" do
+          yielded_rows = []
+
+          subject.each_formatted_row(data) do |*row|
+            yielded_rows << row
+          end
+
+          expect(yielded_rows).to eq(formatted_rows)
+        end
+      end
+
+      context "and #style.numeric.highlights is populated" do
+        subject do
+          described_class.new(
+            highlights: {
+              numeric: {/^4/ => :green}
+            }
+          )
+        end
+
+        let(:ansi_style)  { Hexdump::Theme::ANSI::PARAMETERS[:green] }
+
+        let(:formatted_rows) do
+          [
+            ["%.8x" % (columns * 0), ["#{ansi_style}4#{ansi_reset}1"] * columns, "A" * columns],
+            ["%.8x" % (columns * 1), ["#{ansi_style}4#{ansi_reset}2"] * columns, "B" * columns],
+            ["%.8x" % (columns * 2), ["#{ansi_style}4#{ansi_reset}3"] * columns, "C" * columns],
+          ]
+        end
+
+        it "must selectively insert ANSI control sequences to the numeric columns" do
+          yielded_rows = []
+
+          subject.each_formatted_row(data) do |*row|
+            yielded_rows << row
+          end
+
+          expect(yielded_rows).to eq(formatted_rows)
+        end
+      end
+
+      context "and #style.chars.theme is set" do
+        subject { described_class.new(style: {chars: :green}) }
+
+        let(:ansi_style)  { Hexdump::Theme::ANSI::PARAMETERS[:green] }
+
+        let(:formatted_rows) do
+          [
+            ["%.8x" % (columns * 0), ["41"] * columns, "#{ansi_style}#{"A" * columns}#{ansi_reset}"],
+            ["%.8x" % (columns * 1), ["42"] * columns, "#{ansi_style}#{"B" * columns}#{ansi_reset}"],
+            ["%.8x" % (columns * 2), ["43"] * columns, "#{ansi_style}#{"C" * columns}#{ansi_reset}"],
+          ]
+        end
+
+        it "must apply ANSI control sequences around the chars column" do
+          yielded_rows = []
+
+          subject.each_formatted_row(data) do |*row|
+            yielded_rows << row
+          end
+
+          expect(yielded_rows).to eq(formatted_rows)
+        end
+      end
+
+      context "and #style.chars.highlights is populated" do
+        subject do
+          described_class.new(
+            highlights: {
+              chars: {/[AC]/ => :red}
+            }
+          )
+        end
+
+        let(:ansi_style)  { Hexdump::Theme::ANSI::PARAMETERS[:red] }
+
+        let(:formatted_rows) do
+          [
+            ["%.8x" % (columns * 0), ["41"] * columns, "#{ansi_style}A#{ansi_reset}" * columns],
+            ["%.8x" % (columns * 1), ["42"] * columns, "B" * columns],
+            ["%.8x" % (columns * 2), ["43"] * columns, "#{ansi_style}C#{ansi_reset}" * columns],
+          ]
+        end
+
+        it "must selectively insert ANSI control sequences to the chars column" do
+          yielded_rows = []
+
+          subject.each_formatted_row(data) do |*row|
+            yielded_rows << row
+          end
+
+          expect(yielded_rows).to eq(formatted_rows)
+        end
+      end
+
+      context "but the ansi: keyword is false" do
+        subject do
+          described_class.new(
+            style: {
+              index:   :cyan,
+              numeric: :blue,
+              chars:   :green
+            },
+            highlights: {
+              index:   {/00$/ => :bold},
+              numeric: {/^4/ => :green},
+              chars:   {/[AC]/ => :red}
+            }
+          )
+        end
+
+        it "must not apply any ANSI control sequences" do
+          yielded_rows = []
+
+          subject.each_formatted_row(data, ansi: false) do |*row|
+            yielded_rows << row
+          end
+
+          expect(yielded_rows).to eq(formatted_rows)
+        end
+      end
+
+      context "when #group_chars is set" do
+        let(:group_chars) { 4 }
+
+        subject { described_class.new(group_chars: group_chars) }
+
+        let(:formatted_chars) do
+          [
+            ["A" * group_chars] * (columns / group_chars),
+            ["B" * group_chars] * (columns / group_chars),
+            ["C" * group_chars] * (columns / group_chars)
+          ]
+        end
+
+        it "must group the characters into fixed length strings" do
+          yielded_chars= []
+
+          subject.each_formatted_row(data) do |*row,chars|
+            yielded_chars << chars
+          end
+
+          expect(yielded_chars).to eq(formatted_chars)
+        end
+
+        context "but #chars.encoding is Encoding::UTF_8" do
+          let(:encoding) { Encoding::UTF_8 }
+
+          subject do
+            described_class.new(group_chars: group_chars, encoding: encoding)
+          end
+
+          let(:char)      { "\u8000" }
+          let(:length)    { (columns * 2) / char.bytes.length }
+          let(:data)      { char * length }
+
+          let(:formatted_chars) do
+            [
+              ["耀.", "...", ".耀", "耀."],
+              ["...", ".耀", "耀.", ".."]
+            ]
+          end
+
+          it "must split the characters along byte boundaries" do
+            yielded_chars= []
+
+            subject.each_formatted_row(data) do |*row,chars|
+              yielded_chars << chars
+            end
+
+            expect(yielded_chars).to eq(formatted_chars)
+          end
+        end
+      end
+    end
+
+    context "when no block is given" do
+      it "must return an Enumerator" do
+        expect(subject.each_formatted_row(data)).to be_kind_of(Enumerator)
+      end
+    end
+  end
+
+  describe "#each_line" do
+    let(:lines) do
+      [
+        "00000000  41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41  |AAAAAAAAAAAAAAAA|#{$/}",
+        "00000010  42 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42  |BBBBBBBBBBBBBBBB|#{$/}",
+        "00000020  43 43 43 43 43 43 43 43 43 43 43 43 43 43 43 43  |CCCCCCCCCCCCCCCC|#{$/}",
+        "00000030#{$/}"
+      ]
+    end
+
+    it "must yield each line" do
+      yielded_lines = []
+
+      subject.each_line(data) do |line|
+        yielded_lines << line
+      end
+
+      expect(yielded_lines).to eq(lines)
+    end
+
+    context "when the data's length is not evenly divisble by the columns" do
+      let(:data) do
+        'A' * columns + \
+        'B' * columns + \
+        'C' * (columns / 2)
+      end
+
+      let(:lines) do
+        [
+          "00000000  41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41  |AAAAAAAAAAAAAAAA|#{$/}",
+          "00000010  42 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42  |BBBBBBBBBBBBBBBB|#{$/}",
+          "00000020  43 43 43 43 43 43 43 43                          |CCCCCCCC|#{$/}",
+          "00000028#{$/}"
+        ]
+      end
+
+      it "must yield the last left-adjusted partial row" do
+        yielded_lines = []
+
+        subject.each_line(data) do |line|
+          yielded_lines << line
+        end
+
+        expect(yielded_lines).to eq(lines)
+      end
+    end
+
+    context "when the data contains repeating rows" do
+      let(:data) do
+        'A' * columns + \
+        'B' * columns + \
+        'B' * columns + \
+        'B' * columns + \
+        'C' * columns
+      end
+
+      let(:lines) do
+        [
+          "00000000  41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41  |AAAAAAAAAAAAAAAA|#{$/}",
+          "00000010  42 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42  |BBBBBBBBBBBBBBBB|#{$/}",
+          "*#{$/}",
+          "00000040  43 43 43 43 43 43 43 43 43 43 43 43 43 43 43 43  |CCCCCCCCCCCCCCCC|#{$/}",
+          "00000050#{$/}"
+        ]
+      end
+
+      it "must yield the formatted lines and a '*' row to denote the beginning of repeating lines" do
+        yielded_lines = []
+
+        subject.each_line(data) do |line|
+          yielded_lines << line
+        end
+
+        expect(yielded_lines).to eq(lines)
+      end
+    end
+
+    context "when #repeating is true" do
+      subject { described_class.new(repeating: true) }
+
+      let(:data) do
+        'A' * columns + \
+        'B' * columns + \
+        'B' * columns + \
+        'B' * columns + \
+        'C' * columns
+      end
+
+      let(:lines) do
+        [
+          "00000000  41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41  |AAAAAAAAAAAAAAAA|#{$/}",
+          "00000010  42 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42  |BBBBBBBBBBBBBBBB|#{$/}",
+          "00000020  42 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42  |BBBBBBBBBBBBBBBB|#{$/}",
+          "00000030  42 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42  |BBBBBBBBBBBBBBBB|#{$/}",
+          "00000040  43 43 43 43 43 43 43 43 43 43 43 43 43 43 43 43  |CCCCCCCCCCCCCCCC|#{$/}",
+          "00000050#{$/}"
+        ]
+      end
+
+      it "must yield repeating lines" do
+        yielded_lines = []
+
+        subject.each_line(data) do |line|
+          yielded_lines << line
+        end
+
+        expect(yielded_lines).to eq(lines)
+      end
+    end
+
+    context "when #chars_column is false" do
+      subject { described_class.new(chars_column: false) }
+
+      let(:lines) do
+        [
+          "00000000  41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41#{$/}",
+          "00000010  42 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42#{$/}",
+          "00000020  43 43 43 43 43 43 43 43 43 43 43 43 43 43 43 43#{$/}",
+          "00000030#{$/}"
+        ]
+      end
+
+      it "must omit the characters column" do
+        yielded_lines = []
+
+        subject.each_line(data) do |line|
+          yielded_lines << line
+        end
+
+        expect(yielded_lines).to eq(lines)
+      end
+    end
+
+    context "when #group_columns is set" do
+      subject { described_class.new(group_columns: 4) }
+
+      let(:lines) do
+        [
+          "00000000  41 41 41 41  41 41 41 41  41 41 41 41  41 41 41 41  |AAAAAAAAAAAAAAAA|#{$/}",
+          "00000010  42 42 42 42  42 42 42 42  42 42 42 42  42 42 42 42  |BBBBBBBBBBBBBBBB|#{$/}",
+          "00000020  43 43 43 43  43 43 43 43  43 43 43 43  43 43 43 43  |CCCCCCCCCCCCCCCC|#{$/}",
+          "00000030#{$/}"
+        ]
+      end
+
+      it "must group columns together with an extra space" do
+        yielded_lines = []
+
+        subject.each_line(data) do |line|
+          yielded_lines << line
+        end
+
+        expect(yielded_lines).to eq(lines)
+      end
+    end
+
+    context "when #group_chars is set" do
+      let(:group_chars) { 4 }
+
+      subject { described_class.new(group_chars: group_chars) }
+
+      let(:lines) do
+        [
+          "00000000  41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41  |AAAA|AAAA|AAAA|AAAA|#{$/}",
+          "00000010  42 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42  |BBBB|BBBB|BBBB|BBBB|#{$/}",
+          "00000020  43 43 43 43 43 43 43 43 43 43 43 43 43 43 43 43  |CCCC|CCCC|CCCC|CCCC|#{$/}",
+          "00000030#{$/}"
+        ]
+      end
+
+      it "must group the characters into fixed length strings" do
+        yielded_lines = []
+
+        subject.each_line(data) do |line|
+          yielded_lines << line
+        end
+
+        expect(yielded_lines).to eq(lines)
+      end
+    end
+  end
+
+  let(:lines) { subject.each_line(data).to_a }
+
+  describe "#hexdump" do
+    it "must print each line of the hexdump to stdout" do
+      expect {
+        subject.hexdump(data)
+      }.to output(lines.join).to_stdout
+    end
+
+    context "when the output: keyword argument is given" do
+      let(:output) { StringIO.new }
+
+      it "must print each line of hte hexdump to the given output" do
+        subject.hexdump(data, output: output)
+
+        expect(output.string).to eq(lines.join)
+      end
+
+      context "but the output does not support #<<" do
+        let(:output) { Object.new }
+
+        it do
+          expect {
+            subject.hexdump(data, output: output)
+          }.to raise_error(ArgumentError,"output must support the #<< method")
+        end
+      end
+    end
+  end
+
+  describe "#dump" do
+    it "must append each line of the hexdump to the given String" do
+      expect(subject.dump(data)).to eq(lines.join)
+    end
+  end
+end