finalized tests

Author: sampersand

core/integer.rbs

@@ -520,9 +520,9 @@ class Integer < Numeric
   #
   # Raises an exception if the slice cannot be constructed.
   #
-  def []: (int) -> Integer
-        | (int i, int len) -> Integer
-        | (Range[int]) -> Integer
+  def []: (int offset) -> (0 | 1)
+        | (int offset, int size) -> Integer
+        | (range[int?] range) -> Integer # Technically needs to have things beyond `int` (eg `<=>` and `coerce`), but too cumbersome to annotate
 
   # <!--
   #   rdoc-file=numeric.c
@@ -819,7 +819,6 @@ class Integer < Numeric
     def divmod: (O other) -> R
   end
 
-
   # <!--
   #   rdoc-file=numeric.c
   #   - downto(limit) {|i| ... } -> self
@@ -838,8 +837,10 @@ class Integer < Numeric
   #
   # With no block given, returns an Enumerator.
   #
-  def downto: (Numeric limit) { (Integer) -> void } -> Integer
-            | (Numeric limit) -> ::Enumerator[Integer, self]
+  def downto: (Integer limit) { (Integer i) -> void } -> self
+            | (Integer limit) -> Enumerator[Integer, self]
+            | [S] (Numeric::_Coerce[self, RBS::Ops::_LessThan[S, boolish], S] other) { (Integer i) -> void } -> self
+            | [S] (Numeric::_Coerce[self, RBS::Ops::_LessThan[S, boolish], S] other) -> Enumerator[Integer, self] # Technically, need more bounds for `size`?
 
   # <!--
   #   rdoc-file=numeric.rb
@@ -1341,8 +1342,10 @@ class Integer < Numeric
   #
   # With no block given, returns an Enumerator.
   #
-  def upto: (Numeric limit) { (Integer) -> void } -> Integer
-          | (Numeric limit) -> ::Enumerator[Integer, self]
+  def upto: (Integer limit) { (Integer i) -> void } -> self
+          | (Integer limit) -> Enumerator[Integer, self]
+          | [S] (Numeric::_Coerce[self, RBS::Ops::_GreaterThan[S, boolish], S] other) { (Integer i) -> void } -> self
+          | [S] (Numeric::_Coerce[self, RBS::Ops::_GreaterThan[S, boolish], S] other) -> Enumerator[Integer, self] # Technically, need more bounds for `size`?
 
   # <!--
   #   rdoc-file=numeric.rb

test/stdlib/Integer_test.rb

@@ -217,7 +217,30 @@ def test_op_rsh
   end
 
   def test_op_aref
-    # omit 'todo'
+    with_int 3 do |offset|
+      assert_send_type  '(int) -> (0 | 1)',
+                        38, :[], offset
+
+      with_int 5 do |size|
+        assert_send_type  '(int, int) -> Integer',
+                          38, :[], offset, size
+      end
+    end
+
+    assert_send_type  '(range[int?]) -> Integer',
+                      38, :[], 3..nil
+    assert_send_type  '(range[int?]) -> Integer',
+                      38, :[], nil..0
+    assert_send_type  '(range[int?]) -> Integer',
+                      38, :[], 1r..3r
+    assert_send_type  '(range[int?]) -> Integer',
+                      38, :[], 1.0..3.0
+
+    start = ToInt.new(1)
+    def start.<=>(other) = to_int <=> other.to_int
+    def start.coerce(other) = [other.to_int, to_int]
+    assert_send_type  '(range[int?]) -> Integer',
+                      38, :[], CustomRange.new(start, ToInt.new(3))
   end
 
   def test_op_xor
@@ -346,7 +369,26 @@ def test_divmod
   end
 
   def test_downto
-    # omit 'todo'
+    assert_send_type  '(Integer) { (Integer) -> void } -> 38',
+                      38, :downto, 35 do end
+    assert_send_type  '(Integer) -> Enumerator[Integer, 38]',
+                      38, :downto, 35
+    assert_send_type  '(Rational) { (Integer) -> void } -> 38',
+                      38, :downto, 35r do end
+    assert_send_type  '(Rational) -> Enumerator[Integer, 38]',
+                      38, :downto, 35r
+    assert_send_type  '(Float) { (Integer) -> void } -> 38',
+                      38, :downto, 35.0 do end
+    assert_send_type  '(Float) -> Enumerator[Integer, 38]',
+                      38, :downto, 35.0
+
+    assert_send_type  '(Coercable) { (Integer) -> void } -> 38',
+                      38, :downto, Coercable.for_op(:<) { it.__value__ < 35 } do end
+
+    coercable = Coercable.for_op(:<) { it.__value__ < 35 }
+    def coercable.-(rhs) = 35 - rhs # Required by `Enumerator#size`, which the unit test harness uses
+    assert_send_type  '(Coercable) -> Enumerator[Integer, 38]',
+                      38, :downto, coercable
   end
 
   def test_even?
@@ -568,7 +610,26 @@ def test_truncate
   end
 
   def test_upto
-    # omit 'todo'
+    assert_send_type  '(Integer) { (Integer) -> void } -> 38',
+                      38, :upto, 40 do end
+    assert_send_type  '(Integer) -> Enumerator[Integer, 38]',
+                      38, :upto, 40
+    assert_send_type  '(Rational) { (Integer) -> void } -> 38',
+                      38, :upto, 40r do end
+    assert_send_type  '(Rational) -> Enumerator[Integer, 38]',
+                      38, :upto, 40r
+    assert_send_type  '(Float) { (Integer) -> void } -> 38',
+                      38, :upto, 40.0 do end
+    assert_send_type  '(Float) -> Enumerator[Integer, 38]',
+                      38, :upto, 40.0
+
+    assert_send_type  '(Coercable) { (Integer) -> void } -> 38',
+                      38, :upto, Coercable.for_op(:>) { it.__value__ > 40 } do end
+
+    coercable = Coercable.for_op(:>) { it.__value__ > 40 }
+    def coercable.-(rhs) = 40 - rhs # Required by `Enumerator#size`, which the unit test harness uses
+    assert_send_type  '(Coercable) -> Enumerator[Integer, 38]',
+                      38, :upto, coercable
   end
 
   def test_zero?

test/stdlib/test_helper.rb

@@ -85,16 +85,26 @@ class OpReturn < ::RBS::UnitTest::Convertibles::BlankSlate
   end
 
   class CoerceOther < ::RBS::UnitTest::Convertibles::BlankSlate
+    attr_reader :__value__
+    def initialize(value) = @__value__ = value
   end
 
   class CoerceSelf < ::RBS::UnitTest::Convertibles::BlankSlate
-    def initialize(method, result:)
-      ::Kernel.instance_method(:define_singleton_method).bind_call(self, method) { |other| result }
+    def initialize(method, &block)
+      ::Kernel.instance_method(:define_singleton_method).bind_call(self, method, &block)
     end
   end
 
-  def self.for_op(method, result: OpReturn.new)
-    new(CoerceSelf.new(method, result:)){ |x| CoerceOther.new }
+  def self.for_op(method, result: noresult = true, &block)
+    if block_given?
+      unless noresult
+        raise ArgumentError, "cannot provide both a block and a result"
+      end
+    else
+      block = proc { |other| noresult ? OpReturn.new : result }
+    end
+
+    new(CoerceSelf.new(method, &block)) { |x| CoerceOther.new(x) }
   end
 
   def initialize(self_ret, &converter)