basic101 0.1.0

data/test/spec/argument_checker_spec.rb

@@ -0,0 +1,128 @@
+require_relative 'spec_helper'
+
+module Basic101
+
+  describe ArgumentChecker do
+
+    subject {described_class.new(args, required_types, optional_types)}
+
+    context 'when takes [string]' do
+
+      let(:required_types) {[BasicString]}
+      let(:optional_types) {[]}
+
+      context 'when given [string]' do
+        let(:args) {[BasicString.new('')]}
+        specify do
+          expect{subject.check}.to_not raise_error
+        end
+      end
+
+      context 'when given []' do
+        let(:args) {[]}
+        specify do
+         expect do
+            subject.check
+         end.to raise_error InvalidArgumentError,
+          'Wrong number of arguments (0 instead of 1)'
+        end
+      end
+
+      context 'when given [string, string]' do
+        let(:args) {[BasicString.new(''), BasicString.new('')]}
+        specify do
+         expect do
+            subject.check
+         end.to raise_error InvalidArgumentError,
+          'Wrong number of arguments (2 instead of 1)'
+        end
+      end
+
+      context 'when given [integer]' do
+        let(:args) {[BasicInteger.new('')]}
+        specify do
+          expect do
+            subject.check
+          end.to raise_error InvalidArgumentError,
+          'Expected string but got integer'
+        end
+      end
+
+    end
+
+    context 'when takes [integer, integer?]' do
+
+      let(:required_types) {[BasicInteger]}
+      let(:optional_types) {[BasicInteger]}
+
+      context 'when given [integer]' do
+        let(:args) {[BasicInteger.new(0)]}
+        specify do
+         expect do
+            subject.check
+         end.to_not raise_error
+        end
+      end
+
+      context 'when given [integer, integer]' do
+        let(:args) {[BasicInteger.new(0), BasicInteger.new(0)]}
+        specify do
+          expect{subject.check}.to_not raise_error
+        end
+      end
+
+      context 'when given []' do
+        let(:args) {[]}
+        specify do
+         expect do
+            subject.check
+         end.to raise_error InvalidArgumentError,
+          'Wrong number of arguments (0 instead of 1..2)'
+        end
+      end
+
+      context 'when given [integer, integer, integer]' do
+        let(:args) {3.times.map {BasicInteger.new(0)}}
+        specify do
+         expect do
+            subject.check
+         end.to raise_error InvalidArgumentError,
+          'Wrong number of arguments (3 instead of 1..2)'
+        end
+      end
+
+      context 'when given [integer]' do
+        let(:args) {[BasicString.new('')]}
+        specify do
+          expect do
+            subject.check
+          end.to raise_error InvalidArgumentError,
+          'Expected integer but got string'
+        end
+      end
+
+      context 'when given [integer, string]' do
+        let(:args) {[BasicString.new('')]}
+        specify do
+          expect do
+            subject.check
+          end.to raise_error InvalidArgumentError,
+          'Expected integer but got string'
+        end
+      end
+
+      context 'when given [string, string]' do
+        let(:args) {[BasicString.new('')]}
+        specify do
+          expect do
+            subject.check
+          end.to raise_error InvalidArgumentError,
+          'Expected integer but got string'
+        end
+      end
+
+    end
+
+  end
+
+end

data/test/spec/basic_array_spec.rb

@@ -0,0 +1,100 @@
+require_relative 'spec_helper'
+
+module Basic101
+
+  describe BasicArray do
+
+    let(:default) {BasicInteger.new(0)}
+    subject {BasicArray.new(num_dimensions, default)}
+
+    describe 'default dimensions' do
+
+      context 'when 1 dimension' do
+        let(:num_dimensions) {1}
+        it 'should set each element to the default' do
+          expect(subject.get([0])).to eq default
+          expect(subject.get([10])).to eq default
+        end
+      end
+
+      context 'when 2 dimensions' do
+        let(:num_dimensions) {2}
+        it 'should set each element to the default' do
+          expect(subject.get([0, 0])).to eq default
+          expect(subject.get([0, 10])).to eq default
+          expect(subject.get([10, 0])).to eq default
+          expect(subject.get([10, 10])).to eq default
+        end
+      end
+
+    end
+
+    describe '#dimension' do
+
+      context 'when normal' do
+        let(:num_dimensions) {2}
+        before(:each) {subject.dimension([2, 3])} 
+        it 'should set each element to the default' do
+          expect(subject.get([0, 0])).to eq default
+          expect(subject.get([0, 3])).to eq default
+          expect(subject.get([2, 0])).to eq default
+          expect(subject.get([2, 3])).to eq default
+        end
+      end
+
+      context 'max index 0' do
+        let(:num_dimensions) {1}
+        before(:each) {subject.dimension([0])} 
+        specify do
+          expect(subject.get([0])).to eq default
+        end
+      end
+
+      context 'negative max index' do
+        let(:num_dimensions) {1}
+        specify do
+          expect{subject.dimension([-1])}.to raise_error ArraySizeError
+        end
+      end
+
+    end
+
+    describe '#set' do
+      let(:num_dimensions) {2}
+      before(:each) do
+        subject.dimension([1, 1])
+        subject.set([0, 0], BasicInteger.new(1))
+        subject.set([0, 1], BasicInteger.new(2))
+        subject.set([1, 0], BasicInteger.new(3))
+        subject.set([1, 1], BasicInteger.new(4))
+      end
+      specify {expect(subject.get([0, 0])).to eq BasicInteger.new(1)}
+      specify {expect(subject.get([0, 1])).to eq BasicInteger.new(2)}
+      specify {expect(subject.get([1, 0])).to eq BasicInteger.new(3)}
+      specify {expect(subject.get([1, 1])).to eq BasicInteger.new(4)}
+    end
+
+    describe 'bounds checking' do
+
+      let(:num_dimensions) {2}
+
+      it 'should reject negative indices' do
+        expect{subject.get([0, -1])}.to raise_error IndexError
+      end
+
+      it 'should reject too few indices' do
+        expect{subject.get([0])}.to raise_error IndexError
+      end
+
+      it 'should reject too many indices' do
+        expect{subject.get([0, 0, 0])}.to raise_error IndexError
+      end
+
+      it 'should reject too large an index' do
+        expect{subject.get([0, 11])}.to raise_error IndexError
+      end
+    end
+
+  end
+
+end

data/test/spec/basic_float_spec.rb

@@ -0,0 +1,168 @@
+require_relative 'spec_helper'
+
+module Basic101
+
+  describe BasicFloat do
+
+    it_should_behave_like 'a basic numeric'
+
+    describe '#simplest' do
+
+      context 'when no fractional part' do
+        it 'should return a basic integer' do
+          a = described_class.new(12.0)
+          b = a.simplest
+          b.should eq BasicInteger.new(12)
+        end
+      end
+
+      context 'when fractional part' do
+        it 'should return itself' do
+          a = described_class.new(12.34)
+          b = a.simplest
+          b.should eq a
+        end
+      end
+
+    end
+
+    describe 'type_name' do
+      let(:type_name) {'float'}
+      subject {described_class.new(0)}
+      specify {expect(subject.class.type_name).to eq type_name}
+      specify {expect(subject.type_name).to eq type_name}
+    end
+
+    describe '.from_s' do
+
+      context 'when fixed-point' do
+        specify do
+          a = '1.2'
+          b = described_class.from_s(a)
+          expect(b.value).to eq 1.2
+        end
+      end
+
+      context 'when exponential' do
+        specify do
+          a = '-1.2E-2'
+          b = described_class.from_s(a)
+          expect(b.value).to eq -1.2E-2
+        end
+      end
+
+      context 'when no leading digits' do
+        specify do
+          a = '.2'
+          b = described_class.from_s(a)
+          expect(b.value).to eq 0.2
+        end
+      end
+
+      context 'when no trailing digits' do
+        specify do
+          a = '2.'
+          b = described_class.from_s(a)
+          expect(b.value).to eq 2.0
+        end
+      end
+
+    end
+
+    describe '#to_integer' do
+      specify do
+        a = described_class.new(2.6)
+        expect(a.to_integer).to eq BasicInteger.new(2)
+      end
+    end
+
+    describe '#to_float' do
+      specify do
+        a = described_class.new(2.6)
+        expect(a.to_float).to eq a
+      end
+    end
+
+    describe '#to_string' do
+      specify do
+        a = described_class.new(2.6)
+        expect{a.to_string}.to raise_error TypeError
+      end
+    end
+
+    describe '#and' do
+      specify do
+        a = described_class.new(0b1100)
+        b = BasicInteger.new(0b0110)
+        c = a.and(b)
+        expect(c).to eq BasicInteger.new(0b0100)
+      end
+    end
+
+    describe '#or' do
+      specify do
+        a = described_class.new(0b1100)
+        b = BasicInteger.new(0b0110)
+        c = a.or(b)
+        expect(c).to eq BasicInteger.new(0b1110)
+      end
+    end
+
+    describe '#not' do
+      specify do
+        a = described_class.new(10)
+        b = a.not
+          expect(b).to eq BasicInteger.new(-11)
+      end
+    end
+
+    describe '#floor' do
+      specify do
+        a = described_class.new(-1.5)
+        b = a.floor
+        expect(b).to eq BasicInteger.new(-2.0)
+      end
+    end
+
+    describe '#abs' do
+
+      it 'should turn negative into positive' do
+        a = described_class.new(-1.5)
+        b = a.abs
+        expect(b).to eq described_class.new(1.5)
+      end
+
+      it 'should leave positive alone' do
+        a = described_class.new(1.5)
+        b = a.abs
+        expect(b).to eq described_class.new(1.5)
+      end
+
+    end
+
+    describe '#sqr' do
+      specify do
+        a = described_class.new(2)
+        b = a.sqr
+        expect(b).to eq described_class.new(2 ** 0.5)
+      end
+    end
+
+    describe '#exp' do
+      specify do
+        a = described_class.new(1.5)
+        b = a.exp
+        expect(b).to eq described_class.new(Math::E ** 1.5)
+      end
+    end
+ 
+   describe '#str' do
+      specify do
+        a = described_class.new(-12.34)
+        expect(a.str).to eq BasicString.new('-12.34')
+      end
+    end
+
+  end
+
+end

data/test/spec/basic_integer_spec.rb

@@ -0,0 +1,270 @@
+require_relative 'spec_helper'
+
+module Basic101
+
+  describe BasicInteger do
+
+    it_should_behave_like 'a basic numeric'
+
+    describe '#simplest' do
+      it 'should return itself' do
+        a = BasicInteger.new(1)
+        b = a.simplest
+        expect(b).to eq a
+      end
+    end
+
+    describe '.from_bool' do
+
+      it 'should convert true to basic -1' do
+        a = BasicInteger.from_bool(true)
+        expect(a).to eq BasicInteger.new(-1)
+      end
+
+      it 'should convert false to basic 0' do
+        a = BasicInteger.from_bool(false)
+        expect(a).to eq BasicInteger.new(0)
+      end
+
+    end
+
+    describe 'type_name' do
+      let(:type_name) {'integer'}
+      subject {described_class.new(0)}
+      specify {expect(subject.class.type_name).to eq type_name}
+      specify {expect(subject.type_name).to eq type_name}
+    end
+ 
+   describe '#str' do
+      specify do
+        a = BasicInteger.new(-12)
+        expect(a.str).to eq BasicString.new('-12')
+      end
+    end
+
+    describe '#to_integer' do
+      specify do
+        a = BasicInteger.new(1)
+        expect(a.to_integer).to eq a
+      end
+    end
+
+    describe '#to_float' do
+      specify do
+        a = BasicInteger.new(1)
+        expect(a.to_float).to eq BasicFloat.new(1)
+      end
+    end
+
+    describe '#to_string' do
+      specify do
+        a = BasicInteger.new(1)
+        expect {a.to_string}.to raise_error TypeError
+      end
+    end
+
+    describe '#and' do
+
+      context 'when 0, 0' do
+        specify do
+          a = BasicInteger.new(0)
+          b = BasicInteger.new(0)
+          c = a.and(b)
+          expect(c).to eq BasicInteger.new(0)
+        end
+      end
+
+      context 'when 0, -1' do
+        specify do
+          a = BasicInteger.new(0)
+          b = BasicInteger.new(-1)
+          c = a.and(b)
+          expect(c).to eq BasicInteger.new(0)
+        end
+      end
+
+      context 'when -1, 0' do
+        specify do
+          a = BasicInteger.new(-1)
+          b = BasicInteger.new(0)
+          c = a.and(b)
+          expect(c).to eq BasicInteger.new(0)
+        end
+      end
+
+      context 'when -1, -1' do
+        specify do
+          a = BasicInteger.new(-1)
+          b = BasicInteger.new(-1)
+          c = a.and(b)
+          expect(c).to eq BasicInteger.new(-1)
+        end
+      end
+
+      context 'when bitwise' do
+        specify do
+          a = BasicInteger.new(0b1100)
+          b = BasicInteger.new(0b0110)
+          c = a.and(b)
+          expect(c).to eq BasicInteger.new(0b0100)
+        end
+      end
+
+      context 'when float' do
+        specify do
+          a = BasicFloat.new(0b11)
+          b = BasicFloat.new(-1.5)
+          c = a.and(b)
+          expect(c).to eq BasicInteger.new(0b11)
+        end
+      end
+
+    end
+
+    describe '#or' do
+
+      context 'when 0, 0' do
+        specify do
+          a = BasicInteger.new(0)
+          b = BasicInteger.new(0)
+          c = a.or(b)
+          expect(c).to eq BasicInteger.new(0)
+        end
+      end
+
+      context 'when 0, -1' do
+        specify do
+          a = BasicInteger.new(0)
+          b = BasicInteger.new(-1)
+          c = a.or(b)
+          expect(c).to eq BasicInteger.new(-1)
+        end
+      end
+
+      context 'when -1, 0' do
+        specify do
+          a = BasicInteger.new(-1)
+          b = BasicInteger.new(0)
+          c = a.or(b)
+          expect(c).to eq BasicInteger.new(-1)
+        end
+      end
+
+      context 'when -1, -1' do
+        specify do
+          a = BasicInteger.new(-1)
+          b = BasicInteger.new(-1)
+          c = a.or(b)
+          expect(c).to eq BasicInteger.new(-1)
+        end
+      end
+
+      context 'when bitwise' do
+        specify do
+          a = BasicInteger.new(0b1100)
+          b = BasicInteger.new(0b0110)
+          c = a.or(b)
+          expect(c).to eq BasicInteger.new(0b1110)
+        end
+      end
+
+      context 'when float' do
+        specify do
+          a = BasicFloat.new(1)
+          b = BasicFloat.new(-2.2)
+          c = a.or(b)
+          expect(c).to eq BasicInteger.new(-1)
+        end
+      end
+
+    end
+
+    describe '#not' do
+
+      context 'when 0' do
+        specify do
+          a = BasicInteger.new(0)
+          b = a.not
+          expect(b).to eq BasicInteger.new(-1)
+        end
+      end
+
+      context 'when -1' do
+        specify do
+          a = BasicInteger.new(-1)
+          b = a.not
+          expect(b).to eq BasicInteger.new(0)
+        end
+      end
+
+      context 'when bitwise' do
+        specify do
+          a = BasicInteger.new(123)
+          b = a.not
+            expect(b).to eq BasicInteger.new(-124)
+        end
+      end
+
+    end
+
+    describe '#chr' do
+
+      context 'normal' do
+        specify do
+          a = BasicInteger.new(65)
+          b = a.chr
+          expect(b).to eq BasicString.new("A")
+        end
+      end
+
+      context 'value too small' do
+        specify do
+          a = BasicInteger.new(-1)
+          expect {a.chr}.to raise_error InvalidArgumentError
+        end
+      end
+
+      context 'value too large' do
+        specify do
+          a = BasicInteger.new(256)
+          expect {a.chr}.to raise_error InvalidArgumentError
+        end
+      end
+
+    end
+
+    describe '#abs' do
+
+      it 'should turn negative into positive' do
+        a = BasicInteger.new(-1)
+        b = a.abs
+        expect(b).to eq BasicInteger.new(1)
+      end
+
+      it 'should leave positive alone' do
+        a = BasicInteger.new(1)
+        b = a.abs
+        expect(b).to eq BasicInteger.new(1)
+      end
+
+    end
+
+    describe '#sqr' do
+      specify do
+        a = BasicInteger.new(4)
+        b = a.sqr
+        expect(b).to eq BasicInteger.new(2)
+      end
+    end
+
+    describe '#exp' do
+      specify do
+        a = BasicInteger.new(4)
+        b = a.exp
+        expect(b).to eq BasicFloat.new(Math::E ** 4)
+      end
+    end
+
+  end
+
+end

data/test/spec/basic_numeric_spec.rb

@@ -0,0 +1,16 @@
+require_relative 'spec_helper'
+
+module Basic101
+
+  describe BasicNumeric do
+
+    describe 'type_name' do
+      let(:type_name) {'numeric'}
+      subject {described_class.new(0)}
+      specify {expect(subject.class.type_name).to eq type_name}
+      specify {expect(subject.type_name).to eq type_name}
+    end
+
+  end
+
+end

data/test/spec/basic_object_spec.rb

@@ -0,0 +1,22 @@
+require_relative 'spec_helper'
+
+module Basic101
+
+  describe BasicObject do
+
+    describe 'type_name' do
+      let(:type_name) {'object'}
+      specify {expect(subject.class.type_name).to eq type_name}
+      specify {expect(subject.type_name).to eq type_name}
+    end
+
+    describe '#eval' do
+      let(:runtime) {double Runtime}
+      it 'should return itself' do
+        subject.eval(runtime).should eq subject
+      end
+    end
+
+  end
+
+end