opal 0.4.4 → 0.5.0

data/spec/rubyspec/language/redo_spec.rb

@@ -1,65 +0,0 @@
-require File.expand_path('../../spec_helper', __FILE__)
-
-describe "The redo statement" do
-  it "restarts block execution if used within block" do
-    a = []
-    lambda {
-      a << 1
-      redo if a.size < 2
-      a << 2
-    }.call
-    a.should == [1, 1, 2]
-  end
-
-  it "re-executes the closest loop" do
-    exist = [2,3]
-    processed = []
-    order = []
-    [1,2,3,4].each do |x|
-      order << x
-      begin
-        processed << x
-        if(exist.include?(x))
-          raise StandardError, "included"
-        end
-      rescue StandardError => e
-        exist.delete(x)
-        redo
-      end
-    end
-    processed.should == [1,2,2,3,3,4]
-    exist.should == []
-    order.should == [1,2,2,3,3,4]
-  end
-
-  it "re-executes the last step in enumeration" do
-    list = []
-    [1,2,3].each do |x|
-      list << x
-      break if list.size == 6
-      redo if x == 3
-    end
-    list.should == [1,2,3,3,3,3]
-  end
-
-  # The #count method is on 1.9, but this causes SyntaxError,
-  # Invalid redo in 1.9
-  quarantine! do
-    it "triggers ensure block when re-executing a block" do
-      list = []
-      [1,2,3].each do |x|
-        list << x
-        begin
-          list << 10*x
-          # causes SyntaxError in 1.9
-          # redo if list.count(1) == 1
-        ensure
-          list << 100*x
-        end
-      end
-      list.should == [1,10,100,1,10,100,2,20,200,3,30,300]
-    end
-  end
-end
-
-# language_version __FILE__, "redo"

data/spec/rubyspec/language/rescue_spec.rb

@@ -1,121 +0,0 @@
-require File.expand_path('../../spec_helper', __FILE__)
-class SpecificExampleException < StandardError
-end
-class OtherCustomException < StandardError
-end
-
-def exception_list
-  [SpecificExampleException, ZeroDivisionError]
-end
-describe "The rescue keyword" do
-  before :each do
-    ScratchPad.record []
-  end
-
-  it "can be used to handle a specific exception" do
-    lambda do
-      begin
-        raise SpecificExampleException, "Raising this to be handled below"
-      rescue SpecificExampleException
-      end
-    end.should_not raise_error
-  end
-
-  it "can capture the raised exception in a local variable" do
-    begin
-      raise SpecificExampleException, "some text"
-    rescue SpecificExampleException => e
-      e.message.should == "some text"
-    end
-  end
-
-  it "can rescue multiple raised exceptions with a single rescue block" do
-    lambda do
-      [lambda{1/0}, lambda{raise SpecificExampleException}].each do |block|
-        begin
-          block.call
-        rescue SpecificExampleException, ZeroDivisionError
-        end
-      end
-    end.should_not raise_error
-  end
-
-  it "can rescue a splatted list of exceptions" do
-    caught_it = false
-    begin
-      raise SpecificExampleException, "not important"
-    rescue *exception_list
-      caught_it = true
-    end
-    caught_it.should be_true
-    caught = []
-    lambda do
-      [lambda{1/0}, lambda{raise SpecificExampleException}].each do |block|
-        begin
-          block.call
-        rescue *exception_list
-          caught << $!
-        end
-      end
-    end.should_not raise_error
-    caught.size.should == 2
-    exception_list.each do |exception_class|
-      caught.map{|e| e.class}.include?(exception_class).should be_true
-    end
-  end
-
-  it "will only rescue the specified exceptions when doing a splat rescue" do
-    lambda do
-      begin
-        raise OtherCustomException, "not rescued!"
-      rescue *exception_list
-      end
-    end.should raise_error(OtherCustomException)
-  end
-
-  it "will execute an else block only if no exceptions were raised" do
-    # begin
-    #   ScratchPad << :one
-    # rescue
-    #   ScratchPad << :does_not_run
-    # else
-    #   ScratchPad << :two
-    # end
-    # ScratchPad.recorded.should == [:one, :two]
-  end
-
-  it "will not execute an else block if an exception was raised" do
-    # begin
-    #   ScratchPad << :one
-    #   raise "an error occurred"
-    # rescue
-    #   ScratchPad << :two
-    # else
-    #   ScratchPad << :does_not_run
-    # end
-    # ScratchPad.recorded.should == [:one, :two]
-  end
-
-  it "will not rescue errors raised in an else block in the rescue block above it" do
-    # lambda do
-    #   begin
-    #     ScratchPad << :one
-    #   rescue Exception => e
-    #     ScratchPad << :does_not_run
-    #   else
-    #     ScratchPad << :two
-    #     raise SpecificExampleException, "an error from else"
-    #   end
-    # end.should raise_error(SpecificExampleException)
-    # ScratchPad.recorded.should == [:one, :two]
-  end
-
-  ruby_version_is "1.9" do
-    it "parses  'a += b rescue c' as 'a += (b rescue c)'" do
-      a = 'a'
-      c = 'c'
-      # a += b rescue c
-      a.should == 'ac'
-    end
-  end
-end

data/spec/rubyspec/language/retry_spec.rb

@@ -1,56 +0,0 @@
-require File.expand_path('../../spec_helper', __FILE__)
-
-describe "The retry statement" do
-  it "re-executes the closest block" do
-    retry_first = true
-    retry_second = true
-    results = []
-    begin
-      results << 1
-      raise
-    rescue
-      results << 2
-      if retry_first
-        results << 3
-        retry_first = false
-        retry
-      end
-      begin
-        results << 4
-        raise
-      rescue
-        results << 5
-        if retry_second
-          results << 6
-          retry_second = false
-          retry
-        end
-      end
-    end
-
-    results.should == [1, 2, 3, 1, 2, 4, 5, 6, 4, 5]
-  end
-
-  ruby_version_is "1.9" do
-    it "raises a SyntaxError when used outside of a begin statement" do
-      lambda { eval 'retry' }.should raise_error(SyntaxError)
-    end
-  end
-end
-
-describe "The retry keyword inside a begin block's rescue block" do
-  it "causes the begin block to be executed again" do
-    counter = 0
-
-    begin
-      counter += 1
-      raise "An exception"
-    rescue
-      retry unless counter == 7
-    end
-
-    counter.should == 7
-  end
-end
-
-# language_version __FILE__, "retry"

data/spec/rubyspec/language/return_spec.rb

@@ -1,281 +0,0 @@
-require File.expand_path('../../spec_helper', __FILE__)
-require File.expand_path('../fixtures/return', __FILE__)
-
-describe "The return keyword" do
-  it "returns any object directly" do
-    def r; return 1; end
-    r().should == 1
-  end
-
-  it "returns an single element array directly" do
-    def r; return [1]; end
-    r().should == [1]
-  end
-
-  it "returns an multi element array directly" do
-    def r; return [1,2]; end
-    r().should == [1,2]
-  end
-
-  it "returns nil by default" do
-    def r; return; end
-    r().should be_nil
-  end
-
-  describe "in a Thread" do
-    ruby_version_is "" ... "1.9" do
-      it "raises a ThreadError if used to exit a thread" do
-        lambda { Thread.new { return }.join }.should raise_error(ThreadError)
-      end
-    end
-
-    ruby_version_is "1.9" do
-      it "raises a LocalJumpError if used to exit a thread" do
-        lambda { Thread.new { return }.join }.should raise_error(LocalJumpError)
-      end
-    end
-  end
-
-  describe "when passed a splat" do
-    ruby_version_is "" ... "1.9" do
-      it "returns nil when the ary is empty" do
-        def r; ary = []; return *ary; end
-        r.should be_nil
-      end
-    end
-
-    ruby_version_is "1.9" do
-      it "returns [] when the ary is empty" do
-        def r; ary = []; return *ary; end
-        r.should == []
-      end
-    end
-
-    ruby_version_is "" ... "1.9" do
-      it "returns the first element when the array is size of 1" do
-        def r; ary = [1]; return *ary; end
-        r.should == 1
-      end
-    end
-
-    ruby_version_is "1.9" do
-      it "returns the array when the array is size of 1" do
-        def r; ary = [1]; return *ary; end
-        r.should == [1]
-      end
-    end
-
-    it "returns the whole array when size is greater than 1" do
-      def r; ary = [1,2]; return *ary; end
-      r.should == [1,2]
-
-      def r; ary = [1,2,3]; return *ary; end
-      r.should == [1,2,3]
-    end
-
-    ruby_version_is "" ... "1.9" do
-      it "returns a non-array when used as a splat" do
-        def r; value = 1; return *value; end
-        r.should == 1
-      end
-    end
-
-    ruby_version_is "1.9" do
-      it "returns an array when used as a splat" do
-        def r; value = 1; return *value; end
-        r.should == [1]
-      end
-    end
-
-
-    it "calls 'to_a' on the splatted value first" do
-      def r
-        obj = Object.new
-        def obj.to_a
-          [1,2]
-        end
-
-        return *obj
-      end
-
-      r().should == [1,2]
-    end
-
-    ruby_version_is "" ... "1.9" do
-      it "calls 'to_ary' on the splatted value first" do
-        def r
-          obj = Object.new
-          def obj.to_ary
-            [1,2]
-          end
-
-          return *obj
-        end
-
-        r().should == [1,2]
-      end
-    end
-  end
-
-  describe "within a begin" do
-    before :each do
-      ScratchPad.record []
-    end
-
-    it "executes ensure before returning" do
-      def f()
-        begin
-          ScratchPad << :begin
-          return :begin
-          ScratchPad << :after_begin
-        ensure
-          ScratchPad << :ensure
-        end
-        ScratchPad << :function
-      end
-      f().should == :begin
-      ScratchPad.recorded.should == [:begin, :ensure]
-    end
-
-    it "returns last value returned in ensure" do
-      def f()
-        begin
-          ScratchPad << :begin
-          return :begin
-          ScratchPad << :after_begin
-        ensure
-          ScratchPad << :ensure
-          return :ensure
-          ScratchPad << :after_ensure
-        end
-        ScratchPad << :function
-      end
-      f().should == :ensure
-      ScratchPad.recorded.should == [:begin, :ensure]
-    end
-
-    it "executes nested ensures before returning" do
-      # def f()
-      #   begin
-      #     begin
-      #       ScratchPad << :inner_begin
-      #       return :inner_begin
-      #       ScratchPad << :after_inner_begin
-      #     ensure
-      #       ScratchPad << :inner_ensure
-      #     end
-      #     ScratchPad << :outer_begin
-      #     return :outer_begin
-      #     ScratchPad << :after_outer_begin
-      #   ensure
-      #     # ScratchPad << :outer_ensure
-      #   end
-      #   ScratchPad << :function
-      # end
-      # f().should == :inner_begin
-      # ScratchPad.recorded.should == [:inner_begin, :inner_ensure, :outer_ensure]
-    end
-
-    it "returns last value returned in nested ensures" do
-      # def f()
-      #   begin
-      #     begin
-      #       ScratchPad << :inner_begin
-      #       return :inner_begin
-      #       ScratchPad << :after_inner_begin
-      #     ensure
-      #       ScratchPad << :inner_ensure
-      #       return :inner_ensure
-      #       ScratchPad << :after_inner_ensure
-      #     end
-      #     ScratchPad << :outer_begin
-      #     return :outer_begin
-      #     ScratchPad << :after_outer_begin
-      #   ensure
-      #     ScratchPad << :outer_ensure
-      #     return :outer_ensure
-      #     ScratchPad << :after_outer_ensure
-      #   end
-      #   ScratchPad << :function
-      # end
-      # f().should == :outer_ensure
-      # ScratchPad.recorded.should == [:inner_begin, :inner_ensure, :outer_ensure]
-    end
-
-    it "executes the ensure clause when begin/ensure are inside a lambda" do
-      lambda do
-        begin
-          return
-        ensure
-          ScratchPad.recorded << :ensure
-        end
-      end.call
-      ScratchPad.recorded.should == [:ensure]
-    end
-  end
-
-  describe "within a block" do
-    before :each do
-      ScratchPad.clear
-    end
-
-    ruby_version_is "" ... "1.9" do
-      it "raises a LocalJumpError if there is no lexicaly enclosing method" do
-        def f; yield; end
-        lambda { f { return 5 } }.should raise_error(LocalJumpError)
-      end
-    end
-
-    it "causes lambda to return nil if invoked without any arguments" do
-      lambda { return; 456 }.call.should be_nil
-    end
-
-    it "causes lambda to return nil if invoked with an empty expression" do
-      lambda { return (); 456 }.call.should be_nil
-    end
-
-    it "causes lambda to return the value passed to return" do
-      lambda { return 123; 456 }.call.should == 123
-    end
-
-    it "causes the method that lexically encloses the block to return" do
-      ReturnSpecs::Blocks.new.enclosing_method.should == :return_value
-      ScratchPad.recorded.should == :before_return
-    end
-
-    it "returns from the lexically enclosing method even in case of chained calls" do
-      ReturnSpecs::NestedCalls.new.enclosing_method.should == :return_value
-      ScratchPad.recorded.should == :before_return
-    end
-
-    it "returns from the lexically enclosing method even in case of chained calls(in yield)" do
-      ReturnSpecs::NestedBlocks.new.enclosing_method.should == :return_value
-      ScratchPad.recorded.should == :before_return
-    end
-
-    it "causes the method to return even when the immediate parent has already returned" do
-      ReturnSpecs::SavedInnerBlock.new.start.should == :return_value
-      ScratchPad.recorded.should == :before_return
-    end
-
-  end
-
-  describe "within two blocks" do
-    it "causes the method that lexically encloses the block to return" do
-      def f
-        1.times { 1.times {return true}; false}; false
-      end
-      f.should be_true
-    end
-  end
-
-  describe "within define_method" do
-    it "goes through the method via a closure" do
-      ReturnSpecs::ThroughDefineMethod.new.outer.should == :good
-    end
-
-    it "stops at the method when the return is used directly" do
-      ReturnSpecs::DefineMethod.new.outer.should == :good
-    end
-  end
-end