bindata 1.5.1 → 1.6.0

data/spec/count_bytes_remaining_spec.rb

@@ -1,38 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_common"))
-require 'bindata/count_bytes_remaining'
-
-describe BinData::CountBytesRemaining do
-  it { should == 0 }
-  its(:num_bytes) { should be_zero }
-
-  it "counts till end of stream" do
-    data = "abcdefghij"
-    subject.read(data).should == 10
-  end
-
-  it "does not read any data" do
-    io = StringIO.new "abcdefghij"
-    subject.read(io)
-
-    io.pos.should == 0
-  end
-
-  it "does not write any data" do
-    subject.to_binary_s.should == ""
-  end
-
-  it "allows setting value for completeness" do
-    subject.assign("123")
-    subject.should == "123"
-    subject.to_binary_s.should == ""
-  end
-
-  it "accepts BinData::BasePrimitive parameters" do
-    count = BinData::CountBytesRemaining.new(:check_value => 2)
-    expect {
-      count.read("xyz")
-    }.to raise_error(BinData::ValidityError)
-  end
-end

data/spec/example.rb

@@ -1,21 +0,0 @@
-require 'bindata/base_primitive'
-
-class ExampleSingle < BinData::BasePrimitive
-  def self.io_with_value(val)
-    BinData::IO.new([val].pack("V"))
-  end
-
-  private
-
-  def value_to_binary_string(val)
-    [val].pack("V")
-  end
-
-  def read_and_return_value(io)
-    io.readbytes(4).unpack("V").at(0)
-  end
-
-  def sensible_default
-    0
-  end
-end

data/spec/float_spec.rb

@@ -1,37 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_common"))
-require 'bindata/float'
-
-describe "A FloatLe" do
-  subject { BinData::FloatLe.new(Math::PI) }
-
-  its(:num_bytes)               { should == 4 }
-  its(:to_binary_s)             { should == [Math::PI].pack('e') }
-  its(:value_read_from_written) { should be_within(0.000001).of(Math::PI) }
-end
-
-describe "A FloatBe" do
-  subject { BinData::FloatBe.new(Math::PI) }
-
-  its(:num_bytes)               { should == 4 }
-  its(:to_binary_s)             { should == [Math::PI].pack('g') }
-  its(:value_read_from_written) { should be_within(0.000001).of(Math::PI) }
-end
-
-describe "A DoubleLe" do
-  subject { BinData::DoubleLe.new(Math::PI) }
-
-  its(:num_bytes)               { should == 8 }
-  its(:to_binary_s)             { should == [Math::PI].pack('E') }
-  its(:value_read_from_written) { should be_within(0.0000000000000001).of(Math::PI) }
-end
-
-
-describe "A DoubleBe" do
-  subject { BinData::DoubleBe.new(Math::PI) }
-
-  its(:num_bytes)               { should == 8 }
-  its(:to_binary_s)             { should == [Math::PI].pack('G') }
-  its(:value_read_from_written) { should be_within(0.0000000000000001).of(Math::PI) }
-end

data/spec/registry_spec.rb

@@ -1,108 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_common"))
-require 'bindata/bits'
-require 'bindata/int'
-require 'bindata/float'
-require 'bindata/registry'
-
-describe BinData::Registry do
-  A = Class.new
-  B = Class.new
-  C = Class.new
-  D = Class.new
-
-  let(:r) { BinData::Registry.new }
-
-  it "lookups registered names" do
-    r.register('ASubClass', A)
-    r.register('AnotherSubClass', B)
-
-    r.lookup('ASubClass').should == A
-    r.lookup('a_sub_class').should == A
-    r.lookup('AnotherSubClass').should == B
-    r.lookup('another_sub_class').should == B
-  end
-
-  it "does not lookup unregistered names" do
-    expect {
-      r.lookup('a_non_existent_sub_class')
-    }.to raise_error(BinData::UnRegisteredTypeError)
-  end
-
-  it "unregisters names" do
-    r.register('ASubClass', A)
-    r.unregister('ASubClass')
-
-    expect {
-      r.lookup('ASubClass')
-    }.to raise_error(BinData::UnRegisteredTypeError)
-  end
-
-  it "allows overriding of registered classes" do
-    r.register('A', A)
-    r.register('A', B)
-
-    r.lookup('a').should == B
-  end
-
-  it "converts CamelCase to underscores" do
-    r.underscore_name('CamelCase').should == 'camel_case'
-  end
-
-  it "converts adjacent caps camelCase to underscores" do
-    r.underscore_name('XYZCamelCase').should == 'xyz_camel_case'
-  end
-
-  it "ignores the outer nestings of classes" do
-    r.underscore_name('A::B::C').should == 'c'
-  end
-end
-
-describe BinData::Registry, "with numerics" do
-  let(:r) { BinData::RegisteredClasses }
-
-  it "lookup integers with endian" do
-    r.lookup("int24", :big).to_s.should == "BinData::Int24be"
-    r.lookup("int24", :little).to_s.should == "BinData::Int24le"
-    r.lookup("uint24", :big).to_s.should == "BinData::Uint24be"
-    r.lookup("uint24", :little).to_s.should == "BinData::Uint24le"
-  end
-
-  it "does not lookup integers without endian" do
-    expect {
-      r.lookup("int24")
-    }.to raise_error(BinData::UnRegisteredTypeError)
-  end
-
-  it "does not lookup non byte based integers" do
-    expect {
-      r.lookup("int3")
-    }.to raise_error(BinData::UnRegisteredTypeError)
-    expect {
-      r.lookup("int3", :big)
-    }.to raise_error(BinData::UnRegisteredTypeError)
-    expect {
-      r.lookup("int3", :little)
-    }.to raise_error(BinData::UnRegisteredTypeError)
-  end
-
-  it "lookup floats with endian" do
-    r.lookup("float", :big).to_s.should == "BinData::FloatBe"
-    r.lookup("float", :little).to_s.should == "BinData::FloatLe"
-    r.lookup("double", :big).to_s.should == "BinData::DoubleBe"
-    r.lookup("double", :little).to_s.should == "BinData::DoubleLe"
-  end
-
-  it "lookup bits" do
-    r.lookup("bit5").to_s.should == "BinData::Bit5"
-    r.lookup("bit6le").to_s.should == "BinData::Bit6le"
-  end
-
-  it "lookup bits by ignoring endian" do
-    r.lookup("bit2", :big).to_s.should == "BinData::Bit2"
-    r.lookup("bit3le", :big).to_s.should == "BinData::Bit3le"
-    r.lookup("bit2", :little).to_s.should == "BinData::Bit2"
-    r.lookup("bit3le", :little).to_s.should == "BinData::Bit3le"
-  end
-end

data/spec/rest_spec.rb

@@ -1,26 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_common"))
-require 'bindata/rest'
-
-describe BinData::Rest do
-  it { should == "" }
-
-  it "reads till end of stream" do
-    data = "abcdefghij"
-    subject.read(data).should == data
-  end
-
-  it "allows setting value for completeness" do
-    subject.assign("123")
-    subject.should == "123"
-    subject.to_binary_s.should == "123"
-  end
-
-  it "accepts BinData::BasePrimitive parameters" do
-    rest = BinData::Rest.new(:check_value => "abc")
-    expect {
-      rest.read("xyz")
-    }.to raise_error(BinData::ValidityError)
-  end
-end

data/spec/skip_spec.rb

@@ -1,27 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_common"))
-require 'bindata/skip'
-
-describe BinData::Skip do
-  subject { BinData::Skip.new(:length => 5) }
-  let(:io) { StringIO.new("abcdefghij") }
-
-  it { should == "" }
-  its(:to_binary_s) { should == "\000" * 5 }
-
-  it "skips bytes" do
-    subject.read(io)
-    io.pos.should == 5
-  end
-
-  it "has expected binary representation after setting value" do
-    subject.assign("123")
-    subject.to_binary_s.should == "\000" * 5
-  end
-
-  it "has expected binary representation after reading" do
-    subject.read(io)
-    subject.to_binary_s.should == "\000" * 5
-  end
-end

data/spec/stringz_spec.rb

@@ -1,118 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_common"))
-require 'bindata/stringz'
-
-describe BinData::Stringz, "when empty" do
-  its(:value) { should == "" }
-  its(:num_bytes) { should == 1 }
-  its(:to_binary_s) { should == "\0" }
-end
-
-describe BinData::Stringz, "with value set" do
-  subject { BinData::Stringz.new("abcd") }
-
-  its(:value) { should == "abcd" }
-  its(:num_bytes) { should == 5 }
-  its(:to_binary_s) { should == "abcd\0" }
-end
-
-describe BinData::Stringz, "when reading" do
-  it "stops at the first zero byte" do
-    io = StringIO.new("abcd\0xyz\0")
-    subject.read(io)
-    io.pos.should == 5
-    subject.should == "abcd"
-  end
-
-  it "handles a zero length string" do
-    io = StringIO.new("\0abcd")
-    subject.read(io)
-    io.pos.should == 1
-    subject.should == ""
-  end
-
-  it "fails if no zero byte is found" do
-    expect {subject.read("abcd") }.to raise_error(EOFError)
-  end
-end
-
-describe BinData::Stringz, "when setting the value" do
-  it "includes the zero byte in num_bytes total" do
-    subject.assign("abcd")
-    subject.num_bytes.should == 5
-  end
-
-  it "accepts empty strings" do
-    subject.assign("")
-    subject.should == ""
-  end
-
-  it "accepts strings that aren't zero terminated" do
-    subject.assign("abcd")
-    subject.should == "abcd"
-  end
-
-  it "accepts strings that are zero terminated" do
-    subject.assign("abcd\0")
-    subject.should == "abcd"
-  end
-
-  it "accepts up to the first zero byte" do
-    subject.assign("abcd\0xyz\0")
-    subject.should == "abcd"
-  end
-end
-
-describe BinData::Stringz, "with max_length" do
-  subject { BinData::Stringz.new(:max_length => 5) }
-
-  it "reads less than max_length" do
-    io = StringIO.new("abc\0xyz")
-    subject.read(io)
-    subject.should == "abc"
-  end
-
-  it "reads exactly max_length" do
-    io = StringIO.new("abcd\0xyz")
-    subject.read(io)
-    subject.should == "abcd"
-  end
-
-  it "reads no more than max_length" do
-    io = StringIO.new("abcdefg\0xyz")
-    subject.read(io)
-    io.pos.should == 5
-    subject.should == "abcd"
-  end
-
-  it "accepts values less than max_length" do
-    subject.assign("abc")
-    subject.should == "abc"
-  end
-
-  it "accepts values exactly max_length" do
-    subject.assign("abcd")
-    subject.should == "abcd"
-  end
-
-  it "trims values greater than max_length" do
-    subject.assign("abcde")
-    subject.should == "abcd"
-  end
-
-  it "writes values greater than max_length" do
-    subject.assign("abcde")
-    subject.to_binary_s.should == "abcd\0"
-  end
-
-  it "writes values less than max_length" do
-    subject.assign("abc")
-    subject.to_binary_s.should == "abc\0"
-  end
-
-  it "writes values exactly max_length" do
-    subject.assign("abcd")
-    subject.to_binary_s.should == "abcd\0"
-  end
-end

data/tasks/rspec.rake

@@ -1,17 +0,0 @@
-begin
-  require 'rspec'
-  require 'rspec/core/rake_task'
-
-  RSpec::Core::RakeTask.new("spec") do |t|
-#    t.ruby_opts = "-w"
-    t.rcov = false
-    t.pattern = 'spec/**/*_spec.rb' #.exclude("spec/deprecated_spec.rb", "spec/wrapper_spec.rb")
-  end
-
-  RSpec::Core::RakeTask.new("rcov") do |t|
-    t.ruby_opts = "-w"
-    t.rcov = true
-  end
-rescue LoadError
-  puts "Rspec must be installed to run tests"
-end