erlang-etf 1.1.1 → 2.0.0

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

@@ -1,259 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Erlang::ETF::Extensions::Integer do
-  let(:klass) { ::Integer }
-
-  let(:small_integer_min) { Erlang::ETF::Extensions::Integer::UINT8_MIN }
-  let(:small_integer_max) { Erlang::ETF::Extensions::Integer::UINT8_MAX }
-  let(:integer_min)       { Erlang::ETF::Extensions::Integer::INT32_MIN }
-  let(:integer_max)       { Erlang::ETF::Extensions::Integer::INT32_MAX }
-  let(:small_big_min)     { (-1 << (255 * 8)) + 1 }
-  let(:small_big_max)     { (+1 << (255 * 8)) - 1 }
-
-  describe '[instance]' do
-    describe '__erlang_type__' do
-      subject { instance.__erlang_type__ }
-
-      context "when between #{Erlang::ETF::Extensions::Integer::UINT8_MIN} and #{Erlang::ETF::Extensions::Integer::UINT8_MAX}" do
-        let(:min) { small_integer_min }
-        let(:max) { small_integer_max }
-
-        let(:current)  { :small_integer }
-        let(:positive) { :integer }
-        let(:negative) { :integer }
-
-        context 'minimum' do
-          let(:instance) { min }
-          it { should eq(current) }
-        end
-
-        context 'minimum + 1' do
-          let(:instance) { min + 1 }
-          it { should eq(current) }
-        end
-
-        context 'minimum - 1' do
-          let(:instance) { min - 1 }
-          it { should eq(negative) }
-        end
-
-        context 'maximum' do
-          let(:instance) { max }
-          it { should eq(current) }
-        end
-
-        context 'maximum + 1' do
-          let(:instance) { max + 1 }
-          it { should eq(positive) }
-        end
-
-        context 'maximum - 1' do
-          let(:instance) { max - 1 }
-          it { should eq(current) }
-        end
-      end
-
-      context "when between #{Erlang::ETF::Extensions::Integer::INT32_MIN} and #{Erlang::ETF::Extensions::Integer::INT32_MAX}" do
-        let(:min) { integer_min }
-        let(:max) { integer_max }
-
-        let(:current)  { :integer }
-        let(:positive) { :small_big }
-        let(:negative) { :small_big }
-
-        context 'minimum' do
-          let(:instance) { min }
-          it { should eq(current) }
-        end
-
-        context 'minimum + 1' do
-          let(:instance) { min + 1 }
-          it { should eq(current) }
-        end
-
-        context 'minimum - 1' do
-          let(:instance) { min - 1 }
-          it { should eq(negative) }
-        end
-
-        context 'maximum' do
-          let(:instance) { max }
-          it { should eq(current) }
-        end
-
-        context 'maximum + 1' do
-          let(:instance) { max + 1 }
-          it { should eq(positive) }
-        end
-
-        context 'maximum - 1' do
-          let(:instance) { max - 1 }
-          it { should eq(current) }
-        end
-      end
-
-      context "when between ((-1 << (255 * 8)) + 1) and ((+1 << (255 * 8)) - 1)" do
-        let(:min) { small_big_min }
-        let(:max) { small_big_max }
-
-        let(:current)  { :small_big }
-        let(:positive) { :large_big }
-        let(:negative) { :large_big }
-
-        context 'minimum' do
-          let(:instance) { min }
-          it { should eq(current) }
-        end
-
-        context 'minimum + 1' do
-          let(:instance) { min + 1 }
-          it { should eq(current) }
-        end
-
-        context 'minimum - 1' do
-          let(:instance) { min - 1 }
-          it { should eq(negative) }
-        end
-
-        context 'maximum' do
-          let(:instance) { max }
-          it { should eq(current) }
-        end
-
-        context 'maximum + 1' do
-          let(:instance) { max + 1 }
-          it { should eq(positive) }
-        end
-
-        context 'maximum - 1' do
-          let(:instance) { max - 1 }
-          it { should eq(current) }
-        end
-      end
-    end
-
-    describe '__erlang_evolve__' do
-      subject { instance.__erlang_evolve__ }
-
-      context "when >= #{Erlang::ETF::Extensions::Integer::UINT8_MIN} and <= #{Erlang::ETF::Extensions::Integer::UINT8_MAX}" do
-        let(:min) { small_integer_min }
-        let(:max) { small_integer_max }
-
-        let(:current)  { Erlang::ETF::SmallInteger.new(instance) }
-        let(:positive) { Erlang::ETF::Integer.new(instance) }
-        let(:negative) { Erlang::ETF::Integer.new(instance) }
-
-        context 'minimum' do
-          let(:instance) { min }
-          it { should eq(current) }
-        end
-
-        context 'minimum + 1' do
-          let(:instance) { min + 1 }
-          it { should eq(current) }
-        end
-
-        context 'minimum - 1' do
-          let(:instance) { min - 1 }
-          it { should eq(negative) }
-        end
-
-        context 'maximum' do
-          let(:instance) { max }
-          it { should eq(current) }
-        end
-
-        context 'maximum + 1' do
-          let(:instance) { max + 1 }
-          it { should eq(positive) }
-        end
-
-        context 'maximum - 1' do
-          let(:instance) { max - 1 }
-          it { should eq(current) }
-        end
-      end
-
-      context "when between #{Erlang::ETF::Extensions::Integer::INT32_MIN} and #{Erlang::ETF::Extensions::Integer::INT32_MAX}" do
-        let(:min) { integer_min }
-        let(:max) { integer_max }
-
-        let(:current)  { Erlang::ETF::Integer.new(instance) }
-        let(:positive) { Erlang::ETF::SmallBig.new(instance) }
-        let(:negative) { Erlang::ETF::SmallBig.new(instance) }
-
-        context 'minimum' do
-          let(:instance) { min }
-          it { should eq(current) }
-        end
-
-        context 'minimum + 1' do
-          let(:instance) { min + 1 }
-          it { should eq(current) }
-        end
-
-        context 'minimum - 1' do
-          let(:instance) { min - 1 }
-          it { should eq(negative) }
-        end
-
-        context 'maximum' do
-          let(:instance) { max }
-          it { should eq(current) }
-        end
-
-        context 'maximum + 1' do
-          let(:instance) { max + 1 }
-          it { should eq(positive) }
-        end
-
-        context 'maximum - 1' do
-          let(:instance) { max - 1 }
-          it { should eq(current) }
-        end
-      end
-
-      context "when between ((-1 << (255 * 8)) + 1) and ((+1 << (255 * 8)) - 1)" do
-        let(:min) { small_big_min }
-        let(:max) { small_big_max }
-
-        let(:current)  { Erlang::ETF::SmallBig.new(instance) }
-        let(:positive) { Erlang::ETF::LargeBig.new(instance) }
-        let(:negative) { Erlang::ETF::LargeBig.new(instance) }
-
-        context 'minimum' do
-          let(:instance) { min }
-          it { should eq(current) }
-        end
-
-        context 'minimum + 1' do
-          let(:instance) { min + 1 }
-          it { should eq(current) }
-        end
-
-        context 'minimum - 1' do
-          let(:instance) { min - 1 }
-          it { should eq(negative) }
-        end
-
-        context 'maximum' do
-          let(:instance) { max }
-          it { should eq(current) }
-        end
-
-        context 'maximum + 1' do
-          let(:instance) { max + 1 }
-          it { should eq(positive) }
-        end
-
-        context 'maximum - 1' do
-          let(:instance) { max - 1 }
-          it { should eq(current) }
-        end
-      end
-    end
-  end
-
-end

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

@@ -1,29 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Erlang::ETF::Extensions::NilClass do
-  let(:klass) { ::NilClass }
-
-  describe '[instance]' do
-    let(:instance) { nil }
-
-    describe '__erlang_type__' do
-      subject { instance.__erlang_type__ }
-
-      it { should eq(:bert_nil) }
-    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("nil")
-        ])
-      ) }
-    end
-  end
-
-end

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

@@ -1,30 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Erlang::ETF::Extensions::Object do
-  let(:klass) { ::Object }
-
-  describe '[instance]' do
-    let(:instance) { klass.new }
-
-    describe '__erlang_type__' do
-      subject { -> { instance.__erlang_type__ } }
-
-      it { should raise_error(NotImplementedError) }
-    end
-
-    describe '__erlang_evolve__' do
-      subject { -> { instance.__erlang_evolve__ } }
-
-      it { should raise_error(NotImplementedError) }
-    end
-
-    describe '__erlang_dump__' do
-      subject { -> { instance.__erlang_dump__("") } }
-
-      it { should raise_error(NotImplementedError) }
-    end
-  end
-
-end

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

@@ -1,35 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Erlang::ETF::Extensions::Regexp do
-  let(:klass) { ::Regexp }
-
-  describe '[instance]' do
-    let(:instance) { /./imx }
-
-    describe '__erlang_type__' do
-      subject { instance.__erlang_type__ }
-
-      it { should eq(:bert_regex) }
-    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("regex"),
-          Erlang::ETF::Binary.new("."),
-          Erlang::ETF::List.new([
-            Erlang::ETF::SmallAtom.new("caseless"),
-            Erlang::ETF::SmallAtom.new("extended"),
-            Erlang::ETF::SmallAtom.new("multiline")
-          ])
-        ])
-      ) }
-    end
-  end
-
-end

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

@@ -1,43 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Erlang::ETF::Extensions::String do
-  let(:klass) { ::String }
-
-  describe '[instance]' do
-    let(:instance) { "test" }
-
-    describe '__erlang_type__' do
-      subject { instance.__erlang_type__ }
-
-      it { should eq(:binary) }
-    end
-
-    describe '__erlang_evolve__' do
-      subject { instance.__erlang_evolve__ }
-
-      it { should eq(Erlang::ETF::Binary.new(instance)) }
-    end
-
-    describe 'to_utf8_binary' do
-      it "converts \"Ω\" to \"\\xCE\\xA9\"" do
-        expect("Ω".to_utf8_binary).to eq("\xCE\xA9".force_encoding('BINARY'))
-      end
-
-      it "handles EncodingError" do
-        string = "Ωomega"
-        string.should_receive(:encode).with(Erlang::ETF::Extensions::UTF8_ENCODING).and_raise(EncodingError)
-
-        expect(string.to_utf8_binary).to eq("\xCE\xA9omega".force_encoding('BINARY'))
-      end
-    end
-
-    describe 'from_utf8_binary' do
-      it "converts \"\\xCE\\xA9\" to \"Ω\"" do
-        expect("\xCE\xA9".force_encoding('BINARY').from_utf8_binary).to eq("Ω")
-      end
-    end
-  end
-
-end

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

@@ -1,64 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Erlang::ETF::Extensions::Symbol do
-  let(:klass) { ::Symbol }
-
-  describe '[instance]' do
-    describe '__erlang_type__' do
-      subject { instance.__erlang_type__ }
-
-      context 'when bytesize is < 256' do
-        let(:instance) { :a }
-        it { should eq(:small_atom) }
-
-        context 'when it contains UTF-8 characters' do
-          let(:instance) { :'Ω' }
-          it { should eq(:small_atom_utf8) }
-        end
-      end
-
-      context 'when bytesize is >= 256' do
-        let(:instance) { ("a" * 256).intern }
-        it { should eq(:atom) }
-
-        context 'when it contains UTF-8 characters' do
-          let(:instance) { ("Ω" * 256).intern }
-          it { should eq(:atom_utf8) }
-        end
-      end
-    end
-
-    describe '__erlang_evolve__' do
-      subject { instance.__erlang_evolve__ }
-
-      context 'when bytesize is < 256' do
-        let(:instance) { :a }
-        it { should eq(Erlang::ETF::SmallAtom.new(instance.to_s)) }
-
-        context 'when it contains UTF-8 characters' do
-          let(:instance) { :'Ω' }
-          it { should eq(Erlang::ETF::SmallAtomUTF8.new(instance.to_s)) }
-        end
-      end
-
-      context 'when bytesize is >= 256' do
-        let(:instance) { ("a" * 256).intern }
-        it { should eq(Erlang::ETF::Atom.new(instance.to_s)) }
-
-        context 'when it contains UTF-8 characters' do
-          let(:instance) { ("Ω" * 256).intern }
-          it { should eq(Erlang::ETF::AtomUTF8.new(instance.to_s)) }
-        end
-      end
-    end
-
-    describe 'to_utf8_binary' do
-      it "converts :Ω to \"\\xCE\\xA9\"" do
-        expect(:'Ω'.to_utf8_binary).to eq("\xCE\xA9".force_encoding('BINARY'))
-      end
-    end
-  end
-
-end