opal 0.3.11 → 0.3.15

data/runtime/spec/language/case_spec.rb

@@ -0,0 +1,165 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "The 'case'-construct" do
+  it "evaluates the body of the when clause matching the case target expression" do
+    case 1
+      when 2; false
+      when 1; true
+    end.should == true
+  end
+
+  it "evaluates the body of the when clause whose array expression includes the case target expression" do
+    case 2
+      when 3, 4; false
+      when 1, 2; true
+    end.should == true
+  end
+
+  it "evaluates the body of the when clause in left-to-right order if it's an array expression" do
+    @calls = []
+    def foo; @calls << :foo; end
+    def bar; @calls << :bar; end
+
+    case true
+      when foo, bar;
+    end
+
+    @calls.should == [:foo, :bar]
+  end
+
+  it "evaluates the body of the when clause whose range expression includes the case target expression" do
+    case 5
+      when 21..30; false
+      when 1..20; true
+    end.should == true
+  end
+
+  it "returns nil when no 'then'-bodies are given" do
+    case "a"
+      when "a"
+      when "b"
+    end.should == nil
+  end
+
+  it "evaluates the 'else'-body when no other expression matches" do
+    case "c"
+      when "a"; 'foo'
+      when "b"; 'bar'
+      else 'zzz'
+    end.should == 'zzz'
+  end
+
+  it "returns nil when no expression matches and 'else'-body is empty" do
+    case "c"
+      when "a"; "a"
+      when "b"; "b"
+      else
+    end.should == nil
+  end
+
+  it "returns 2 when a then body is empty" do
+    case Object.new
+    when Numeric then
+      1
+    when String then
+      # ok
+    else
+      2
+    end.should == 2
+  end
+
+  it "returns the statement following 'then'" do
+    case "a"
+      when "a" then 'foo'
+      when "b" then 'bar'
+    end.should == 'foo'
+  end
+
+  it "tests classes with case equality" do
+    case "a"
+      when String
+        'foo'
+      when Symbol
+        'bar'
+    end.should == 'foo'
+  end
+
+  it "tests with matching regexps" do
+    case "hello"
+      when /abc/; false
+      when /^hell/; true
+    end.should == true
+  end
+
+  it "does not test with equality when given classes" do
+    case :symbol.class
+      when Symbol
+        "bar"
+      when String
+        "bar"
+      else
+        "foo"
+    end.should == "foo"
+  end
+
+  it "takes lists of values" do
+    case 'z'
+      when 'a', 'b', 'c', 'd'
+        "foo"
+      when 'x', 'y', 'z'
+        "bar"
+    end.should == "bar"
+
+    case 'b'
+      when 'a', 'b', 'c', 'd'
+        "foo"
+      when 'x', 'y', 'z'
+        "bar"
+    end.should == "foo"
+  end
+
+  it "expands arrays to lists of values" do
+    case 'z'
+      when *['a', 'b', 'c', 'd']
+        "foo"
+      when *['x', 'y', 'z']
+        "bar"
+    end.should == "bar"
+  end
+
+  it "takes an expanded array in addition to a list of values" do
+    case 'f'
+      when 'f', *['a',  'b', 'c', 'd']
+        "foo"
+      when *['x', 'y', 'z']
+        "bar"
+    end.should == "foo"
+
+    case 'b'
+      when 'f', *['a', 'b', 'c', 'd']
+        "foo"
+      when *['x', 'y', 'z']
+        "bar"
+    end.should == "foo"
+  end
+
+  it "concats arrays before expanding them" do
+    a = ['a', 'b', 'c', 'd']
+    b = ['f']
+
+    case 'f'
+      when 'f', *a|b
+        "foo"
+      when *['x', 'y', 'z']
+        "bar"
+    end.should == "foo"
+  end
+
+  it "never matchers when clauses with no values" do
+    case nil
+      when *[]
+        "foo"
+    end.should == nil
+  end
+end
+

data/runtime/spec/language/defined_spec.rb

@@ -0,0 +1,80 @@
+require File.expand_path('../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/defined', __FILE__)
+
+describe "The defined? keyword for literals" do
+  it "returns 'self' for self" do
+    ret = defined?(self)
+    ret.should == "self"
+  end
+
+  it "returns 'nil' for nil" do
+    ret = defined?(nil)
+    ret.should == "nil"
+  end
+
+  it "returns 'true' for true" do
+    ret = defined?(true)
+    ret.should == "true"
+  end
+
+  it "returns 'false' for false" do
+    ret = defined?(false)
+    ret.should == "false"
+  end
+end
+
+describe "The defined? keyword when called with a method name" do
+  describe "without a receiver" do
+    it "returns 'method' if the method is defined" do
+      defined?(puts).should == "method"
+    end
+
+    it "returns nil if the method is not defined" do
+      defined?(defined_specs_undefined_method).should be_nil
+    end
+  end
+
+  describe "having a module as a receiver" do
+    it "returns 'method' if the method is defined" do
+      defined?(Kernel.puts).should == "method"
+    end
+
+    it "returns nil if the method is private" do
+      # FIXME: should opal-spec have some special not_opal_compatible error that is similar to skip?
+      #defined?(Object.print).should be_nil
+    end
+
+    it "returns nil if the method is protected" do
+      # FIXME: see above
+      # defined?(DefinedSpecs::Basic.new.protected_method).should be_nil
+    end
+
+    it "returns nil if the method is not defined" do
+      defined?(Kernel.defined_specs_undefined_method).should be_nil
+    end
+  end
+
+  describe "having a local variable as receiver" do
+    it "returns 'method' if the method is defined" do
+      obj = DefinedSpecs::Basic.new
+      defined?(obj.a_defined_method).should == "method"
+    end
+
+    it "returns nil if the method is not defined" do
+      obj = DefinedSpecs::Basic.new
+      defined?(obj.an_undefined_method).should be_nil
+    end
+  end
+
+  describe "having an instance variable as receiver" do
+    it "returns 'method' if the method is defined" do
+      @defined_specs_obj = DefinedSpecs::Basic.new
+      defined?(@defined_specs_obj.a_defined_method).should == "method"
+    end
+
+    it "returns nil if the method is not defined" do
+      @defined_specs_obj = DefinedSpecs::Basic.new
+      defined?(@defined_specs_obj.an_undefined_method).should be_nil
+    end
+  end
+end

data/runtime/spec/language/ensure_spec.rb

@@ -0,0 +1,82 @@
+require File.expand_path('../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/ensure', __FILE__)
+
+describe "An ensure block inside a begin block" do
+  before :each do
+    ScratchPad.record []
+  end
+
+  it "is executed when an exception is raised in it's corresponding begin block" do
+    begin
+      lambda {
+        begin
+          ScratchPad << :begin
+          raise "An exception occured!"
+        ensure
+          ScratchPad << :ensure
+        end
+      }.should raise_error(RuntimeError)
+
+      ScratchPad.recorded.should == [:begin, :ensure]
+    end
+  end
+
+  it "is executed when an exception is raised and rescued in it's corresponding begin block" do
+    begin
+      begin
+        ScratchPad << :begin
+        raise "An exception occured!"
+      rescue
+        ScratchPad << :rescue
+      ensure
+        ScratchPad << :ensure
+      end
+
+      ScratchPad.recorded.should == [:begin, :rescue, :ensure]
+    end
+  end
+
+  it "is executed when nothing is raised or thrown in it's corresponding begin block" do
+    begin
+      ScratchPad << :begin
+    rescue
+      ScratchPad << :rescue
+    ensure
+      ScratchPad << :ensure
+    end
+
+    ScratchPad.recorded.should == [:begin, :ensure]
+  end
+
+  it "has no return value" do
+    begin
+      :begin
+    ensure
+      :ensure
+    end.should == :begin
+  end
+end
+
+describe "An ensure block inside a method" do
+  before(:each) do
+    @obj = EnsureSpec::Container.new
+  end
+
+  it "is executed when an exception is raised in the method" do
+    lambda { @obj.raise_in_method_with_ensure }.should raise_error(RuntimeError)
+    @obj.executed.should == [:method, :ensure]
+  end
+
+  it "is executed when an exception is raised and rescued in the method" do
+    @obj.raise_and_rescue_in_method_with_ensure
+    @obj.executed.should == [:method, :rescue, :ensure]
+  end
+
+  it "has no impact on the method's implicit return value" do
+    @obj.implicit_return_in_method_with_ensure.should == :method
+  end
+
+  it "has an impact on the method's explicit return value" do
+    @obj.explicit_return_in_method_with_ensure.should == :ensure
+  end
+end

data/runtime/spec/language/fixtures/block.rb

@@ -0,0 +1,19 @@
+module BlockSpecs
+  class Yielder
+    def z
+      yield
+    end
+
+    def m(*a)
+      yield(*a)
+    end
+
+    def s(a)
+      yield(a)
+    end
+
+    def r(a)
+      yield(*a)
+    end
+  end
+end

data/runtime/spec/language/fixtures/break.rb

@@ -0,0 +1,39 @@
+module BreakSpecs
+  class Driver
+    def initialize(ensures=false)
+      @ensures = ensures
+    end
+
+    def note(value)
+      ScratchPad << value
+    end
+  end
+
+  class Block < Driver
+    def break_nil
+      note :a
+      note yielding {
+        note :b
+        break
+        note :c
+      }
+      note :d
+    end
+
+    def break_value
+      note :a
+      note yielding {
+        note :b
+        break :break
+        note :c
+      }
+      note :d
+    end
+
+    def yielding
+      note :aa
+      note yield
+      note :bb
+    end
+  end
+end

data/runtime/spec/language/fixtures/defined.rb

@@ -0,0 +1,9 @@
+module DefinedSpecs
+
+  class Basic
+    A = 42
+
+    def a_defined_method
+    end
+  end
+end

data/runtime/spec/language/fixtures/ensure.rb

@@ -0,0 +1,37 @@
+module EnsureSpec
+  class Container
+    attr_reader :executed
+
+    def initialize
+      @executed = []
+    end
+
+    def raise_in_method_with_ensure
+      @executed << :method
+      raise "An Exception"
+    ensure
+      @executed << :ensure
+    end
+
+    def raise_and_rescue_in_method_with_ensure
+      @executed << :method
+      raise "An Exception"
+    rescue
+      @executed << :rescue
+    ensure
+      @executed << :ensure
+    end
+
+    def implicit_return_in_method_with_ensure
+      :method
+    ensure
+      :ensure
+    end
+
+    def explicit_return_in_method_with_ensure
+      return :method
+    ensure
+      return :ensure
+    end
+  end
+end

data/runtime/spec/language/fixtures/next.rb

@@ -0,0 +1,46 @@
+class NextSpecs
+  def self.yielding_method(expected)
+    yield.should == expected
+    :method_return_value
+  end
+
+  def self.yielding
+    yield
+  end
+
+  def self.while_next(arg)
+    x = true
+    while x
+      begin
+        ScratchPad << :begin
+        x = false
+        if arg
+          next 42
+        else
+          next
+        end
+      ensure
+        ScratchPad << :ensure
+      end
+    end
+  end
+
+  def self.while_within_iter(arg)
+    yielding do
+      x = true
+      while x
+        begin
+          ScratchPad << :begin
+          x = false
+          if arg
+            next 42
+          else
+            next
+          end
+        ensure
+          ScratchPad << :ensure
+        end
+      end
+    end
+  end
+end