opal 0.3.41 → 0.3.42

data/spec/core/array/shuffle_spec.rb

@@ -1,11 +1,87 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
 describe "Array#shuffle" do
-  it "returns an array mixed up" do
-    ary = [1, 2, 3, 4, 5]
-    [1, 2, 3, 4, 5].shuffle.size.should eq(ary.size)
+  ruby_version_is "1.8.7" do
+    it "returns the same values, in a usually different order" do
+      a = [1, 2, 3, 4]
+      different = false
+      10.times do
+        s = a.shuffle
+        s.sort.should == a
+        different ||= (a != s)
+      end
+      different.should be_true # Will fail once in a blue moon (4!^10)
+    end
+
+    it "is not destructive" do
+      a = [1, 2, 3]
+      10.times do
+        a.shuffle
+        a.should == [1, 2, 3]
+      end
+    end
+  end
+
+  ruby_version_is "1.8.7" ... "1.9.3" do
+    pending "returns subclass instances with Array subclass" do
+      ArraySpecs::MyArray[1, 2, 3].shuffle.should be_an_instance_of(ArraySpecs::MyArray)
+    end
   end
 
-  it "returns an array mixed up with UTF-8 characters" do
-    ary = ["á", "é", "à", "ñÑ", "¥ØŁØ"]
-    ["á", "é", "à", "ñÑ", "¥ØŁØ"].shuffle.size.should eq(ary.size)
+  ruby_version_is "1.9.3" do
+    it "does not return subclass instances with Array subclass" do
+      ArraySpecs::MyArray[1, 2, 3].shuffle.should be_an_instance_of(Array)
+    end
+  end
+
+  ruby_version_is "1.9.3" do
+    it "attempts coercion via #to_hash" do
+      obj = mock('hash')
+      obj.should_receive(:to_hash).once.and_return({})
+      [2, 3].shuffle(obj)
+    end
+
+    it "uses default random generator" do
+      Kernel.should_receive(:rand).exactly(2).and_return(1, 0)
+      [2, 3].shuffle(:random => Object.new).should == [3, 2]
+    end
+
+    it "uses given random generator" do
+      random = Random.new
+      random.should_receive(:rand).exactly(2).and_return(1, 0)
+      [2, 3].shuffle(:random => random).should == [3, 2]
+    end
+  end
+end
+
+describe "Array#shuffle!" do
+  ruby_version_is "1.8.7" do
+    it "returns the same values, in a usually different order" do
+      a = [1, 2, 3, 4]
+      original = a
+      different = false
+      10.times do
+        a = a.shuffle!
+        a.sort.should == [1, 2, 3, 4]
+        different ||= (a != [1, 2, 3, 4])
+      end
+      different.should be_true # Will fail once in a blue moon (4!^10)
+      a.should equal(original)
+    end
+
+    ruby_version_is ""..."1.9" do
+      it "raises a TypeError on a frozen array" do
+        lambda { ArraySpecs.frozen_array.shuffle! }.should raise_error(TypeError)
+        lambda { ArraySpecs.empty_frozen_array.shuffle! }.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.shuffle! }.should raise_error(RuntimeError)
+        lambda { ArraySpecs.empty_frozen_array.shuffle! }.should raise_error(RuntimeError)
+      end
+    end
   end
 end

data/spec/core/array/size_spec.rb

@@ -1,6 +1,9 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+require File.expand_path('../shared/length', __FILE__)
+
 describe "Array#size" do
-  it "returns the number of elements" do
-    [].size.should == 0
-    [1, 2, 3].size.should == 3
+  pending do
+    it_behaves_like(:array_length, :size)
   end
-end
+end

data/spec/core/array/slice_spec.rb

@@ -1,3 +1,7 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+require File.expand_path('../shared/slice', __FILE__)
+
 describe "Array#slice!" do
   it "removes and return the element at index" do
     a = [1, 2, 3, 4]
@@ -34,4 +38,131 @@ describe "Array#slice!" do
     a.slice!(0, 4).should == []
     a.should == []
   end
-end
+
+  pending "properly handles recursive arrays" do
+    empty = ArraySpecs.empty_recursive_array
+    empty.slice(0).should == empty
+
+    array = ArraySpecs.recursive_array
+    array.slice(4).should == array
+    array.slice(0..3).should == [1, 'two', 3.0, array]
+  end
+
+  pending "calls to_int on start and length arguments" do
+    obj = mock('2')
+    def obj.to_int() 2 end
+
+    a = [1, 2, 3, 4, 5]
+    a.slice!(obj).should == 3
+    a.should == [1, 2, 4, 5]
+    a.slice!(obj, obj).should == [4, 5]
+    a.should == [1, 2]
+    a.slice!(0, obj).should == [1, 2]
+    a.should == []
+  end
+
+  pending "removes and return elements in range" do
+    a = [1, 2, 3, 4, 5, 6, 7, 8]
+    a.slice!(1..4).should == [2, 3, 4, 5]
+    a.should == [1, 6, 7, 8]
+    a.slice!(1...3).should == [6, 7]
+    a.should == [1, 8]
+    a.slice!(-1..-1).should == [8]
+    a.should == [1]
+    a.slice!(0...0).should == []
+    a.should == [1]
+    a.slice!(0..0).should == [1]
+    a.should == []
+
+    a = [1,2,3]
+    a.slice!(0..3).should == [1,2,3]
+    a.should == []
+  end
+
+  pending "calls to_int on range arguments" do
+    from = mock('from')
+    to = mock('to')
+
+    # So we can construct a range out of them...
+    def from.<=>(o) 0 end
+    def to.<=>(o) 0 end
+
+    def from.to_int() 1 end
+    # def to.to_int() -2 end
+
+    a = [1, 2, 3, 4, 5]
+
+    a.slice!(from .. to).should == [2, 3, 4]
+    a.should == [1, 5]
+
+    lambda { a.slice!("a" .. "b")  }.should raise_error(TypeError)
+    lambda { a.slice!(from .. "b") }.should raise_error(TypeError)
+  end
+
+  it "returns last element for consecutive calls at zero index" do
+    a = [ 1, 2, 3 ]
+    a.slice!(0).should == 1
+    a.slice!(0).should == 2
+    a.slice!(0).should == 3
+    a.should == []
+  end
+
+  ruby_version_is "" ... "1.8.7" do
+    # See http://groups.google.com/group/ruby-core-google/t/af70e3d0e9b82f39
+    it "expands self when indices are out of bounds" do
+      a = [1, 2]
+      a.slice!(4).should == nil
+      a.should == [1, 2]
+      a.slice!(4, 0).should == nil
+      a.should == [1, 2, nil, nil]
+      a.slice!(6, 1).should == nil
+      a.should == [1, 2, nil, nil, nil, nil]
+      a.slice!(8...8).should == nil
+      a.should == [1, 2, nil, nil, nil, nil, nil, nil]
+      a.slice!(10..10).should == nil
+      a.should == [1, 2, nil, nil, nil, nil, nil, nil, nil, nil]
+    end
+  end
+
+  ruby_version_is "1.8.7" do
+    it "does not expand array with indices out of bounds" do
+      a = [1, 2]
+      a.slice!(4).should == nil
+      a.should == [1, 2]
+      a.slice!(4, 0).should == nil
+      a.should == [1, 2]
+      a.slice!(6, 1).should == nil
+      a.should == [1, 2]
+      a.slice!(8...8).should == nil
+      a.should == [1, 2]
+      a.slice!(10..10).should == nil
+      a.should == [1, 2]
+    end
+
+    it "does not expand array with negative indices out of bounds" do
+      a = [1, 2]
+      a.slice!(-3, 1).should == nil
+      a.should == [1, 2]
+      a.slice!(-3..2).should == nil
+      a.should == [1, 2]
+    end
+  end
+
+  ruby_version_is "" ... "1.9" do
+    it "raises a TypeError on a frozen array" do
+      lambda { ArraySpecs.frozen_array.slice!(0, 0) }.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.slice!(0, 0) }.should raise_error(RuntimeError)
+    end
+  end
+end
+
+describe "Array#slice" do
+  pending do
+    it_behaves_like(:array_slice, :slice)
+  end
+end

data/spec/core/array/sort_spec.rb

@@ -1,22 +1,271 @@
-describe "Array#sort and Array#sort!" do
-  it "return new sorted Array if #sort" do
-    a = [2, 7, 5, 9]
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe "Array#sort" do
+  pending "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
+
+  pending "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
+
+  pending "sorts already-sorted Arrays" do
+    (0..15).to_a.sort.should == (0..15).to_a
+  end
+
+  pending "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
+
+  pending "properly handles recursive arrays" do
+    empty = ArraySpecs.empty_recursive_array
+    empty.sort.should == empty
+
+    array = [[]]; array << array
+    array.sort.should == [[], array]
+  end
+
+  pending "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
 
-    b.should == [2, 5, 7, 9]
-    b.object_id.should_not == a.object_id
+  pending "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
+
+  pending "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
+
+  pending "does not freezes self during being sorted" do
+    a = [1, 2, 3]
+    a.sort { |x,y| a.frozen?.should == false; x <=> y }
   end
 
-  it "return same sorted Array if #sort!" do
-    a = [2, 7, 5, 9]
-    b = a.sort!
+  pending "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
+
+  pending "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
+
+  pending "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
+    pending "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
+  pending "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
+
+  pending "properly handles recursive arrays" do
+    empty = ArraySpecs.empty_recursive_array
+    empty.sort!.should == empty
+
+    array = [[]]; array << array
+    array.sort!.should == array
+  end
+
+  pending "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
 
-    b.should == [2, 5, 7, 9]
-    b.object_id.should == a.object_id
+  pending "returns the specified value when it would break in the given block" do
+    [1, 2, 3].sort{ break :a }.should == :a
   end
 
-  it "#sort and #sort! should support sorting functions" do
-    ["one", "two", "three", "four"].sort {|a , b| a.length  <=> b.length }.should == ["one", "two", "four", "three"]
-    [2, 7, 5, 9].sort! {|a , b| b <=> a }.should == [9, 7, 5, 2]
+  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
+end