fastruby 0.0.18 → 0.0.19

data/spec/ruby/block/break_spec.rb~

@@ -0,0 +1,236 @@
+require "fastruby"
+
+describe FastRuby, "fastruby" do
+  class ::V1
+    fastruby "
+      def foo(ary)
+        sum = 0
+        ary.each do |a|
+          sum = sum + a
+        end
+
+        sum
+      end
+    "
+  end
+
+  it "should execute basic test iterating an array" do
+    ::V1.new.foo([1,2,3]).should be == 6
+  end
+
+  class ::V2
+    fastruby "
+      def foo(ary)
+        sum = 0
+        ary.each do |a|
+          sum = sum + a
+          break
+        end
+
+        sum
+      end
+    "
+  end
+
+  it "should execute basic test iterating an array with a break" do
+    ::V2.new.foo([1,2,3]).should be == 1
+  end
+
+  class ::V3
+    fastruby "
+      def foo(ary)
+        sum = 0
+        ary.each do |a|
+          sum = sum + a
+          break if a == 2
+        end
+
+        sum
+      end
+    "
+  end
+
+  it "should execute basic test iterating an array with a conditional break" do
+    ::V3.new.foo([1,2,3]).should be == 3
+  end
+
+  class ::V4
+    fastruby "
+      def foo
+        break
+      end
+    "
+  end
+
+  it "should raise LocalJumpError with illegal break" do
+    lambda {
+    ::V4.new.foo
+    }.should raise_error(LocalJumpError)
+  end
+
+  class ::V5
+    fastruby "
+
+      def each
+        yield(1)
+        yield(2)
+        yield(3)
+      end
+
+      def foo
+        sum = 0
+        each do |a|
+          sum = sum + a
+          break if a == 2
+        end
+
+        sum
+      end
+    "
+  end
+
+  it "should execute basic test iterating an array with a conditional break (method with block on fastruby)" do
+    ::V5.new.foo.should be == 3
+  end
+
+  class ::V6
+    fastruby "
+      def foo(ary)
+        ary.each do |a|
+          break 85 if a == 2
+        end
+      end
+    "
+  end
+
+  it "should allow return value on parent method using break" do
+    ::V6.new.foo([1,2,3]).should be == 85
+  end
+
+  class ::V7
+
+    attr_reader :a
+
+    fastruby "
+
+      def each
+        yield(1)
+        yield(2)
+        yield(3)
+      ensure
+        @a = 87
+      end
+
+      def foo
+        each do |a|
+          break if a == 2
+        end
+      end
+    "
+  end
+
+  it "should execute ensure on parent frame when using break" do
+    x = ::V7.new
+
+    x.foo
+    x.a.should be == 87
+  end
+
+
+  class ::V8
+
+    attr_reader :a
+
+      def each
+        yield(1)
+        yield(2)
+        yield(3)
+      ensure
+        @a = 87
+      end
+
+    fastruby "
+
+      def foo
+        each do |x|
+          break if x == 2
+        end
+      end
+    "
+  end
+
+  it "should execute ensure on parent frame when using break (and called method is ruby)" do
+    x = ::V8.new
+
+    x.foo
+    x.a.should be == 87
+  end
+
+  class ::V9
+    fastruby "
+      def each
+        yield(1)
+        yield(2)
+        yield(3)
+      end
+
+      def foo
+        each do |a|
+          break 85
+        end
+      end
+    "
+  end
+
+  it "should allow return value on parent method using break when called method is fastruby" do
+    ::V9.new.foo.should be == 85
+  end
+
+
+
+  class ::V10
+
+    attr_accessor :a, :b, :c, :c_e, :b_e
+
+    fastruby "
+
+      def moo
+        yield(1)
+        @c = 32 # this should't be executed
+      ensure
+        @c_e = 4
+      end
+
+      def bar
+        yield(2)
+        @b = 16 # this should't be executed
+      ensure
+        @b_e = 4
+      end
+
+      def foo
+        ret = moo do |x|
+          bar do |y|
+            break 9
+          end
+          @a = 111
+          break 10
+        end
+        ret + 1
+      end
+
+    "
+  end
+
+  it "should break for nested blocks" do
+    v10 = ::V10.new
+    v10.foo.should be == 11
+    v10.a.should be == 111
+    v10.b.should be == nil
+    v10.c.should be == nil
+    v10.b_e.should be == 4
+    v10.c_e.should be == 4
+  end
+
+
+end

data/spec/ruby/block/lambda_spec.rb~

@@ -0,0 +1,38 @@
+require "fastruby"
+
+describe FastRuby, "fastruby" do
+
+    fastruby "
+  class ::LL4
+      def foo
+        lambda {|x|
+          yield(x)
+        }
+      end
+
+      def bar
+        z = 99
+        foo do |x|
+          x+z
+        end
+      end
+
+      def xt
+        lambda_object = bar()
+        lambda_object.call(1)
+      end
+  end
+    "
+
+  it "lambda must be able to access local variables of parent scopes through yield (from fastruby)" do
+    ll4 = ::LL4.new
+    ll4.xt.should be == 100
+  end
+
+  it "lambda must be able to access local variables of parent scopes through yield" do
+    ll4 = ::LL4.new
+    lambda_object = ll4.bar
+    lambda_object.call(1).should be == 100
+  end
+
+end

data/spec/ruby/block/next_spec.rb~

@@ -0,0 +1,85 @@
+require "fastruby"
+
+describe FastRuby, "fastruby" do
+  class ::W1
+    fastruby "
+      def foo(ary)
+        sum = 0
+        ary.each do |a|
+          next if a == 2
+          sum = sum + a
+        end
+
+        sum
+      end
+    "
+  end
+
+  it "should execute basic test iterating an array" do
+    ::W1.new.foo([1,2,3]).should be == 4
+  end
+
+  class ::W2
+    fastruby "
+      def foo
+        next
+      end
+    "
+  end
+
+  it "should raise LocalJumpError with illegal next" do
+    lambda {
+    ::W2.new.foo
+    }.should raise_error(LocalJumpError)
+  end
+
+  class ::W3
+    attr_reader :x, :y
+
+    fastruby "
+      def bar
+        @x = yield(1)
+        @y = yield(2)
+      end
+
+      def foo
+        bar do |a|
+          next 16 if a == 1
+          next 32 if a == 2
+        end
+      end
+    "
+  end
+
+  it "should return values on block using next" do
+     x = ::W3.new
+     x.foo
+     x.x.should be == 16
+     x.y.should be == 32
+  end
+
+  class ::W4
+    attr_reader :x, :y
+
+    fastruby "
+      def foo(ary)
+        sum = 0
+        ary.each do |a|
+          begin
+            next if a == 2
+          ensure
+            sum = sum + a
+          end
+        end
+
+        sum
+      end
+    "
+  end
+
+  it "should execute ensure when using next" do
+     x = ::W4.new
+     x.foo([1,2,3]).should be == 6
+  end
+
+end

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

@@ -0,0 +1,83 @@
+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
+      
+          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}]")
+          
+          eval("::CYR1_#{argnum}").new.foo(*array).should be == array 
+    end
+  end
+  
+  (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(1)
+end

data/spec/ruby/defn/replacement_spec.rb

@@ -98,5 +98,55 @@ describe FastRuby, "fastruby" do
     fastruby code
 
     ::JU4.new.foo.should be == 6
-  end  
-end
+  end
+  
+  
+  it "should allow replaced called method when inlined from many functions" do
+    fastruby "
+      class ::JU5
+        def bar
+          77
+        end
+      end
+      class ::JU6
+        def foo(a,b)
+          b.bar
+        end
+      end
+    "
+    
+    ::JU6.new.foo(0,::JU5.new)
+    ::JU6.new.foo("0",::JU5.new)
+    
+    fastruby "
+       class ::JU5
+        def bar
+          99
+        end
+      end
+    "
+
+    ::JU6.new.foo(0,::JU5.new).should be == 99
+    ::JU6.new.foo("0",::JU5.new).should be == 99
+  end
+
+  it "should allow replace CFUNC methods using ruby after they are called and compiled at runtime (through other method)" do
+    fastruby "
+      class ::JU6
+        def foo(a)
+          a.conj
+        end
+      end
+    "
+    
+    ::JU6.new.foo(0)
+    
+      class Fixnum
+        def conj
+          86
+        end
+      end
+    
+    ::JU6.new.foo(0).should be == 86 
+  end 
+end

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

@@ -98,5 +98,55 @@ describe FastRuby, "fastruby" do
     fastruby code
 
     ::JU4.new.foo.should be == 6
-  end  
-end
+  end
+  
+  
+  it "should allow replaced called method when inlined from many functions" do
+    fastruby "
+      class ::JU5
+        def bar
+          77
+        end
+      end
+      class ::JU6
+        def foo(a,b)
+          b.bar
+        end
+      end
+    "
+    
+    ::JU6.new.foo(0,::JU5.new)
+    ::JU6.new.foo("0",::JU5.new)
+    
+    fastruby "
+       class ::JU5
+        def bar
+          99
+        end
+      end
+    "
+
+    ::JU6.new.foo(0,::JU5.new).should be == 99
+    ::JU6.new.foo("0",::JU5.new).should be == 99
+  end
+
+  it "should allow replace CFUNC methods using ruby after they are called and compiled at runtime (through other method)" do
+    eval "
+      class ::JU6
+        def foo(a)
+          a.conj
+        end
+      end
+    "
+    
+    ::JU6.new.foo(0)
+    
+      class Fixnum
+        def conj
+          86
+        end
+      end
+    
+    ::JU6.new.foo(0).should be == 86 
+  end 
+end

data/spec/ruby/exception/base_spec.rb

@@ -61,5 +61,26 @@ ENDSTR
     }.should raise_exception(RuntimeError)
     
   end
-
+  
+  it "should allow return from rescue body" do
+    
+    fastruby <<ENDSTR
+    
+    class EXC3
+      def foo
+        begin
+          return 99
+        rescue
+        end
+      end
+    
+      def bar
+        foo
+      end
+    end
+    
+ENDSTR
+    
+    ::EXC3.new.bar.should be == 99
+  end
 end

data/spec/ruby/return_spec.rb~

@@ -0,0 +1,99 @@
+require "fastruby"
+
+describe FastRuby, "fastruby" do
+  it "should allow basic return" do
+   fastruby "
+      class ::P1
+        def foo
+          return 1
+        end
+      end
+    "
+    ::P1.new.foo.should be == 1
+  end
+
+  it "should allow return from inside a block" do
+   fastruby "
+      class ::P2
+        def bar
+          yield
+        end
+
+        def foo
+          bar do
+            return 8
+          end
+
+          return 0
+        end
+      end
+    "
+    ::P2.new.foo.should be == 8
+  end
+
+  it "should allow basic return on singleton method" do
+   fastruby "
+      class ::P3
+      end
+
+      class ::P31
+        def bar(x)
+          def x.foo
+            return 1
+          end
+        end
+      end
+    "
+
+    p3 = ::P3.new
+    ::P31.new.bar(p3)
+    p3.foo.should be == 1
+  end
+
+  it "should allow return from inside a block on a singleton method" do
+   fastruby "
+      class ::P4
+        def bar
+          yield
+        end
+      end
+
+      class ::P41
+        def bar(x)
+          def x.foo
+            bar do
+              return 8
+            end
+            return 0
+          end
+        end
+      end
+    "
+    p4 = ::P4.new
+    ::P41.new.bar(p4)
+    p4.foo.should be == 8
+  end
+
+  it "should execute ensure when ensure impl has a return" do
+   fastruby "
+      class ::P5
+        def a
+          @a
+        end
+
+        def foo
+          begin
+            return 16
+          ensure
+            @a = 9
+          end
+
+          return 32
+        end
+      end
+    "
+    p5 = ::P5.new
+    p5.foo.should be == 16
+    p5.a.should be ==9
+  end
+end