finitio 0.4.1 → 0.5.0

data/spec/{unit/type → type}/set_type/test_equality.rb

@@ -7,19 +7,19 @@ module Finitio
     let(:type3){ SetType.new(floatType) }
 
     it 'should apply structural equality' do
-      (type == type2).should be_true
+      expect(type == type2).to eq(true)
     end
 
     it 'should apply distinguish different types' do
-      (type == type3).should be_false
+      expect(type == type3).to eq(false)
     end
 
     it 'should be a total function, with false for non types' do
-      (type == 12).should be_false
+      expect(type == 12).to eq(false)
     end
 
     it 'should implement hash accordingly' do
-      (type.hash == type2.hash).should be_true
+      expect(type.hash == type2.hash).to eq(true)
     end
 
   end

data/spec/{unit/type → type}/set_type/test_include.rb

@@ -9,7 +9,7 @@ module Finitio
     context 'when included on empty set' do
       let(:arg){ Set.new }
 
-      it{ should be_true }
+      it{ should eq(true) }
     end
 
     context 'when included on non empty set' do
@@ -19,13 +19,13 @@ module Finitio
         arg << 12
       end
 
-      it{ should be_true }
+      it{ should eq(true) }
     end
 
     context 'when not a set' do
       let(:arg){ [] }
 
-      it{ should be_false }
+      it{ should eq(false) }
     end
 
     context 'when a set with non ints' do
@@ -36,7 +36,7 @@ module Finitio
         arg << "foo"
       end
 
-      it{ should be_false }
+      it{ should eq(false) }
     end
 
   end

data/spec/{unit/type → type}/set_type/test_initialize.rb

@@ -10,7 +10,7 @@ module Finitio
       it{ should be_a(SetType) }
 
       it 'should set the instance variables' do
-        subject.elm_type.should eq(intType)
+        expect(subject.elm_type).to eq(intType)
       end
     end
 
@@ -18,9 +18,9 @@ module Finitio
       subject{ SetType.new("foo") }
 
       it 'should raise an error' do
-        ->{
+        expect{
           subject
-        }.should raise_error(ArgumentError, 'Finitio::Type expected, got `foo`')
+        }.to raise_error(ArgumentError, 'Finitio::Type expected, got `foo`')
       end
     end
 

data/spec/type/struct_type/test_default_name.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+module Finitio
+  describe StructType, "default_name" do
+
+    subject{ StructType.new([intType, floatType]).default_name }
+
+    it{ should eq("<intType, floatType>") }
+
+  end
+end

data/spec/type/struct_type/test_dress.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+module Finitio
+  describe StructType, "dress" do
+
+    let(:type){
+      StructType.new([intType, floatType], "point")
+    }
+
+    subject{ type.dress(arg)  }
+
+    context 'with a valid Array' do
+      let(:arg){
+        [ 12, 14.0 ]
+      }
+
+      it 'should coerce to an array' do
+        expect(subject).to eq(arg)
+      end
+    end
+
+    context 'when raising an error' do
+
+      subject do
+        type.dress(arg) rescue $!
+      end
+
+      context 'with something else than an Array' do
+        let(:arg){
+          "foo"
+        }
+
+        it 'should raise a TypeError' do
+          expect(subject).to be_a(TypeError)
+          expect(subject.message).to eq("Invalid point `foo`")
+        end
+
+        it 'should have no cause' do
+          expect(subject.cause).to be_nil
+        end
+
+        it 'should have an empty location' do
+          expect(subject.location).to eq('')
+        end
+      end
+
+      context 'with a missing component' do
+        let(:arg){
+          [ 12 ]
+        }
+
+        it 'should raise a TypeError' do
+          expect(subject).to be_a(TypeError)
+          expect(subject.message).to eq("Struct size mismatch (1 for 2)")
+        end
+
+        it 'should have no cause' do
+          expect(subject.cause).to be_nil
+        end
+
+        it 'should have an empty location' do
+          expect(subject.location).to eq('')
+        end
+      end
+
+      context 'with an extra attribute' do
+        let(:arg){
+          [ 12, 14.0, "bar" ]
+        }
+
+        it 'should raise a TypeError' do
+          expect(subject).to be_a(TypeError)
+          expect(subject.message).to eq("Struct size mismatch (3 for 2)")
+        end
+
+        it 'should have no cause' do
+          expect(subject.cause).to be_nil
+        end
+
+        it 'should have an empty location' do
+          expect(subject.location).to eq('')
+        end
+      end
+
+      context 'with an invalid attribute' do
+        let(:arg){
+          [ 12, "bar" ]
+        }
+
+        it 'should raise a TypeError' do
+          expect(subject).to be_a(TypeError)
+          expect(subject.message).to eq("Invalid floatType `bar`")
+        end
+
+        it 'should have no cause' do
+          expect(subject.cause).to be_nil
+        end
+
+        it 'should have the correct location' do
+          expect(subject.location).to eq("1")
+        end
+      end
+    end
+
+  end
+end

data/spec/type/struct_type/test_equality.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+module Finitio
+  describe StructType, "equality" do
+
+    let(:type1)  { StructType.new([intType, floatType]) }
+    let(:type2)  { StructType.new([intType, floatType]) }
+    let(:type3)  { StructType.new([floatType, intType]) }
+
+    it 'should apply structural equality' do
+      expect(type1 == type2).to eq(true)
+      expect(type2 == type1).to eq(true)
+    end
+
+    it 'should apply distinguish different types' do
+      expect(type1 == type3).to eq(false)
+      expect(type2 == type3).to eq(false)
+    end
+
+    it 'should be a total function, with nil for non types' do
+      expect(type1 == 12).to eq(false)
+    end
+
+    it 'should implement hash accordingly' do
+      expect([type1, type2].map(&:hash).uniq.size).to eq(1)
+    end
+
+  end
+end

data/spec/type/struct_type/test_include.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+module Finitio
+  describe StructType, "include?" do
+
+    let(:type){ StructType.new([intType, floatType]) }
+
+    subject{ type.include?(arg) }
+
+    context 'when a valid array' do
+      let(:arg){ [12, 14.0] }
+
+      it{ should eq(true) }
+    end
+
+    context 'when not an array' do
+      let(:arg){ "bar" }
+
+      it{ should eq(false) }
+    end
+
+    context 'when an invalid array (too few attributes)' do
+      let(:arg){ [ 12 ] }
+
+      it{ should eq(false) }
+    end
+
+    context 'when an invalid array (too many attributes)' do
+      let(:arg){ [ 12, 14.0, "foo" ] }
+
+      it{ should eq(false) }
+    end
+
+    context 'when an invalid array (wrong type)' do
+      let(:arg){ [ 12, 'bar' ] }
+
+      it{ should eq(false) }
+    end
+
+  end
+end

data/spec/type/struct_type/test_initialize.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+module Finitio
+  describe StructType, "initialize" do
+
+    context 'with valid components' do
+      subject{ StructType.new([intType]) }
+
+      it{ should be_a(StructType) }
+    end
+
+    context 'with invalid components' do
+      subject{ StructType.new("foo") }
+
+      it 'should raise an error' do
+        expect{
+          subject
+        }.to raise_error(ArgumentError, "[Finitio::Type] expected, got `foo`")
+      end
+    end
+
+  end
+end

data/spec/type/struct_type/test_name.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Finitio
+  describe StructType, "name" do
+
+    subject{ type.name }
+
+    context 'when not provided' do
+      let(:type){ StructType.new([intType]) }
+
+      it{ should eq("<intType>") }
+    end
+
+    context 'when provided' do
+      let(:type){ StructType.new([intType], "myStruct") }
+
+      it{ should eq("myStruct") }
+    end
+
+  end
+end

data/spec/{unit/type → type}/sub_type/test_default_name.rb

@@ -2,12 +2,12 @@ require 'spec_helper'
 module Finitio
   describe SubType, "default_name" do
 
-    let(:type){ SubType.new(intType, posint: ->(i){}) }
+    let(:type){ SubType.new(intType, [positive]) }
 
     subject{ type.default_name }
 
     it 'uses the first constraint name' do
-      subject.should eq("Posint")
+      expect(subject).to eq("Positive")
     end
 
   end

data/spec/{unit/type → type}/sub_type/test_dress.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 module Finitio
   describe SubType, "dress" do
 
-    let(:type){ SubType.new(intType, {default: ->(i){ i>0 }, small: ->(i){ i<255 }}, "byte") }
+    let(:type){ SubType.new(intType, [byte_full], "byte") }
 
     subject{ type.dress(arg) }
 
@@ -22,17 +22,17 @@ module Finitio
         let(:arg){ 12.0 }
 
         it 'should raise an Error' do
-          subject.should be_a(TypeError)
-          subject.message.should eq("Invalid value `12.0` for byte")
+          expect(subject).to be_a(TypeError)
+          expect(subject.message).to eq("Invalid byte `12.0`")
         end
 
         it "should have the proper cause from super type's up" do
-          subject.cause.should be_a(TypeError)
-          subject.cause.message.should eq("Invalid value `12.0` for intType")
+          expect(subject.cause).to be_a(TypeError)
+          expect(subject.cause.message).to eq("Invalid intType `12.0`")
         end
 
         it "should have an empty location" do
-          subject.location.should eq('')
+          expect(subject.location).to eq('')
         end
       end
 
@@ -40,16 +40,16 @@ module Finitio
         let(:arg){ -12 }
 
         it 'should raise an Error' do
-          subject.should be_a(TypeError)
-          subject.message.should eq("Invalid value `-12` for byte")
+          expect(subject).to be_a(TypeError)
+          expect(subject.message).to eq("Invalid byte `-12`")
         end
 
         it "should have no cause" do
-          subject.cause.should be_nil
+          expect(subject.cause).to be_nil
         end
 
         it "should have an empty location" do
-          subject.location.should eq('')
+          expect(subject.location).to eq('')
         end
       end
 
@@ -57,16 +57,16 @@ module Finitio
         let(:arg){ 1000 }
 
         it 'should raise an Error' do
-          subject.should be_a(TypeError)
-          subject.message.should eq("Invalid value `1000` for byte (not small)")
+          expect(subject).to be_a(TypeError)
+          expect(subject.message).to eq("Invalid byte `1000`")
         end
 
         it "should have no cause" do
-          subject.cause.should be_nil
+          expect(subject.cause).to be_nil
         end
 
         it "should have an empty location" do
-          subject.location.should eq('')
+          expect(subject.location).to eq('')
         end
       end
     end

data/spec/type/sub_type/test_equality.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+module Finitio
+  describe SubType, "equality" do
+
+    def sub(parent, constraints, name = nil)
+      SubType.new(parent, constraints, name)
+    end
+
+    it 'recognizes same sub types' do
+      s1 = sub(intType, [byte_min])
+      s2 = sub(intType, [byte_min])
+      expect(s1).to eq(s2)
+    end
+
+    it 'does not take name into account' do
+      s1 = sub(intType, [byte_min], 'foo')
+      s2 = sub(intType, [byte_min], 'bar')
+      expect(s1).to eq(s2)
+    end
+
+    it 'recognizes same sub types with multiple constraints' do
+      s1 = sub(intType, [byte_min, byte_max])
+      s2 = sub(intType, [byte_max, byte_min])
+      expect(s1).to eq(s2)
+    end
+
+    it 'distinguishes different sub types' do
+      s1 = sub(intType, [byte_min])
+      s2 = sub(intType, [byte_max])
+      expect(s1).not_to eq(s2)
+    end
+
+    it 'implements hash code accordingly' do
+      s1 = sub(intType, [byte_min])
+      s2 = sub(intType, [byte_min])
+      expect(s1.hash).to eq(s2.hash)
+    end
+
+    it 'is smart enough to have hashes for different sub types' do
+      s1 = sub(intType, [byte_max])
+      s2 = sub(intType, [byte_min])
+      expect(s1.hash).not_to eq(s2.hash)
+    end
+
+  end
+end