auom 0.0.3

data/spec/unit/auom/algebra/add_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe AUOM::Algebra,'#add' do
+  subject { object.add(operand) }
+
+  let(:object) { AUOM::Unit.new(*arguments) }
+
+  context 'when unit is unitless' do
+    let(:arguments) { [1] }
+
+    context 'and operand is a Fixnum' do
+      let(:operand) { 1 }
+
+      it_should_behave_like 'an operation'
+
+      it { should eql(AUOM::Unit.new(2)) }
+    end
+
+    context 'and operand is a unitless unit' do
+      let(:operand) { AUOM::Unit.new(1) }
+
+      it { should eql(AUOM::Unit.new(2)) }
+    end
+
+    context 'and operand is a unitful unit' do
+      let(:operand) { AUOM::Unit.new(1,:meter) }
+
+      it_should_behave_like 'an incompatible operation'
+    end
+  end
+
+  context 'when unit is unitful' do
+    let(:arguments) { [1,:meter] }
+
+    context 'and operand is a Fixnum' do
+      let(:operand) { 1 }
+
+      it_should_behave_like 'an incompatible operation'
+    end
+
+    context 'and operand is a unitless unit' do
+      let(:operand) { AUOM::Unit.new(1) }
+
+      it_should_behave_like 'an incompatible operation'
+    end
+
+    context 'and operand is a incompatible unit' do
+      let(:operand) { AUOM::Unit.new(1,:euro) }
+
+      it_should_behave_like 'an incompatible operation'
+    end
+
+    context 'and operand is a compatible unit' do
+      let(:operand) { AUOM::Unit.new(1,:meter) }
+
+      it { should eql(AUOM::Unit.new(2,:meter)) }
+    end
+  end
+end

data/spec/unit/auom/algebra/divide_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe AUOM::Algebra,'#divide' do
+  subject { object.divide(operand) }
+
+  let(:object) { AUOM::Unit.new(*arguments) }
+
+  context 'with unitless unit' do
+    let(:arguments) { [2] }
+
+    context 'when operand is a fixnum' do
+      let(:operand) { 1 }
+
+      it_should_behave_like 'an operation'
+
+      it { should eql(AUOM::Unit.new(2)) }
+    end
+
+    context 'when operand is a unitless unit' do
+      let(:operand) { AUOM::Unit.new(1) }
+
+      it_should_behave_like 'an operation'
+
+      it { should eql(AUOM::Unit.new(2)) }
+    end
+
+    context 'when operand is a unitful unit' do
+      let(:operand) { AUOM::Unit.new(1,:meter) }
+
+      it_should_behave_like 'an operation'
+
+      it { should eql(AUOM::Unit.new(2,[],:meter)) }
+    end
+  end
+  
+  context 'with unitful unit' do
+    let(:arguments) { [2,:meter] }
+
+    context 'when operand is a fixnum' do
+      let(:operand) { 1 }
+
+      it_should_behave_like 'an operation'
+
+      it { should eql(AUOM::Unit.new(2,:meter)) }
+    end
+
+    context 'when operand is a unitless unit' do
+      let(:operand) { AUOM::Unit.new(1) }
+
+      it_should_behave_like 'an operation'
+
+      it { should eql(AUOM::Unit.new(2,:meter)) }
+    end
+
+    context 'when operand is a unitful unit' do
+
+      context 'and units NOT cancle each other' do
+        let(:operand) { AUOM::Unit.new(1,:euro) }
+
+        it_should_behave_like 'an operation'
+
+        it { should eql(AUOM::Unit.new(2,:meter,:euro)) }
+      end
+
+      context 'and untis cancle each other' do
+        let(:operand) { AUOM::Unit.new(1,:meter) }
+
+        it_should_behave_like 'an operation'
+
+        it { should eql(AUOM::Unit.new(2)) }
+      end
+    end
+  end
+end

data/spec/unit/auom/algebra/multiply_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe AUOM::Algebra,'#multiply' do
+  subject { object.multiply(operand) }
+
+  let(:object) { AUOM::Unit.new(*arguments) }
+
+  context 'with unitless unit' do
+    let(:arguments) { [1] }
+
+    context 'when operand is a fixnum' do
+      let(:operand) { 2 }
+
+      it_should_behave_like 'an operation'
+
+      it { should eql(AUOM::Unit.new(2)) }
+    end
+
+    context 'when operand is a unitless unit' do
+      let(:operand) { AUOM::Unit.new(2) }
+
+      it_should_behave_like 'an operation'
+
+      it { should eql(AUOM::Unit.new(2)) }
+    end
+
+    context 'when operand is a unitful unit' do
+      let(:operand) { AUOM::Unit.new(2,:meter) }
+
+      it_should_behave_like 'an operation'
+
+      it { should eql(AUOM::Unit.new(2,:meter)) }
+    end
+  end
+  
+  context 'with unitful unit' do
+    let(:arguments) { [1,:meter] }
+
+    context 'when operand is a fixnum' do
+      let(:operand) { 2 }
+
+      it_should_behave_like 'an operation'
+
+      it { should eql(AUOM::Unit.new(2,:meter)) }
+    end
+
+    context 'when operand is a unitless unit' do
+      let(:operand) { AUOM::Unit.new(2) }
+
+      it_should_behave_like 'an operation'
+
+      it { should eql(AUOM::Unit.new(2,:meter)) }
+    end
+
+    context 'when operand is a unitful unit' do
+
+      context 'and units NOT cancle each other' do
+        let(:operand) { AUOM::Unit.new(2,:meter) }
+
+        it_should_behave_like 'an operation'
+
+        it { should eql(AUOM::Unit.new(2,[:meter,:meter])) }
+      end
+
+      context 'and units cancle each other' do
+        let(:operand) { AUOM::Unit.new(2,[],:meter) }
+
+        it_should_behave_like 'an operation'
+
+        it { should eql(AUOM::Unit.new(2)) }
+      end
+    end
+  end
+end

data/spec/unit/auom/algebra/substract_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe AUOM::Algebra,'#substract' do
+  subject { object.substract(operand) }
+
+  let(:object) { AUOM::Unit.new(*arguments) }
+
+  context 'when unit is unitless' do
+    let(:arguments) { [1] }
+
+    context 'and operand is a Fixnum' do
+      let(:operand) { 1 }
+
+      it_should_behave_like 'an operation'
+
+      it { should eql(AUOM::Unit.new(0)) }
+    end
+
+    context 'and operand is a unitless unit' do
+      let(:operand) { AUOM::Unit.new(1) }
+
+      it { should eql(AUOM::Unit.new(0)) }
+    end
+
+    context 'and operand is a unitful unit' do
+      let(:operand) { AUOM::Unit.new(1,:meter) }
+
+      it_should_behave_like 'an incompatible operation'
+    end
+  end
+
+  context 'when unit is unitful' do
+    let(:arguments) { [1,:meter] }
+
+    context 'and operand is a Fixnum' do
+      let(:operand) { 1 }
+
+      it_should_behave_like 'an incompatible operation'
+    end
+
+    context 'and operand is a unitless unit' do
+      let(:operand) { AUOM::Unit.new(1) }
+
+      it_should_behave_like 'an incompatible operation'
+    end
+
+    context 'and operand is a incompatible unit' do
+      let(:operand) { AUOM::Unit.new(1,:euro) }
+
+      it_should_behave_like 'an incompatible operation'
+    end
+
+    context 'and operand is a compatible unit' do
+      let(:operand) { AUOM::Unit.new(1,:meter) }
+
+      it { should eql(AUOM::Unit.new(0,:meter)) }
+    end
+  end
+end

data/spec/unit/auom/equalization/eql_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe AUOM::Equalization,'#eql?' do
+  subject { object.eql?(other) }
+
+  let(:object) { AUOM::Unit.new(1,:meter) }
+
+  context 'when is other kind of object' do
+    let(:other) { Object.new }
+
+    it { should be(false) }
+  end
+
+  context 'when is same kind of object' do
+    let(:other) { AUOM::Unit.new(scalar,*unit) }
+
+    let(:scalar) { 1 }
+    let(:unit) { [:meter] }
+
+    context 'and scalar and unit are the same' do
+      it { should be(true) }
+    end
+
+    context 'and scalar is differend' do
+      let(:scalar) { 2 }
+      it { should be(false) }
+    end
+
+    context 'and unit is differend' do
+      let(:unit) { [:euro] }
+      it { should be(false) }
+    end
+
+    context 'and scalar and unit is differend' do
+      let(:scalar) { 2 }
+      let(:unit) { [:euro] }
+      it { should be(false) }
+    end
+  end
+end

data/spec/unit/auom/equalization/equal_value_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe AUOM::Equalization,'#==' do
+  subject { object == other }
+
+  let(:object) { AUOM::Unit.new(1,:meter) }
+
+  context 'when is other kind of object' do
+
+    context 'that cannot be converted' do
+      let(:other) { Object.new }
+
+      it { should be(false) }
+    end
+
+    context 'that can be converted' do
+      let(:other) { 1 }
+
+      context 'and does not have the same values' do
+        it { should be(false) }
+      end
+
+      context 'and does have the same values' do
+        let(:other) { 1 }
+        let(:object) { AUOM::Unit.new(1) }
+        it { should be(true) }
+      end
+    end
+  end
+
+  context 'when is same kind of object' do
+    let(:other) { AUOM::Unit.new(scalar,*unit) }
+
+    let(:scalar) { 1 }
+    let(:unit) { [:meter] }
+
+    context 'and scalar and unit are the same' do
+      it { should be(true) }
+    end
+
+    context 'and scalar is differend' do
+      let(:scalar) { 2 }
+      it { should be(false) }
+    end
+
+    context 'and unit is differend' do
+      let(:unit) { [:euro] }
+      it { should be(false) }
+    end
+
+    context 'and scalar and unit is differend' do
+      let(:scalar) { 2 }
+      let(:unit) { [:euro] }
+      it { should be(false) }
+    end
+  end
+end

data/spec/unit/auom/equalization/hash_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe AUOM::Equalization, '#hash' do
+  subject { object.hash }
+
+  let(:object) { AUOM::Unit.new(1) }
+
+  it { should be_a(Fixnum) }
+
+  it_should_behave_like 'an idempotent method'
+
+  it { should be(Rational(1).hash ^ [[],[]].hash) }
+end

data/spec/unit/auom/inspection/class_methods/prettify_unit_part_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe AUOM::Inspection,'.prettify_unit_part' do
+  subject { object.prettify_unit_part(part) }
+
+  let(:object) { AUOM::Inspection }
+
+  context 'with simple part' do
+    let(:part) { [:meter] }
+    it { should eql('meter') }
+  end
+
+  context 'with mixed part' do
+    let(:part) { [:meter,:euro] }
+    it { should eql('euro*meter') }
+  end
+
+  context 'with complex part' do
+    let(:part) { [:meter,:meter,:euro] }
+    it { should eql('meter^2*euro') }
+  end
+
+  context 'with very complex part' do
+    let(:part) { [:meter,:meter,:euro,:euro,:kilogramm] }
+    it { should eql('euro^2*meter^2*kilogramm') }
+  end
+end

data/spec/unit/auom/inspection/inspect_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe AUOM::Inspection,'#inspect' do
+  subject { object.inspect }
+
+  let(:object) { AUOM::Unit.new(scalar,*unit) }
+  let(:unit) { [] }
+
+  context 'when scalar is exact in decimal' do
+    let(:scalar) { 1 }
+
+    it { should eql("<AUOM::Unit @scalar=1>") }
+  end
+
+  context 'when scalar is NOT exact in decimal' do
+    let(:scalar) { Rational(1,3) }
+
+    it { should eql("<AUOM::Unit @scalar=~0.3333>") }
+  end
+
+  context 'when has only numerator' do
+    let(:scalar) { Rational(1,3) }
+    let(:unit) { [:meter] }
+
+    it { should eql("<AUOM::Unit @scalar=~0.3333 meter>") }
+  end
+
+  context 'when has only denominator' do
+    let(:scalar) { Rational(1,3) }
+    let(:unit) { [[],:meter] }
+
+    it { should eql("<AUOM::Unit @scalar=~0.3333 1/meter>") }
+  end
+
+  context 'when has numerator and denominator' do
+    let(:scalar) { Rational(1,3) }
+    let(:unit) { [:euro,:meter] }
+
+    it { should eql("<AUOM::Unit @scalar=~0.3333 euro/meter>") }
+  end
+end