diff --git a/core/builtin.rbs b/core/builtin.rbs
index ad1253bc0..41a9d2a88 100644
--- a/core/builtin.rbs
+++ b/core/builtin.rbs
@@ -214,6 +214,7 @@ interface _Range[T]
   def exclude_end?: () -> bool
 end
 
+%a{steep:deprecate}
 interface _Exception
   def exception: () -> Exception
                | (String arg0) -> Exception
diff --git a/core/exception.rbs b/core/exception.rbs
index 45c9df4d1..eeb0415b3 100644
--- a/core/exception.rbs
+++ b/core/exception.rbs
@@ -106,6 +106,10 @@
 # *   fatal
 #
 class Exception
+  interface _Exception[T]
+    def exception: (?T message) -> Exception
+  end
+
   # <!--
   #   rdoc-file=error.c
   #   - Exception.to_tty?   ->  true or false
diff --git a/core/kernel.rbs b/core/kernel.rbs
index 954801a91..f657db076 100644
--- a/core/kernel.rbs
+++ b/core/kernel.rbs
@@ -154,7 +154,6 @@
 # *   #trap: Specifies the handling of system signals.
 # *   #warn: Issue a warning based on the given messages and options.
 #
-%a{annotate:rdoc:source:from=object.c}
 module Kernel : BasicObject
   # <!--
   #   rdoc-file=vm_backtrace.c
@@ -191,9 +190,9 @@ module Kernel : BasicObject
   #     c(4)   #=> []
   #     c(5)   #=> nil
   #
-  def self?.caller: (Integer start_or_range, ?Integer length) -> ::Array[String]?
-                  | (::Range[Integer] start_or_range) -> ::Array[String]?
-                  | () -> ::Array[String]
+  def self?.caller: () -> Array[String]
+                  | (int start, ?int? length) -> Array[String]?
+                  | (range[int?] range) -> Array[String]?
 
   # <!--
   #   rdoc-file=vm_backtrace.c
@@ -216,8 +215,9 @@ module Kernel : BasicObject
   # Optionally you can pass a range, which will return an array containing the
   # entries within the specified range.
   #
-  def self?.caller_locations: (?Integer start_or_range, ?Integer length) -> ::Array[Thread::Backtrace::Location]?
-                            | (?::Range[Integer] start_or_range) -> ::Array[Thread::Backtrace::Location]?
+  def self?.caller_locations: () -> Array[Thread::Backtrace::Location]
+                            | (int start, ?int? length) -> Array[Thread::Backtrace::Location]?
+                            | (range[int?] range) -> Array[Thread::Backtrace::Location]?
 
   # <!--
   #   rdoc-file=vm_eval.c
@@ -269,8 +269,8 @@ module Kernel : BasicObject
   #
   #     # => 123
   #
-  def self?.catch: [T] (T tag) { (T tag) -> untyped } -> untyped
-                 | () { (Object tag) -> untyped } -> untyped
+  def self?.catch: () { (Object tag) -> untyped } -> untyped
+                 | [T] (T tag) { (T tag) -> untyped } -> untyped
 
   # <!--
   #   rdoc-file=kernel.rb
@@ -334,7 +334,7 @@ module Kernel : BasicObject
   #     end
   #     local_variables   #=> [:fred, :i]
   #
-  def self?.local_variables: () -> ::Array[Symbol]
+  def self?.local_variables: () -> Array[Symbol]
 
   # <!--
   #   rdoc-file=random.c
@@ -441,7 +441,7 @@ module Kernel : BasicObject
   #
   def self?.Array: (nil) -> []
                  | [T] (array[T] | _ToA[T] array_like) -> Array[T]
-                 | [T] (T ele) -> [T]
+                 | [T] (T element) -> [T]
 
   # <!--
   #   rdoc-file=complex.c
@@ -495,8 +495,8 @@ module Kernel : BasicObject
   #
   def self?.Complex: (_ToC complex_like, ?exception: true) -> Complex
                    | (_ToC complex_like, exception: bool) -> Complex?
-                   | (Numeric | String real, ?Numeric | String imag, ?exception: true) -> Complex
-                   | (Numeric | String real, ?Numeric | String imag, exception: bool) -> Complex?
+                   | (Numeric | String real, ?(Numeric & _ToF) | String imag, ?exception: true) -> Complex
+                   | (Numeric | String real, ?(Numeric & _ToF) | String imag, exception: bool) -> Complex?
                    | (untyped, ?untyped, ?exception: bool) -> Complex?
 
   # <!--
@@ -541,7 +541,7 @@ module Kernel : BasicObject
   #     Hash(nil)              # => {}
   #     Hash([])               # => {}
   #
-  def self?.Hash: [K, V] (nil | [] _empty) -> Hash[K, V]
+  def self?.Hash: [K, V] ([]?) -> Hash[K, V]
                 | [K, V] (hash[K, V] hash_like) -> Hash[K, V]
 
   # <!--
@@ -678,6 +678,7 @@ module Kernel : BasicObject
                     | [T] (Numeric&_RationalDiv[T] numer, Numeric denom, ?exception: bool) -> T
                     | [T < Numeric] (T value, 1, ?exception: bool) -> T
                     | (untyped, ?untyped, ?exception: bool) -> Rational?
+                    | (__todo__) -> __todo__
 
   interface _RationalDiv[T]
     def /: (Numeric) -> T
@@ -747,7 +748,7 @@ module Kernel : BasicObject
   #
   # The built-in syntax `%x{...}` uses this method.
   #
-  def self?.`: (String arg0) -> String
+  def self?.`: (string command) -> String
 
   # <!--
   #   rdoc-file=process.c
@@ -796,7 +797,7 @@ module Kernel : BasicObject
   # If *const* is defined as autoload, the file name to be loaded is replaced with
   # *filename*.  If *const* is defined but not as autoload, does nothing.
   #
-  def self?.autoload: (interned _module, String filename) -> NilClass
+  def self?.autoload: (interned const, path filename) -> nil
 
   # <!--
   #   rdoc-file=load.c
@@ -807,7 +808,7 @@ module Kernel : BasicObject
   #     autoload(:B, "b")
   #     autoload?(:B)            #=> "b"
   #
-  def self?.autoload?: (interned name) -> String?
+  def self?.autoload?: (interned name, ?boolish inherit) -> String?
 
   # <!--
   #   rdoc-file=proc.c
@@ -931,8 +932,7 @@ module Kernel : BasicObject
   #
   def self?.fail: () -> bot
                 | (string message, ?cause: Exception?) -> bot
-                | (_Exception exception, ?_ToS? message, ?String | Array[String] | nil backtrace, ?cause: Exception?) -> bot
-                | (_Exception exception, ?cause: Exception?, **untyped) -> bot
+                | [T] (Exception::_Exception[T] exception, ?T message, ?Array[String] | String | Thread::Backtrace | nil backtrace, ?cause: Exception?) -> bot
 
   # <!--
   #   rdoc-file=eval.c
@@ -964,26 +964,28 @@ module Kernel : BasicObject
 
   alias self.raise self.fail
 
-  # <!-- rdoc-file=object.c -->
+  # <!--
+  #   rdoc-file=object.c
+  #   - sprintf(format_string *objects)  -> string
+  # -->
   # Returns the string resulting from formatting `objects` into `format_string`.
   #
   # For details on `format_string`, see [Format
   # Specifications](rdoc-ref:format_specifications.rdoc).
   #
-  def self?.format: (String format, *untyped args) -> String
+  def self?.sprintf: (string format, hash[Symbol, untyped] keywords) -> String
+                   | (string format, **untyped keywords) -> String
+                   | (string format, *untyped positional) -> String
 
-  # <!--
-  #   rdoc-file=object.c
-  #   - sprintf(format_string *objects)  -> string
-  # -->
+  # <!-- rdoc-file=object.c -->
   # Returns the string resulting from formatting `objects` into `format_string`.
   #
   # For details on `format_string`, see [Format
   # Specifications](rdoc-ref:format_specifications.rdoc).
   #
-  alias sprintf format
+  alias format sprintf
 
-  alias self.sprintf self.format
+  alias self.format self.sprintf
 
   # <!--
   #   rdoc-file=io.c
@@ -1015,7 +1017,8 @@ module Kernel : BasicObject
   # The style of programming using `$_` as an implicit parameter is gradually
   # losing favor in the Ruby community.
   #
-  def self?.gets: (?String arg0, ?Integer arg1) -> String?
+  def self?.gets: (?string? separator, ?int limit, ?chomp: boolish) -> String?
+                | (int limit, ?chomp: boolish) -> String?
 
   # <!--
   #   rdoc-file=eval.c
@@ -1027,7 +1030,7 @@ module Kernel : BasicObject
   #
   #     global_variables.grep /std/   #=> [:$stdin, :$stdout, :$stderr]
   #
-  def self?.global_variables: () -> ::Array[Symbol]
+  def self?.global_variables: () -> Array[Symbol]
 
   # <!--
   #   rdoc-file=load.c
@@ -1056,7 +1059,7 @@ module Kernel : BasicObject
   # executed under the given module. In no circumstance will any local variables
   # in the loaded file be propagated to the loading environment.
   #
-  def self?.load: (String filename, ?Module | bool) -> bool
+  def self?.load: (path filename, ?Module | bool wrap) -> true
 
   # <!--
   #   rdoc-file=kernel.rb
@@ -1087,8 +1090,8 @@ module Kernel : BasicObject
   #       puts enum.next
   #     } #=> :ok
   #
-  def self?.loop: () { () -> void } -> bot
-                | () -> ::Enumerator[nil, bot]
+  def self?.loop: () -> Enumerator[nil, untyped]
+                | () { () -> void } -> untyped
 
   # <!--
   #   rdoc-file=io.c
@@ -1165,7 +1168,7 @@ module Kernel : BasicObject
   #     gets  # Sets $_ to the most recent user input.
   #     print # Prints $_.
   #
-  def self?.print: (*_ToS args) -> nil
+  def self?.print: (*_ToS objects) -> nil
 
   # <!--
   #   rdoc-file=io.c
@@ -1200,8 +1203,12 @@ module Kernel : BasicObject
   # With no arguments, does nothing.
   #
   def self?.printf: () -> nil
-                  | (String fmt, *untyped args) -> nil
-                  | (_Writer io, string fmt, *untyped args) -> nil
+                  | (String fmt, hash[Symbol, untyped] keywords) -> nil
+                  | (String fmt, **untyped keywords) -> nil
+                  | (String fmt, *untyped positional) -> nil
+                  | (_Writer io, string fmt, hash[Symbol, untyped] keywords) -> nil
+                  | (_Writer io, string fmt, **untyped keywords) -> nil
+                  | (_Writer io, string fmt, *untyped positional) -> nil
 
   # <!--
   #   rdoc-file=proc.c
@@ -1209,7 +1216,7 @@ module Kernel : BasicObject
   # -->
   # Equivalent to Proc.new.
   #
-  def self?.proc: () { () -> untyped } -> Proc
+  def self?.proc: () { (?) -> untyped } -> Proc
 
   # <!--
   #   rdoc-file=proc.c
@@ -1218,7 +1225,7 @@ module Kernel : BasicObject
   # Equivalent to Proc.new, except the resulting Proc objects check the number of
   # parameters passed when called.
   #
-  def self?.lambda: () { () -> untyped } -> Proc
+  def self?.lambda: () { (?) -> untyped } -> Proc
 
   # <!--
   #   rdoc-file=io.c
@@ -1230,8 +1237,8 @@ module Kernel : BasicObject
   #
   # See IO#putc for important information regarding multi-byte characters.
   #
-  def self?.putc: [T < _ToInt] (T chr) -> T
-                | (String chr) -> String
+  def self?.putc: (String chr) -> String
+                | [T < _ToInt] (T chr) -> T
 
   # <!--
   #   rdoc-file=io.c
@@ -1272,9 +1279,9 @@ module Kernel : BasicObject
   # Kernel#p to be uninterruptible in whole or in part. On CRuby, Kernel#p's
   # writing of data is uninterruptible.
   #
-  def self?.p: [T < _Inspect] (T arg0) -> T
-             | (_Inspect arg0, _Inspect arg1, *_Inspect rest) -> Array[_Inspect]
-             | () -> nil
+  def self?.p: () -> nil
+             | [T < _Inspect] (T object) -> T
+             | [T < _Inspect] (T object1, T object2, *T objects) -> Array[T]
 
   # <!--
   #   rdoc-file=lib/pp.rb
@@ -1284,9 +1291,9 @@ module Kernel : BasicObject
   #
   # pp returns argument(s).
   #
-  def self?.pp: [T] (T arg0) -> T
-              | (untyped, untyped, *untyped) -> Array[untyped]
-              | () -> nil
+  def self?.pp: () -> nil
+              | [T < PP::_PrettyPrint] (T object) -> T
+              | [T < PP::_PrettyPrint] (T object1, T object2, *T objects) -> Array[T]
 
   # <!--
   #   rdoc-file=random.c
@@ -1339,7 +1346,8 @@ module Kernel : BasicObject
   # Optional keyword argument `chomp` specifies whether line separators are to be
   # omitted.
   #
-  def self?.readline: (?String arg0, ?Integer arg1) -> String
+  def self?.readline: (?string? separator, ?int limit, ?chomp: boolish) -> String
+                    | (int limit, ?chomp: boolish) -> String
 
   # <!--
   #   rdoc-file=io.c
@@ -1394,7 +1402,8 @@ module Kernel : BasicObject
   # Optional keyword arguments `enc_opts` specify encoding options; see [Encoding
   # options](rdoc-ref:encodings.rdoc@Encoding+Options).
   #
-  def self?.readlines: (?String arg0, ?Integer arg1) -> ::Array[String]
+  def self?.readlines: (?string? separator, ?int limit, ?chomp: boolish) -> Array[String]
+                     | (int limit, ?chomp: boolish) -> Array[String]
 
   # <!--
   #   rdoc-file=lib/rubygems/core_ext/kernel_require.rb
@@ -1412,7 +1421,7 @@ module Kernel : BasicObject
   # The normal `require` functionality of returning false if that file has already
   # been loaded is preserved.
   #
-  def self?.require: (String path) -> bool
+  def self?.require: (path feature) -> bool
 
   # <!--
   #   rdoc-file=load.c
@@ -1423,7 +1432,7 @@ module Kernel : BasicObject
   # raised. Returns `true` if the file was loaded and `false` if the file was
   # already loaded before.
   #
-  def self?.require_relative: (String feature) -> bool
+  def self?.require_relative: (path feature) -> bool
 
   # <!--
   #   rdoc-file=io.c
@@ -1564,7 +1573,14 @@ module Kernel : BasicObject
   #     (snipped)
   #     ping
   #
-  def self?.select: (::Array[IO] read, ?::Array[IO] write, ?::Array[IO] error, ?Time::_Timeout timeout) -> ::Array[String]
+  def self?.select: ([]?, ?[]?, ?[]?, ?nil) -> bot
+                  | [R < _ToIO]                       (Array[R] read, ?[]?,            ?[]?,            ?nil                  ) -> [Array[R], [], []]
+                  | [R < _ToIO]                       (Array[R] read,  []?,             []?,            Time::_Timeout timeout) -> [Array[R], [], []]?
+                  | [R < _ToIO, W < _ToIO]            (Array[R] read, ?Array[W] write, ?[]?,            ?nil                  ) -> [Array[R], Array[W], []]
+                  | [R < _ToIO, W < _ToIO]            (Array[R] read,  Array[W] write,  []?,            Time::_Timeout timeout) -> [Array[R], Array[W], []]?
+                  | [R < _ToIO, W < _ToIO, E < _ToIO] (Array[R] read, ?Array[W] write, ?Array[E] error, ?nil                  ) -> [Array[R], Array[W], Array[E]]
+                  | [R < _ToIO, W < _ToIO, E < _ToIO] (Array[R] read,  Array[W] write,  Array[E] error, Time::_Timeout timeout) -> [Array[R], Array[W], Array[E]]?
+                  | (Array[_ToIO]? read, ?Array[_ToIO]? write, ?Array[_ToIO]? error, ?Time::_Timeout? timeout) -> [Array[_ToIO], Array[_ToIO], Array[_ToIO]]?
 
   # <!--
   #   rdoc-file=process.c
@@ -1670,7 +1686,12 @@ module Kernel : BasicObject
   #     ">"  | boolean | True if the modification time of file1
   #          |         | is after that of file2
   #
-  def self?.test: (String | Integer cmd, String | IO file1, ?String | IO file2) -> (TrueClass | FalseClass | Time | nil | Integer)
+  def self?.test: ('b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'G' | 'k' | 'o' | 'O' | 'p' | 'S' | 'u' | 'z' |  98 |  99 | 100 | 101 | 102 | 103 |  71 | 107 | 111 |  79 | 112 |  83 | 117 | 122, IO | path file) -> bool
+                | ('l' | 'r' | 'R' | 'w' | 'W' | 'x' | 'X' | 108 | 114 | 82 | 119 | 87 | 120 | 88, path filename) -> bool
+                | ('s' | 115, IO | path filename) -> Integer?
+                | ('M' | 'A' | 'C' | 77  | 65 | 67, IO | path file) -> Time
+                | ('-' | '=' | '<' | '>' | 45 | 60 | 61 | 62, IO | path file1, IO | path file2) -> bool
+                | (String | int cmd, IO | path file1, ?IO | path file2) -> (bool | Integer? | Time)
 
   # <!--
   #   rdoc-file=vm_eval.c
@@ -1728,7 +1749,7 @@ module Kernel : BasicObject
   # :experimental
   # :   Used for experimental features that may change in future releases.
   #
-  def self?.warn: (*_ToS msg, ?uplevel: int?, ?category: Warning::category?) -> nil
+  def self?.warn: (*_ToS msgs, ?uplevel: int?, ?category: Warning::category | _ToSym | nil) -> nil
 
   # <!--
   #   rdoc-file=process.c
diff --git a/lib/rbs/test/type_check.rb b/lib/rbs/test/type_check.rb
index 70fe06286..60b95ede5 100644
--- a/lib/rbs/test/type_check.rb
+++ b/lib/rbs/test/type_check.rb
@@ -331,7 +331,7 @@ def value(val, type)
         when Types::Variable
           true
         when Types::Literal
-          type.literal == val
+          defined?(val.==) and type.literal == val
         when Types::Union
           type.types.any? {|type| value(val, type) }
         when Types::Intersection
diff --git a/lib/rbs/unit_test/type_assertions.rb b/lib/rbs/unit_test/type_assertions.rb
index 10ae4c90b..458dadd3d 100644
--- a/lib/rbs/unit_test/type_assertions.rb
+++ b/lib/rbs/unit_test/type_assertions.rb
@@ -336,6 +336,27 @@ def break_from_block(value = nil)
       def pass(message = nil)
         assert true, message
       end
+
+      def assert_send_raises(sig, errclass, object, method, ...)
+        # TODO: ensure args match with signature
+        _ignored = sig
+
+        ::BasicObject.instance_method(:__send__).bind_call(object, method, ...)
+      rescue (:any.equal?(errclass) ? StandardError : errclass) => err
+        if :any.equal?(errclass)
+          pass "`#{::Kernel.instance_method(:class).bind_call(object)}##{method}` returned `bot`"
+          return
+        end
+
+        # Ensure it's actually a `errclass`, and not some subclass that indicates some other
+        # problem (like `ArgumentError < RuntimeError`).
+        assert(
+          ::Kernel.instance_method(:instance_of?).bind_call(err, errclass),
+          "#{::Kernel.instance_method(:inspect).bind_call(err)} should be an #{errclass}"
+        )
+      else
+        assert false, "`#{::Kernel.instance_method(:class).bind_call(object)}##{method}` doesn't return `bot`"
+      end
     end
   end
 end
diff --git a/test/stdlib/Kernel_test.rb b/test/stdlib/Kernel_test.rb
index 137726110..e3b6d8ca4 100644
--- a/test/stdlib/Kernel_test.rb
+++ b/test/stdlib/Kernel_test.rb
@@ -1,111 +1,1101 @@
 require_relative "test_helper"
 
-require "securerandom"
+require 'shellwords'
+require 'pathname'
+require 'stringio'
+require 'tempfile'
 
-class KernelSingletonTest < Test::Unit::TestCase
+class KernelModuleMethodsTest < Test::Unit::TestCase
   include TestHelper
 
-  testing "singleton(::Kernel)"
+  testing 'singleton(::Kernel)'
+
+  def capture_stdout
+    old_stdout = $stdout
+    $stdout = File.new File::NULL, 'w'
+    yield
+  ensure
+    $stdout.close rescue nil
+    $stdout = old_stdout
+  end
+
+  class OnlyKernel < BlankSlate
+    include ::Kernel
+
+    # Temporary hack until `self?.` is solved.
+    public ::Kernel.private_instance_methods
+  end
+
+  def with_kernel
+    yield Kernel
+    yield OnlyKernel.new
+  end
+
+  # It looks like these tests are working in parallel, so this ensures they're not.
+  GETS_READLINE_READLINES_MUTEX = Mutex.new
+  def with_no_argv_and_stdin(stdin)
+    GETS_READLINE_READLINES_MUTEX.lock do
+      old_argv = ARGV.dup
+      ARGV.clear
+
+      old_stdin, $stdin = $stdin, StringIO.new(stdin)
+      yield
+    ensure
+      ARGV.replace old_argv
+      $stdin = old_stdin
+    end
+  end
+
+  # We use 1 trillion stackframes to be positive that between the test method and when
+  # the `Kernel.caller` and `Kernel.caller_locations` is eventually called we don't create enough
+  # stackframes to make the return value not nil.
+  MORE_STACKFRAMES_THAN_POSSIBLE = 1_000_000_000_000
+
+  def test_caller
+    with_kernel do |kernel|
+      assert_send_type  '() -> Array[String]',
+                        kernel, :caller
+
+      with_int 0 do |start|
+        assert_send_type  '(int) -> Array[String]',
+                          kernel, :caller, start
+
+        with_int(1).and_nil do |length|
+          assert_send_type  '(int, int?) -> Array[String]',
+                            kernel, :caller, start, length
+        end
+      end
+
+      with_int MORE_STACKFRAMES_THAN_POSSIBLE do |start|
+        assert_send_type  '(int) -> nil',
+                          kernel, :caller, start
+
+        with_int(1).and_nil do |length|
+          assert_send_type  '(int, int?) -> nil',
+                            kernel, :caller, start, length
+        end
+      end
+
+      with_range with_int(0).and_nil, with_int(1).and_nil do |range|
+        assert_send_type  '(range[int?]) -> Array[String]',
+                          kernel, :caller, range
+      end
+
+      # Don't include a nil start, because it's impossible to get a nil return value then.
+      with_range with_int(MORE_STACKFRAMES_THAN_POSSIBLE), with_int(MORE_STACKFRAMES_THAN_POSSIBLE + 1).and_nil do |range|
+        assert_send_type  '(range[int?]) -> nil',
+                          kernel, :caller, range
+      end
+    end
+  end
+
+  def test_caller_locations
+    with_kernel do |kernel|
+      assert_send_type  '() -> Array[Thread::Backtrace::Location]',
+                        kernel, :caller_locations
+
+      with_int 0 do |start|
+        assert_send_type  '(int) -> Array[Thread::Backtrace::Location]',
+                          kernel, :caller_locations, start
+
+        with_int(1).and_nil do |length|
+          assert_send_type  '(int, int?) -> Array[Thread::Backtrace::Location]',
+                            kernel, :caller_locations, start, length
+        end
+      end
+
+      with_int MORE_STACKFRAMES_THAN_POSSIBLE do |start|
+        assert_send_type  '(int) -> nil',
+                          kernel, :caller_locations, start
+
+        with_int(1).and_nil do |length|
+          assert_send_type  '(int, int?) -> nil',
+                            kernel, :caller_locations, start, length
+        end
+      end
+
+      with_range with_int(0).and_nil, with_int(1).and_nil do |range|
+        assert_send_type  '(range[int?]) -> Array[Thread::Backtrace::Location]',
+                          kernel, :caller_locations, range
+      end
+
+      # Don't include a nil start, because it's impossible to get a nil return value then.
+      with_range with_int(MORE_STACKFRAMES_THAN_POSSIBLE), with_int(MORE_STACKFRAMES_THAN_POSSIBLE + 1).and_nil do |range|
+        assert_send_type  '(range[int?]) -> nil',
+                          kernel, :caller_locations, range
+      end
+    end
+  end
+
+  def test_catch
+    with_kernel do |kernel|
+      assert_send_type  '() { (Object) -> untyped } -> untyped',
+                        kernel, :catch do 1r end
+      assert_send_type  '[T] (T) { (T) -> untyped } -> untyped',
+                        kernel, :catch, BlankSlate.new do 1r end
+    end
+  end
+
+  def test_eval
+    with_kernel do |kernel|
+      with_string '1+2' do |src|
+        assert_send_type  '(string) -> untyped',
+                          kernel, :eval, src
+
+        with(binding).and_nil do |scope|
+          assert_send_type  '(string, Binding?) -> untyped',
+                            kernel, :eval, src, scope
+
+          with_string 'some-file' do |filename|
+            assert_send_type  '(string, Binding?, string) -> untyped',
+                              kernel, :eval, src, scope, filename
+
+            with_int 123 do |lineno|
+              assert_send_type  '(string, Binding?, string, int) -> untyped',
+                                kernel, :eval, src, scope, filename, lineno
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def was_block_given = block_given?
+  def test_block_given?
+    assert_type 'false', was_block_given
+    assert_type 'true', was_block_given{}
+  end
+
+  def test_local_variables
+    with_kernel do |kernel|
+      x = 3
+      assert_send_type  '() -> Array[Symbol]',
+                        kernel, :local_variables
+    end
+  end
+
+  def test_srand
+    with_kernel do |kernel|
+      prev_seed = kernel.srand 0
+
+      assert_send_type  '() -> Integer',
+                        kernel, :srand
+
+      with_int 123 do |int|
+        assert_send_type  '(int) -> Integer',
+                          kernel, :srand, int
+      end
+    ensure
+      kernel.srand prev_seed
+    end
+  end
+
+  def test_fork
+    with_kernel do |kernel|
+      assert_send_type  '() { () -> void } -> Integer',
+                        kernel, :fork do :foo end
+
+      # There's no real easy way to test the no-argument variation of `fork()`, as it spawns a whole
+      # new process. We have to test to make sure both `nil` and `Integer` are returned, so to do that
+      # we have the child process exit with a predetermined exit code 
+
+      # Keep track of the parent pid so the child knows to `exit!`
+      parent_pid = Process.pid
+
+      # Fork, we'll have both a child process and parent process.
+      pid = kernel.fork
+
+      # In the child process, we exit truthy if the pid is `nil` (i.e. what we expect), and falsey if
+      # it's anything else. (Note we do `nil.equal?` instead of `pid.nil?` to ensure that `pid` is
+      # actually `nil`, and isn't just overwriting `.nil?` (or anything else).)
+      exit! nil.equal?(pid) unless Process.pid == parent_pid
+
+      # -- Here and below, we know we're just the parent process --
+
+      # Wait for the child to finish.
+      _pid, status = Process.waitpid2 pid
+
+      # Make sure the `pid` is actually an integer (check the `-> Integer` variant)
+      assert_type 'Integer', pid
+
+      # If `status` is successful, that means that the `nil.equal?(pid)` is true, and thus the child
+      # process exited successfully.
+      assert status.success?
+    end
+  end
 
   def test_Array
-    assert_send_type "(nil) -> []",
-                     Kernel, :Array, nil
+    with_kernel do |kernel|
+      assert_send_type  '(nil) -> []',
+                        kernel, :Array, nil
 
-    with_array(1r, 2r).chain([ToA.new(1r,2r)]).each do |ary|
-      assert_send_type "(::array[Rational] | ::_ToA[Rational]) -> Array[Rational]",
-                       Kernel, :Array, ary
+      with_array(1r).and ToA.new(1r) do |array|
+        assert_send_type  '[T] (array[T] | _ToA[T]) -> Array[T]',
+                          kernel, :Array, array
+      end
+
+      with_untyped do |element|
+        next if defined?(element.to_ary) || defined?(element.to_a)
+
+        assert_send_type  '[T] (T) -> [T]',
+                          kernel, :Array, element
+      end
     end
+  end
 
-    assert_send_type "(Rational) -> [Rational]",
-                     Kernel, :Array, 1r
+  def test_Complex
+    omit "todo: #{__method__}"
   end
 
   def test_Float
-    with_float 1.0 do |float|
-      assert_send_type "(::float) -> Float",
-                       Kernel, :Float, float
-      assert_send_type "(::float, exception: true) -> Float",
-                       Kernel, :Float, float, exception: true
-      assert_send_type "(::float, exception: bool) -> Float?",
-                       Kernel, :Float, float, exception: false
-    end
+    with_kernel do |kernel|
+      with 1, 1r, 1.0, '123e45', ToF.new do |float_like|
+        assert_send_type  '(_ToF) -> Float',
+                          kernel, :Float, float_like
+        assert_send_type  '(_ToF, exception: true) -> Float',
+                          kernel, :Float, float_like, exception: true
+      end
 
-    assert_send_type "(untyped, ?exception: bool) -> Float?",
-                     Kernel, :Float, :hello, exception: false
+      assert_send_type  '(_ToF, exception: bool) -> nil',
+                        kernel, :Float, Class.new{def to_f = raise}.new, exception: false
+
+      with_untyped.and 1.0 do |untyped|
+        # Ensure sure we're testing the no-`exception` case, but also ensure that it's not
+        # going to raise an exception on us.
+        if nil != Float(untyped, exception: false)
+          assert_send_type  '(untyped) -> Float',
+                            kernel, :Float, untyped
+          assert_send_type  '(untyped, exception: true) -> Float',
+                            kernel, :Float, untyped, exception: true
+        end
+
+        assert_send_type  '(untyped, exception: bool) -> Float?',
+                          kernel, :Float, untyped, exception: false
+      end
+    end
   end
 
   def test_Hash
-    assert_send_type "(nil) -> Hash[untyped, untyped]",
-                     Kernel, :Hash, nil
-    assert_send_type "([]) -> Hash[untyped, untyped]",
-                     Kernel, :Hash, []
-
-    with_hash 'a' => 3 do |hash|
-      assert_send_type "(::hash[String, Integer]) -> Hash[String, Integer]",
-                       Kernel, :Hash, hash
+    with_kernel do |kernel|
+      assert_send_type  '[K, V] (nil) -> Hash[K, V]',
+                        kernel, :Hash, nil
+      assert_send_type  '[K, V] ([]) -> Hash[K, V]',
+                        kernel, :Hash, []
+
+      with_hash 'a' => :b do |hash|
+        assert_send_type  '[K, V] (hash[K, V]) -> Hash[K, V]',
+                          kernel, :Hash, hash
+      end
     end
   end
 
   def test_Integer
-    with_int(1).chain([ToI.new(1)]).each do |int|
-      assert_send_type "(::int | ::_ToI) -> Integer",
-                       Kernel, :Integer, int
-      assert_send_type "(::int | ::_ToI, exception: true) -> Integer",
-                       Kernel, :Integer, int, exception: true
-      assert_send_type "(::int | ::_ToI, exception: bool) -> Integer?",
-                       Kernel, :Integer, int, exception: false
-    end
+    with_kernel do |kernel|
+      with_int.and ToI.new, '12' do |int_like|
+        assert_send_type  '(int | _ToI) -> Integer',
+                          kernel, :Integer, int_like
+        assert_send_type  '(int | _ToI, exception: true) -> Integer',
+                          kernel, :Integer, int_like, exception: true
 
-    with_string "123" do |string|
-      with_int 8 do |base|
-        assert_send_type "(::string, ::int) -> Integer",
-                         Kernel, :Integer, string, base
-        assert_send_type "(::string, ::int, exception: true) -> Integer",
-                         Kernel, :Integer, string, base, exception: true
-        assert_send_type "(::string, ::int, exception: bool) -> Integer?",
-                         Kernel, :Integer, string, base, exception: false
+      end
+      assert_send_type  '(int | _ToI, exception: bool) -> nil',
+                        kernel, :Integer, Class.new{def to_i = fail}.new, exception: false
+
+      with_int 11 do |base|
+        with_string '12' do |string|
+          assert_send_type  '(string, int) -> Integer',
+                            kernel, :Integer, string, base
+          assert_send_type  '(string, int, exception: true) -> Integer',
+                            kernel, :Integer, string, base, exception: true
+        end
+
+        with_string '&' do |string|
+          assert_send_type  '(string, int, exception: bool) -> Integer',
+                            kernel, :Integer, string, base, exception: false
+        end
       end
     end
+  end
 
-    assert_send_type "(untyped, ?exception: bool) -> Integer?",
-                     Kernel, :Integer, :hello, exception: false
+  def test_Rational
+    omit "todo: #{__method__}"
   end
 
   def test_String
-    with_string do |string|
-      assert_send_type "(::string) -> String",
-                       Kernel, :String, string
+    with_kernel do |kernel|
+      with_string.and ToS.new do |string|
+        assert_send_type  '(string | _ToS) -> String',
+                          kernel, :String, string
+      end
+    end
+  end
+
+  def test___callee__
+    with_kernel do |kernel|
+      assert_send_type  '() -> Symbol',
+                        kernel, :__callee__
+
+      # We're in a function, so we have to use this to ensure we're not in one.
+      # Since we're using the top-level binding, we need to use a global.
+      $__rbs_test___callee___kernel = kernel
+      assert_type 'nil', TOPLEVEL_BINDING.eval('$__rbs_test___callee___kernel.__callee__')
+    end
+  end
+
+  def test___dir__
+    with_kernel do |kernel|
+      assert_send_type  '() -> String',
+                        kernel, :__dir__
+      assert_type 'nil', eval('kernel.__dir__', binding) # no __FILE__ given means no `__dir__`
+    end
+  end
+
+  def test___method__
+    with_kernel do |kernel|
+      assert_send_type  '() -> Symbol',
+                        kernel, :__method__
+
+      # We're in a function, so we have to use this to ensure we're not in one.
+      $__rbs_test___method___kernel = kernel
+      assert_type 'nil', TOPLEVEL_BINDING.eval('$__rbs_test___method___kernel.__method__')
+    end
+  end
+
+  def test_op_grave
+    with_kernel do |kernel|
+      capture_stdout do
+        with_string "#{RUBY_EXECUTABLE.shellescape} -v" do |cmd|
+          assert_send_type  '(string) -> String',
+                            kernel, :`, cmd
+        end
+      end
+    end
+  end
+
+  def test_abort
+    old_stderr = $stderr
+    $stderr = File.new(File::NULL, 'w')
+
+    with_kernel do |kernel|
+      with_string 'oopsies' do |message|
+        kernel.abort message
+      rescue SystemExit
+        pass 'abort raised `SystemExit` correctly'
+      else
+        flunk '`abort` should raise `SystemExit`'
+      end
     end
 
-    assert_send_type "(::_ToS) -> String",
-                     Kernel, :String, ToS.new
+  ensure
+    $stderr.close rescue nil
+    $stderr = old_stderr
+  end
+
+  def test_at_exit
+    with_kernel do |kernel|
+      assert_send_type '() { () -> void } -> ^() -> void',
+                       kernel, :at_exit do end
+    end
+  end
+
+  def test_autoload
+    with_kernel do |kernel|
+      with_interned :RBS_Autoload_test_autoload do |const|
+        with_path File.join(__dir__, 'util', 'valid.rb') do |path|
+          assert_send_type  '(interned, path) -> nil',
+                            kernel, :autoload, const, path
+        end
+      end
+    end
   end
 
   def test_autoload?
-    with_interned :TestModuleForAutoload do |interned|
-      assert_send_type "(::interned) -> String?",
-                       Kernel, :autoload?, interned
+    Kernel.autoload :RBS_Autoload_test_autoload_p, File.join(__dir__, 'util', 'valid.rb')
+
+    with_kernel do |kernel|
+      with_interned :RBS_Autoload_test_autoload_p do |const|
+        assert_send_type  '(interned) -> String',
+                          kernel, :autoload?, const
+        with_boolish do |inherit|      
+          assert_send_type  '(interned, boolish) -> String',
+                            kernel, :autoload?, const, inherit
+        end
+      end
+
+      with_interned :RBS_Autoload_test_autoload_p_doesnt_exist do |const|
+        assert_send_type  '(interned) -> nil',
+                          kernel, :autoload?, const
+        with_boolish do |inherit|      
+          assert_send_type  '(interned, boolish) -> nil',
+                            kernel, :autoload?, const, inherit
+        end
+      end
     end
+  end
 
-    autoload :TestModuleForAutoload, '/shouldnt/be/executed'
+  def test_binding
+    with_kernel do |kernel|
+      assert_send_type  '() -> Binding',
+                        kernel, :binding
+    end
+  end
+
+  def test_exit
+    with_kernel do |kernel|
+      with_int.and(with_bool) do |status|
+        assert_send_raises  '(int | bool) -> bot', SystemExit,
+                            kernel, :exit, status
+      end
+    end
+  end
 
-    with_interned :TestModuleForAutoload do |interned|
-      assert_send_type "(::interned) -> String?",
-                       Kernel, :autoload?, interned
+  def test_exit!
+    with_kernel do |kernel|
+      with_int(12).and(with_bool) do |status|
+        _pid, proc_status = Process.waitpid2 fork { kernel.exit! status }
+
+        case status
+        when true  then assert proc_status.success?
+        when false then refute proc_status.success?
+        else            assert proc_status.exitstatus.equal?(status.to_int)
+        end
+      end
+    end
+  end
+
+  def test_fail(method: :fail)
+    with_kernel do |kernel|
+      # Since `test_fail` could theoretically have been called within the `rescue` block of some
+      # other function, we cannot rely on a `Kernel.fail()` always raising a runtime error, so we
+      # have to do it ourselves.
+      assert_send_raises  '() -> bot', :any,
+                          kernel, method
+
+      with_string do |message|
+        assert_send_raises  '(string) -> bot', :any,
+                            kernel, method, message
+
+        with(Exception.new).and_nil do |cause|
+          assert_send_raises  '(string, cause: Exception?) -> bot', :any,
+                              kernel, method, message, cause: cause
+        end
+      end
+
+      assert_type_fn = method(:assert_type)
+      exception = BlankSlate.new.__with_object_methods(:define_singleton_method)
+      exception.define_singleton_method(:exception) do |message = (nomessage=true)|
+        if nomessage
+          pass 'no message given'
+        else
+          assert_type_fn.call('Rational', message)
+        end
+        StandardError.new
+      end
+
+      assert_send_raises  '[T] (Exception::_Exception[T]) -> bot', :any,
+                          kernel, method, exception
+      assert_send_raises  '[T] (Exception::_Exception[T], T) -> bot', :any,
+                          kernel, method, exception, 1r
+      with %w[a b c], 'd', Thread::Backtrace.allocate, nil do |backtrace|
+        assert_send_raises  '[T] (Exception::_Exception[T], T, Array[String] | String | Thread::Backtrace | nil) -> bot', :any,
+                            kernel, method, exception, 1r, backtrace
+      end
+
+      with(Exception.new).and_nil do |cause|
+        assert_send_raises  '[T] (Exception::_Exception[T], cause: Exception?) -> bot', :any,
+                            kernel, method, exception, cause: cause
+        assert_send_raises  '[T] (Exception::_Exception[T], T, cause: Exception?) -> bot', :any,
+                            kernel, method, exception, 1r, cause: cause
+        with %w[a b c], 'd', Thread::Backtrace.allocate, nil do |backtrace|
+          assert_send_raises  '[T] (Exception::_Exception[T], T, Array[String] | String | Thread::Backtrace | nil, cause: Exception?) -> bot', :any,
+                              kernel, method, exception, 1r, backtrace, cause: cause
+        end
+      end
+    end
+  end
+
+  def test_raise
+    test_fail(method: :raise)
+  end
+
+  def test_sprintf(method: :sprintf)
+    with_kernel do |kernel|
+      with_string '%{a} %{b}' do |fmt|
+        with_hash a: 3, b: 4 do |keywords|
+          assert_send_type  '(string, hash[Symbol, untyped]) -> String',
+                            kernel, method, fmt, keywords
+        end
+
+        assert_send_type  '(string, **untyped) -> String',
+                          kernel, method, fmt, a: 3, b: 4
+      end
+
+      with_string '%s %s' do |fmt|
+        assert_send_type  '(string, *untyped) -> String',
+                          kernel, method, fmt, 3, 4
+      end
+    end
+  end
+
+  def test_format
+    test_sprintf(method: :format)
+  end
+
+  def test_gets
+    with_no_argv_and_stdin "abc\n" do
+      with_kernel do |kernel|
+        $stdin.rewind
+        assert_send_type  '() -> String',
+                          kernel, :gets
+        assert_send_type  '() -> nil',
+                          kernel, :gets
+
+        with_boolish do |chomp|
+          $stdin.rewind
+          assert_send_type  '() -> String',
+                            kernel, :gets
+          assert_send_type  '() -> nil',
+                            kernel, :gets
+        end
+
+        with_string("\n").and_nil do |sep|
+          $stdin.rewind
+          assert_send_type  '(string?) -> String',
+                            kernel, :gets, sep
+          assert_send_type  '(string?) -> nil',
+                            kernel, :gets, sep
+
+          with_boolish do |chomp|
+            $stdin.rewind
+            assert_send_type  '(string?, chomp: boolish) -> String',
+                              kernel, :gets, sep, chomp: chomp
+            assert_send_type  '(string?, chomp: boolish) -> nil',
+                              kernel, :gets, sep, chomp: chomp
+          end
+
+          with_int 5 do |limit|
+            $stdin.rewind
+            assert_send_type  '(string?, int) -> String',
+                              kernel, :gets, sep, limit
+            assert_send_type  '(string?, int) -> nil',
+                              kernel, :gets, sep, limit
+
+            with_boolish do |chomp|
+              $stdin.rewind
+              assert_send_type  '(string?, int, chomp: boolish) -> String',
+                                kernel, :gets, sep, limit, chomp: chomp
+              assert_send_type  '(string?, int, chomp: boolish) -> nil',
+                                kernel, :gets, sep, limit, chomp: chomp
+            end
+          end
+        end
+
+        with_int 5 do |limit|
+          $stdin.rewind
+          assert_send_type  '(int) -> String',
+                            kernel, :gets, limit
+          assert_send_type  '(int) -> nil',
+                            kernel, :gets, limit
+
+          with_boolish do |chomp|
+            $stdin.rewind
+            assert_send_type  '(int, chomp: boolish) -> String',
+                              kernel, :gets, limit, chomp: chomp
+            assert_send_type  '(int, chomp: boolish) -> nil',
+                              kernel, :gets, limit, chomp: chomp
+          end
+        end
+      end
+    end
+  end
+
+  def test_global_variables
+    with_kernel do |kernel|
+      assert_send_type  '() -> Array[Symbol]',
+                        kernel, :global_variables
+    end
+  end
+
+  def test_load
+    with_kernel do |kernel|
+      with_path File.join(__dir__, 'util', 'valid.rb') do |path|
+        assert_send_type  '(path) -> true',
+                          kernel, :load, path
+
+        # Technically MRI accepts `boolish`, but the docs state `Module | bool`, so im using that.
+        with_bool.and Module.new do |wrap|
+          assert_send_type  '(path, Module | bool) -> true',
+                            kernel, :load, path, wrap
+        end
+      end
+    end
+  end
+
+  def test_loop
+    with_kernel do |kernel|
+      # Technically, `loop.each` doesn't actually yield any arguments, so it doesn't fit into the
+      # `Enumerator` interface, as that expects it to yield exactly one argument. So, since it
+      # doesn't actually fit the interface (even though it technically _is_ an `Enumerator`), I've
+      # commented out the interface.
+      # assert_send_type  '() -> Enumerator[nil, untyped]',
+      #                   kernel, :loop
+
+      # The testing framework doesn't support breaking out of blocks given to `assert_send_type`.
+      assert_type 'untyped', kernel.loop { break 123 }
+    end
+  end
+
+  def test_open
+    omit "todo: #{__method__}"
+  end
+
+  def test_print
+    with_kernel do |kernel|
+      capture_stdout do
+        assert_send_type  '(*untyped) -> String',
+                          kernel, :print, 12, 1r, ToS.new('123')
+      end
+    end
+  end
+
+  def test_printf
+    with_kernel do |kernel|
+      capture_stdout do
+        writer = BlankSlate.new
+        def writer.write(*x) = 0
+
+        with_string '%{a} %{b}' do |fmt|
+          with_hash a: 3, b: 4 do |keywords|
+            assert_send_type  '(_Writer, string, hash[Symbol, untyped]) -> nil',
+                              kernel, :printf, writer, fmt, keywords
+
+            next unless String === fmt
+            assert_send_type  '(String, hash[Symbol, untyped]) -> nil',
+                              kernel, :printf, fmt, keywords
+          end
+
+          assert_send_type  '(_Writer, string, **untyped) -> nil',
+                            kernel, :printf, writer, fmt, a: 3, b: 4
+
+          next unless String === fmt
+          assert_send_type  '(string, **untyped) -> nil',
+                            kernel, :printf, fmt, a: 3, b: 4
+        end
+
+        with_string '%s %s' do |fmt|
+          assert_send_type  '(_Writer, string, *untyped) -> nil',
+                            kernel, :printf, writer, fmt, 3, 4
+
+          next unless String === fmt
+          assert_send_type  '(String, *untyped) -> nil',
+                            kernel, :printf, fmt, 3, 4
+        end
+      end
+    end
+  end
+
+  def test_proc
+    with_kernel do |kernel|
+      assert_send_type  '() { (?) -> untyped } -> Proc',
+                        kernel, :proc do |a, *b, c:, d: 2, **e, &f| end 
+    end
+  end
+
+  def test_lambda
+    with_kernel do |kernel|
+      assert_send_type  '() { (?) -> untyped } -> Proc',
+                        kernel, :lambda do |a, *b, c:, d: 2, **e, &f| end 
+    end
+  end
+
+  def test_putc
+    with_kernel do |kernel|
+      capture_stdout do
+        assert_send_type  '(String) -> String',
+                          kernel, :putc, '&'
+
+        with_int ?&.ord do |chr|
+          assert_send_type  '[T < _ToInt] (T) -> T',
+                            kernel, :putc, chr
+        end
+      end
+    end
+  end
+
+  def test_puts
+    with_kernel do |kernel|
+      capture_stdout do
+        assert_send_type  '(*_ToS) -> nil',
+                          kernel, :puts, 1, [2], ToS.new('123')
+      end
+    end
+  end
+
+  def test_p
+    with_kernel do |kernel|
+      assert_send_type  '() -> nil',
+                        kernel, :p
+
+      capture_stdout do
+        inspectable = BlankSlate.new
+        def inspectable.inspect = 'hi!'
+
+        assert_send_type  '[T < _Inspect] (T) -> T',
+                          kernel, :p, inspectable
+
+        inspectable2 = BlankSlate.new
+        def inspectable2.inspect = 'hi2!'
+
+        assert_send_type  '[T < _Inspect] (T, T) -> Array[T]',
+                          kernel, :p, inspectable, inspectable2
+      end
+    end
+  end
+
+  def test_pp
+    with_kernel do |kernel|
+      assert_send_type  '() -> nil',
+                        kernel, :pp
+
+      capture_stdout do
+        pretty = BlankSlate.new.__with_object_methods(:is_a?)
+        def pretty.pretty_print(x) = BlankSlate.new
+        def pretty.pretty_print_cycle(x) = BlankSlate.new
+
+        assert_send_type  '[T < PP::_PrettyPrint] (T) -> T',
+                          kernel, :pp, pretty
+
+        pretty2 = BlankSlate.new.__with_object_methods(:is_a?)
+        def pretty2.pretty_print(x) = BlankSlate.new
+        def pretty2.pretty_print_cycle(x) = BlankSlate.new
+
+        assert_send_type  '[T < PP::_PrettyPrint] (T, T) -> Array[T]',
+                          kernel, :pp, pretty, pretty2
+      end
     end
   end
 
   def test_rand
-    assert_send_type "() -> Float", Kernel, :rand
-    assert_send_type "(0) -> Float", Kernel, :rand, 0
-    assert_send_type "(_ToInt) -> Float", Kernel, :rand, 0.0
-    assert_send_type "(_ToInt) -> Float", Kernel, :rand, 0r
-    assert_send_type "(_ToInt) -> Float", Kernel, :rand, 0i
-    assert_send_type "(_ToInt) -> Integer", Kernel, :rand, 10
-    assert_send_type "(Range[Integer]) -> Integer", Kernel, :rand, 1..10
-    assert_send_type "(Range[Integer]) -> nil", Kernel, :rand, 0...0
-    assert_send_type "(Range[Float]) -> Float", Kernel, :rand, 0.0...10.0
-    assert_send_type "(Range[Float]) -> nil", Kernel, :rand, 0.0...0.0
+    omit "todo: #{__method__}"
+  end
+
+  def test_readline
+    with_no_argv_and_stdin "abc\n" do
+      with_kernel do |kernel|
+        $stdin.rewind
+        assert_send_type  '() -> String',
+                          kernel, :readline
+
+        with_boolish do |chomp|
+          $stdin.rewind
+          assert_send_type  '() -> String',
+                            kernel, :readline
+        end
+
+        with_string("\n").and_nil do |sep|
+          $stdin.rewind
+          assert_send_type  '(string?) -> String',
+                            kernel, :readline, sep
+
+          with_boolish do |chomp|
+            $stdin.rewind
+            assert_send_type  '(string?, chomp: boolish) -> String',
+                              kernel, :readline, sep, chomp: chomp
+          end
+
+          with_int 5 do |limit|
+            $stdin.rewind
+            assert_send_type  '(string?, int) -> String',
+                              kernel, :readline, sep, limit
+
+            with_boolish do |chomp|
+              $stdin.rewind
+              assert_send_type  '(string?, int, chomp: boolish) -> String',
+                                kernel, :readline, sep, limit, chomp: chomp
+            end
+          end
+        end
+
+        with_int 5 do |limit|
+          $stdin.rewind
+          assert_send_type  '(int) -> String',
+                            kernel, :readline, limit
+
+          with_boolish do |chomp|
+            $stdin.rewind
+            assert_send_type  '(int, chomp: boolish) -> String',
+                              kernel, :readline, limit, chomp: chomp
+          end
+        end
+      end
+    end
+  end
+
+  def test_readlines
+    with_no_argv_and_stdin "abc\ndef\n" do
+      with_kernel do |kernel|
+        $stdin.rewind
+        assert_send_type  '() -> Array[String]',
+                          kernel, :readlines
+
+        with_boolish do |chomp|
+          $stdin.rewind
+          assert_send_type  '() -> Array[String]',
+                            kernel, :readlines
+        end
+
+        with_string("\n").and_nil do |sep|
+          $stdin.rewind
+          assert_send_type  '(string?) -> Array[String]',
+                            kernel, :readlines, sep
+
+          with_boolish do |chomp|
+            $stdin.rewind
+            assert_send_type  '(string?, chomp: boolish) -> Array[String]',
+                              kernel, :readlines, sep, chomp: chomp
+          end
+
+          with_int 5 do |limit|
+            $stdin.rewind
+            assert_send_type  '(string?, int) -> Array[String]',
+                              kernel, :readlines, sep, limit
+
+            with_boolish do |chomp|
+              $stdin.rewind
+              assert_send_type  '(string?, int, chomp: boolish) -> Array[String]',
+                                kernel, :readlines, sep, limit, chomp: chomp
+            end
+          end
+        end
+
+        with_int 5 do |limit|
+          $stdin.rewind
+          assert_send_type  '(int) -> Array[String]',
+                            kernel, :readlines, limit
+
+          with_boolish do |chomp|
+            $stdin.rewind
+            assert_send_type  '(int, chomp: boolish) -> Array[String]',
+                              kernel, :readlines, limit, chomp: chomp
+          end
+        end
+      end
+    end
+  end
+
+  def test_require
+    with_kernel do |kernel|
+      with_path File.join(__dir__, 'util', 'valid.rb') do |path|
+        assert_send_type  '(path) -> bool',
+                          kernel, :require, path
+      end
+    end
+  end
+
+  def test_require_relative
+    with_kernel do |kernel|
+      # Technically `require_relative` can accept absolute paths; since the actual file where
+      # `require_relative` will be run isn't this one, it's base `__dir__` is different. So we use
+      # an absolute path to ensure we're requiring the valid file.
+      with_path File.join(__dir__, 'util', 'valid.rb') do |path|
+        assert_send_type  '(path) -> bool',
+                          kernel, :require_relative, path
+      end
+    end
+  end
+
+  def test_select
+    omit "todo: #{__method__}"
+  end
+
+  def test_sleep
+    with_kernel do |kernel|
+      with_timeout(seconds: 0, nanoseconds: 1) do |timeout|
+        Thread.new do
+          assert_send_type  '(Time::_Timeout) -> Integer',
+                            kernel, :sleep, timeout
+        end.join
+      end
+
+      # No way to test for `-> bot`, so instead check that the args given are ok.
+
+      # Make sure we can call `sleep()`
+      th_sleep = Thread.new do
+        Thread.current.report_on_exception = false
+        kernel.sleep
+      end
+      begin
+        sleep 0.1 while th_sleep.status == 'run' # Wait until the thread's finished running
+        assert_equal 'sleep', th_sleep.status # make sure it's sleeping (ie no exception was raised)
+      ensure
+        th_sleep.kill # cleanup after ourselves
+      end
+
+      # Make sure we can call `sleep(nil)`
+      th = Thread.new do
+        Thread.current.report_on_exception = false
+        kernel.sleep(nil)
+      end
+      begin
+        sleep 0.1 while th_sleep.status == 'run' # Wait until the thread's finished running
+        assert_equal 'sleep', th_sleep.status # make sure it's sleeping (ie no exception was raised)
+      ensure
+        th_sleep.kill # cleanup after ourselves
+      end
+    end
+  end
+
+  def test_syscall
+    omit 'There is no way to portably and safely test Kernel.syscall'
+  end
+
+  def test_test
+    with_kernel do |kernel|
+      %w[b c d e f g G k o O p S u z].each do |character|
+        with_path(__FILE__).and $stdout do |file|
+          assert_send_type  "(#{character.inspect}, IO | path) -> bool",
+                            kernel, :test, character, file
+          assert_send_type  "(#{character.ord}, IO | path) -> bool",
+                            kernel, :test, character.ord, file
+
+          with_int(character.ord).and character do |cmd|
+            assert_send_type  '(String | int, IO | path, ?IO | path) -> (bool | Integer? | Time)',
+                              kernel, :test, cmd, file
+          end
+        end
+      end
+
+      %w[l r R w W x X].each do |character|
+        with_path __FILE__ do |file|
+          assert_send_type  "(#{character.inspect}, path) -> bool",
+                            kernel, :test, character, file
+          assert_send_type  "(#{character.ord}, path) -> bool",
+                            kernel, :test, character.ord, file
+
+          with_int(character.ord).and character do |cmd|
+            assert_send_type  '(String | int, IO | path, ?IO | path) -> (bool | Integer? | Time)',
+                              kernel, :test, cmd, file
+          end
+        end
+      end
+
+      %w[s].each do |character|
+        File.open __FILE__ do |f|
+          with_path(__FILE__).and f do |file|
+            assert_send_type  "(#{character.inspect}, IO | path) -> Integer",
+                              kernel, :test, character, file
+            assert_send_type  "(#{character.ord}, IO | path) -> Integer",
+                              kernel, :test, character.ord, file
+
+            with_int(character.ord).and character do |cmd|
+              assert_send_type  '(String | int, IO | path, ?IO | path) -> (bool | Integer? | Time)',
+                                kernel, :test, cmd, file
+            end
+          end
+        end
+
+        # We have to use `STDOUT` here because `$stdout` might be redefined to
+        # an actual file or even a `StringIO`.
+        with_path('/__rbs/does/not/exist').and STDOUT do |file|
+          assert_send_type  "(#{character.inspect}, IO | path) -> nil",
+                            kernel, :test, character, file
+          assert_send_type  "(#{character.ord}, IO | path) -> nil",
+                            kernel, :test, character.ord, file
+
+          with_int(character.ord).and character do |cmd|
+            assert_send_type  '(String | int, IO | path, ?IO | path) -> (bool | Integer? | Time)',
+                              kernel, :test, cmd, file
+          end
+        end
+      end
+
+      %w[M A C].each do |character|
+        File.open __FILE__ do |f|
+          with_path(__FILE__).and f do |file|
+            assert_send_type  "(#{character.inspect}, IO | path) -> Time",
+                              kernel, :test, character, file
+            assert_send_type  "(#{character.ord}, IO | path) -> Time",
+                              kernel, :test, character.ord, file
+
+            with_int(character.ord).and character do |cmd|
+              assert_send_type  '(String | int, IO | path, ?IO | path) -> (bool | Integer? | Time)',
+                                kernel, :test, cmd, file
+            end
+          end
+        end
+      end
+
+      %w[- = < >].each do |character|
+        File.open __FILE__ do |f|
+          with_path(__FILE__).and f do |file|
+            assert_send_type  "(#{character.inspect}, IO | path, IO | path) -> bool",
+                              kernel, :test, character, file, file
+            assert_send_type  "(#{character.ord}, IO | path, IO | path) -> bool",
+                              kernel, :test, character.ord, file, file
+
+            with_int(character.ord).and character do |cmd|
+              assert_send_type  '(String | int, IO | path, ?IO | path) -> (bool | Integer? | Time)',
+                                kernel, :test, cmd, file, file
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def test_throw
+    with_kernel do |kernel|
+      # no way to test for `-> bot`, so just test arguments
+      with_untyped do |tag|
+        assert_send_raises  '(untyped) -> bot', UncaughtThrowError,
+                            kernel, :throw, tag
+
+        with_untyped do |obj|
+          assert_send_raises  '(untyped, untyped) -> bot', UncaughtThrowError,
+                              kernel, :throw, tag, obj
+        end
+      end
+    end
+  end
+
+  # These are some known warning categories 
+  KNOWN_WARNING_CATS = %i[deprecated experimental performance].select { (Warning[_1]; true) rescue false }
+
+  def test_warn
+    old_stderr, $stderr = $stderr, File.open(File::NULL, 'w')
+
+    with_kernel do |kernel|
+      assert_send_type  '() -> nil',
+                        kernel, :warn
+
+      assert_send_type  '(*_ToS) -> nil',
+                        kernel, :warn, ToS.new, ToS.new
+
+      with_int(3).and_nil do |uplevel|
+        assert_send_type  '(*_ToS, uplevel: int?) -> nil',
+                          kernel, :warn, ToS.new, ToS.new, uplevel: uplevel
+
+        with(*KNOWN_WARNING_CATS, *KNOWN_WARNING_CATS.map(&ToSym.method(:new))).and_nil do |category|
+          assert_send_type  '(*_ToS, uplevel: int?, category: Warning::category | _ToSym | nil) -> nil',
+                            kernel, :warn, ToS.new, ToS.new, uplevel: uplevel, category: category
+        end
+      end
+    end
+  ensure
+    $stderr.close rescue nil
+    $stderr = old_stderr
+  end
+
+  def test_exec
+    omit "todo: #{__method__}"
+  end
+
+  def test_spawn
+    omit "todo: #{__method__}"
+  end
+
+  def test_system
+    omit "todo: #{__method__}"
   end
 end
 
diff --git a/test/stdlib/test_helper.rb b/test/stdlib/test_helper.rb
index 020a52f7b..75e06f3d8 100644
--- a/test/stdlib/test_helper.rb
+++ b/test/stdlib/test_helper.rb
@@ -53,7 +53,7 @@ def if_ruby31(&block)
 module WithStdlibAliases
   def with_timeout(seconds: 1, nanoseconds: 0)
     unless block_given?    
-      return RBS::UnitTest::Convertibles::WithAliases::WithEnum.new(
+      return RBS::UnitTest::WithAliases::WithEnum.new(
         to_enum(__method__, seconds: seconds, nanoseconds: nanoseconds)
       )
     end
diff --git a/test/stdlib/util/valid.rb b/test/stdlib/util/valid.rb
new file mode 100644
index 000000000..5da47d1a7
--- /dev/null
+++ b/test/stdlib/util/valid.rb
@@ -0,0 +1,2 @@
+# A valid ruby file, used for testing functions such as `Kernel#load`.
+1 + 2 # rubocop:disable Rubycw/Rubycw