erlang-etf 1.1.1 → 2.0.0

data/spec/erlang/etf/atom_spec.rb

@@ -1,90 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Erlang::ETF::Atom do
-  let(:term_class) { Erlang::ETF::Atom }
-
-  describe '[class]' do
-    describe 'deserialize' do
-      let(:buffer) { StringIO.new(bytes.pack('C*')) }
-      subject { term_class.deserialize(buffer) }
-
-      context "ASCII bytes" do
-        let(:bytes) { [0, 4, 116, 101, 115, 116] }
-
-        its(:len)       { should eq(4) }
-        its(:atom_name) { should eq("test") }
-      end
-
-      context "UTF-8 bytes" do
-        let(:bytes) { [0, 2, 206, 169] }
-
-        its(:len)       { should eq(2) }
-        its(:atom_name) { should eq("Ω") }
-      end
-    end
-
-    describe 'new' do
-      subject { term_class.new(atom_name) }
-
-      context "ASCII" do
-        let(:atom_name) { "test" }
-
-        its(:atom_name) { should eq(atom_name) }
-      end
-
-      context "UTF-8" do
-        let(:atom_name) { "Ω" }
-
-        its(:atom_name) { should eq(atom_name) }
-      end
-    end
-  end
-
-  describe '[instance]' do
-    let(:term) { term_class.new(atom_name) }
-
-    describe 'serialize' do
-      subject { term.serialize }
-
-      context "ASCII" do
-        let(:atom_name) { "test" } 
-        let(:bytes)     { [100, 0, 4, 116, 101, 115, 116].pack('C*') }
-
-        it { should eq(bytes) }
-      end
-
-      context "UTF-8" do
-        let(:atom_name) { "Ω" } 
-        let(:bytes)     { [100, 0, 2, 206, 169].pack('C*') }
-
-        it { should eq(bytes) }
-      end
-    end
-
-    describe '__erlang_type__' do
-      subject { term.__erlang_type__ }
-
-      let(:atom_name) { "test" }
-      it { should eq(:atom) }
-    end
-
-    describe '__ruby_evolve__' do
-      subject { term.__ruby_evolve__ }
-
-      context "ASCII" do
-        let(:atom_name) { "test" }
-
-        it { should eq(:test) }
-      end
-
-      context "UTF-8" do
-        let(:atom_name) { "Ω" }
-
-        it { should eq(:'Ω') }
-      end
-    end
-  end
-
-end

data/spec/erlang/etf/atom_utf8_spec.rb

@@ -1,90 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Erlang::ETF::AtomUTF8 do
-  let(:term_class) { Erlang::ETF::AtomUTF8 }
-
-  describe '[class]' do
-    describe 'deserialize' do
-      let(:buffer) { StringIO.new(bytes.pack('C*')) }
-      subject { term_class.deserialize(buffer) }
-
-      context "ASCII bytes" do
-        let(:bytes) { [0, 4, 116, 101, 115, 116] }
-
-        its(:len)       { should eq(4) }
-        its(:atom_name) { should eq("test") }
-      end
-
-      context "UTF-8 bytes" do
-        let(:bytes) { [0, 2, 206, 169] }
-
-        its(:len)       { should eq(2) }
-        its(:atom_name) { should eq("Ω") }
-      end
-    end
-
-    describe 'new' do
-      subject { term_class.new(atom_name) }
-
-      context "ASCII" do
-        let(:atom_name) { "test" }
-
-        its(:atom_name) { should eq(atom_name) }
-      end
-
-      context "UTF-8" do
-        let(:atom_name) { "Ω" }
-
-        its(:atom_name) { should eq(atom_name) }
-      end
-    end
-  end
-
-  describe '[instance]' do
-    let(:term) { term_class.new(atom_name) }
-
-    describe 'serialize' do
-      subject { term.serialize }
-
-      context "ASCII" do
-        let(:atom_name) { "test" } 
-        let(:bytes)     { [118, 0, 4, 116, 101, 115, 116].pack('C*') }
-
-        it { should eq(bytes) }
-      end
-
-      context "UTF-8" do
-        let(:atom_name) { "Ω" } 
-        let(:bytes)     { [118, 0, 2, 206, 169].pack('C*') }
-
-        it { should eq(bytes) }
-      end
-    end
-
-    describe '__erlang_type__' do
-      subject { term.__erlang_type__ }
-
-      let(:atom_name) { "Ω" }
-      it { should eq(:atom_utf8) }
-    end
-
-    describe '__ruby_evolve__' do
-      subject { term.__ruby_evolve__ }
-
-      context "ASCII" do
-        let(:atom_name) { "test" }
-
-        it { should eq(:test) }
-      end
-
-      context "UTF-8" do
-        let(:atom_name) { "Ω" }
-
-        it { should eq(:'Ω') }
-      end
-    end
-  end
-
-end

data/spec/erlang/etf/binary_spec.rb

@@ -1,90 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Erlang::ETF::Binary do
-  let(:term_class) { Erlang::ETF::Binary }
-
-  describe '[class]' do
-    describe 'deserialize' do
-      let(:buffer) { StringIO.new(bytes.pack('C*')) }
-      subject { term_class.deserialize(buffer) }
-
-      context "ASCII bytes" do
-        let(:bytes) { [0, 0, 0, 4, 116, 101, 115, 116] }
-
-        its(:len)  { should eq(4) }
-        its(:data) { should eq("test") }
-      end
-
-      context "UTF-8 bytes" do
-        let(:bytes) { [0, 0, 0, 2, 206, 169] }
-
-        its(:len)  { should eq(2) }
-        its(:data) { should eq("Ω") }
-      end
-    end
-
-    describe 'new' do
-      subject { term_class.new(data) }
-
-      context "ASCII" do
-        let(:data) { "test" }
-
-        its(:data) { should eq(data) }
-      end
-
-      context "UTF-8" do
-        let(:data) { "Ω" }
-
-        its(:data) { should eq(data) }
-      end
-    end
-  end
-
-  describe '[instance]' do
-    let(:term) { term_class.new(data) }
-
-    describe 'serialize' do
-      subject { term.serialize }
-
-      context "ASCII" do
-        let(:data)  { "test" } 
-        let(:bytes) { [109, 0, 0, 0, 4, 116, 101, 115, 116].pack('C*') }
-
-        it { should eq(bytes) }
-      end
-
-      context "UTF-8" do
-        let(:data)  { "Ω" } 
-        let(:bytes) { [109, 0, 0, 0, 2, 206, 169].pack('C*') }
-
-        it { should eq(bytes) }
-      end
-    end
-
-    describe '__erlang_type__' do
-      subject { term.__erlang_type__ }
-
-      let(:data) { "test" }
-      it { should eq(:binary) }
-    end
-
-    describe '__ruby_evolve__' do
-      subject { term.__ruby_evolve__ }
-
-      context "ASCII" do
-        let(:data) { "test" }
-
-        it { should eq("test") }
-      end
-
-      context "UTF-8" do
-        let(:data) { "Ω" }
-
-        it { should eq("Ω") }
-      end
-    end
-  end
-
-end

data/spec/erlang/etf/bit_binary_spec.rb

@@ -1,99 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Erlang::ETF::BitBinary do
-  let(:term_class) { Erlang::ETF::BitBinary }
-
-  describe '[class]' do
-    describe 'deserialize' do
-      let(:buffer) { StringIO.new(bytes.pack('C*')) }
-      subject { term_class.deserialize(buffer) }
-
-      context "ASCII bytes" do
-        let(:bytes) { [0, 0, 0, 5, 1, 116, 101, 115, 116, 128] }
-
-        its(:len)  { should eq(5) }
-        its(:bits) { should eq(1) }
-        its(:data) { should eq("test\x80") }
-      end
-
-      context "UTF-8 bytes" do
-        let(:bytes) { [0, 0, 0, 3, 1, 206, 169, 128] }
-
-        its(:len)  { should eq(3) }
-        its(:bits) { should eq(1) }
-        its(:data) { should eq("Ω\x80") }
-      end
-    end
-
-    describe 'new' do
-      subject { term_class.new(bits, data) }
-
-      context "ASCII" do
-        let(:bits) { 1 }
-        let(:data) { "test\x80" }
-
-        its(:data) { should eq(data) }
-      end
-
-      context "UTF-8" do
-        let(:bits) { 1 }
-        let(:data) { "Ω\x80" }
-
-        its(:data) { should eq(data) }
-      end
-    end
-  end
-
-  describe '[instance]' do
-    let(:term) { term_class.new(bits, data) }
-
-    describe 'serialize' do
-      subject { term.serialize }
-
-      context "ASCII" do
-        let(:bits)  { 1 }
-        let(:data)  { "test\x80" } 
-        let(:bytes) { [77, 0, 0, 0, 5, 1, 116, 101, 115, 116, 128].pack('C*') }
-
-        it { should eq(bytes) }
-      end
-
-      context "UTF-8" do
-        let(:bits)  { 1 }
-        let(:data)  { "Ω\x80" } 
-        let(:bytes) { [77, 0, 0, 0, 3, 1, 206, 169, 128].pack('C*') }
-
-        it { should eq(bytes) }
-      end
-    end
-
-    describe '__erlang_type__' do
-      subject { term.__erlang_type__ }
-
-      let(:bits) { 1 }
-      let(:data) { "test\x80" }
-      it { should eq(:bit_binary) }
-    end
-
-    describe '__ruby_evolve__' do
-      subject { term.__ruby_evolve__ }
-
-      context "ASCII" do
-        let(:bits) { 1 }
-        let(:data) { "test\x80" }
-
-        it { should eq(term) }
-      end
-
-      context "UTF-8" do
-        let(:bits) { 1 }
-        let(:data) { "Ω\x80" }
-
-        it { should eq(term) }
-      end
-    end
-  end
-
-end

data/spec/erlang/etf/compressed_spec.rb

@@ -1,37 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Erlang::ETF::Compressed do
-  let(:term_class) { Erlang::ETF::Compressed }
-
-  describe '[class]' do
-    describe 'deserialize' do
-      let(:buffer) { StringIO.new(bytes.pack('C*')) }
-      subject { term_class.deserialize(buffer) }
-
-      context "valid zlib bytes" do
-        let(:bytes) { [0, 0, 0, 18, 120, 218, 203, 102, 224, 103, 68, 5, 0, 9, 0, 0, 138] }
-
-        its(:uncompressed_size) { should eq(18) }
-        its(:data)              { should eq(::Erlang::ETF::String.new(([1] * 15).pack('C*').from_utf8_binary).tap { |s| s.len = 15 }) }
-        its(:__ruby_evolve__)   { should eq(::Erlang::String.new(([1] * 15).pack('C*').from_utf8_binary)) }
-      end
-
-      context "invalid zlib bytes" do
-        subject { -> { term_class.deserialize(buffer) } }
-        let(:bytes) { [0, 0, 0, 18, 120, 218, 203, 102, 224, 103, 68, 5, 0, 9, 0, 0] }
-
-        it { should raise_error(::Zlib::BufError) }
-      end
-
-      context "valid zlib bytes, invalid uncompressed size" do
-        subject { -> { term_class.deserialize(buffer) } }
-        let(:bytes) { [0, 0, 0, 17, 120, 218, 203, 102, 224, 103, 68, 5, 0, 9, 0, 0, 138] }
-
-        it { should raise_error(::Zlib::DataError) }
-      end
-    end
-  end
-
-end

data/spec/erlang/etf/export_spec.rb

@@ -1,58 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Erlang::ETF::Export do
-  let(:term_class) { Erlang::ETF::Export }
-
-  let(:mod)      { Erlang::ETF::Atom.new("erlang").tap(&:serialize) }
-  let(:function) { Erlang::ETF::Atom.new("now").tap(&:serialize) }
-  let(:arity)    { Erlang::ETF::SmallInteger.new(0).tap(&:serialize) }
-
-  describe '[class]' do
-    describe 'deserialize' do
-      let(:buffer) { StringIO.new(bytes.pack('C*')) }
-      subject { term_class.deserialize(buffer) }
-
-      let(:bytes) { [100, 0, 6, 101, 114, 108, 97, 110, 103, 100, 0, 3, 110, 111, 119, 97, 0] }
-
-      its(:mod)      { should eq(mod) }
-      its(:function) { should eq(function) }
-      its(:arity)    { should eq(arity) }
-    end
-
-    describe 'new' do
-      subject { term_class.new(mod, function, arity) }
-
-      its(:mod)      { should eq(mod) }
-      its(:function) { should eq(function) }
-      its(:arity)    { should eq(arity) }
-    end
-  end
-
-  describe '[instance]' do
-    let(:term) { term_class.new(mod, function, arity) }
-
-    describe 'serialize' do
-      subject { term.serialize }
-
-      let(:bytes) { [113, 100, 0, 6, 101, 114, 108, 97, 110, 103, 100, 0, 3, 110, 111, 119, 97, 0].pack('C*') }
-
-      it { should eq(bytes) }
-    end
-
-    describe '__erlang_type__' do
-      subject { term.__erlang_type__ }
-
-      it { should eq(:export) }
-    end
-
-    describe '__ruby_evolve__' do
-      let(:ruby_obj) { ::Erlang::Export.new(:erlang, :now, 0) }
-      subject { term.__ruby_evolve__ }
-
-      it { should eq(ruby_obj) }
-    end
-  end
-
-end