wip, split specs into multiple

Author: lxxxvi

Diff for: core/array/shared/slice.rb

@@ -534,22 +534,292 @@ def to.to_int() -2 end
   end
 
   ruby_version_is "3.0" do
-    it "can be sliced with Enumerator::ArithmeticSequence" do
-      a = [0, 1, 2, 3, 4, 5]
-      a.send(@method, eval("(0..).step(1)")).should == [0, 1, 2, 3, 4, 5]
-      a.send(@method, eval("(0..).step(2)")).should == [0, 2, 4]
-      a.send(@method, eval("(0..).step(3)")).should == [0, 3]
-      a.send(@method, eval("(0..).step(10)")).should == [0]
-      a.send(@method, eval("(0..1).step(2)")).should == [0]
-      a.send(@method, eval("(..0).step(1)")).should == [0]
-      a.send(@method, eval("(...0).step(1)")).should == []
-      a.send(@method, eval("(2..).step(2)")).should == [2, 4]
-      a.send(@method, eval("(2..-2).step(2)")).should == [2, 4]
-      a.send(@method, eval("(2...-2).step(2)")).should == [2]
-      a.send(@method, eval("(2..).step(-2)")).should == [2, 0]
-      a.send(@method, eval("(2..).step(-3)")).should == [2]
-      a.send(@method, eval("(..-2).step(2)")).should == [0, 2, 4]
-      a.send(@method, eval("(...-2).step(2)")).should == [0, 2]
+    describe "can be sliced with Enumerator::ArithmeticSequence" do
+      before :each do
+        @array = [0, 1, 2, 3, 4, 5]
+      end
+
+      it "has endless range and positive steps" do
+        @array.send(@method, eval("(0..).step(1)")).should == [0, 1, 2, 3, 4, 5]
+        @array.send(@method, eval("(0..).step(2)")).should == [0, 2, 4]
+        @array.send(@method, eval("(0..).step(10)")).should == [0]
+
+        @array.send(@method, eval("(2..).step(1)")).should == [2, 3, 4, 5]
+        @array.send(@method, eval("(2..).step(2)")).should == [2, 4]
+        @array.send(@method, eval("(2..).step(10)")).should == [2]
+
+        @array.send(@method, eval("(-3..).step(1)")).should == [3, 4, 5]
+        @array.send(@method, eval("(-3..).step(2)")).should == [3, 5]
+        @array.send(@method, eval("(-3..).step(10)")).should == [3]
+      end
+
+      it "has beginless range and positive steps" do
+        # end with zero index
+        @array.send(@method, eval("(..0).step(1)")).should == [0]
+        @array.send(@method, eval("(...0).step(1)")).should == []
+
+        @array.send(@method, eval("(..0).step(2)")).should == [0]
+        @array.send(@method, eval("(...0).step(2)")).should == []
+
+        @array.send(@method, eval("(..0).step(10)")).should == [0]
+        @array.send(@method, eval("(...0).step(10)")).should == []
+
+        # end with positive index
+        @array.send(@method, eval("(..3).step(1)")).should == [0, 1, 2, 3]
+        @array.send(@method, eval("(...3).step(1)")).should == [0, 1, 2]
+
+        @array.send(@method, eval("(..3).step(2)")).should == [0, 2]
+        @array.send(@method, eval("(...3).step(2)")).should == [0, 2]
+
+        @array.send(@method, eval("(..3).step(10)")).should == [0]
+        @array.send(@method, eval("(...3).step(10)")).should == [0]
+
+        # end with negative index
+        @array.send(@method, eval("(..-2).step(1)")).should == [0, 1, 2, 3, 4,]
+        @array.send(@method, eval("(...-2).step(1)")).should == [0, 1, 2, 3]
+
+        @array.send(@method, eval("(..-2).step(2)")).should == [0, 2, 4]
+        @array.send(@method, eval("(...-2).step(2)")).should == [0, 2]
+
+        @array.send(@method, eval("(..-2).step(10)")).should == [0]
+        @array.send(@method, eval("(...-2).step(10)")).should == [0]
+      end
+
+      it "has endless range and negative steps" do
+        @array.send(@method, eval("(0..).step(-1)")).should == [0]
+        @array.send(@method, eval("(0..).step(-2)")).should == [0]
+        @array.send(@method, eval("(0..).step(-10)")).should == [0]
+
+        @array.send(@method, eval("(2..).step(-1)")).should == [2, 1, 0]
+        @array.send(@method, eval("(2..).step(-2)")).should == [2, 0]
+        @array.send(@method, eval("(2..).step(-10)")).should == [0]                   # ???
+
+        @array.send(@method, eval("(-3..).step(-1)")).should == [3, 2, 1, 0]
+        @array.send(@method, eval("(-3..).step(-2)")).should == [3, 1]
+        @array.send(@method, eval("(-3..).step(-10)")).should == [0]                  # ???
+      end
+
+      # ????????
+      it "has beginless range and negative steps" do
+        # end with zero index
+        @array.send(@method, eval("(..0).step(-1)")).should == [5, 4, 3, 2, 1, 0]
+        @array.send(@method, eval("(...0).step(-1)")).should == [5, 4, 3, 2, 1, 0]
+
+        @array.send(@method, eval("(..0).step(-2)")).should == [5, 3, 1]
+        @array.send(@method, eval("(...0).step(-2)")).should == [5, 3, 1]
+
+        @array.send(@method, eval("(..0).step(-10)")).should == [0]
+        @array.send(@method, eval("(...0).step(-10)")).should == [0]
+
+        # end with positive index
+        @array.send(@method, eval("(..3).step(-1)")).should == [5, 4, 3]
+        @array.send(@method, eval("(...3).step(-1)")).should == [5, 4, 3]
+
+        @array.send(@method, eval("(..3).step(-2)")).should == [5, 3]
+        @array.send(@method, eval("(...3).step(-2)")).should == [5, 3]
+
+        @array.send(@method, eval("(..3).step(-10)")).should == [3]
+        @array.send(@method, eval("(...3).step(-10)")).should == [3]
+
+        # end with negative index
+        @array.send(@method, eval("(..-2).step(-1)")).should == [5, 4]
+        @array.send(@method, eval("(...-2).step(-1)")).should ==[5, 4]
+
+        @array.send(@method, eval("(..-2).step(-2)")).should == [5]
+        @array.send(@method, eval("(...-2).step(-2)")).should == [5]
+
+        @array.send(@method, eval("(..-2).step(-10)")).should == [4]
+        @array.send(@method, eval("(...-2).step(-10)")).should == [4]
+      end
+
+      it "has closed range and positive steps" do
+        # start and end with 0
+        @array.send(@method, eval("(0..0).step(1)")).should == [0]
+        @array.send(@method, eval("(0...0).step(1)")).should == []
+
+        @array.send(@method, eval("(0..0).step(2)")).should == [0]
+        @array.send(@method, eval("(0...0).step(2)")).should == []
+
+        @array.send(@method, eval("(0..0).step(10)")).should == [0]
+        @array.send(@method, eval("(0...0).step(10)")).should == []
+
+        # start and end with positive index
+        @array.send(@method, eval("(1..3).step(1)")).should == [1, 2, 3]
+        @array.send(@method, eval("(1...3).step(1)")).should == [1, 2]
+
+        @array.send(@method, eval("(1..3).step(2)")).should == [1, 3]
+        @array.send(@method, eval("(1...3).step(2)")).should == [1]
+
+        @array.send(@method, eval("(1..3).step(10)")).should == [1]
+        @array.send(@method, eval("(1...3).step(10)")).should == [1]
+
+        # start with positive index, end with negative index
+        @array.send(@method, eval("(1..-2).step(1)")).should == [1, 2, 3, 4]
+        @array.send(@method, eval("(1...-2).step(1)")).should == [1, 2, 3]
+
+        @array.send(@method, eval("(1..-2).step(2)")).should ==  [1, 3]
+        @array.send(@method, eval("(1...-2).step(2)")).should ==  [1, 3]
+
+        @array.send(@method, eval("(1..-2).step(10)")).should == [1]
+        @array.send(@method, eval("(1...-2).step(10)")).should == [1]
+
+        # start with negative index, end with positive index
+        @array.send(@method, eval("(-4..4).step(1)")).should == [2, 3, 4]
+        @array.send(@method, eval("(-4...4).step(1)")).should == [2, 3]
+
+        @array.send(@method, eval("(-4..4).step(2)")).should == [2, 4]
+        @array.send(@method, eval("(-4...4).step(2)")).should == [2]
+
+        @array.send(@method, eval("(-4..4).step(10)")).should == [2]
+        @array.send(@method, eval("(-4...4).step(10)")).should == [2]
+
+        # start with negative index, end with negative index
+        @array.send(@method, eval("(-4..-2).step(1)")).should == [2, 3, 4]
+        @array.send(@method, eval("(-4...-2).step(1)")).should == [2, 3]
+
+        @array.send(@method, eval("(-4..-2).step(2)")).should == [2, 4]
+        @array.send(@method, eval("(-4...-2).step(2)")).should == [2]
+
+        @array.send(@method, eval("(-4..-2).step(10)")).should == [2]
+        @array.send(@method, eval("(-4...-2).step(10)")).should == [2]
+      end
+
+      it "has closed range and negative steps" do
+        # start and end with 0
+        @array.send(@method, eval("(0..0).step(-1)")).should == [0]
+        @array.send(@method, eval("(0...0).step(-1)")).should == []
+
+        @array.send(@method, eval("(0..0).step(-2)")).should == [0]
+        @array.send(@method, eval("(0...0).step(-2)")).should == []
+
+        @array.send(@method, eval("(0..0).step(-10)")).should == [0]
+        @array.send(@method, eval("(0...0).step(-10)")).should == []
+
+        # start and end with positive index
+        @array.send(@method, eval("(1..3).step(-1)")).should == []
+        @array.send(@method, eval("(1...3).step(-1)")).should == []
+
+        @array.send(@method, eval("(1..3).step(-2)")).should == []
+        @array.send(@method, eval("(1...3).step(-2)")).should == []
+
+        @array.send(@method, eval("(1..3).step(-10)")).should == []
+        @array.send(@method, eval("(1...3).step(-10)")).should == []
+
+        # start with positive index, end with negative index
+        @array.send(@method, eval("(1..-2).step(-1)")).should == []
+        @array.send(@method, eval("(1...-2).step(-1)")).should == []
+
+        @array.send(@method, eval("(1..-2).step(-2)")).should ==  []
+        @array.send(@method, eval("(1...-2).step(-2)")).should ==  []
+
+        @array.send(@method, eval("(1..-2).step(-10)")).should == []
+        @array.send(@method, eval("(1...-2).step(-10)")).should == []
+
+        # start with negative index, end with positive index
+        @array.send(@method, eval("(-4..4).step(-1)")).should == []
+        @array.send(@method, eval("(-4...4).step(-1)")).should == []
+
+        @array.send(@method, eval("(-4..4).step(-2)")).should == []
+        @array.send(@method, eval("(-4...4).step(-2)")).should == []
+
+        @array.send(@method, eval("(-4..4).step(-10)")).should == []
+        @array.send(@method, eval("(-4...4).step(-10)")).should == []
+
+        # start with negative index, end with negative index
+        @array.send(@method, eval("(-4..-2).step(-1)")).should == []
+        @array.send(@method, eval("(-4...-2).step(-1)")).should == []
+
+        @array.send(@method, eval("(-4..-2).step(-2)")).should == []
+        @array.send(@method, eval("(-4...-2).step(-2)")).should == []
+
+        @array.send(@method, eval("(-4..-2).step(-10)")).should == []
+        @array.send(@method, eval("(-4...-2).step(-10)")).should == []
+      end
+
+      it "has inverted closed range and positive steps" do
+        # start and end with positive index
+        @array.send(@method, eval("(3..1).step(1)")).should == []
+        @array.send(@method, eval("(3...1).step(1)")).should == []
+
+        @array.send(@method, eval("(3..1).step(2)")).should == []
+        @array.send(@method, eval("(3...1).step(2)")).should == []
+
+        @array.send(@method, eval("(3..1).step(10)")).should == []
+        @array.send(@method, eval("(3...1).step(10)")).should == []
+
+        # start with negative index, end with positive index
+        @array.send(@method, eval("(-2..1).step(1)")).should == []
+        @array.send(@method, eval("(-2...1).step(1)")).should == []
+
+        @array.send(@method, eval("(-2..1).step(2)")).should ==  []
+        @array.send(@method, eval("(-2...1).step(2)")).should ==  []
+
+        @array.send(@method, eval("(-2..1).step(10)")).should == []
+        @array.send(@method, eval("(-2...1).step(10)")).should == []
+
+        # start with positive index, end with negative index
+        @array.send(@method, eval("(4..-4).step(1)")).should == []
+        @array.send(@method, eval("(4...-4).step(1)")).should == []
+
+        @array.send(@method, eval("(4..-4).step(2)")).should == []
+        @array.send(@method, eval("(4...-4).step(2)")).should == []
+
+        @array.send(@method, eval("(4..-4).step(10)")).should == []
+        @array.send(@method, eval("(4...-4).step(10)")).should == []
+
+        # start with negative index, end with negative index
+        @array.send(@method, eval("(-2..-4).step(1)")).should == []
+        @array.send(@method, eval("(-2...-4).step(1)")).should == []
+
+        @array.send(@method, eval("(-2..-4).step(2)")).should == []
+        @array.send(@method, eval("(-2...-4).step(2)")).should == []
+
+        @array.send(@method, eval("(-2..-4).step(10)")).should == []
+        @array.send(@method, eval("(-2...-4).step(10)")).should == []
+      end
+
+      # ????????
+      it "has inverted closed range and negative steps" do
+        # start and end with positive index
+        @array.send(@method, eval("(3..1).step(-1)")).should == [3, 2, 1]
+        @array.send(@method, eval("(3...1).step(-1)")).should == [2, 1]
+
+        @array.send(@method, eval("(3..1).step(-2)")).should == [3, 1]
+        @array.send(@method, eval("(3...1).step(-2)")).should == [2]
+
+        @array.send(@method, eval("(3..1).step(-10)")).should == [1]
+        @array.send(@method, eval("(3...1).step(-10)")).should == [1]
+
+        # start with negative index, end with positive index
+        @array.send(@method, eval("(-2..1).step(-1)")).should ==  [4, 3, 2, 1]
+        @array.send(@method, eval("(-2...1).step(-1)")).should == [3, 2, 1]
+
+        @array.send(@method, eval("(-2..1).step(-2)")).should ==  [4, 2]
+        @array.send(@method, eval("(-2...1).step(-2)")).should ==  [3, 1]
+
+        @array.send(@method, eval("(-2..1).step(-10)")).should == [1]
+        @array.send(@method, eval("(-2...1).step(-10)")).should == [1]
+
+        # start with positive index, end with negative index
+        @array.send(@method, eval("(4..-4).step(-1)")).should == [4, 3, 2]
+        @array.send(@method, eval("(4...-4).step(-1)")).should == [3, 2]
+
+        @array.send(@method, eval("(4..-4).step(-2)")).should == [4, 2]
+        @array.send(@method, eval("(4...-4).step(-2)")).should == [3]
+
+        @array.send(@method, eval("(4..-4).step(-10)")).should == [2]
+        @array.send(@method, eval("(4...-4).step(-10)")).should == [2]
+
+        # start with negative index, end with negative index
+        @array.send(@method, eval("(-2..-4).step(-1)")).should == [4, 3, 2]
+        @array.send(@method, eval("(-2...-4).step(-1)")).should == [3, 2]
+
+        @array.send(@method, eval("(-2..-4).step(-2)")).should == [4, 2]
+        @array.send(@method, eval("(-2...-4).step(-2)")).should == [3]
+
+        @array.send(@method, eval("(-2..-4).step(-10)")).should == [2]
+        @array.send(@method, eval("(-2...-4).step(-10)")).should == [2]
+      end
     end
   end