opal 0.4.4 → 0.5.0

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

@@ -1,271 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-require File.expand_path('../fixtures/classes', __FILE__)
-
-describe "Array#sort" do
-  it "returns a new array sorted based on comparing elements with <=>" do
-    a = [1, -2, 3, 9, 1, 5, -5, 1000, -5, 2, -10, 14, 6, 23, 0]
-    a.sort.should == [-10, -5, -5, -2, 0, 1, 1, 2, 3, 5, 6, 9, 14, 23, 1000]
-  end
-
-  it "does not affect the original Array" do
-    a = [0, 15, 2, 3, 4, 6, 14, 5, 7, 12, 8, 9, 1, 10, 11, 13]
-    b = a.sort
-    a.should == [0, 15, 2, 3, 4, 6, 14, 5, 7, 12, 8, 9, 1, 10, 11, 13]
-    b.should == (0..15).to_a
-  end
-
-  it "sorts already-sorted Arrays" do
-    (0..15).to_a.sort.should == (0..15).to_a
-  end
-
-  it "sorts reverse-sorted Arrays" do
-    (0..15).to_a.reverse.sort.should == (0..15).to_a
-  end
-
-  it "sorts Arrays that consist entirely of equal elements" do
-    a = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
-    a.sort.should == a
-    b = Array.new(15).map { ArraySpecs::SortSame.new }
-    b.sort.should == b
-  end
-
-  it "sorts Arrays that consist mostly of equal elements" do
-    a = [1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1]
-    a.sort.should == [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
-  end
-
-  it "does not return self even if the array would be already sorted" do
-    a = [1, 2, 3]
-    sorted = a.sort
-    sorted.should == a
-    sorted.should_not equal(a)
-  end
-
-  it "properly handles recursive arrays" do
-    empty = ArraySpecs.empty_recursive_array
-    empty.sort.should == empty
-
-    array = [[]]; array << array
-    array.sort.should == [[], array]
-  end
-
-  it "uses #<=> of elements in order to sort" do
-    a = ArraySpecs::MockForCompared.new
-    b = ArraySpecs::MockForCompared.new
-    c = ArraySpecs::MockForCompared.new
-
-    ArraySpecs::MockForCompared.compared?.should == false
-    [a, b, c].sort.should == [c, b, a]
-    ArraySpecs::MockForCompared.compared?.should == true
-  end
-
-  it "does not deal with exceptions raised by unimplemented or incorrect #<=>" do
-    o = Object.new
-
-    lambda { [o, 1].sort }.should raise_error
-  end
-
-  it "may take a block which is used to determine the order of objects a and b described as -1, 0 or +1" do
-    a = [5, 1, 4, 3, 2]
-    a.sort.should == [1, 2, 3, 4, 5]
-    a.sort {|x, y| y <=> x}.should == [5, 4, 3, 2, 1]
-  end
-
-  it "raises an error when a given block returns nil" do
-    lambda { [1, 2].sort {} }.should raise_error(ArgumentError)
-  end
-
-  it "does not call #<=> on contained objects when invoked with a block" do
-    a = Array.new(25)
-    (0...25).each {|i| a[i] = ArraySpecs::UFOSceptic.new }
-
-    a.sort { -1 }.should be_kind_of(Array)
-  end
-
-  it "does not call #<=> on elements when invoked with a block even if Array is large (Rubinius #412)" do
-    a = Array.new(1500)
-    (0...1500).each {|i| a[i] = ArraySpecs::UFOSceptic.new }
-
-    a.sort { -1 }.should be_kind_of(Array)
-  end
-
-  it "completes when supplied a block that always returns the same result" do
-    a = [2, 3, 5, 1, 4]
-    a.sort {  1 }.should be_kind_of(Array)
-    a.sort {  0 }.should be_kind_of(Array)
-    a.sort { -1 }.should be_kind_of(Array)
-  end
-
-  it "does not freezes self during being sorted" do
-    a = [1, 2, 3]
-    a.sort { |x,y| a.frozen?.should == false; x <=> y }
-  end
-
-  it "returns the specified value when it would break in the given block" do
-    [1, 2, 3].sort{ break :a }.should == :a
-  end
-
-  it "uses the sign of Bignum block results as the sort result" do
-    a = [1, 2, 5, 10, 7, -4, 12]
-    begin
-      class Bignum;
-        alias old_spaceship <=>
-        def <=>(other)
-          raise
-        end
-      end
-      a.sort {|n, m| (n - m) * (2 ** 200)}.should == [-4, 1, 2, 5, 7, 10, 12]
-    ensure
-      class Bignum
-        alias <=> old_spaceship
-      end
-    end
-  end
-
-  it "compares values returned by block with 0" do
-    a = [1, 2, 5, 10, 7, -4, 12]
-    a.sort { |n, m| n - m }.should == [-4, 1, 2, 5, 7, 10, 12]
-    a.sort { |n, m|
-      ArraySpecs::ComparableWithFixnum.new(n-m)
-    }.should == [-4, 1, 2, 5, 7, 10, 12]
-    lambda {
-      a.sort { |n, m| (n - m).to_s }
-    }.should raise_error(ArgumentError)
-  end
-
-  it "sorts an array that has a value shifted off without a block" do
-    a = Array.new(20, 1)
-    a.shift
-    a[0] = 2
-    a.sort.last.should == 2
-  end
-
-  it "sorts an array that has a value shifted off with a block" do
-    a = Array.new(20, 1)
-    a.shift
-    a[0] = 2
-    a.sort {|a, b| a <=> b }.last.should == 2
-  end
-
-  it "raises an error if objects can't be compared" do
-    a=[ArraySpecs::Uncomparable.new, ArraySpecs::Uncomparable.new]
-    lambda {a.sort}.should raise_error(ArgumentError)
-  end
-
-  # From a strange Rubinius bug
-  it "handles a large array that has been pruned" do
-    pruned = ArraySpecs::LargeArray.dup.delete_if { |n| n !~ /^test./ }
-    pruned.sort.should == ArraySpecs::LargeTestArraySorted
-  end
-
-  ruby_version_is "" ... "1.9.3" do
-    it "returns subclass instance on Array subclasses" do
-      ary = ArraySpecs::MyArray[1, 2, 3]
-      ary.sort.should be_kind_of(ArraySpecs::MyArray)
-    end
-  end
-
-  ruby_version_is "1.9.3" do
-    it "does not return subclass instance on Array subclasses" do
-      ary = ArraySpecs::MyArray[1, 2, 3]
-      ary.sort.should be_kind_of(Array)
-    end
-  end
-end
-
-describe "Array#sort!" do
-  it "sorts array in place using <=>" do
-    a = [1, -2, 3, 9, 1, 5, -5, 1000, -5, 2, -10, 14, 6, 23, 0]
-    a.sort!
-    a.should == [-10, -5, -5, -2, 0, 1, 1, 2, 3, 5, 6, 9, 14, 23, 1000]
-  end
-
-  it "sorts array in place using block value if a block given" do
-    a = [0, 15, 2, 3, 4, 6, 14, 5, 7, 12, 8, 9, 1, 10, 11, 13]
-    a.sort! { |x, y| y <=> x }.should == (0..15).to_a.reverse
-  end
-
-  it "returns self if the order of elements changed" do
-    a = [6, 7, 2, 3, 7]
-    a.sort!.should equal(a)
-    a.should == [2, 3, 6, 7, 7]
-  end
-
-  it "returns self even if makes no modification" do
-    a = [1, 2, 3, 4, 5]
-    a.sort!.should equal(a)
-    a.should == [1, 2, 3, 4, 5]
-  end
-
-  it "properly handles recursive arrays" do
-    empty = ArraySpecs.empty_recursive_array
-    empty.sort!.should == empty
-
-    array = [[]]; array << array
-    array.sort!.should == array
-  end
-
-  it "uses #<=> of elements in order to sort" do
-    a = ArraySpecs::MockForCompared.new
-    b = ArraySpecs::MockForCompared.new
-    c = ArraySpecs::MockForCompared.new
-
-    ArraySpecs::MockForCompared.compared?.should == false
-    [a, b, c].sort!.should == [c, b, a]
-    ArraySpecs::MockForCompared.compared?.should == true
-  end
-
-  it "does not call #<=> on contained objects when invoked with a block" do
-    a = Array.new(25)
-    (0...25).each {|i| a[i] = ArraySpecs::UFOSceptic.new }
-
-    a.sort! { -1 }.should be_kind_of(Array)
-  end
-
-  it "does not call #<=> on elements when invoked with a block even if Array is large (Rubinius #412)" do
-    a = Array.new(1500)
-    (0...1500).each {|i| a[i] = ArraySpecs::UFOSceptic.new }
-
-    a.sort! { -1 }.should be_kind_of(Array)
-  end
-
-  it "completes when supplied a block that always returns the same result" do
-    a = [2, 3, 5, 1, 4]
-    a.sort!{  1 }.should be_kind_of(Array)
-    a.sort!{  0 }.should be_kind_of(Array)
-    a.sort!{ -1 }.should be_kind_of(Array)
-  end
-
-  ruby_version_is '' ... '1.9' do
-    it "raises a TypeError on a frozen array" do
-      lambda { ArraySpecs.frozen_array.sort! }.should raise_error(TypeError)
-    end
-
-    not_compliant_on :rubinius do
-      it "temporarily freezes self and recovers after sorted" do
-        a = [1, 2, 3]
-        a.sort! { |x,y| a.frozen?.should == true; x <=> y }
-        a.frozen?.should == false
-      end
-    end
-  end
-
-  ruby_version_is '1.9' do
-    it "raises a RuntimeError on a frozen array" do
-      lambda { ArraySpecs.frozen_array.sort! }.should raise_error(RuntimeError)
-    end
-  end
-
-  it "returns the specified value when it would break in the given block" do
-    [1, 2, 3].sort{ break :a }.should == :a
-  end
-
-  it "makes some modification even if finished sorting when it would break in the given block" do
-    partially_sorted = (1..5).map{|i|
-      ary = [5, 4, 3, 2, 1]
-      ary.sort!{|x,y| break if x==i; x<=>y}
-      ary
-    }
-    partially_sorted.any?{|ary| ary != [1, 2, 3, 4, 5]}.should be_true
-  end
-end

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

@@ -1,29 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-ruby_version_is "1.8.7" do
-  describe "Array#take" do
-    it "returns the first specified number of elements" do
-      [1, 2, 3].take(2).should == [1, 2]
-    end
-
-    it "returns all elements when the argument is greater than the Array size" do
-      [1, 2].take(99).should == [1, 2]
-    end
-
-    it "returns all elements when the argument is less than the Array size" do
-      [1, 2].take(4).should == [1, 2]
-    end
-
-    it "returns an empty Array when passed zero" do
-      [1].take(0).should == []
-    end
-
-    it "returns an empty Array when called on an empty Array" do
-      [].take(3).should == []
-    end
-
-    it "raises an ArgumentError when the argument is negative" do
-      lambda{ [1].take(-3) }.should raise_error(ArgumentError)
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-ruby_version_is "1.8.7" do
-  describe "Array#take_while" do
-    it "returns all elements until the block returns false" do
-      [1, 2, 3].take_while{ |element| element < 3 }.should == [1, 2]
-    end
-
-    it "returns all elements until the block returns nil" do
-      [1, 2, nil, 4].take_while{ |element| element }.should == [1, 2]
-    end
-
-    it "returns all elements until the block returns false" do
-      [1, 2, false, 4].take_while{ |element| element }.should == [1, 2]
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-require File.expand_path('../fixtures/classes', __FILE__)
-
-describe "Array#to_a" do
-  it "returns self" do
-    a = [1, 2, 3]
-    a.to_a.should == [1, 2, 3]
-    a.should equal(a.to_a)
-  end
-
-  it "does not return subclass instance on Array subclasses" do
-    e = ArraySpecs::MyArray.new(1, 2)
-    e.to_a.should be_an_instance_of(Array)
-    e.to_a.should == [1, 2]
-  end
-
-  it "properly handles recursive arrays" do
-    empty = ArraySpecs.empty_recursive_array
-    empty.to_a.should == empty
-
-    array = ArraySpecs.recursive_array
-    array.to_a.should == array
-  end
-end

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

@@ -1,20 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-require File.expand_path('../fixtures/classes', __FILE__)
-
-describe "Array#to_ary" do
-  it "returns self" do
-    a = [1, 2, 3]
-    a.should equal(a.to_ary)
-    a = ArraySpecs::MyArray[1, 2, 3]
-    a.should equal(a.to_ary)
-  end
-
-  it "properly handles recursive arrays" do
-    empty = ArraySpecs.empty_recursive_array
-    empty.to_ary.should == empty
-
-    array = ArraySpecs.recursive_array
-    array.to_ary.should == array
-  end
-
-end

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

@@ -1,52 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-require File.expand_path('../fixtures/classes', __FILE__)
-
-ruby_version_is "1.9" do
-  describe "Array.try_convert" do
-    it "returns the argument if it's an Array" do
-      x = Array.new
-      Array.try_convert(x).should equal(x)
-    end
-
-    it "returns the argument if it's a kind of Array" do
-      x = ArraySpecs::MyArray[]
-      Array.try_convert(x).should equal(x)
-    end
-
-    it "returns nil when the argument does not respond to #to_ary" do
-      Array.try_convert(Object.new).should be_nil
-    end
-
-    it "sends #to_ary to the argument and returns the result if it's nil" do
-      obj = mock("to_ary")
-      obj.should_receive(:to_ary).and_return(nil)
-      Array.try_convert(obj).should be_nil
-    end
-
-    it "sends #to_ary to the argument and returns the result if it's an Array" do
-      x = Array.new
-      obj = mock("to_ary")
-      obj.should_receive(:to_ary).and_return(x)
-      Array.try_convert(obj).should equal(x)
-    end
-
-    it "sends #to_ary to the argument and returns the result if it's a kind of Array" do
-      x = ArraySpecs::MyArray[]
-      obj = mock("to_ary")
-      obj.should_receive(:to_ary).and_return(x)
-      Array.try_convert(obj).should equal(x)
-    end
-
-    it "sends #to_ary to the argument and raises TypeError if it's not a kind of Array" do
-      obj = mock("to_ary")
-      obj.should_receive(:to_ary).and_return(Object.new)
-      lambda { Array.try_convert obj }.should raise_error(TypeError)
-    end
-
-    it "does not rescue exceptions raised by #to_ary" do
-      obj = mock("to_ary")
-      obj.should_receive(:to_ary).and_raise(RuntimeError)
-      lambda { Array.try_convert obj }.should raise_error(RuntimeError)
-    end
-  end
-end

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

@@ -1,167 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-require File.expand_path('../fixtures/classes', __FILE__)
-
-describe "Array#uniq" do
-  it "returns an array with no duplicates" do
-    ["a", "a", "b", "b", "c"].uniq.should == ["a", "b", "c"]
-  end
-
-  ruby_bug "#", "1.8.6.277" do
-    it "properly handles recursive arrays" do
-      empty = ArraySpecs.empty_recursive_array
-      empty.uniq.should == [empty]
-
-      array = ArraySpecs.recursive_array
-      array.uniq.should == [1, 'two', 3.0, array]
-    end
-  end
-
-  it "uses eql? semantics" do
-    [1.0, 1].uniq.should == [1.0, 1]
-  end
-
-  it "compares elements first with hash" do
-    # Can't use should_receive because it uses hash internally
-    x = mock('0')
-    def x.hash() 0 end
-    y = mock('0')
-    def y.hash() 0 end
-
-    [x, y].uniq.should == [x, y]
-  end
-
-  it "does not compare elements with different hash codes via eql?" do
-    # Can't use should_receive because it uses hash and eql? internally
-    x = mock('0')
-    def x.eql?(o) raise("Shouldn't receive eql?") end
-    y = mock('1')
-    def y.eql?(o) raise("Shouldn't receive eql?") end
-
-    def x.hash() 0 end
-    def y.hash() 1 end
-
-    [x, y].uniq.should == [x, y]
-  end
-
-  it "compares elements with matching hash codes with #eql?" do
-    # Can't use should_receive because it uses hash and eql? internally
-    a = Array.new(2) do
-      obj = mock('0')
-
-      def obj.hash()
-        # It's undefined whether the impl does a[0].eql?(a[1]) or
-        # a[1].eql?(a[0]) so we taint both.
-        def self.eql?(o) taint; o.taint; false; end
-        return 0
-      end
-
-      obj
-    end
-
-    a.uniq.should == a
-    a[0].tainted?.should == true
-    a[1].tainted?.should == true
-
-    a = Array.new(2) do
-      obj = mock('0')
-
-      def obj.hash()
-        # It's undefined whether the impl does a[0].eql?(a[1]) or
-        # a[1].eql?(a[0]) so we taint both.
-        def self.eql?(o) taint; o.taint; true; end
-        return 0
-      end
-
-      obj
-    end
-
-    a.uniq.size.should == 1
-    a[0].tainted?.should == true
-    a[1].tainted?.should == true
-  end
-
-  ruby_version_is "1.9" do
-    it "compares elements based on the value returned from the block" do
-      a = [1, 2, 3, 4]
-      a.uniq { |x| x >= 2 ? 1 : 0 }.should == [1, 2]
-    end
-  end
-
-  ruby_version_is "" ... "1.9.3" do
-    it "returns subclass instance on Array subclasses" do
-      ArraySpecs::MyArray[1, 2, 3].uniq.should be_kind_of(ArraySpecs::MyArray)
-    end
-  end
-
-  ruby_version_is "1.9.3" do
-    it "does not return subclass instance on Array subclasses" do
-      ArraySpecs::MyArray[1, 2, 3].uniq.should be_kind_of(Array)
-    end
-  end
-end
-
-describe "Array#uniq!" do
-  it "modifies the array in place" do
-    a = [ "a", "a", "b", "b", "c" ]
-    a.uniq!
-    a.should == ["a", "b", "c"]
-  end
-
-  it "returns self" do
-    a = [ "a", "a", "b", "b", "c" ]
-    a.should equal(a.uniq!)
-  end
-
-  ruby_bug "#", "1.8.6.277" do
-    it "properly handles recursive arrays" do
-      empty = ArraySpecs.empty_recursive_array
-      empty_dup = empty.dup
-      empty.uniq!
-      empty.should == empty_dup
-
-      array = ArraySpecs.recursive_array
-      expected = array[0..3]
-      array.uniq!
-      array.should == expected
-    end
-  end
-
-  it "returns nil if no changes are made to the array" do
-    [ "a", "b", "c" ].uniq!.should == nil
-  end
-
-  ruby_version_is ""..."1.9" do
-    it "raises a TypeError on a frozen array when the array is modified" do
-      dup_ary = [1, 1, 2]
-      dup_ary.freeze
-      lambda { dup_ary.uniq! }.should raise_error(TypeError)
-    end
-
-    it "does not raise an exception on a frozen array when the array would not be modified" do
-      ArraySpecs.frozen_array.uniq!.should be_nil
-    end
-  end
-
-  ruby_version_is "1.9" do
-    it "raises a RuntimeError on a frozen array when the array is modified" do
-      dup_ary = [1, 1, 2]
-      dup_ary.freeze
-      lambda { dup_ary.uniq! }.should raise_error(RuntimeError)
-    end
-
-    # see [ruby-core:23666]
-    it "raises a RuntimeError on a frozen array when the array would not be modified" do
-      lambda { ArraySpecs.frozen_array.uniq!}.should raise_error(RuntimeError)
-      lambda { ArraySpecs.empty_frozen_array.uniq!}.should raise_error(RuntimeError)
-    end
-
-    it "doesn't yield to the block on a frozen array" do
-      lambda { ArraySpecs.frozen_array.uniq!{ raise RangeError, "shouldn't yield"}}.should raise_error(RuntimeError)
-    end
-
-    it "compares elements based on the value returned from the block" do
-      a = [1, 2, 3, 4]
-      a.uniq! { |x| x >= 2 ? 1 : 0 }.should == [1, 2]
-    end
-  end
-end