opal 0.3.11 → 0.3.15

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

@@ -0,0 +1,36 @@
+module LangSendSpecs
+
+  def self.fooM0; 100; end
+  def self.fooM1(a); [a]; end
+  def self.fooM2(a,b); [a,b]; end
+  def self.fooM3(a,b,c); [a,b,c]; end
+  def self.fooM4(a,b,c,d); [a,b,c,d]; end
+  def self.fooM5(a,b,c,d,e); [a,b,c,d,e]; end
+  def self.fooM0O1(a=1); [a]; end
+  def self.fooM1O1(a,b=1); [a,b]; end
+  def self.fooM2O1(a,b,c=1); [a,b,c]; end
+  def self.fooM3O1(a,b,c,d=1); [a,b,c,d]; end
+  def self.fooM4O1(a,b,c,d,e=1); [a,b,c,d,e]; end
+  def self.fooM0O2(a=1,b=2); [a,b]; end
+  def self.fooM0R(*r); r; end
+  def self.fooM1R(a, *r); [a, r]; end
+  def self.fooM0O1R(a=1, *r); [a, r]; end
+  def self.fooM1O1R(a, b=1, *r); [a, b, r]; end
+
+  def self.one(a); a; end
+  def self.oneb(a,&b); [a,yield(b)]; end
+
+  def self.makeproc(&b) b end
+
+  def self.yield_now; yield; end
+
+  class ToProc
+    def initialize(val)
+      @val = val
+    end
+
+    def to_proc
+      Proc.new { @val }
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Super
+  module S1
+    class A
+      def foo(a)
+        a << "A#foo"
+        bar(a)
+      end
+      def bar(a)
+        a << "A#bar"
+      end
+    end
+    class B < A
+      def foo(a)
+        a << "B#foo"
+        super(a)
+      end
+      def bar(a)
+        a << "B#bar"
+        super(a)
+      end
+    end
+  end
+
+  module S2
+    class A
+      def baz(a)
+        a << "A#baz"
+      end
+    end
+    class B < A
+      def foo(a)
+        a << "B#foo"
+        baz(a)
+      end
+    end
+    class C < B
+      def baz(a)
+        a << "C#baz"
+        super(a)
+      end
+    end
+  end
+end

data/runtime/spec/language/hash_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "Hash literal" do
+  it "{} should return an empty hash" do
+    {}.size.should == 0
+    {}.should == {}
+  end
+
+  it "{} should return a new hash populated with the given elements" do
+    h = {:a => 'a', 'b' => 3, 44 => 2.3}
+    h.size.should == 3
+    h.should == {:a => 'a', 'b' => 3, 44 => 2.3}
+  end
+
+  it "treats empty expressions an nils" do
+    h = {() => ()}
+    h.keys.should == [nil]
+    h.values.should == [nil]
+    h[nil].should == nil
+
+    h = {() => :value}
+    h.keys.should == [nil]
+    h.values.should == [:value]
+    h[nil].should == :value
+
+    h = {:keys => ()}
+    h.keys.should == [:keys]
+    h.values.should == [nil]
+    h[:key].should == nil
+  end
+
+  it "checks duplicated keys on initialization" do
+    h = {:foo => :bar, :foo => :foo}
+    h.keys.size.should == 1
+    h.should == {:foo => :foo}
+  end
+
+  it "accepts a hanging comma" do
+    h = {:a => 1, :b => 2,}
+    h.size.should == 2
+    h.should == {:a => 1, :b => 2}
+  end
+end

data/runtime/spec/language/if_spec.rb

@@ -0,0 +1,278 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "The if expression" do
+  it "evaluates body if expression is true" do
+    a = []
+    if true
+      a << 123
+    end
+    a.should == [123]
+  end
+
+  it "does not evaluate body if expression if false" do
+    a = []
+    if false
+      a << 123
+    end
+    a.should == []
+  end
+
+  it "does not evaluate body if expression is empty" do
+    a = []
+    if ()
+      a << 123
+    end
+    a.should == []
+  end
+
+  it "does not evaluate else-body if expression is true" do
+    a = []
+    if true
+      a << 123
+    else
+      a << 456
+    end
+    a.should == [123]
+  end
+
+  it "evaluates only else-body if expression is false" do
+    a = []
+    if false
+      a << 123
+    else
+      a << 456
+    end
+    a.should == [456]
+  end
+
+  it "returns result of then-body evaluation if expression is true" do
+    if true
+      123
+    end.should == 123
+  end
+
+  it "returns result of last statement in then-body if expression is true" do
+    if true
+      'foo'
+      'bar'
+      'baz'
+    end.should == 'baz'
+  end
+
+  it "returns result of then-body evaluation if expression is true and else part is present" do
+    if true
+      123
+    else
+      456
+    end.should == 123
+  end
+
+  it "returns result of else-body evaluation if expression is false" do
+    if false
+      123
+    else
+      456
+    end.should == 456
+  end
+
+  it "returns nil if then-body is empty and expression is true" do
+    if true
+    end.should == nil
+  end
+
+  it "returns nil if then-body is empty, expression is true and else part is present" do
+    if true
+    else
+      456
+    end.should == nil
+  end
+
+  it "returns nil if then-body is empty, expression is true and else part is empty" do
+    if true
+    else
+    end.should == nil
+  end
+
+  it "returns nil if else-body is empty and expression is false" do
+    if false
+      123
+    else
+    end.should == nil
+  end
+
+  it "returns nil if else-body is empty, expression is false and then-body is empty" do
+    if false
+    else
+    end.should == nil
+  end
+
+  it "considers an expression with nil result as false" do
+    if nil
+      123
+    else
+      456
+    end.should == 456
+  end
+
+  it "considers a non-nil and non-boolean object in expression result as true" do
+    if 'x'
+      123
+    else
+      456
+    end.should == 123
+  end
+
+  it "considers a zero integer in expression result as true" do
+    if 0
+      123
+    else
+      456
+    end.should == 123
+  end
+
+  it "allows starting else-body on the same line" do
+    if false
+      123
+    else 456
+    end.should == 456
+  end
+
+  it "evaluates subsequent elsif statements and executes body of first matching" do
+    if false
+      123
+    elsif false
+      234
+    elsif true
+      345
+    elsif true
+      456
+    end.should == 345
+  end
+
+  it "evaluates else-body if no if/elsif statements match" do
+    if false
+      123
+    elsif false
+      234
+    elsif false
+      345
+    else
+      456
+    end.should == 456
+  end
+
+  it "allows 'then' after expression when then-body is on the next line" do
+    if true then
+      123
+    end.should == 123
+
+    if true then ; 123; end.should == 123
+  end
+
+  it "allows then-body on the same line separated with 'then'" do
+    if true then 123
+    end.should == 123
+
+    if true then 123; end.should == 123
+  end
+
+  it "returns nil when then-body on the same line separated with 'then' and expression is false" do
+    if false then 123
+    end.should == nil
+
+    if false then 123; end.should == nil
+  end
+
+  it "returns nil when then-body separated by 'then' is empty and expression is true" do
+    if true then
+    end.should == nil
+
+    if true then ; end.should == nil
+  end
+
+  it "returns nil when then-body separated by 'then', expression is false and no else part" do
+    if false then
+    end.should == nil
+
+    if false then ; end.should == nil
+  end
+
+  it "evaluates then-body when then-body separated by 'then', expression is true and else part is present" do
+    if true then 123
+    else 456
+    end.should == 123
+
+    if true then 123; else 456; end.should == 123
+  end
+
+  it "evaluates else-body when then-body separated by 'then' and expression is false" do
+    if false then 123
+    else 456
+    end.should == 456
+
+    if false then 123; else 456; end.should == 456
+  end
+end
+
+describe "The postfix if form" do
+  it "evaluates statement if expression is true" do
+    a = []
+    a << 123 if true
+    a.should == [123]
+  end
+
+  it "does not evaluate statement if expression if false" do
+    a = []
+    a << 123 if false
+    a.should == []
+  end
+
+  it "returns result of expression if value is true" do
+    (123 if true).should == 123
+  end
+
+  it "returns nil if value is false" do
+    (123 if false).should == nil
+  end
+
+  it "considers a nil expression as false" do
+    (123 if nil).should == nil
+  end
+
+  it "considers a non-nil object as true" do
+    (123 if 'x').should == 123
+  end
+
+  it "evaluates then-body in containing scope" do
+    a = 123
+    if true
+      b = a+1
+    end
+    b.should == 124
+  end
+
+  it "evaluates else-body if containing scope" do
+    a = 123
+    if false
+      b = a+1
+    else
+      b= a+2
+    end
+    b.should == 125
+  end
+
+  it "evaluates elsif-body in containing scope" do
+    a = 123
+    if false
+      b = a+1
+    elsif false
+      b = a+2
+    elsif true
+      b = a+3
+    else
+      b = a+4
+    end
+    b.should == 126
+  end
+end
+

data/runtime/spec/language/loop_spec.rb

@@ -0,0 +1,32 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "The loop expression" do
+  it "repeats the given block until a break is called" do
+    outer_loop = 0
+    loop do
+      outer_loop += 1
+      break if outer_loop == 10
+    end
+    outer_loop.should == 10
+  end
+
+  it "executes code in its own scope" do
+    loop do
+      inner_loop = 123
+      break
+    end
+    lambda { inner_loop }.should raise_error(NameError)
+  end
+
+  it "returns the value passed to break if interrupted by break" do
+    loop do
+      break 123
+    end.should == 123
+  end
+
+  it "returns nil if interrupted by break with no arguments" do
+    loop do
+      break
+    end.should == nil
+  end
+end

data/runtime/spec/language/next_spec.rb

@@ -0,0 +1,128 @@
+require File.expand_path('../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/next', __FILE__)
+
+describe "The next statement from within the block" do
+  before :each do
+    ScratchPad.record []
+  end
+
+  it "ends block execution" do
+    a = []
+    lambda {
+      a << 1
+      next
+      a << 2
+    }.call
+    a.should == [1]
+  end
+
+  it "causes block to return nil if invoked without arguments" do
+    lambda { 123; next; 456 }.call.should == nil
+  end
+
+  it "causes block to return nil if invoked with an empty expression" do
+    lambda { next (); 456 }.call.should be_nil
+  end
+
+  it "returns the argument passed" do
+    lambda { 123; next 234; 345 }.call.should == 234
+  end
+
+  it "returns to the invoking method" do
+    NextSpecs.yielding_method(nil) { next }.should == :method_return_value
+  end
+
+  it "returns to the invoking method, with the specified value" do
+    NextSpecs.yielding_method(nil) {
+      next nil;
+      fail("next didn't end the block execution")
+    }.should == :method_return_value
+
+    NextSpecs.yielding_method(1) {
+      next 1;
+      fail("next didn't end the block execution")
+    }.should == :method_return_value
+
+    NextSpecs.yielding_method([1, 2, 3]) {
+      next 1, 2, 3;
+      fail("next didn't end the block execution")
+    }.should == :method_return_value
+  end
+
+  it "returns to the currently yielding method in case of chained calls" do
+    class ChainedNextTest
+      def self.meth_with_yield(&b)
+        yield.should == :next_return_value
+        :method_return_value
+      end
+      def self.invoking_method(&b)
+        meth_with_yield(&b)
+      end
+      def self.enclosing_method
+        invoking_method do
+          next :next_return_value
+          :wrong_return_value
+        end
+      end
+    end
+
+    ChainedNextTest.enclosing_method.should == :method_return_value
+  end
+
+  it "causes ensure blocks to run" do
+    [1].each do |i|
+      begin
+        ScratchPad << :begin
+        next
+      ensure
+        ScratchPad << :ensure
+      end
+    end
+
+    ScratchPad.recorded.should == [:begin, :ensure]
+  end
+end
+
+describe "The next statement" do
+  before :each do
+    ScratchPad.record []
+  end
+
+  describe "in a while loop" do
+    describe "when not passed an argument" do
+      before :each do
+        ScratchPad.record []
+      end
+
+      it "causes ensure blocks to run" do
+        NextSpecs.while_next(false)
+
+        ScratchPad.recorded.should == [:begin, :ensure]
+      end
+
+      it "causes ensure blocks to run when nested in an block" do
+        NextSpecs.while_within_iter(false)
+
+        ScratchPad.recorded.should == [:begin, :ensure]
+      end
+    end
+
+    describe "when passed an argument" do
+      before :each do
+        ScratchPad.record []
+      end
+
+      it "causes ensure blocks to run" do
+        NextSpecs.while_next(true)
+
+        ScratchPad.recorded.should == [:begin, :ensure]
+      end
+
+      it "causes ensure blocks to run when nested in an block" do
+        NextSpecs.while_within_iter(true)
+
+        ScratchPad.recorded.should == [:begin, :ensure]
+      end
+    end
+  end
+end