erlang-etf 1.0.0

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

@@ -0,0 +1,259 @@
+# 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

@@ -0,0 +1,29 @@
+# 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

@@ -0,0 +1,30 @@
+# 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

@@ -0,0 +1,35 @@
+# 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

@@ -0,0 +1,43 @@
+# 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

@@ -0,0 +1,64 @@
+# 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