erlang-etf 1.1.1 → 2.0.0

data/spec/erlang/etf/extensions/array_spec.rb

@@ -1,40 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Erlang::ETF::Extensions::Array do
-  let(:klass) { ::Array }
-
-  describe '[instance]' do
-    let(:instance) { klass.new(*args) }
-
-    describe '__erlang_type__' do
-      subject { instance.__erlang_type__ }
-
-      context 'when empty' do
-        let(:args) {[ ]}
-        it { should eq(:nil) }
-      end
-
-      context 'when not empty' do
-        let(:args) {[ [:a] ]}
-        it { should eq(:list) }
-      end
-    end
-
-    describe '__erlang_evolve__' do
-      subject { instance.__erlang_evolve__ }
-
-      context 'when empty' do
-        let(:args) {[ ]}
-        it { should eq(Erlang::ETF::Nil.new) }
-      end
-
-      context 'when not empty' do
-        let(:args) {[ [:a] ]}
-        it { should eq(Erlang::ETF::List.new([Erlang::ETF::SmallAtom.new("a")])) }
-      end
-    end
-  end
-
-end

data/spec/erlang/etf/extensions/big_decimal_spec.rb

@@ -1,26 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Erlang::ETF::Extensions::BigDecimal do
-  let(:klass) { ::BigDecimal }
-
-  describe '[instance]' do
-    let(:instance) { klass.new(*args) }
-
-    describe '__erlang_type__' do
-      subject { instance.__erlang_type__ }
-
-      let(:args) {[ "1.1" ]}
-      it { should eq(:float) }
-    end
-
-    describe '__erlang_evolve__' do
-      subject { instance.__erlang_evolve__ }
-
-      let(:args) {[ "1.1" ]}
-      it { should eq(Erlang::ETF::Float.new(instance)) }
-    end
-  end
-
-end

data/spec/erlang/etf/extensions/erlang-export_spec.rb

@@ -1,32 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Erlang::ETF::Extensions::ErlangExport do
-  let(:klass) { ::Erlang::Export }
-
-  describe '[instance]' do
-    let(:instance) { klass.new(*args) }
-
-    describe '__erlang_type__' do
-      subject { instance.__erlang_type__ }
-
-      let(:args) {[ :erlang, :now, 0 ]}
-      it { should eq(:export) }
-    end
-
-    describe '__erlang_evolve__' do
-      subject { instance.__erlang_evolve__ }
-
-      let(:args) {[ :erlang, :now, 0 ]}
-      it { should eq(
-        Erlang::ETF::Export.new(
-          Erlang::ETF::SmallAtom.new("erlang"),
-          Erlang::ETF::SmallAtom.new("now"),
-          Erlang::ETF::SmallInteger.new(0)
-        )
-      ) }
-    end
-  end
-
-end

data/spec/erlang/etf/extensions/erlang-list_spec.rb

@@ -1,76 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Erlang::ETF::Extensions::ErlangList do
-  let(:klass) { ::Erlang::List }
-
-  describe '[instance]' do
-    let(:instance) { klass[*elements].tail(tail) }
-
-    describe '__erlang_type__' do
-      subject { instance.__erlang_type__ }
-
-      context 'when empty and proper' do
-        let(:elements) { [] }
-        let(:tail)     { [] }
-
-        it { should eq(:nil) }
-      end
-
-      context 'when empty and improper' do
-        let(:elements) { [] }
-        let(:tail)     { :a }
-
-        it { should eq(:list) }
-      end
-
-      context 'when not empty and proper' do
-        let(:elements) { [:a] }
-        let(:tail)     { [] }
-
-        it { should eq(:list) }
-      end
-
-      context 'when not empty and improper' do
-        let(:elements) { [:a] }
-        let(:tail)     { :a }
-
-        it { should eq(:list) }
-      end
-    end
-
-    describe '__erlang_evolve__' do
-      subject { instance.__erlang_evolve__ }
-
-      context 'when empty and proper' do
-        let(:elements) { [] }
-        let(:tail)     { [] }
-
-        it { should eq(Erlang::ETF::Nil.new) }
-      end
-
-      context 'when empty and improper' do
-        let(:elements) { [] }
-        let(:tail)     { :a }
-
-        it { should eq(Erlang::ETF::List.new([], Erlang::ETF::SmallAtom.new("a"))) }
-      end
-
-      context 'when not empty and proper' do
-        let(:elements) { [:a] }
-        let(:tail)     { [] }
-
-        it { should eq(Erlang::ETF::List.new([Erlang::ETF::SmallAtom.new("a")])) }
-      end
-
-      context 'when not empty and improper' do
-        let(:elements) { [:a] }
-        let(:tail)     { :a }
-
-        it { should eq(Erlang::ETF::List.new([Erlang::ETF::SmallAtom.new("a")], Erlang::ETF::SmallAtom.new("a"))) }
-      end
-    end
-  end
-
-end

data/spec/erlang/etf/extensions/erlang-map_spec.rb

@@ -1,48 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Erlang::ETF::Extensions::ErlangMap do
-  let(:klass) { ::Erlang::Map }
-
-  describe '[instance]' do
-    let(:instance) { klass[keys.zip(values)] }
-
-    describe '__erlang_type__' do
-      subject { instance.__erlang_type__ }
-
-      context 'when empty' do
-        let(:keys)   { [] }
-        let(:values) { [] }
-
-        it { should eq(:map) }
-      end
-
-      context 'when not empty' do
-        let(:keys)   { [:a] }
-        let(:values) { [1] }
-
-        it { should eq(:map) }
-      end
-    end
-
-    describe '__erlang_evolve__' do
-      subject { instance.__erlang_evolve__ }
-
-      context 'when empty' do
-        let(:keys)   { [] }
-        let(:values) { [] }
-
-        it { should eq(Erlang::ETF::Map.new([], [])) }
-      end
-
-      context 'when not empty' do
-        let(:keys)   { [:a] }
-        let(:values) { [1] }
-
-        it { should eq(Erlang::ETF::Map.new([Erlang::ETF::SmallAtom.new("a")], [Erlang::ETF::SmallInteger.new(1)])) }
-      end
-    end
-  end
-
-end

data/spec/erlang/etf/extensions/erlang-nil_spec.rb

@@ -1,24 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Erlang::ETF::Extensions::ErlangNil do
-  let(:klass) { ::Erlang::Nil }
-
-  describe '[instance]' do
-    let(:instance) { klass.new }
-
-    describe '__erlang_type__' do
-      subject { instance.__erlang_type__ }
-
-      it { should eq(:nil) }
-    end
-
-    describe '__erlang_evolve__' do
-      subject { instance.__erlang_evolve__ }
-
-      it { should eq(Erlang::ETF::Nil.new) }
-    end
-  end
-
-end

data/spec/erlang/etf/extensions/erlang-pid_spec.rb

@@ -1,33 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Erlang::ETF::Extensions::ErlangPid do
-  let(:klass) { ::Erlang::Pid }
-
-  describe '[instance]' do
-    let(:instance) { klass.new(*args) }
-
-    describe '__erlang_type__' do
-      subject { instance.__erlang_type__ }
-
-      let(:args) {[ :'nonode@nohost', 100, 10, 1 ]}
-      it { should eq(:pid) }
-    end
-
-    describe '__erlang_evolve__' do
-      subject { instance.__erlang_evolve__ }
-
-      let(:args) {[ :'nonode@nohost', 100, 10, 1 ]}
-      it { should eq(
-        Erlang::ETF::Pid.new(
-          Erlang::ETF::SmallAtom.new("nonode@nohost"),
-          100,
-          10,
-          1
-        )
-      ) }
-    end
-  end
-
-end

data/spec/erlang/etf/extensions/erlang-string_spec.rb

@@ -1,41 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Erlang::ETF::Extensions::ErlangString do
-  let(:klass) { ::Erlang::String }
-
-  describe '[instance]' do
-    let(:instance) { klass.new(*args) }
-
-    describe '__erlang_type__' do
-      subject { instance.__erlang_type__ }
-
-      context 'simple string' do
-        let(:args) {[ "test" ]}
-        it { should eq(:string) }
-      end
-
-      context 'when bytesize larger than 1 << 16' do
-        let(:args) {[ "a" * (1 << 16) ]}
-        it { should eq(:list) }
-      end
-    end
-
-    describe '__erlang_evolve__' do
-      subject { instance.__erlang_evolve__ }
-
-      context 'simple string' do
-        let(:args) {[ "test" ]}
-        it { should eq(Erlang::ETF::String.new("test")) }
-      end
-
-      context 'when bytesize larger than 1 << 16' do
-        let(:args) {[ "a" * (1 << 16) ]}
-        its(:len) { should eq(1 << 16) }
-        it { should be_a(Erlang::ETF::List) }
-      end
-    end
-  end
-
-end

data/spec/erlang/etf/extensions/erlang-tuple_spec.rb

@@ -1,57 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Erlang::ETF::Extensions::ErlangTuple do
-  let(:klass) { ::Erlang::Tuple }
-
-  describe '[instance]' do
-    let(:instance) { klass[*elements] }
-
-    describe '__erlang_type__' do
-      subject { instance.__erlang_type__ }
-
-      context 'when empty' do
-        let(:elements) { [] }
-
-        it { should eq(:small_tuple) }
-      end
-
-      context 'when arity is less than 256' do
-        let(:elements) { [:a] }
-
-        it { should eq(:small_tuple) }
-      end
-
-      context 'when arity is greater than or equal to 256' do
-        let(:elements) { [[]] * 256 }
-
-        it { should eq(:large_tuple) }
-      end
-    end
-
-    describe '__erlang_evolve__' do
-      subject { instance.__erlang_evolve__ }
-
-      context 'when empty' do
-        let(:elements) { [] }
-
-        it { should eq(Erlang::ETF::SmallTuple.new([])) }
-      end
-
-      context 'when arity is less than 256' do
-        let(:elements) { [:a] }
-
-        it { should eq(Erlang::ETF::SmallTuple.new([Erlang::ETF::SmallAtom.new("a")])) }
-      end
-
-      context 'when arity is greater than or equal to 256' do
-        let(:elements) { [[]] * 256 }
-
-        its(:arity) { should eq(256) }
-        it { should be_a(Erlang::ETF::LargeTuple) }
-      end
-    end
-  end
-
-end

data/spec/erlang/etf/extensions/false_class_spec.rb

@@ -1,29 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Erlang::ETF::Extensions::FalseClass do
-  let(:klass) { ::FalseClass }
-
-  describe '[instance]' do
-    let(:instance) { false }
-
-    describe '__erlang_type__' do
-      subject { instance.__erlang_type__ }
-
-      it { should eq(:bert_boolean) }
-    end
-
-    describe '__erlang_evolve__' do
-      subject { instance.__erlang_evolve__ }
-
-      it { should eq(
-        Erlang::ETF::SmallTuple.new([
-          Erlang::ETF::SmallAtom.new("bert"),
-          Erlang::ETF::SmallAtom.new("false")
-        ])
-      ) }
-    end
-  end
-
-end

data/spec/erlang/etf/extensions/float_spec.rb

@@ -1,24 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Erlang::ETF::Extensions::Float do
-  let(:klass) { ::Float }
-
-  describe '[instance]' do
-    let(:instance) { 1.1 }
-
-    describe '__erlang_type__' do
-      subject { instance.__erlang_type__ }
-
-      it { should eq(:new_float) }
-    end
-
-    describe '__erlang_evolve__' do
-      subject { instance.__erlang_evolve__ }
-
-      it { should eq(Erlang::ETF::NewFloat.new(instance)) }
-    end
-  end
-
-end

data/spec/erlang/etf/extensions/hash_spec.rb

@@ -1,90 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Erlang::ETF::Extensions::Hash do
-  let(:klass) { ::Hash }
-
-  describe '[instance]' do
-    let(:instance) { klass[*keyvalues] }
-
-    describe '__erlang_type__' do
-      subject { instance.__erlang_type__ }
-
-      context 'when empty' do
-        let(:keyvalues) { [] }
-
-        it { should eq(:bert_dict) }
-      end
-
-      context 'when arity is less than 256' do
-        let(:keyvalues) { [:a, 1] }
-
-        it { should eq(:bert_dict) }
-      end
-
-      context 'when arity is greater than or equal to 256' do
-        let(:keyvalues) { (1..256).zip([Erlang::Nil.new] * 256).flatten }
-
-        it { should eq(:bert_dict) }
-      end
-    end
-
-    describe '__erlang_evolve__' do
-      subject { instance.__erlang_evolve__ }
-
-      context 'when empty' do
-        let(:keyvalues) { [] }
-
-        it("should eq {:bert, :dict, []}") { should eq(
-          Erlang::ETF::SmallTuple.new([
-            Erlang::ETF::SmallAtom.new("bert"),
-            Erlang::ETF::SmallAtom.new("dict"),
-            Erlang::ETF::Nil.new
-          ])
-        ) }
-      end
-
-      context 'when arity is less than 256' do
-        let(:keyvalues) { [:a, 1] }
-
-        it("should eq {:bert, :dict, [{:a, 1}]}") { should eq(
-          Erlang::ETF::SmallTuple.new([
-            Erlang::ETF::SmallAtom.new("bert"),
-            Erlang::ETF::SmallAtom.new("dict"),
-            Erlang::ETF::List.new([
-              Erlang::ETF::SmallTuple.new([
-                Erlang::ETF::SmallAtom.new("a"),
-                Erlang::ETF::SmallInteger.new(1)
-              ])
-            ])
-          ])
-        ) }
-      end
-
-      context 'when arity is greater than or equal to 256' do
-        let(:keyvalues) { (1..256).zip([Erlang::Nil.new] * 256).flatten }
-
-        let(:elements) {
-          elements = []
-          1.upto(256) do |i|
-            elements << Erlang::ETF::SmallTuple.new([
-              i.__erlang_evolve__,
-              Erlang::ETF::Nil.new
-            ])
-          end
-          elements
-        }
-
-        it("should eq {:bert, :dict, [{1, []}, {2, []}, ..., {256, []}]}") { should eq(
-          Erlang::ETF::SmallTuple.new([
-            Erlang::ETF::SmallAtom.new("bert"),
-            Erlang::ETF::SmallAtom.new("dict"),
-            Erlang::ETF::List.new(elements)
-          ])
-        ) }
-      end
-    end
-  end
-
-end