opal 0.4.4 → 0.5.0

data/spec/rubyspec/core/array/new_spec.rb

@@ -1,137 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-require File.expand_path('../fixtures/classes', __FILE__)
-
-describe "Array.new" do
-  it "returns an instance of Array" do
-    Array.new.should be_kind_of(Array)
-  end
-
-  it "returns an instance of a subclass" do
-    ArraySpecs::MyArray.new(1, 2).should be_an_instance_of(ArraySpecs::MyArray)
-  end
-
-  it "raise an ArgumentError if passed 3 or more arguments" do
-    lambda do
-      Array.new(1, 'x', true)
-    end.should raise_error(ArgumentError)
-    lambda do
-      [1, 2].send(:initialize, 1, 'x', true) {}
-    end.should raise_error(ArgumentError)
-  end
-end
-
-describe "Array.new with no arguments" do
-  it "returns an empty array" do
-    Array.new.should be_empty
-  end
-
-  it "does not use the given block" do
-    lambda{ Array.new { raise } }.should_not raise_error
-  end
-end
-
-describe "Array.new with (array)" do
-  it "returns an array initialized to the other array" do
-    b = [4, 5, 6]
-    Array.new(b).should == b
-  end
-
-  it "does not use the given block" do
-    lambda{ Array.new([1, 2]) { raise } }.should_not raise_error
-  end
-
-  it "calls #to_ary to convert the value to an array" do
-    a = mock("array")
-    def a.to_ary; [1,2]; end
-    Array.new(a).should == [1, 2]
-  end
-
-  it "does not call #to_ary on instances of Array or subclasses of Array" do
-    a = [1, 2]
-    def a.to_ary; [1,2,3]; end
-    Array.new(a).should == [1,2]
-  end
-
-  it "raises a TypeError if an Array type argument and a default object" do
-    lambda { Array.new([1, 2], 1) }.should raise_error(TypeError)
-  end
-end
-
-describe "Array.new with (size, object=nil)" do
-  it "returns an array of size filled with object" do
-    obj = [3]
-    a = Array.new(2, obj)
-    a.should == [obj, obj]
-    a[0].should equal(obj)
-    a[1].should equal(obj)
-  end
-
-  it "returns an array of size filled with nil when object is omitted" do
-    Array.new(3).should == [nil, nil, nil]
-  end
-
-  it "raises an ArgumentError if size is negative" do
-    lambda { Array.new(-1, :a) }.should raise_error(ArgumentError)
-    lambda { Array.new(-1) }.should raise_error(ArgumentError)
-  end
-
-  platform_is :wordsize => 32 do
-    it "raises an ArgumentError if size is too large" do
-      max_size = ArraySpecs.max_32bit_size
-      lambda { Array.new(max_size + 1) }.should raise_error(ArgumentError)
-    end
-  end
-
-  platform_is :wordsize => 64 do
-    it "raises an ArgumentError if size is too large" do
-      max_size = ArraySpecs.max_64bit_size
-      lambda { Array.new(max_size + 1) }.should raise_error(ArgumentError)
-    end
-  end
-
-  it "calls #to_int to convert the size argument to an Integer when object is given" do
-    obj = mock('1')
-    def obj.to_int; 1; end
-    Array.new(obj, :a).should == [:a]
-  end
-
-  it "calls #to_int to convert the size argument to an Integer when object is not given" do
-    obj = mock('1')
-    def obj.to_int; 1; end
-    Array.new(obj).should == [nil]
-  end
-
-  it "raises a TypeError if the size argument is not an Integer type" do
-    obj1 = mock('nonnumeric')
-    def obj1.to_int; [1,2]; end
-    lambda{ Array.new(obj1, :a) }.should raise_error(TypeError)
-
-    obj2 = mock('nonnumeric')
-    def obj2.to_int; "123"; end
-    lambda{ Array.new(obj2, :a) }.should raise_error(TypeError)
-
-    obj3 = mock('nonnumeric')
-    def obj3.to_int; 1.2; end
-    lambda{ Array.new(obj3, :a) }.should raise_error(TypeError)
-  end
-
-  it "yields the index of the element and sets the element to the value of the block" do
-    Array.new(3) { |i| i.to_s }.should == ['0', '1', '2']
-  end
-
-  it "uses the block value instead of using the default value" do
-    Array.new(3, :obj) { |i| i.to_s }.should == ['0', '1', '2']
-  end
-
-  it "returns the value passed to break" do
-    Array.new(3) do |i|
-      break if i == 2
-      i.to_s
-    end.should == nil
-
-    Array.new(3) do |i|
-      break 3 if i == 2
-      i.to_s
-    end.should == 3
-  end
-end

data/spec/rubyspec/core/array/ntimes_spec.rb

@@ -1,26 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-require File.expand_path('../fixtures/classes', __FILE__)
-
-# Array#nitems was removed from Ruby 1.9.
-ruby_version_is '' ... '1.9' do
-  describe "Array#nitems" do
-    it "returns the number of non-nil elements" do
-      [nil].nitems.should == 0
-      [].nitems.should == 0
-      [1, 2, 3, nil].nitems.should == 3
-      [1, 2, 3].nitems.should == 3
-      [1, nil, 2, 3, nil, nil, 4].nitems.should == 4
-      [1, nil, 2, false, 3, nil, nil, 4].nitems.should == 5
-    end
-
-    it "properly handles recursive arrays" do
-      empty = ArraySpecs.empty_recursive_array
-      empty.nitems.should == 1
-
-      array = ArraySpecs.recursive_array
-      array.nitems.should == 8
-
-      [nil, empty, array].nitems.should == 2
-    end
-  end
-end

data/spec/rubyspec/core/array/plus_spec.rb

@@ -1,64 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-require File.expand_path('../fixtures/classes', __FILE__)
-
-describe "Array#+" do
-  it "concatenates two arrays" do
-    ([ 1, 2, 3 ] + [ 3, 4, 5 ]).should == [1, 2, 3, 3, 4, 5]
-    ([ 1, 2, 3 ] + []).should == [1, 2, 3]
-    ([] + [ 1, 2, 3 ]).should == [1, 2, 3]
-    ([] + []).should == []
-  end
-
-  it "can concatenate an array with itself" do
-    ary = [1, 2, 3]
-    (ary + ary).should == [1, 2, 3, 1, 2, 3]
-  end
-
-  it "tries to convert the passed argument to an Array using #to_ary" do
-    obj = mock('["x", "y"]')
-    def obj.to_ary ; ["x", "y"] ; end
-
-    ([1, 2, 3] + obj).should == [1, 2, 3, "x", "y"]
-  end
-
-  it "raise TypeError when not convert to array" do 
-    lambda { [1] + mock('["x", "y"]') }.should raise_error(TypeError)
-  end
-
-  it "properly handles recursive arrays" do
-    empty = ArraySpecs.empty_recursive_array
-    (empty + empty).should == [empty, empty]
-
-    array = ArraySpecs.recursive_array
-    (empty + array).should == [empty, 1, 'two', 3.0, array, array, array, array, array]
-    (array + array).should == [
-      1, 'two', 3.0, array, array, array, array, array,
-      1, 'two', 3.0, array, array, array, array, array]
-  end
-
-  it "does return subclass instances with Array subclasses" do
-    (ArraySpecs::MyArray[1, 2, 3] + []).should be_kind_of(Array)
-    (ArraySpecs::MyArray[1, 2, 3] + ArraySpecs::MyArray[]).should be_kind_of(Array)
-    ([1, 2, 3] + ArraySpecs::MyArray[]).should be_kind_of(Array)
-  end
-
-  it "does not call to_ary on array subclasses" do
-    ([5, 6] + ArraySpecs::ToAryArray[1, 2]).should == [5, 6, 1, 2]
-  end
-
-  it "does not get infected even if an original array is tainted" do
-    ([1, 2] + [3, 4]).tainted?.should be_false
-    ([1, 2].taint + [3, 4]).tainted?.should be_false
-    ([1, 2] + [3, 4].taint).tainted?.should be_false
-    ([1, 2].taint + [3, 4].taint).tainted?.should be_false
-  end
-
-  ruby_version_is '1.9' do
-    it "does not infected even if an original array is untrusted" do
-      ([1, 2] + [3, 4]).untrusted?.should be_false
-      ([1, 2].untrust + [3, 4]).untrusted?.should be_false
-      ([1, 2] + [3, 4].untrust).untrusted?.should be_false
-      ([1, 2].untrust + [3, 4].untrust).untrusted?.should be_false
-    end
-  end
-end

data/spec/rubyspec/core/array/pop_spec.rb

@@ -1,196 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-require File.expand_path('../fixtures/classes', __FILE__)
-
-describe "Array#pop" do
-  it "removes and returns the last element of the array" do
-    a = ["a", 1, nil, true]
-
-    a.pop.should == true
-    a.should == ["a", 1, nil]
-
-    a.pop.should == nil
-    a.should == ["a", 1]
-
-    a.pop.should == 1
-    a.should == ["a"]
-
-    a.pop.should == "a"
-    a.should == []
-  end
-
-  it "returns nil if there are no more elements" do
-    [].pop.should == nil
-  end
-
-  it "properly handles recursive arrays" do
-    empty = ArraySpecs.empty_recursive_array
-    empty.pop.should == []
-
-    array = ArraySpecs.recursive_array
-    array.pop.should == [1, 'two', 3.0, array, array, array, array]
-  end
-
-  it "keeps taint status" do
-    a = [1, 2].taint
-    a.pop
-    a.tainted?.should be_true
-    a.pop
-    a.tainted?.should be_true
-  end
-
-  ruby_version_is '' ... '1.9' do
-    it "raises a TypeError on a frozen array" do
-      lambda { ArraySpecs.frozen_array.pop }.should raise_error(TypeError)
-    end
-    it "raises a TypeError on an empty frozen array" do
-      lambda { ArraySpecs.empty_frozen_array.pop }.should raise_error(TypeError)
-    end
-  end
-
-  ruby_version_is '1.9' do
-    it "raises a RuntimeError on a frozen array" do
-      lambda { ArraySpecs.frozen_array.pop }.should raise_error(RuntimeError)
-    end
-
-    it "raises a RuntimeError on an empty frozen array" do
-      lambda { ArraySpecs.empty_frozen_array.pop }.should raise_error(RuntimeError)
-    end
-
-    it "keeps untrusted status" do
-      a = [1, 2].untrust
-      a.pop
-      a.untrusted?.should be_true
-      a.pop
-      a.untrusted?.should be_true
-    end
-  end
-
-  ruby_version_is '' ... '1.8.7' do
-    it "raises an ArgumentError if passed an argument" do
-      lambda{ [1, 2].pop(1) }.should raise_error(ArgumentError)
-    end
-  end
-
-  describe "passed a number n as an argument" do
-    ruby_version_is '1.8.7' do
-      it "removes and returns an array with the last n elements of the array" do
-        a = [1, 2, 3, 4, 5, 6]
-
-        a.pop(0).should == []
-        a.should == [1, 2, 3, 4, 5, 6]
-
-        a.pop(1).should == [6]
-        a.should == [1, 2, 3, 4, 5]
-
-        a.pop(2).should == [4, 5]
-        a.should == [1, 2, 3]
-
-        a.pop(3).should == [1, 2, 3]
-        a.should == []
-      end
-
-      it "returns an array with the last n elements even if shift was invoked" do
-        a = [1, 2, 3, 4]
-        a.shift
-        a.pop(3).should == [2, 3, 4]
-      end
-
-      it "returns a new empty array if there are no more elements" do
-        a = []
-        popped1 = a.pop(1)
-        popped1.should == []
-        a.should == []
-
-        popped2 = a.pop(2)
-        popped2.should == []
-        a.should == []
-
-        popped1.should_not equal(popped2)
-      end
-
-      it "returns whole elements if n exceeds size of the array" do
-        a = [1, 2, 3, 4, 5]
-        a.pop(6).should == [1, 2, 3, 4, 5]
-        a.should == []
-      end
-
-      it "does not return self even when it returns whole elements" do
-        a = [1, 2, 3, 4, 5]
-        a.pop(5).should_not equal(a)
-
-        a = [1, 2, 3, 4, 5]
-        a.pop(6).should_not equal(a)
-      end
-
-      it "raises an ArgumentError if n is negative" do
-        lambda{ [1, 2, 3].pop(-1) }.should raise_error(ArgumentError)
-      end
-
-      it "tries to convert n to an Integer using #to_int" do
-        a = [1, 2, 3, 4]
-        a.pop(2.3).should == [3, 4]
-
-        obj = mock('to_int')
-        obj.should_receive(:to_int).and_return(2)
-        a.should == [1, 2]
-        a.pop(obj).should == [1, 2]
-        a.should == []
-      end
-
-      it "raises a TypeError when the passed n can be coerced to Integer" do
-        lambda{ [1, 2].pop("cat") }.should raise_error(TypeError)
-        lambda{ [1, 2].pop(nil) }.should raise_error(TypeError)
-      end
-
-      it "raises an ArgumentError if more arguments are passed" do
-        lambda{ [1, 2].pop(1, 2) }.should raise_error(ArgumentError)
-      end
-
-      it "does not return subclass instances with Array subclass" do
-        ArraySpecs::MyArray[1, 2, 3].pop(2).should be_kind_of(Array)
-      end
-
-      it "returns an untainted array even if the array is tainted" do
-        ary = [1, 2].taint
-        ary.pop(2).tainted?.should be_false
-        ary.pop(0).tainted?.should be_false
-      end
-
-      it "keeps taint status" do
-        a = [1, 2].taint
-        a.pop(2)
-        a.tainted?.should be_true
-        a.pop(2)
-        a.tainted?.should be_true
-      end
-
-      ruby_version_is '' ... '1.9' do
-        it "raises a TypeError on a frozen array" do
-          lambda { ArraySpecs.frozen_array.pop(2) }.should raise_error(TypeError)
-          lambda { ArraySpecs.frozen_array.pop(0) }.should raise_error(TypeError)
-        end
-      end
-    end
-
-    ruby_version_is '1.9' do
-      it "returns a trusted array even if the array is untrusted" do
-        ary = [1, 2].untrust
-        ary.pop(2).untrusted?.should be_false
-        ary.pop(0).untrusted?.should be_false
-      end
-
-      it "raises a RuntimeError on a frozen array" do
-        lambda { ArraySpecs.frozen_array.pop(2) }.should raise_error(RuntimeError)
-        lambda { ArraySpecs.frozen_array.pop(0) }.should raise_error(RuntimeError)
-      end
-
-      it "keeps untrusted status" do
-        a = [1, 2].untrust
-        a.pop(2)
-        a.untrusted?.should be_true
-        a.pop(2)
-        a.untrusted?.should be_true
-      end
-    end
-  end
-end

data/spec/rubyspec/core/array/push_spec.rb

@@ -1,44 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-require File.expand_path('../fixtures/classes', __FILE__)
-
-describe "Array#push" do
-  it "appends the arguments to the array" do
-    a = [ "a", "b", "c" ]
-    a.push("d", "e", "f").should equal(a)
-    a.push().should == ["a", "b", "c", "d", "e", "f"]
-    a.push(5)
-    a.should == ["a", "b", "c", "d", "e", "f", 5]
-  end
-
-  it "isn't confused by previous shift" do
-    a = [ "a", "b", "c" ]
-    a.shift
-    a.push("foo")
-    a.should == ["b", "c", "foo"]
-  end
-
-  it "properly handles recursive arrays" do
-    empty = ArraySpecs.empty_recursive_array
-    empty.push(:last).should == [empty, :last]
-
-    array = ArraySpecs.recursive_array
-    array.push(:last).should == [1, 'two', 3.0, array, array, array, array, array, :last]
-  end
-
-  ruby_version_is "" ... "1.9" do
-    it "raises a TypeError on a frozen array if modification takes place" do
-      lambda { ArraySpecs.frozen_array.push(1) }.should raise_error(TypeError)
-    end
-
-    it "does not raise on a frozen array if no modification is made" do
-      ArraySpecs.frozen_array.push.should == [1, 2, 3]
-    end
-  end
-
-  ruby_version_is "1.9" do
-    it "raises a RuntimeError on a frozen array" do
-      lambda { ArraySpecs.frozen_array.push(1) }.should raise_error(RuntimeError)
-      lambda { ArraySpecs.frozen_array.push }.should raise_error(RuntimeError)
-    end
-  end
-end