opal 0.4.4 → 0.5.0

data/spec/rubyspec/language/case_spec.rb

@@ -1,310 +0,0 @@
-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
-
-  # MR: critical
-  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 matches when clauses with no values" do
-    case nil
-      when *[]
-        "foo"
-    end.should == nil
-  end
-
-  it "lets you define a method after the case statement" do
-    case (def foo; 'foo'; end; 'f')
-      when 'a'
-        'foo'
-      when 'f'
-        'bar'
-    end.should == 'bar'
-  end
-
-  it "raises a SyntaxError when 'else' is used when no 'when' is given" do
-    lambda {
-      eval <<-CODE
-      case 4
-        else
-          true
-      end
-      CODE
-    }.should raise_error(SyntaxError)
-  end
-
-  it "raises a SyntaxError when 'else' is used before a 'when' was given" do
-    lambda {
-      eval <<-CODE
-      case 4
-        else
-          true
-        when 4; false
-      end
-      CODE
-    }.should raise_error(SyntaxError)
-  end
-
-  it "supports nested case statements" do
-    result = false
-    case :x
-    when Symbol
-      case :y
-      when Symbol
-        result = true
-      end
-    end
-    result.should == true
-  end
-
-  it "supports nested case statements followed by a when with a splatted array" do
-    result = false
-    case :x
-    when Symbol
-      case :y
-      when Symbol
-        result = true
-      end
-    when *[Symbol]
-      result = false
-    end
-    result.should == true
-  end
-
-  it "supports nested case statements followed by a when with a splatted non-array" do
-    result = false
-    case :x
-    when Symbol
-      case :y
-      when Symbol
-        result = true
-      end
-    when *Symbol
-      result = false
-    end
-    result.should == true
-  end
-
-  it "works even if there's only one when statement" do
-    case 1
-    when 1
-      100
-    end.should == 100
-  end
-end
-
-describe "The 'case'-construct with no target expression" do
-  it "evaluates the body of the first clause when at least one of its condition expressions is true" do
-    case
-      when true, false; 'foo'
-    end.should == 'foo'
-  end
-
-  it "evaluates the body of the first when clause that is not false/nil" do
-    case
-      when false; 'foo'
-      when 2; 'bar'
-      when 1 == 1; 'baz'
-    end.should == 'bar'
-
-    case
-      when false; 'foo'
-      when nil; 'foo'
-      when 1 == 1; 'bar'
-    end.should == 'bar'
-  end
-
-  it "evaluates the body of the else clause if all when clauses are false/nil" do
-    case
-      when false; 'foo'
-      when nil; 'foo'
-      when 1 == 2; 'bar'
-      else 'baz'
-    end.should == 'baz'
-  end
-
-  it "evaluates multiple conditional expressions as a boolean disjunction" do
-    case
-      when true, false; 'foo'
-      else 'bar'
-    end.should == 'foo'
-
-    case
-      when false, true; 'foo'
-      else 'bar'
-    end.should == 'foo'
-  end
-
-  it "evaluates true as only 'true' when true is the first clause" do
-    case 1
-      when true; "bad"
-      when Integer; "good"
-    end.should == "good"
-  end
-
-  it "evaluates false as only 'false' when false is the first clause" do
-    case nil
-      when false; "bad"
-      when nil; "good"
-    end.should == "good"
-  end
-
-  it "treats a literal array as its own when argument, rather than a list of arguments" do
-    case 'foo'
-    when ['foo', 'foo']; 'bad'
-    when 'foo'; 'good'
-    end.should == 'good'
-  end
-end
-
-language_version __FILE__, "case"

data/spec/rubyspec/language/class_spec.rb

@@ -1,190 +0,0 @@
-require File.expand_path('../../spec_helper', __FILE__)
-require File.expand_path('../../fixtures/class', __FILE__)
-
-ClassSpecsNumber = 12
-
-module ClassSpecs
-  Number = 12
-end
-
-describe "A class definition" do
-  it "creates a new class" do
-    ClassSpecs::A.should be_kind_of(Class)
-    ClassSpecs::A.new.should be_kind_of(ClassSpecs::A)
-  end
-
-  it "has no class variables" do
-    ClassSpecs::A.class_variables.should == []
-  end
-
-  it "raises TypeError if constant given as class name exists and is not a Module" do
-    # 1.9 needs the constant defined here because of it's scoping rules
-    ClassSpecsNumber = 12
-    lambda {
-      class ClassSpecsNumber
-      end
-    }.should raise_error(TypeError)
-  end
-
-  # test case known to be detecting bugs (JRuby, MRI 1.9)
-  it "raises TypeError if the constant qualifying the class is nil" do
-    lambda {
-      class nil::Foo
-      end
-    }.should raise_error(TypeError)
-  end
-
-  it "raises TypeError if any constant qualifying the class is not a Module" do
-    lambda {
-      class ClassSpecs::Number::MyClass
-      end
-    }.should raise_error(TypeError)
-
-    lambda {
-      class ClassSpecsNumber::MyClass
-      end
-    }.should raise_error(TypeError)
-  end
-
-  it "allows using self as the superclass if self is a class" do
-    ClassSpecs::I::J.superclass.should == ClassSpecs::I
-
-    lambda {
-      class ShouldNotWork < self; end
-    }.should raise_error(TypeError)
-  end
-
-  it "raises a TypeError if inheriting from a metaclass" do
-    obj = mock("metaclass super")
-    meta = obj.singleton_class
-    lambda { class ClassSpecs::MetaclassSuper < meta; end }.should raise_error(TypeError)
-  end
-
-#  # I do not think this is a valid spec   -- rue
-#  it "has no class-level instance variables" do
-#    ClassSpecs::A.instance_variables.should == []
-#  end
-
-  it "allows the declaration of class variables in the body" do
-    ClassSpecs.string_class_variables(ClassSpecs::B).should == ["@@cvar"]
-    ClassSpecs::B.send(:class_variable_get, :@@cvar).should == :cvar
-  end
-
-  it "stores instance variables defined in the class body in the class object" do
-    ClassSpecs.string_instance_variables(ClassSpecs::B).should include("@ivar")
-    ClassSpecs::B.instance_variable_get(:@ivar).should == :ivar
-  end
-
-  it "allows the declaration of class variables in a class method" do
-    ClassSpecs::C.class_variables.should == []
-    ClassSpecs::C.make_class_variable
-    ClassSpecs.string_class_variables(ClassSpecs::C).should == ["@@cvar"]
-  end
-
-  it "allows the definition of class-level instance variables in a class method" do
-    ClassSpecs.string_instance_variables(ClassSpecs::C).should_not include("@civ")
-    ClassSpecs::C.make_class_instance_variable
-    ClassSpecs.string_instance_variables(ClassSpecs::C).should include("@civ")
-  end
-
-  it "allows the declaration of class variables in an instance method" do
-    ClassSpecs::D.class_variables.should == []
-    ClassSpecs::D.new.make_class_variable
-    ClassSpecs.string_class_variables(ClassSpecs::D).should == ["@@cvar"]
-  end
-
-  it "allows the definition of instance methods" do
-    ClassSpecs::E.new.meth.should == :meth
-  end
-
-  it "allows the definition of class methods" do
-    ClassSpecs::E.cmeth.should == :cmeth
-  end
-
-  it "allows the definition of class methods using class << self" do
-    ClassSpecs::E.smeth.should == :smeth
-  end
-
-  it "allows the definition of Constants" do
-    Object.const_defined?('CONSTANT').should == false
-    ClassSpecs::E.const_defined?('CONSTANT').should == true
-    ClassSpecs::E::CONSTANT.should == :constant!
-  end
-
-  it "returns the value of the last statement in the body" do
-    class ClassSpecs::Empty; end.should == nil
-    class ClassSpecs::Twenty; 20; end.should == 20
-    class ClassSpecs::Plus; 10 + 20; end.should == 30
-    class ClassSpecs::Singleton; class << self; :singleton; end; end.should == :singleton
-  end
-end
-
-describe "An outer class definition" do
-  it "contains the inner classes" do
-    ClassSpecs::Container.constants.should include('A', 'B')
-  end
-
-  it "contains the inner classes" do
-    ClassSpecs::Container.constants.should include(:A, :B)
-  end
-end
-
-describe "A class definition extending an object (sclass)" do
-  it "allows adding methods" do
-    ClassSpecs::O.smeth.should == :smeth
-  end
-
-  it "raises a TypeError when trying to extend numbers" do
-    lambda {
-      eval <<-CODE
-        class << 1
-          def xyz
-            self
-          end
-        end
-      CODE
-    }.should raise_error(TypeError)
-  end
-
-  it "allows accessing the block of the original scope" do
-    ClassSpecs.sclass_with_block { 123 }.should == 123
-  end
-
-  not_compliant_on :rubinius do
-    it "can use return to cause the enclosing method to return" do
-      ClassSpecs.sclass_with_return.should == :inner
-    end
-  end
-end
-
-describe "Reopening a class" do
-  it "extends the previous definitions" do
-    c = ClassSpecs::F.new
-    c.meth.should == :meth
-    c.another.should == :another
-  end
-
-  it "overwrites existing methods" do
-    ClassSpecs::G.new.override.should == :override
-  end
-
-  it "raises a TypeError when superclasses mismatch" do
-    lambda { class ClassSpecs::A < Array; end }.should raise_error(TypeError)
-  end
-
-  it "adds new methods to subclasses" do
-    lambda { ClassSpecs::M.m }.should raise_error(NoMethodError)
-    class ClassSpecs::L
-      def self.m
-        1
-      end
-    end
-    ClassSpecs::M.m.should == 1
-  end
-end
-
-describe "class provides hooks" do
-  it "calls inherited when a class is created" do
-    ClassSpecs::H.track_inherited.should == [ClassSpecs::K]
-  end
-end