hexdump 0.3.0 → 1.0.0

data/spec/hexdump_module_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'hexdump'
+
+describe Hexdump do
+  let(:data)    { ("A" * 32) + ("B" * 32) + ("C" * 32) }
+  let(:hexdump) { Hexdump::Hexdump.new.dump(data) }
+
+  describe ".hexdump" do
+    it "must write the hexdump lines of the given data to the output" do
+      expect {
+        subject.hexdump(data)
+      }.to output(hexdump).to_stdout
+    end
+  end
+
+  describe ".dump" do
+    it "must write the hexdump lines of the given data to the output" do
+      expect {
+        subject.dump(data)
+      }.to output(hexdump).to_stdout
+    end
+  end
+end

data/spec/mixin_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'hexdump/mixin'
+
+describe Hexdump::Mixin do
+  class TestMixin
+
+    include Hexdump::Mixin
+
+    def initialize(data)
+      @data = data
+    end
+
+    def each_byte(&block)
+      @data.each_byte(&block)
+    end
+
+  end
+
+  let(:data)    { ("A" * 32) + ("B" * 32) + ("C" * 32) }
+  let(:hexdump) { Hexdump::Hexdump.new.dump(data) }
+
+  subject { TestMixin.new(data) }
+
+  describe "#hexdump" do
+    it "must write the hexdump lines of the object to $stdout" do
+      expect {
+        subject.hexdump
+      }.to output(hexdump).to_stdout
+    end
+  end
+
+  describe "#to_hexdump" do
+    it "must return the hexdump lines of the object" do
+      expect(subject.to_hexdump).to eq(hexdump)
+    end
+  end
+end

data/spec/numeric/binary_spec.rb

@@ -0,0 +1,239 @@
+require 'spec_helper'
+require 'hexdump/numeric/binary'
+require 'hexdump/type'
+
+describe Hexdump::Numeric::Binary do
+  describe "#initialize" do
+    subject { described_class.new(type) }
+
+    context "when given a Type::Int type" do
+      context "and size is 1" do
+        let(:type) { Hexdump::Type::Int8.new }
+
+        it "must set #width to 8 + 1" do
+          expect(subject.width).to eq(8 + 1)
+        end
+      end
+
+      context "and size is 2" do
+        let(:type) { Hexdump::Type::Int16.new }
+
+        it "must set #width to 16 + 1" do
+          expect(subject.width).to eq(16 + 1)
+        end
+      end
+
+      context "and size is 4" do
+        let(:type) { Hexdump::Type::Int32.new }
+
+        it "must set #width to 32 + 1" do
+          expect(subject.width).to eq(32 + 1)
+        end
+      end
+
+      context "and size is 8" do
+        let(:type) { Hexdump::Type::Int64.new }
+
+        it "must set #width to 64 + 1" do
+          expect(subject.width).to eq(64 + 1)
+        end
+      end
+
+      context "but the type has an unsupported size" do
+        class UnsupportedIntType < Hexdump::Type::Int
+
+          def initialize
+            super(size: 3)
+          end
+
+        end
+
+        let(:type) { UnsupportedIntType.new }
+
+        it do
+          expect { described_class.new(type) }.to raise_error(NotImplementedError)
+        end
+      end
+    end
+
+    context "when given a Type::UInt type" do
+      context "and size is 1" do
+        let(:type) { Hexdump::Type::UInt8.new }
+
+        it "must set #width to 8" do
+          expect(subject.width).to eq(8)
+        end
+      end
+
+      context "and size is 2" do
+        let(:type) { Hexdump::Type::UInt16.new }
+
+        it "must set #width to 16" do
+          expect(subject.width).to eq(16)
+        end
+      end
+
+      context "and size is 4" do
+        let(:type) { Hexdump::Type::UInt32.new }
+
+        it "must set #width to 32" do
+          expect(subject.width).to eq(32)
+        end
+      end
+
+      context "and size is 8" do
+        let(:type) { Hexdump::Type::UInt64.new }
+
+        it "must set #width to 64" do
+          expect(subject.width).to eq(64)
+        end
+      end
+
+      context "but the type has an unsupported size" do
+        class UnsupportedUIntType < Hexdump::Type::UInt
+
+          def initialize
+            super(size: 3)
+          end
+
+        end
+
+        let(:type) { UnsupportedUIntType.new }
+
+        it do
+          expect { described_class.new(type) }.to raise_error(NotImplementedError)
+        end
+      end
+    end
+
+    context "when given a Type::Float type" do
+      let(:type) { Hexdump::Type::Float32.new }
+
+      it do
+        expect {
+          described_class.new(type)
+        }.to raise_error(Hexdump::Numeric::IncompatibleTypeError,"cannot format floating-point numbers in binary")
+      end
+    end
+
+    context "when given a non-Type object" do
+      let(:type) { Object.new }
+
+      it do
+        expect { described_class.new(type) }.to raise_error(TypeError)
+      end
+    end
+  end
+
+  describe "#%" do
+    subject { described_class.new(type) }
+
+    context "when the given type has size 1" do
+      let(:type) { Hexdump::Type::UInt8.new }
+
+      let(:value) { 0xf }
+      let(:binary) { '00001111' }
+
+      it "must return a binary string of length 8" do
+        expect(subject % value).to eq(binary)
+      end
+
+      context "and is signed" do
+        let(:type) { Hexdump::Type::Int8.new }
+
+        context "and the value is positive" do
+          it "must return a binary string of length 8 prefixed with a ' '" do
+            expect(subject % value).to eq(" #{binary}")
+          end
+        end
+
+        context "and the value is negative" do
+          it "must return a binary string of length 8 prefixed with a '-'" do
+            expect(subject % -value).to eq("-#{binary}")
+          end
+        end
+      end
+    end
+
+    context "when the given type has size 2" do
+      let(:type) { Hexdump::Type::UInt16.new }
+
+      let(:value) { 0xff }
+      let(:binary) { '0000000011111111' }
+
+      it "must return a binary string of length 16" do
+        expect(subject % value).to eq(binary)
+      end
+
+      context "and is signed" do
+        let(:type) { Hexdump::Type::Int16.new }
+
+        context "and the value is positive" do
+          it "must return a binary string of length 16 prefixed with a ' '" do
+            expect(subject % value).to eq(" #{binary}")
+          end
+        end
+
+        context "and the value is negative" do
+          it "must return a binary string of length 16 prefixed with a '-'" do
+            expect(subject % -value).to eq("-#{binary}")
+          end
+        end
+      end
+    end
+
+    context "when the given type has size 4" do
+      let(:type) { Hexdump::Type::UInt32.new }
+
+      let(:value) { 0xffff }
+      let(:binary) { '00000000000000001111111111111111' }
+
+      it "must return a binary string of length 32" do
+        expect(subject % value).to eq(binary)
+      end
+
+      context "and is signed" do
+        let(:type) { Hexdump::Type::Int32.new }
+
+        context "and the value is positive" do
+          it "must return a binary string of length 32 prefixed with a ' '" do
+            expect(subject % value).to eq(" #{binary}")
+          end
+        end
+
+        context "and the value is negative" do
+          it "must return a binary string of length 32 prefixed with a '-'" do
+            expect(subject % -value).to eq("-#{binary}")
+          end
+        end
+      end
+    end
+
+    context "when the given type has size 8" do
+      let(:type) { Hexdump::Type::UInt64.new }
+
+      let(:value)  { 0xffffffff }
+      let(:binary) { '0000000000000000000000000000000011111111111111111111111111111111' }
+
+      it "must return a binary string of length 64" do
+        expect(subject % value).to eq(binary)
+      end
+
+      context "and is signed" do
+        let(:type) { Hexdump::Type::Int64.new }
+
+        context "and the value is positive" do
+          it "must return a binary string of length 64 prefixed with a ' '" do
+            expect(subject % value).to eq(" #{binary}")
+          end
+        end
+
+        context "and the value is negative" do
+          it "must return a binary string of length 64 prefixed with a '-'" do
+            expect(subject % -value).to eq("-#{binary}")
+          end
+        end
+      end
+    end
+  end
+end

data/spec/numeric/char_or_int_spec.rb

@@ -0,0 +1,210 @@
+require 'spec_helper'
+require 'hexdump/numeric/char_or_int'
+require 'hexdump/numeric/hexadecimal'
+require 'hexdump/type'
+
+describe Hexdump::Numeric::CharOrInt do
+  let(:type) { Hexdump::Type::UInt8.new }
+  let(:base) { Hexdump::Numeric::Hexadecimal.new(type) }
+
+  subject { described_class.new(base) }
+
+  describe "#initialize" do
+    it "must set #base" do
+      expect(subject.base).to eq(base)
+    end
+
+    it "must default #encoding to nil" do
+      expect(subject.encoding).to be(nil)
+    end
+
+    it "must initialize the format string" do
+      expect(subject.to_s).to eq("%#{base.width}s")
+    end
+
+    context "when given an encoding" do
+      let(:encoding) { Encoding::UTF_8 }
+
+      subject { described_class.new(base,encoding) }
+
+      it "must set #encoding" do
+        expect(subject.encoding).to eq(encoding)
+      end
+    end
+  end
+
+  describe "#width" do
+    it "return the base's #width" do
+      expect(subject.width).to eq(base.width)
+    end
+  end
+
+  describe "#%" do
+    (0x20..0x7e).each do |byte|
+      context "when given #{byte.to_s(16)}" do
+        it "must return ' #{byte.chr}'" do
+          expect(subject % byte).to eq(" #{byte.chr}")
+        end
+      end
+    end
+
+    context "when given 0x00" do
+      it "must return '\\0'" do
+        expect(subject % 0x00).to eq("\\0")
+      end
+    end
+
+    context "when given 0x07" do
+      it "must return '\\a'" do
+        expect(subject % 0x07).to eq("\\a")
+      end
+    end
+
+    context "when given 0x08" do
+      it "must return '\\b'" do
+        expect(subject % 0x08).to eq("\\b")
+      end
+    end
+
+    context "when given 0x09" do
+      it "must return '\\t'" do
+        expect(subject % 0x09).to eq("\\t")
+      end
+    end
+
+    context "when given 0x0a" do
+      it "must return '\\n'" do
+        expect(subject % 0x0a).to eq("\\n")
+      end
+    end
+
+    context "when given 0x0b" do
+      it "must return '\\v'" do
+        expect(subject % 0x0b).to eq("\\v")
+      end
+    end
+
+    context "when given 0x0c" do
+      it "must return '\\f'" do
+        expect(subject % 0x0c).to eq("\\f")
+      end
+    end
+
+    context "when given 0x0d" do
+      it "must return '\\r'" do
+        expect(subject % 0x0d).to eq("\\r")
+      end
+    end
+
+    context "when given a byte that does not map to a printable character" do
+      it "must return the formatted byte" do
+        expect(subject % 0xff).to eq("ff")
+      end
+    end
+
+    context "when the numeric base has a width > 2" do
+      let(:type) { Hexdump::Type::UInt16.new }
+      let(:width) { base.width }
+
+      it "must left-pad printable characters with width-1 additional spaces" do
+        left_pad = ' ' * (width - 1)
+
+        expect(subject % 0x41).to eq("#{left_pad}A")
+      end
+
+      it "must left-pad escaped characters with width-2 additional spaces" do
+        left_pad = ' ' * (width - 2)
+
+        expect(subject % 0x00).to eq("#{left_pad}\\0")
+      end
+
+      it "must not left-pad numerically formatted values with spaces" do
+        expect(subject % 0xff).to eq("00ff")
+      end
+    end
+
+    context "when initialized with an encoding" do
+      let(:encoding) { Encoding::UTF_8 }
+
+      subject { described_class.new(base,encoding) }
+
+      context "when given 0x00" do
+        it "must return '\\0'" do
+          expect(subject % 0x00).to eq("\\0")
+        end
+      end
+
+      context "when given 0x07" do
+        it "must return '\\a'" do
+          expect(subject % 0x07).to eq("\\a")
+        end
+      end
+
+      context "when given 0x08" do
+        it "must return '\\b'" do
+          expect(subject % 0x08).to eq("\\b")
+        end
+      end
+
+      context "when given 0x09" do
+        it "must return '\\t'" do
+          expect(subject % 0x09).to eq("\\t")
+        end
+      end
+
+      context "when given 0x0a" do
+        it "must return '\\n'" do
+          expect(subject % 0x0a).to eq("\\n")
+        end
+      end
+
+      context "when given 0x0b" do
+        it "must return '\\v'" do
+          expect(subject % 0x0b).to eq("\\v")
+        end
+      end
+
+      context "when given 0x0c" do
+        it "must return '\\f'" do
+          expect(subject % 0x0c).to eq("\\f")
+        end
+      end
+
+      context "when given 0x0d" do
+        it "must return '\\r'" do
+          expect(subject % 0x0d).to eq("\\r")
+        end
+      end
+
+      context "when given a byte that does map to a printable character" do
+        it "must return the formatted character" do
+          expect(subject % 0x2603).to eq(" ☃")
+        end
+      end
+
+      context "when given a byte that does not map to a printable character" do
+        let(:byte) { 888 }
+
+        it "must return the numeric formatted value" do
+          expect(subject % byte).to eq(base % byte)
+        end
+      end
+
+      context "when given a byte that does not map any character" do
+        let(:byte) { 0xd800 }
+
+        it "must return the numeric formatted value" do
+          expect(subject % byte).to eq(base % byte)
+        end
+      end
+
+      context "when given a negative value" do
+        let(:byte) { -1 }
+
+        it "must return the numeric formatted value" do
+          expect(subject % byte).to eq(base % byte)
+        end
+      end
+    end
+  end
+end