fastruby 0.0.21 → 0.0.22

data/spec/ruby/call/base_call_spec.rb~

@@ -1,7 +1,36 @@
 require "fastruby"
 
 describe FastRuby, "fastruby" do
-   
+  def self.test_arguments(x)
+    it "should allow #{x} arguments calling to cfunc" do
+      
+          arguments = (0..x).map(&:to_s).join(",")
+      
+            fastruby "
+          class ::CYR#{x}
+              def foo
+                a = []
+                a.infer(Array).push(#{arguments})
+                a
+              end
+          end
+            "
+          
+          eval("::CYR#{x}").new.foo.should be == eval("[#{arguments}]")
+    end
+  end
+  
+  #test_arguments(10)
+  #test_arguments(15)
+  #test_arguments(20)
+  
+  (23..27).each do |i|
+   # test_arguments(i)
+  end
+  
+  #test_arguments(20)
+  
+    
   def self.test_fastruby_arguments(argnum)
     it "should allow #{argnum} arguments calling fastruby" do
       
@@ -21,5 +50,34 @@ describe FastRuby, "fastruby" do
           eval("::CYR1_#{argnum}").new.foo(*array).should be == array 
     end
   end
-  test_fastruby_arguments(1024)
+  
+  #(8..12).each do |i|
+  #  test_fastruby_arguments(i)
+  #end
+  
+  def self.test_invalid_fastruby_arguments(argnum)
+    it "should allow #{argnum} arguments calling fastruby" do
+      
+          arguments_name = (0..argnum-1).map{|x| "a"+x.to_s}.join(",")
+          arguments = (0..argnum-1).map(&:to_s).join(",")
+      
+            fastruby "
+          class ::CYR1_#{argnum}
+              def foo(#{arguments_name})
+                [#{arguments_name}]
+              end
+          end
+            "
+          
+          array = eval("[#{arguments}]")
+          
+          lambda {
+          eval("::CYR1_#{argnum}").new.foo(*array).should be == array
+          }.should raise_error(ArgumentError) 
+    end
+  end
+  
+  #test_invalid_fastruby_arguments(15)
+
+  test_fastruby_arguments(1000)
 end

data/spec/ruby/defn/default_args_spec.rb~

@@ -0,0 +1,303 @@
+require "fastruby"
+
+describe FastRuby, "fastruby" do
+  it "should allow one optional argument" do
+    fastruby "
+      class CFX1
+        def foo(a=0)
+          a
+        end
+      end
+    "
+  end
+
+  it "should allow one optional argument and should return the default when no specified" do
+    fastruby "
+      class CFX2
+        def foo(a=0)
+          a
+        end
+      end
+    "
+    
+    CFX2.new.foo.should be == 0
+  end
+
+  it "should allow one optional argument and should return the passed value when specified" do
+    fastruby "
+      class CFX3
+        def foo(a=0)
+          a
+        end
+      end
+    "
+    
+    CFX3.new.foo(99).should be == 99
+  end
+
+  fastruby "
+    class CFX4
+      def foo(a=7,b=4)
+        [a,b]
+      end
+    end
+  "
+
+  it "should allow two optional argument and should return the passed value when no arguments is passed" do
+    cfx4 = CFX4.new
+    cfx4.foo().should be == [7,4]
+  end
+
+  it "should allow two optional argument and should return the passed value when one argument is passed" do
+    cfx4 = CFX4.new
+    cfx4.foo(99).should be == [99,4]
+  end
+
+  it "should allow two optional argument and should return the passed value when two arguments are passed" do
+    cfx4 = CFX4.new
+    cfx4.foo(99,88).should be == [99,88]
+  end
+
+  fastruby "
+    class CFX5
+      def foo(a,b=4)
+        [a,b]
+      end
+    end
+  "
+
+  it "should allow one mandatory and one optional argument and should return the passed value when one argument is passed" do
+    cfx5 = CFX5.new
+    cfx5.foo(99).should be == [99,4]
+  end
+
+  it "should allow one mandatory and one optional argument and should return the passed value when two arguments are passed" do
+    cfx5 = CFX5.new
+    cfx5.foo(99,88).should be == [99,88]
+  end
+
+  it "should raise ArgumentError when no arguments are passed" do
+    lambda {
+      cfx5 = CFX5.new
+      cfx5.foo
+    }.should raise_error(ArgumentError)
+  end
+
+  it "should raise ArgumentError when three arguments are passed" do
+    lambda {
+      cfx5 = CFX5.new
+      cfx5.foo(1,2,3)
+    }.should raise_error(ArgumentError)
+  end
+
+  it "should allow splat arguments with default arguments " do
+    fastruby "
+      class CFX6
+        def foo(x=44,*y)
+        end
+      end
+    "
+  end
+
+  fastruby "
+      class CFX7
+        def foo(x=44,*y)
+          x
+        end
+      end
+    "
+
+  it "should allow splat arguments with default arguments accepting no arguments " do
+    CFX7.new.foo.should be == 44
+  end
+
+  it "should allow splat arguments with default arguments accepting one argument" do
+    CFX7.new.foo(55).should be == 55
+  end
+
+  fastruby "
+      class CFX8
+        def foo(x=44,*y)
+          y
+        end
+      end
+    "
+
+  it "should allow splat arguments with default arguments accepting no arguments" do
+    CFX8.new.foo.should be == []
+  end
+
+  it "should allow splat arguments with default arguments accepting one arguments" do
+    CFX8.new.foo(55).should be == []
+  end
+
+  it "should allow splat arguments with default arguments accepting two arguments" do
+    CFX8.new.foo(55,66).should be == [66]
+  end
+
+  it "should allow splat arguments with default arguments accepting three arguments" do
+    CFX8.new.foo(55,66,67,68).should be == [66,67,68]
+  end
+
+  fastruby "
+      class CFX9
+        def foo(a,x=44,*y)
+          a
+        end
+      end
+    "
+
+  it "should allow splat arguments with default arguments accepting one argument" do
+    CFX9.new.foo(55).should be == 55
+  end
+
+  it "should allow splat arguments with default arguments accepting two argument" do
+    CFX9.new.foo(55,66).should be == 55
+  end
+
+  it "should allow splat arguments with default arguments accepting three argument" do
+    CFX9.new.foo(55,66,77).should be == 55
+  end
+
+  fastruby "
+      class CFX10
+        def foo(a,x=44,*y)
+          x
+        end
+      end
+    "
+  it "should allow splat arguments with default arguments accepting one argument" do
+    CFX10.new.foo(55).should be == 44
+  end
+
+  it "should allow splat arguments with default arguments accepting two argument" do
+    CFX10.new.foo(55,66).should be == 66
+  end
+
+  it "should allow splat arguments with default arguments accepting three argument" do
+    CFX10.new.foo(55,66,77).should be == 66
+  end
+
+  fastruby "
+      class CFX11
+        def foo(a,x=44,*y)
+          y
+        end
+      end
+    "
+
+  it "should raise ArgumentError with splat arguments with default arguments when no arguments are passed" do
+    lambda {
+      CFX11.new.foo
+    }.should raise_error(ArgumentError)
+  end
+
+  it "should allow splat arguments with default arguments accepting one argument" do
+    CFX11.new.foo(55).should be == []
+  end
+
+  it "should allow splat arguments with default arguments accepting two argument" do
+    CFX11.new.foo(55,66).should be == []
+  end
+
+  it "should allow splat arguments with default arguments accepting three argument" do
+    CFX11.new.foo(55,66,77).should be == [77]
+  end
+  
+  fastruby "
+      class CFX12
+        def foo(a=0,&block)
+          a
+        end
+      end
+    "
+
+  it "should allow splat arguments with default with block arguments accepting no argument" do
+    CFX12.new.foo() {
+      
+    }.should be == 0
+  end
+
+  it "should allow splat arguments with default with block arguments accepting one argument" do
+    CFX12.new.foo(44) {
+      
+    }.should be == 44
+  end
+  
+  fastruby "
+      class CFX13
+        def foo(a=0,&block)
+          block.call
+        end
+      end
+    "
+
+  it "should allow splat arguments with default with block arguments accepting no argument" do
+    CFX13.new.foo() {
+      66
+    }.should be == 66
+  end
+
+  it "should allow splat arguments with default with block arguments accepting one argument" do
+    CFX13.new.foo(44) {
+      77
+    }.should be == 77
+  end
+
+  fastruby "
+      class CFX14
+        def foo
+          55
+        end
+      end
+    "
+
+  fastruby "
+      class CFX15
+        def foo(cfx14,b = cfx14.foo)
+        end
+      end
+    "
+
+  it "should execute default blocks when no argument is passed" do
+    cfx14 = CFX14.new
+    cfx15 = CFX15.new
+    
+    cfx14.should_receive :foo
+    
+    cfx15.foo(cfx14)
+  end
+
+  it "should not execute default blocks when argument is passed" do
+    cfx14 = CFX14.new
+    cfx15 = CFX15.new
+    
+    cfx14.should_not_receive :foo
+    
+    cfx15.foo(cfx14,99)
+  end
+
+  it "should allow if on default argument" do
+    fastruby "
+      class ::CFX16
+        def foo(a, b = if a
+              87
+            else
+              55
+            end
+          )
+          b
+        end
+      end
+    "
+
+
+    cfx16 = ::CFX16.new
+    
+    cfx16.foo(false).should be == 55
+    cfx16.foo(true).should be == 87
+    cfx16.foo(true,99).should be == 99
+    cfx16.foo(false,99).should be == 99
+  end
+  
+end

data/spec/ruby/defn/multiple_args_spec.rb~

@@ -0,0 +1,317 @@
+require "fastruby"
+
+describe FastRuby, "fastruby" do
+  it "should allow define method with array arguments" do
+    lambda {
+      fastruby "
+        class CF1
+          def foo(*x)
+          end
+        end
+      "
+    }.should_not raise_error
+  end
+  
+  it "should allow define method with array arguments and call with no arguments" do
+    lambda {
+      fastruby "
+        class ::CF2
+          def foo(*x)
+            x
+          end
+        end
+      "
+      
+      ::CF2.new.foo().should be == []
+    }.should_not raise_error
+  end  
+
+  it "should allow define method with array arguments and call with one argument" do
+    lambda {
+      fastruby "
+        class ::CF3
+          def foo(*x)
+            x
+          end
+        end
+      "
+      
+      ::CF3.new.foo(1).should be == [1]
+    }.should_not raise_error
+  end  
+
+  it "should allow define method with array arguments and call with two arguments" do
+    lambda {
+      fastruby "
+        class ::CF4
+          def foo(*x)
+            x
+          end
+        end
+      "
+      
+      ::CF4.new.foo(1,2).should be == [1,2]
+    }.should_not raise_error
+  end  
+  
+  it "should allow define method with normal argument plus array arguments and call with one argument" do
+    lambda {
+      fastruby "
+        class ::CF5
+          def foo(a, *x)
+            x
+          end
+        end
+      "
+      
+      ::CF5.new.foo(1).should be == []
+    }.should_not raise_error
+  end  
+
+  it "should allow define method with normal argument plus array arguments and call with two arguments" do
+    lambda {
+      fastruby "
+        class ::CF6
+          def foo(a, *x)
+            x
+          end
+        end
+      "
+      
+      ::CF6.new.foo(1,2).should be == [2]
+    }.should_not raise_error
+  end  
+  
+  it "should allow define method with normal argument plus array arguments and call with one argument" do
+    lambda {
+      fastruby "
+        class ::CF7
+          def foo(a, *x)
+            a
+          end
+        end
+      "
+      
+      ::CF7.new.foo(1).should be == 1
+    }.should_not raise_error
+  end  
+
+  it "should allow define method with normal argument plus array arguments and call with two arguments" do
+    lambda {
+      fastruby "
+        class ::CF8
+          def foo(a, *x)
+            a
+          end
+        end
+      "
+      
+      ::CF8.new.foo(1,2).should be == 1
+    }.should_not raise_error
+  end
+  
+  it "should allow define method with array arguments and call with no arguments from fastruby" do
+    lambda {
+      fastruby "
+        class ::CF9
+          def foo(*x)
+            x
+          end
+          
+          def bar
+            foo
+          end
+        end
+      "
+      
+      ::CF9.new.bar.should be == []
+    }.should_not raise_error
+  end  
+
+  it "should allow define method with array arguments and call with one argument from fastruby" do
+    lambda {
+      fastruby "
+        class ::CF10
+          def foo(*x)
+            x
+          end
+          
+          def bar
+            foo(1)
+          end
+        end
+      "
+      
+      ::CF10.new.bar.should be == [1]
+    }.should_not raise_error
+  end  
+
+  it "should allow define method with array arguments and call with two arguments from fastruby" do
+    lambda {
+      fastruby "
+        class ::CF11
+          def foo(*x)
+            x
+          end
+          
+          def bar
+            foo(1,2)
+          end
+        end
+      "
+      
+      ::CF11.new.bar.should be == [1,2]
+    }.should_not raise_error
+  end  
+  
+  it "should allow define method with normal argument plus array arguments and call with one argument from fastruby" do
+    lambda {
+      fastruby "
+        class ::CF12
+          def foo(a, *x)
+            x
+          end
+          
+          def bar
+            foo(1)
+          end
+        end
+      "
+      
+      ::CF12.new.bar.should be == []
+    }.should_not raise_error
+  end  
+
+  it "should allow define method with normal argument plus array arguments and call with two arguments from fastruby" do
+    lambda {
+      fastruby "
+        class ::CF13
+          def foo(a, *x)
+            x
+          end
+          
+          def bar
+            foo(1,2)
+          end
+        end
+      "
+      
+      ::CF13.new.bar.should be == [2]
+    }.should_not raise_error
+  end  
+  
+  it "should allow define method with normal argument plus array arguments and call with one argument from fastruby" do
+    lambda {
+      fastruby "
+        class ::CF14
+          def foo(a, *x)
+            a
+          end
+          
+          def bar
+            foo(1)
+          end
+        end
+      "
+      
+      ::CF14.new.bar.should be == 1
+    }.should_not raise_error
+  end  
+
+  it "should allow define method with normal argument plus array arguments and call with two arguments from fastruby" do
+    lambda {
+      fastruby "
+        class ::CF15
+          def foo(a, *x)
+            a
+          end
+
+          def bar
+            foo(1.2)
+          end
+        end
+      "
+      
+      ::CF15.new.foo(1,2).should be == 1
+    }.should_not raise_error
+  end
+  
+  it "should raise ArgumentError when trying to call with too few arguments" do
+    lambda {
+      fastruby "
+        class ::CF16
+          def foo(a, *x)
+            a
+          end
+        end
+      "
+      
+      ::CF16.new.foo
+    }.should raise_error(ArgumentError)
+  end
+  
+  it "should raise ArgumentError when trying to call with too few arguments from fastruby" do
+    lambda {
+      fastruby "
+        class ::CF17
+          def foo(a, *x)
+            a
+          end
+          
+          def bar
+            foo
+          end
+        end
+      "
+      
+      ::CF17.new.bar
+    }.should raise_error(ArgumentError)
+  end
+  
+  it "should call Array#to_s when infering array type for splat argument" do
+      fastruby "
+        class ::CF18
+          def foo(*x)
+            x
+          end
+        end
+      "
+
+      ::CF18.new.foo(1,2,3,4,5).should be == [1,2,3,4,5]
+  end
+  
+  
+  class ::CFF
+    
+  end
+  it "should allow define splat arguments on singleton method" do
+      fastruby "
+        class ::CF19
+          def bar(x)
+            def x.foo(*y)
+            end
+          end
+        end
+      "
+
+      x = ::CFF.new
+      ::CF19.new.bar(x)
+      x.foo(1,2,3,4,5)
+  end
+    
+  it "should read splat arguments on singleton method" do
+      fastruby "
+        class ::CF20
+          def bar(x)
+            def x.foo(*y)
+              y
+            end
+          end
+        end
+      "
+
+      x = ::CFF.new
+      ::CF20.new.bar(x)
+      x.foo(1,2,3,4,5).should be == [1,2,3,4,5]
+  end
+end