[Bug #20511] Update reline-0.5.7 (#10848)

* Update reline-0.5.7

* Update irb-1.13.1

39 files changed, 3010 insertions, 2720 deletions

diff --git a/test/irb/command/test_custom_command.rb b/test/irb/command/test_custom_command.rb
new file mode 100644
index 0000000000..3a3ad11d5a
--- /dev/null
+++ b/test/irb/command/test_custom_command.rb
@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+require "irb"
+
+require_relative "../helper"
+
+module TestIRB
+  class CustomCommandIntegrationTest < TestIRB::IntegrationTestCase
+    def test_command_registration_can_happen_after_irb_require
+      write_ruby <<~RUBY
+        require "irb"
+        require "irb/command"
+
+        class PrintCommand < IRB::Command::Base
+          category 'CommandTest'
+          description 'print_command'
+          def execute(*)
+            puts "Hello from PrintCommand"
+          end
+        end
+
+        IRB::Command.register(:print!, PrintCommand)
+
+        binding.irb
+      RUBY
+
+      output = run_ruby_file do
+        type "print!"
+        type "exit"
+      end
+
+      assert_include(output, "Hello from PrintCommand")
+    end
+
+    def test_command_registration_accepts_string_too
+      write_ruby <<~RUBY
+        require "irb/command"
+
+        class PrintCommand < IRB::Command::Base
+          category 'CommandTest'
+          description 'print_command'
+          def execute(*)
+            puts "Hello from PrintCommand"
+          end
+        end
+
+        IRB::Command.register("print!", PrintCommand)
+
+        binding.irb
+      RUBY
+
+      output = run_ruby_file do
+        type "print!"
+        type "exit"
+      end
+
+      assert_include(output, "Hello from PrintCommand")
+    end
+
+    def test_arguments_propagation
+      write_ruby <<~RUBY
+        require "irb/command"
+
+        class PrintArgCommand < IRB::Command::Base
+          category 'CommandTest'
+          description 'print_command_arg'
+          def execute(arg)
+            $nth_execution ||= 0
+            puts "\#{$nth_execution} arg=\#{arg.inspect}"
+            $nth_execution += 1
+          end
+        end
+
+        IRB::Command.register(:print_arg, PrintArgCommand)
+
+        binding.irb
+      RUBY
+
+      output = run_ruby_file do
+        type "print_arg"
+        type "print_arg  \n"
+        type "print_arg a r  g"
+        type "print_arg  a r  g  \n"
+        type "exit"
+      end
+
+      assert_include(output, "0 arg=\"\"")
+      assert_include(output, "1 arg=\"\"")
+      assert_include(output, "2 arg=\"a r  g\"")
+      assert_include(output, "3 arg=\"a r  g\"")
+    end
+
+    def test_def_extend_command_still_works
+      write_ruby <<~RUBY
+        require "irb"
+
+        class FooBarCommand < IRB::Command::Base
+          category 'FooBarCategory'
+          description 'foobar_description'
+          def execute(*)
+            $nth_execution ||= 1
+            puts "\#{$nth_execution} FooBar executed"
+            $nth_execution += 1
+          end
+        end
+
+        IRB::ExtendCommandBundle.def_extend_command(:foobar, FooBarCommand, nil, [:fbalias, IRB::Command::OVERRIDE_ALL])
+
+        binding.irb
+      RUBY
+
+      output = run_ruby_file do
+        type "foobar"
+        type "fbalias"
+        type "help foobar"
+        type "exit"
+      end
+
+      assert_include(output, "1 FooBar executed")
+      assert_include(output, "2 FooBar executed")
+      assert_include(output, "foobar_description")
+    end
+
+    def test_no_meta_command_also_works
+      write_ruby <<~RUBY
+        require "irb/command"
+
+        class NoMetaCommand < IRB::Command::Base
+          def execute(*)
+            puts "This command does not override meta attributes"
+          end
+        end
+
+        IRB::Command.register(:no_meta, NoMetaCommand)
+
+        binding.irb
+      RUBY
+
+      output = run_ruby_file do
+        type "no_meta"
+        type "help no_meta"
+        type "exit"
+      end
+
+      assert_include(output, "This command does not override meta attributes")
+      assert_include(output, "No description provided.")
+      assert_not_include(output, "Maybe IRB bug")
+    end
+  end
+end
diff --git a/test/irb/command/test_force_exit.rb b/test/irb/command/test_force_exit.rb
new file mode 100644
index 0000000000..191a786872
--- /dev/null
+++ b/test/irb/command/test_force_exit.rb
@@ -0,0 +1,51 @@
+# frozen_string_literal: false
+require 'irb'
+
+require_relative "../helper"
+
+module TestIRB
+  class ForceExitTest < IntegrationTestCase
+    def test_forced_exit_finishes_process_immediately
+      write_ruby <<~'ruby'
+        puts "First line"
+        puts "Second line"
+        binding.irb
+        puts "Third line"
+        binding.irb
+        puts "Fourth line"
+      ruby
+
+      output = run_ruby_file do
+        type "123"
+        type "456"
+        type "exit!"
+      end
+
+      assert_match(/First line\r\n/, output)
+      assert_match(/Second line\r\n/, output)
+      assert_match(/irb\(main\):001> 123/, output)
+      assert_match(/irb\(main\):002> 456/, output)
+      refute_match(/Third line\r\n/, output)
+      refute_match(/Fourth line\r\n/, output)
+    end
+
+    def test_forced_exit_in_nested_sessions
+      write_ruby <<~'ruby'
+        def foo
+          binding.irb
+        end
+
+        binding.irb
+        binding.irb
+      ruby
+
+      output = run_ruby_file do
+        type "123"
+        type "foo"
+        type "exit!"
+      end
+
+      assert_match(/irb\(main\):001> 123/, output)
+    end
+  end
+end
diff --git a/test/irb/command/test_help.rb b/test/irb/command/test_help.rb
new file mode 100644
index 0000000000..b34832b022
--- /dev/null
+++ b/test/irb/command/test_help.rb
@@ -0,0 +1,75 @@
+require "tempfile"
+require_relative "../helper"
+
+module TestIRB
+  class HelpTest < IntegrationTestCase
+    def setup
+      super
+
+      write_rc <<~'RUBY'
+        IRB.conf[:USE_PAGER] = false
+      RUBY
+
+      write_ruby <<~'RUBY'
+        binding.irb
+      RUBY
+    end
+
+    def test_help
+      out = run_ruby_file do
+        type "help"
+        type "exit"
+      end
+
+      assert_match(/List all available commands/, out)
+      assert_match(/Start the debugger of debug\.gem/, out)
+    end
+
+    def test_command_help
+      out = run_ruby_file do
+        type "help ls"
+        type "exit"
+      end
+
+      assert_match(/Usage: ls \[obj\]/, out)
+    end
+
+    def test_command_help_not_found
+      out = run_ruby_file do
+        type "help foo"
+        type "exit"
+      end
+
+      assert_match(/Can't find command `foo`\. Please check the command name and try again\./, out)
+    end
+
+    def test_show_cmds
+      out = run_ruby_file do
+        type "help"
+        type "exit"
+      end
+
+      assert_match(/List all available commands/, out)
+      assert_match(/Start the debugger of debug\.gem/, out)
+    end
+
+    def test_help_lists_user_aliases
+      out = run_ruby_file do
+        type "help"
+        type "exit"
+      end
+
+      assert_match(/\$\s+Alias for `show_source`/, out)
+      assert_match(/@\s+Alias for `whereami`/, out)
+    end
+
+    def test_help_lists_helper_methods
+      out = run_ruby_file do
+        type "help"
+        type "exit"
+      end
+
+      assert_match(/Helper methods\s+conf\s+Returns the current IRB context/, out)
+    end
+  end
+end
diff --git a/test/irb/command/test_multi_irb_commands.rb b/test/irb/command/test_multi_irb_commands.rb
new file mode 100644
index 0000000000..e313c0c5d2
--- /dev/null
+++ b/test/irb/command/test_multi_irb_commands.rb
@@ -0,0 +1,50 @@
+require "tempfile"
+require_relative "../helper"
+
+module TestIRB
+  class MultiIRBTest < IntegrationTestCase
+    def setup
+      super
+
+      write_ruby <<~'RUBY'
+        binding.irb
+      RUBY
+    end
+
+    def test_jobs_command_with_print_deprecated_warning
+      out = run_ruby_file do
+        type "jobs"
+        type "exit"
+      end
+
+      assert_match(/Multi-irb commands are deprecated and will be removed in IRB 2\.0\.0\. Please use workspace commands instead\./, out)
+      assert_match(%r|If you have any use case for multi-irb, please leave a comment at https://github.com/ruby/irb/issues/653|, out)
+      assert_match(/#0->irb on main \(#<Thread:0x.+ run>: running\)/, out)
+    end
+
+    def test_irb_jobs_and_kill_commands
+      out = run_ruby_file do
+        type "irb"
+        type "jobs"
+        type "kill 1"
+        type "exit"
+      end
+
+      assert_match(/#0->irb on main \(#<Thread:0x.+ sleep_forever>: stop\)/, out)
+      assert_match(/#1->irb#1 on main \(#<Thread:0x.+ run>: running\)/, out)
+    end
+
+    def test_irb_fg_jobs_and_kill_commands
+      out = run_ruby_file do
+        type "irb"
+        type "fg 0"
+        type "jobs"
+        type "kill 1"
+        type "exit"
+      end
+
+      assert_match(/#0->irb on main \(#<Thread:0x.+ run>: running\)/, out)
+      assert_match(/#1->irb#1 on main \(#<Thread:0x.+ sleep_forever>: stop\)/, out)
+    end
+  end
+end
diff --git a/test/irb/cmd/test_show_source.rb b/test/irb/command/test_show_source.rb
index cedec8aa6f..d014c78fc4 100644
--- a/test/irb/cmd/test_show_source.rb
+++ b/test/irb/command/test_show_source.rb
@@ -52,6 +52,19 @@ module TestIRB
       assert_match(%r[Couldn't locate a definition for foo], out)
     end
 
+    def test_show_source_with_missing_constant
+      write_ruby <<~'RUBY'
+        binding.irb
+      RUBY
+
+      out = run_ruby_file do
+        type "show_source Foo"
+        type "exit"
+      end
+
+      assert_match(%r[Couldn't locate a definition for Foo], out)
+    end
+
     def test_show_source_string
       write_ruby <<~'RUBY'
         binding.irb
@@ -272,5 +285,113 @@ module TestIRB
 
       assert_match(%r[#{@ruby_file.to_path}:2\s+def foo\r\n  end], out)
     end
+
+    def test_show_source_with_double_colons
+      write_ruby <<~RUBY
+        class Foo
+        end
+
+        class Foo
+          class Bar
+          end
+        end
+
+        binding.irb
+      RUBY
+
+      out = run_ruby_file do
+        type "show_source ::Foo"
+        type "exit"
+      end
+
+      assert_match(%r[#{@ruby_file.to_path}:1\s+class Foo\r\nend], out)
+
+      out = run_ruby_file do
+        type "show_source ::Foo::Bar"
+        type "exit"
+      end
+
+      assert_match(%r[#{@ruby_file.to_path}:5\s+class Bar\r\n  end], out)
+    end
+
+    def test_show_source_keep_script_lines
+      pend unless defined?(RubyVM.keep_script_lines)
+
+      write_ruby <<~RUBY
+        binding.irb
+      RUBY
+
+      out = run_ruby_file do
+        type "def foo; end"
+        type "show_source foo"
+        type "exit"
+      end
+
+      assert_match(%r[#{@ruby_file.to_path}\(irb\):1\s+def foo; end], out)
+    end
+
+    def test_show_source_unavailable_source
+      write_ruby <<~RUBY
+        binding.irb
+      RUBY
+
+      out = run_ruby_file do
+        type "RubyVM.keep_script_lines = false if defined?(RubyVM.keep_script_lines)"
+        type "def foo; end"
+        type "show_source foo"
+        type "exit"
+      end
+      assert_match(%r[#{@ruby_file.to_path}\(irb\):2\s+Source not available], out)
+    end
+
+    def test_show_source_shows_binary_source
+      write_ruby <<~RUBY
+        # io-console is an indirect dependency of irb
+        require "io/console"
+
+        binding.irb
+      RUBY
+
+      out = run_ruby_file do
+        # IO::ConsoleMode is defined in io-console gem's C extension
+        type "show_source IO::ConsoleMode"
+        type "exit"
+      end
+
+      # A safeguard to make sure the test subject is actually defined
+      refute_match(/NameError/, out)
+      assert_match(%r[Defined in binary file:.+io/console], out)
+    end
+
+    def test_show_source_with_constant_lookup
+      write_ruby <<~RUBY
+        X = 1
+        module M
+          Y = 1
+          Z = 2
+        end
+        class A
+          Z = 1
+          Array = 1
+          class B
+            include M
+            Object.new.instance_eval { binding.irb }
+          end
+        end
+      RUBY
+
+      out = run_ruby_file do
+        type "show_source X"
+        type "show_source Y"
+        type "show_source Z"
+        type "show_source Array"
+        type "exit"
+      end
+
+      assert_match(%r[#{@ruby_file.to_path}:1\s+X = 1], out)
+      assert_match(%r[#{@ruby_file.to_path}:3\s+Y = 1], out)
+      assert_match(%r[#{@ruby_file.to_path}:7\s+Z = 1], out)
+      assert_match(%r[#{@ruby_file.to_path}:8\s+Array = 1], out)
+    end
   end
 end
diff --git a/test/irb/helper.rb b/test/irb/helper.rb
index 38bdbb4c31..acaf6277f3 100644
--- a/test/irb/helper.rb
+++ b/test/irb/helper.rb
@@ -1,5 +1,6 @@
 require "test/unit"
 require "pathname"
+require "rubygems"
 
 begin
   require_relative "../lib/helper"
@@ -17,6 +18,7 @@ module IRB
 end
 
 module TestIRB
+  RUBY_3_4 = Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("3.4.0.dev")
   class TestCase < Test::Unit::TestCase
     class TestInputMethod < ::IRB::InputMethod
       attr_reader :list, :line_no
@@ -119,7 +121,9 @@ module TestIRB
       @envs["XDG_CONFIG_HOME"] ||= tmp_dir
       @envs["IRBRC"] = nil unless @envs.key?("IRBRC")
 
-      PTY.spawn(@envs.merge("TERM" => "dumb"), *cmd) do |read, write, pid|
+      envs_for_spawn = @envs.merge('TERM' => 'dumb', 'TEST_IRB_FORCE_INTERACTIVE' => 'true')
+
+      PTY.spawn(envs_for_spawn, *cmd) do |read, write, pid|
         Timeout.timeout(TIMEOUT_SEC) do
           while line = safe_gets(read)
             lines << line
@@ -194,7 +198,7 @@ module TestIRB
     end
 
     def write_ruby(program)
-      @ruby_file = Tempfile.create(%w{irb- .rb})
+      @ruby_file = Tempfile.create(%w{irbtest- .rb})
       @tmpfiles << @ruby_file
       @ruby_file.write(program)
       @ruby_file.close
diff --git a/test/irb/test_color.rb b/test/irb/test_color.rb
index c9d2512dc5..9d78f5233e 100644
--- a/test/irb/test_color.rb
+++ b/test/irb/test_color.rb
@@ -1,6 +1,5 @@
 # frozen_string_literal: false
 require 'irb/color'
-require 'rubygems'
 require 'stringio'
 
 require_relative "helper"
@@ -100,7 +99,7 @@ module TestIRB
         "foo %i[bar]" => "foo #{YELLOW}%i[#{CLEAR}#{YELLOW}bar#{CLEAR}#{YELLOW}]#{CLEAR}",
         "foo :@bar, baz, :@@qux, :$quux" => "foo #{YELLOW}:#{CLEAR}#{YELLOW}@bar#{CLEAR}, baz, #{YELLOW}:#{CLEAR}#{YELLOW}@@qux#{CLEAR}, #{YELLOW}:#{CLEAR}#{YELLOW}$quux#{CLEAR}",
         "`echo`" => "#{RED}#{BOLD}`#{CLEAR}#{RED}echo#{CLEAR}#{RED}#{BOLD}`#{CLEAR}",
-        "\t" => "\t", # not ^I
+        "\t" => Reline::Unicode.escape_for_print("\t") == '  ' ? '  ' : "\t", # not ^I
         "foo(*%W(bar))" => "foo(*#{RED}#{BOLD}%W(#{CLEAR}#{RED}bar#{CLEAR}#{RED}#{BOLD})#{CLEAR})",
         "$stdout" => "#{GREEN}#{BOLD}$stdout#{CLEAR}",
         "__END__" => "#{GREEN}__END__#{CLEAR}",
diff --git a/test/irb/test_color_printer.rb b/test/irb/test_color_printer.rb
index f162b88548..c2c624d868 100644
--- a/test/irb/test_color_printer.rb
+++ b/test/irb/test_color_printer.rb
@@ -1,6 +1,5 @@
 # frozen_string_literal: false
 require 'irb/color_printer'
-require 'rubygems'
 require 'stringio'
 
 require_relative "helper"
diff --git a/test/irb/test_cmd.rb b/test/irb/test_command.rb
index d99ac05c5d..8cb8928adb 100644
--- a/test/irb/test_cmd.rb
+++ b/test/irb/test_command.rb
@@ -1,7 +1,5 @@
 # frozen_string_literal: false
-require "rubygems"
 require "irb"
-require "irb/extend-command"
 
 require_relative "helper"
 
@@ -22,6 +20,7 @@ module TestIRB
       @xdg_config_home_backup = ENV.delete("XDG_CONFIG_HOME")
       save_encodings
       IRB.instance_variable_get(:@CONF).clear
+      IRB.instance_variable_set(:@existing_rc_name_generators, nil)
       @is_win = (RbConfig::CONFIG['host_os'] =~ /mswin|msys|mingw|cygwin|bccwin|wince|emc/)
     end
 
@@ -34,17 +33,17 @@ module TestIRB
     end
 
     def execute_lines(*lines, conf: {}, main: self, irb_path: nil)
-      IRB.init_config(nil)
-      IRB.conf[:VERBOSE] = false
-      IRB.conf[:PROMPT_MODE] = :SIMPLE
-      IRB.conf[:USE_PAGER] = false
-      IRB.conf.merge!(conf)
-      input = TestInputMethod.new(lines)
-      irb = IRB::Irb.new(IRB::WorkSpace.new(main), input)
-      irb.context.return_format = "=> %s\n"
-      irb.context.irb_path = irb_path if irb_path
-      IRB.conf[:MAIN_CONTEXT] = irb.context
       capture_output do
+        IRB.init_config(nil)
+        IRB.conf[:VERBOSE] = false
+        IRB.conf[:PROMPT_MODE] = :SIMPLE
+        IRB.conf[:USE_PAGER] = false
+        IRB.conf.merge!(conf)
+        input = TestInputMethod.new(lines)
+        irb = IRB::Irb.new(IRB::WorkSpace.new(main), input)
+        irb.context.return_format = "=> %s\n"
+        irb.context.irb_path = irb_path if irb_path
+        IRB.conf[:MAIN_CONTEXT] = irb.context
         irb.eval_input
       end
     end
@@ -58,7 +57,7 @@ module TestIRB
         "irb_info",
         main: main
       )
-      assert_empty err
+      assert_empty(err)
       assert_match(/RUBY_PLATFORM/, out)
     end
   end
@@ -77,6 +76,7 @@ module TestIRB
     def test_irb_info_multiline
       FileUtils.touch("#{@tmpdir}/.inputrc")
       FileUtils.touch("#{@tmpdir}/.irbrc")
+      FileUtils.touch("#{@tmpdir}/_irbrc")
 
       out, err = execute_lines(
         "irb_info",
@@ -88,7 +88,7 @@ module TestIRB
         IRB\sversion:\sirb\s.+\n
         InputMethod:\sAbstract\sInputMethod\n
         Completion: .+\n
-        \.irbrc\spath:\s.+\n
+        \.irbrc\spaths:.*\.irbrc.*_irbrc\n
         RUBY_PLATFORM:\s.+\n
         East\sAsian\sAmbiguous\sWidth:\s\d\n
         #{@is_win ? 'Code\spage:\s\d+\n' : ''}
@@ -112,7 +112,7 @@ module TestIRB
         IRB\sversion:\sirb\s.+\n
         InputMethod:\sAbstract\sInputMethod\n
         Completion: .+\n
-        \.irbrc\spath:\s.+\n
+        \.irbrc\spaths:\s.+\n
         RUBY_PLATFORM:\s.+\n
         East\sAsian\sAmbiguous\sWidth:\s\d\n
         #{@is_win ? 'Code\spage:\s\d+\n' : ''}
@@ -198,7 +198,7 @@ module TestIRB
         IRB\sversion:\sirb .+\n
         InputMethod:\sAbstract\sInputMethod\n
         Completion: .+\n
-        \.irbrc\spath: .+\n
+        \.irbrc\spaths: .+\n
         RUBY_PLATFORM: .+\n
         LANG\senv:\sja_JP\.UTF-8\n
         LC_ALL\senv:\sen_US\.UTF-8\n
@@ -373,17 +373,19 @@ module TestIRB
         }
       }
       out, err = execute_lines(
-        "measure :foo",
-        "measure :on, :bar",
-        "3\n",
+        "measure :foo\n",
+        "1\n",
+        "measure :on, :bar\n",
+        "2\n",
         "measure :off, :foo\n",
-        "measure :off, :bar\n",
         "3\n",
+        "measure :off, :bar\n",
+        "4\n",
         conf: conf
       )
 
       assert_empty err
-      assert_match(/\AFOO is added\.\n=> nil\nfoo\nBAR is added\.\n=> nil\nbar\nfoo\n=> 3\nbar\nfoo\n=> nil\nbar\n=> nil\n=> 3\n/, out)
+      assert_match(/\AFOO is added\.\n=> nil\nfoo\n=> 1\nBAR is added\.\n=> nil\nbar\nfoo\n=> 2\n=> nil\nbar\n=> 3\n=> nil\n=> 4\n/, out)
     end
 
     def test_measure_with_proc_warning
@@ -402,7 +404,6 @@ module TestIRB
       out, err = execute_lines(
         "3\n",
         "measure do\n",
-        "end\n",
         "3\n",
         conf: conf,
         main: c
@@ -484,62 +485,67 @@ module TestIRB
   class CwwsTest < WorkspaceCommandTestCase
     def test_cwws_returns_the_current_workspace_object
       out, err = execute_lines(
-        "cwws.class",
+        "cwws"
       )
 
       assert_empty err
-      assert_include(out, self.class.name)
+      assert_include(out, "Current workspace: #{self}")
     end
   end
 
   class PushwsTest < WorkspaceCommandTestCase
     def test_pushws_switches_to_new_workspace_and_pushes_the_current_one_to_the_stack
       out, err = execute_lines(
-        "pushws #{self.class}::Foo.new\n",
-        "cwws.class",
+        "pushws #{self.class}::Foo.new",
+        "self.class",
+        "popws",
+        "self.class"
       )
       assert_empty err
-      assert_include(out, "#{self.class}::Foo")
+
+      assert_match(/=> #{self.class}::Foo\n/, out)
+      assert_match(/=> #{self.class}\n$/, out)
     end
 
     def test_pushws_extends_the_new_workspace_with_command_bundle
       out, err = execute_lines(
-        "pushws Object.new\n",
+        "pushws Object.new",
         "self.singleton_class.ancestors"
       )
       assert_empty err
       assert_include(out, "IRB::ExtendCommandBundle")
     end
 
-    def test_pushws_prints_help_message_when_no_arg_is_given
+    def test_pushws_prints_workspace_stack_when_no_arg_is_given
       out, err = execute_lines(
-        "pushws\n",
+        "pushws",
       )
       assert_empty err
-      assert_match(/No other workspace/, out)
+      assert_include(out, "[#<TestIRB::PushwsTe...>]")
     end
-  end
 
-  class WorkspacesTest < WorkspaceCommandTestCase
-    def test_workspaces_returns_the_array_of_non_main_workspaces
+    def test_pushws_without_argument_swaps_the_top_two_workspaces
       out, err = execute_lines(
-        "pushws #{self.class}::Foo.new\n",
-        "workspaces.map { |w| w.class.name }",
+        "pushws #{self.class}::Foo.new",
+        "self.class",
+        "pushws",
+        "self.class"
       )
-
       assert_empty err
-      # self.class::Foo would be the current workspace
-      # self.class would be the old workspace that's pushed to the stack
-      assert_include(out, "=> [\"#{self.class}\"]")
+      assert_match(/=> #{self.class}::Foo\n/, out)
+      assert_match(/=> #{self.class}\n$/, out)
     end
+  end
 
-    def test_workspaces_returns_empty_array_when_no_workspaces_were_added
+  class WorkspacesTest < WorkspaceCommandTestCase
+    def test_workspaces_returns_the_stack_of_workspaces
       out, err = execute_lines(
-        "workspaces.map(&:to_s)",
+        "pushws #{self.class}::Foo.new\n",
+        "workspaces",
       )
 
       assert_empty err
-      assert_include(out, "=> []")
+      assert_match(/\[#<TestIRB::Workspac...>, #<TestIRB::Workspac...>\]\n/, out)
     end
   end
 
@@ -548,7 +554,8 @@ module TestIRB
       out, err = execute_lines(
         "pushws Foo.new\n",
         "popws\n",
-        "cwws.class",
+        "cwws\n",
+        "self.class",
       )
       assert_empty err
       assert_include(out, "=> #{self.class}")
@@ -559,7 +566,7 @@ module TestIRB
         "popws\n",
       )
       assert_empty err
-      assert_match(/workspace stack empty/, out)
+      assert_match(/\[#<TestIRB::PopwsTes...>\]\n/, out)
     end
   end
 
@@ -567,19 +574,20 @@ module TestIRB
     def test_chws_replaces_the_current_workspace
       out, err = execute_lines(
         "chws #{self.class}::Foo.new\n",
-        "cwws.class",
+        "cwws\n",
+        "self.class\n"
       )
       assert_empty err
+      assert_include(out, "Current workspace: #<#{self.class.name}::Foo")
       assert_include(out, "=> #{self.class}::Foo")
     end
 
     def test_chws_does_nothing_when_receiving_no_argument
       out, err = execute_lines(
         "chws\n",
-        "cwws.class",
       )
       assert_empty err
-      assert_include(out, "=> #{self.class}")
+      assert_include(out, "Current workspace: #{self}")
     end
   end
 
@@ -601,29 +609,6 @@ module TestIRB
     end
   end
 
-
-  class ShowCmdsTest < CommandTestCase
-    def test_show_cmds
-      out, err = execute_lines(
-        "show_cmds\n"
-      )
-
-      assert_empty err
-      assert_match(/List all available commands and their description/, out)
-      assert_match(/Start the debugger of debug\.gem/, out)
-    end
-
-    def test_show_cmds_list_user_aliases
-      out, err = execute_lines(
-        "show_cmds\n"
-      )
-
-      assert_empty err
-      assert_match(/\$\s+Alias for `show_source`/, out)
-      assert_match(/@\s+Alias for `whereami`/, out)
-    end
-  end
-
   class LsTest < CommandTestCase
     def test_ls
       out, err = execute_lines(
@@ -747,18 +732,18 @@ module TestIRB
     def test_ls_grep_empty
       out, err = execute_lines("ls\n")
       assert_empty err
-      assert_match(/whereami/, out)
-      assert_match(/show_source/, out)
+      assert_match(/assert/, out)
+      assert_match(/refute/, out)
 
       [
-        "ls grep: /whereami/\n",
-        "ls -g whereami\n",
-        "ls -G whereami\n",
+        "ls grep: /assert/\n",
+        "ls -g assert\n",
+        "ls -G assert\n",
       ].each do |line|
         out, err = execute_lines(line)
         assert_empty err
-        assert_match(/whereami/, out)
-        assert_not_match(/show_source/, out)
+        assert_match(/assert/, out)
+        assert_not_match(/refute/, out)
       end
     end
 
@@ -774,22 +759,6 @@ module TestIRB
   end
 
   class ShowDocTest < CommandTestCase
-    def test_help
-      out, err = execute_lines(
-        "help String#gsub\n",
-        "\n",
-      )
-
-      # the former is what we'd get without document content installed, like on CI
-      # the latter is what we may get locally
-      possible_rdoc_output = [/Nothing known about String#gsub/, /gsub\(pattern\)/]
-      assert_include err, "[Deprecation] The `help` command will be repurposed to display command help in the future.\n"
-      assert(possible_rdoc_output.any? { |output| output.match?(out) }, "Expect the `help` command to match one of the possible outputs. Got:\n#{out}")
-    ensure
-      # this is the only way to reset the redefined method without coupling the test with its implementation
-      EnvUtil.suppress_warning { load "irb/cmd/help.rb" }
-    end
-
     def test_show_doc
       out, err = execute_lines(
         "show_doc String#gsub\n",
@@ -803,7 +772,7 @@ module TestIRB
       assert(possible_rdoc_output.any? { |output| output.match?(out) }, "Expect the `show_doc` command to match one of the possible outputs. Got:\n#{out}")
     ensure
       # this is the only way to reset the redefined method without coupling the test with its implementation
-      EnvUtil.suppress_warning { load "irb/cmd/help.rb" }
+      EnvUtil.suppress_warning { load "irb/command/help.rb" }
     end
 
     def test_show_doc_without_rdoc
@@ -819,7 +788,7 @@ module TestIRB
       assert_include(err, "Can't display document because `rdoc` is not installed.\n")
     ensure
       # this is the only way to reset the redefined method without coupling the test with its implementation
-      EnvUtil.suppress_warning { load "irb/cmd/help.rb" }
+      EnvUtil.suppress_warning { load "irb/command/help.rb" }
     end
   end
 
@@ -848,6 +817,16 @@ module TestIRB
       assert_match("command: ': code'", out)
     end
 
+    def test_edit_without_arg_and_non_existing_irb_path
+      out, err = execute_lines(
+        "edit",
+        irb_path: '/path/to/file.rb(irb)'
+      )
+
+      assert_empty err
+      assert_match(/Can not find file: \/path\/to\/file\.rb\(irb\)/, out)
+    end
+
     def test_edit_with_path
       out, err = execute_lines(
         "edit #{__FILE__}"
@@ -974,4 +953,19 @@ module TestIRB
 
   end
 
+  class HelperMethodInsallTest < CommandTestCase
+    def test_helper_method_install
+      IRB::ExtendCommandBundle.module_eval do
+        def foobar
+          "test_helper_method_foobar"
+        end
+      end
+
+      out, err = execute_lines("foobar.upcase")
+      assert_empty err
+      assert_include(out, '=> "TEST_HELPER_METHOD_FOOBAR"')
+    ensure
+      IRB::ExtendCommandBundle.remove_method :foobar
+    end
+  end
 end
diff --git a/test/irb/test_completion.rb b/test/irb/test_completion.rb
index 0625c96976..5fe7952b3d 100644
--- a/test/irb/test_completion.rb
+++ b/test/irb/test_completion.rb
@@ -14,6 +14,13 @@ module TestIRB
       IRB::RegexpCompletor.new.doc_namespace('', target, '', bind: bind)
     end
 
+    class CommandCompletionTest < CompletionTest
+      def test_command_completion
+        assert_include(IRB::RegexpCompletor.new.completion_candidates('', 'show_s', '', bind: binding), 'show_source')
+        assert_not_include(IRB::RegexpCompletor.new.completion_candidates(';', 'show_s', '', bind: binding), 'show_source')
+      end
+    end
+
     class MethodCompletionTest < CompletionTest
       def test_complete_string
         assert_include(completion_candidates("'foo'.up", binding), "'foo'.upcase")
@@ -124,8 +131,9 @@ module TestIRB
       end
 
       def test_complete_require_library_name_first
-        candidates = IRB::RegexpCompletor.new.completion_candidates("require ", "'csv", "", bind: binding)
-        assert_equal "'csv", candidates.first
+        # Test that library name is completed first with subdirectories
+        candidates = IRB::RegexpCompletor.new.completion_candidates("require ", "'irb", "", bind: binding)
+        assert_equal "'irb", candidates.first
       end
 
       def test_complete_require_relative
@@ -204,6 +212,13 @@ module TestIRB
       end
     end
 
+    def test_not_completing_empty_string
+      assert_equal([], completion_candidates("", binding))
+      assert_equal([], completion_candidates(" ", binding))
+      assert_equal([], completion_candidates("\t", binding))
+      assert_equal(nil, doc_namespace("", binding))
+    end
+
     def test_complete_symbol
       symbols = %w"UTF-16LE UTF-7".map do |enc|
         "K".force_encoding(enc).to_sym
diff --git a/test/irb/test_context.rb b/test/irb/test_context.rb
index 79186f13a1..cd3f2c8f62 100644
--- a/test/irb/test_context.rb
+++ b/test/irb/test_context.rb
@@ -1,7 +1,6 @@
 # frozen_string_literal: false
 require 'tempfile'
 require 'irb'
-require 'rubygems' if defined?(Gem)
 
 require_relative "helper"
 
@@ -29,27 +28,6 @@ module TestIRB
       restore_encodings
     end
 
-    def test_last_value
-      assert_nil(@context.last_value)
-      assert_nil(@context.evaluate('_', 1))
-      obj = Object.new
-      @context.set_last_value(obj)
-      assert_same(obj, @context.last_value)
-      assert_same(obj, @context.evaluate('_', 1))
-    end
-
-    def test_evaluate_with_encoding_error_without_lineno
-      assert_raise_with_message(EncodingError, /invalid symbol/) {
-        @context.evaluate(%q[:"\xAE"], 1)
-        # The backtrace of this invalid encoding hash doesn't contain lineno.
-      }
-    end
-
-    def test_evaluate_still_emits_warning
-      assert_warning("(irb):1: warning: END in method; use at_exit\n") do
-        @context.evaluate(%q[def foo; END {}; end], 1)
-      end
-    end
 
     def test_eval_input
       verbose, $VERBOSE = $VERBOSE, nil
@@ -64,11 +42,27 @@ module TestIRB
         irb.eval_input
       end
       assert_empty err
-      assert_pattern_list([:*, /\(irb\):1:in `<main>': Foo \(RuntimeError\)\n/,
-                           :*, /#<RuntimeError: Foo>\n/,
-                           :*, /0$/,
-                           :*, /0$/,
-                           /\s*/], out)
+
+      expected_output =
+        if RUBY_3_4
+          [
+            :*, /\(irb\):1:in '<main>': Foo \(RuntimeError\)\n/,
+            :*, /#<RuntimeError: Foo>\n/,
+            :*, /0$/,
+            :*, /0$/,
+            /\s*/
+          ]
+        else
+          [
+            :*, /\(irb\):1:in `<main>': Foo \(RuntimeError\)\n/,
+            :*, /#<RuntimeError: Foo>\n/,
+            :*, /0$/,
+            :*, /0$/,
+            /\s*/
+          ]
+        end
+
+      assert_pattern_list(expected_output, out)
     ensure
       $VERBOSE = verbose
     end
@@ -84,11 +78,21 @@ module TestIRB
         irb.eval_input
       end
       assert_empty err
-      assert_pattern_list([
-          :*, /\(irb\):1:in `<main>': Foo \(RuntimeError\)\n/,
-          :*, /\(irb\):2:in `<main>': Bar \(RuntimeError\)\n/,
-          :*, /#<RuntimeError: Bar>\n/,
-        ], out)
+      expected_output =
+        if RUBY_3_4
+          [
+            :*, /\(irb\):1:in '<main>': Foo \(RuntimeError\)\n/,
+            :*, /\(irb\):2:in '<main>': Bar \(RuntimeError\)\n/,
+            :*, /#<RuntimeError: Bar>\n/,
+          ]
+        else
+          [
+            :*, /\(irb\):1:in `<main>': Foo \(RuntimeError\)\n/,
+            :*, /\(irb\):2:in `<main>': Bar \(RuntimeError\)\n/,
+            :*, /#<RuntimeError: Bar>\n/,
+          ]
+        end
+      assert_pattern_list(expected_output, out)
     end
 
     def test_prompt_n_deprecation
@@ -126,9 +130,9 @@ module TestIRB
         [:marshal, "123", Marshal.dump(123)],
       ],
       failed: [
-        [false, "BasicObject.new", /#<NoMethodError: undefined method `to_s' for/],
-        [:p, "class Foo; undef inspect ;end; Foo.new", /#<NoMethodError: undefined method `inspect' for/],
-        [:yaml, "BasicObject.new", /#<NoMethodError: undefined method `inspect' for/],
+        [false, "BasicObject.new", /#<NoMethodError: undefined method (`|')to_s' for/],
+        [:p, "class Foo; undef inspect ;end; Foo.new", /#<NoMethodError: undefined method (`|')inspect' for/],
+        [:yaml, "BasicObject.new", /#<NoMethodError: undefined method (`|')inspect' for/],
         [:marshal, "[Object.new, Class.new]", /#<TypeError: can't dump anonymous class #<Class:/]
       ]
     }.each do |scenario, cases|
@@ -206,7 +210,7 @@ module TestIRB
       end
       assert_empty err
       assert_match(/An error occurred when inspecting the object: #<RuntimeError: foo>/, out)
-      assert_match(/An error occurred when running Kernel#inspect: #<NoMethodError: undefined method `inspect' for/, out)
+      assert_match(/An error occurred when running Kernel#inspect: #<NoMethodError: undefined method (`|')inspect' for/, out)
     ensure
       $VERBOSE = verbose
     end
@@ -349,7 +353,7 @@ module TestIRB
         end
         assert_empty err
         assert_equal("=> \n#{value}\n", out)
-        irb.context.evaluate('A.remove_method(:inspect)', 0)
+        irb.context.evaluate_expression('A.remove_method(:inspect)', 0)
 
         input.reset
         irb.context.echo = true
@@ -359,7 +363,7 @@ module TestIRB
         end
         assert_empty err
         assert_equal("=> #{value_first_line[0..(input.winsize.last - 9)]}...\n=> \n#{value}\n", out)
-        irb.context.evaluate('A.remove_method(:inspect)', 0)
+        irb.context.evaluate_expression('A.remove_method(:inspect)', 0)
 
         input.reset
         irb.context.echo = true
@@ -369,7 +373,7 @@ module TestIRB
         end
         assert_empty err
         assert_equal("=> \n#{value}\n=> \n#{value}\n", out)
-        irb.context.evaluate('A.remove_method(:inspect)', 0)
+        irb.context.evaluate_expression('A.remove_method(:inspect)', 0)
 
         input.reset
         irb.context.echo = false
@@ -379,7 +383,7 @@ module TestIRB
         end
         assert_empty err
         assert_equal("", out)
-        irb.context.evaluate('A.remove_method(:inspect)', 0)
+        irb.context.evaluate_expression('A.remove_method(:inspect)', 0)
 
         input.reset
         irb.context.echo = false
@@ -389,7 +393,7 @@ module TestIRB
         end
         assert_empty err
         assert_equal("", out)
-        irb.context.evaluate('A.remove_method(:inspect)', 0)
+        irb.context.evaluate_expression('A.remove_method(:inspect)', 0)
 
         input.reset
         irb.context.echo = false
@@ -399,7 +403,7 @@ module TestIRB
         end
         assert_empty err
         assert_equal("", out)
-        irb.context.evaluate('A.remove_method(:inspect)', 0)
+        irb.context.evaluate_expression('A.remove_method(:inspect)', 0)
       end
     end
 
@@ -496,22 +500,30 @@ module TestIRB
         irb.eval_input
       end
       assert_empty err
-      if RUBY_VERSION < '3.0.0' && STDOUT.tty?
-        expected = [
-          :*, /Traceback \(most recent call last\):\n/,
-          :*, /\t 2: from \(irb\):1:in `<main>'\n/,
-          :*, /\t 1: from \(irb\):1:in `hoge'\n/,
-          :*, /\(irb\):1:in `fuga': unhandled exception\n/,
-        ]
-      else
-        expected = [
-          :*, /\(irb\):1:in `fuga': unhandled exception\n/,
-          :*, /\tfrom \(irb\):1:in `hoge'\n/,
-          :*, /\tfrom \(irb\):1:in `<main>'\n/,
-          :*
-        ]
-      end
-      assert_pattern_list(expected, out)
+      expected_output =
+        if RUBY_3_4
+          [
+            :*, /\(irb\):1:in 'fuga': unhandled exception\n/,
+            :*, /\tfrom \(irb\):1:in 'hoge'\n/,
+            :*, /\tfrom \(irb\):1:in '<main>'\n/,
+            :*
+          ]
+        elsif RUBY_VERSION < '3.0.0' && STDOUT.tty?
+          [
+            :*, /Traceback \(most recent call last\):\n/,
+            :*, /\t 2: from \(irb\):1:in `<main>'\n/,
+            :*, /\t 1: from \(irb\):1:in `hoge'\n/,
+            :*, /\(irb\):1:in `fuga': unhandled exception\n/,
+          ]
+        else
+          [
+            :*, /\(irb\):1:in `fuga': unhandled exception\n/,
+            :*, /\tfrom \(irb\):1:in `hoge'\n/,
+            :*, /\tfrom \(irb\):1:in `<main>'\n/,
+            :*
+          ]
+        end
+      assert_pattern_list(expected_output, out)
     ensure
       $VERBOSE = verbose
     end
@@ -526,22 +538,31 @@ module TestIRB
         irb.eval_input
       end
       assert_empty err
-      if RUBY_VERSION < '3.0.0' && STDOUT.tty?
-        expected = [
-          :*, /Traceback \(most recent call last\):\n/,
-          :*, /\t 2: from \(irb\):1:in `<main>'\n/,
-          :*, /\t 1: from \(irb\):1:in `hoge'\n/,
-          :*, /\(irb\):1:in `fuga': A\\xF3B \(RuntimeError\)\n/,
-        ]
-      else
-        expected = [
-          :*, /\(irb\):1:in `fuga': A\\xF3B \(RuntimeError\)\n/,
-          :*, /\tfrom \(irb\):1:in `hoge'\n/,
-          :*, /\tfrom \(irb\):1:in `<main>'\n/,
-          :*
-        ]
-      end
-      assert_pattern_list(expected, out)
+      expected_output =
+        if RUBY_3_4
+          [
+            :*, /\(irb\):1:in 'fuga': A\\xF3B \(RuntimeError\)\n/,
+            :*, /\tfrom \(irb\):1:in 'hoge'\n/,
+            :*, /\tfrom \(irb\):1:in '<main>'\n/,
+            :*
+          ]
+        elsif RUBY_VERSION < '3.0.0' && STDOUT.tty?
+          [
+            :*, /Traceback \(most recent call last\):\n/,
+            :*, /\t 2: from \(irb\):1:in `<main>'\n/,
+            :*, /\t 1: from \(irb\):1:in `hoge'\n/,
+            :*, /\(irb\):1:in `fuga': A\\xF3B \(RuntimeError\)\n/,
+          ]
+        else
+          [
+            :*, /\(irb\):1:in `fuga': A\\xF3B \(RuntimeError\)\n/,
+            :*, /\tfrom \(irb\):1:in `hoge'\n/,
+            :*, /\tfrom \(irb\):1:in `<main>'\n/,
+            :*
+          ]
+        end
+
+      assert_pattern_list(expected_output, out)
     ensure
       $VERBOSE = verbose
     end
@@ -567,43 +588,43 @@ module TestIRB
         expected = [
           :*, /Traceback \(most recent call last\):\n/,
           :*, /\t... \d+ levels...\n/,
-          :*, /\t16: from \(irb\):1:in `a4'\n/,
-          :*, /\t15: from \(irb\):1:in `a5'\n/,
-          :*, /\t14: from \(irb\):1:in `a6'\n/,
-          :*, /\t13: from \(irb\):1:in `a7'\n/,
-          :*, /\t12: from \(irb\):1:in `a8'\n/,
-          :*, /\t11: from \(irb\):1:in `a9'\n/,
-          :*, /\t10: from \(irb\):1:in `a10'\n/,
-          :*, /\t 9: from \(irb\):1:in `a11'\n/,
-          :*, /\t 8: from \(irb\):1:in `a12'\n/,
-          :*, /\t 7: from \(irb\):1:in `a13'\n/,
-          :*, /\t 6: from \(irb\):1:in `a14'\n/,
-          :*, /\t 5: from \(irb\):1:in `a15'\n/,
-          :*, /\t 4: from \(irb\):1:in `a16'\n/,
-          :*, /\t 3: from \(irb\):1:in `a17'\n/,
-          :*, /\t 2: from \(irb\):1:in `a18'\n/,
-          :*, /\t 1: from \(irb\):1:in `a19'\n/,
-          :*, /\(irb\):1:in `a20': unhandled exception\n/,
+          :*, /\t16: from \(irb\):1:in (`|')a4'\n/,
+          :*, /\t15: from \(irb\):1:in (`|')a5'\n/,
+          :*, /\t14: from \(irb\):1:in (`|')a6'\n/,
+          :*, /\t13: from \(irb\):1:in (`|')a7'\n/,
+          :*, /\t12: from \(irb\):1:in (`|')a8'\n/,
+          :*, /\t11: from \(irb\):1:in (`|')a9'\n/,
+          :*, /\t10: from \(irb\):1:in (`|')a10'\n/,
+          :*, /\t 9: from \(irb\):1:in (`|')a11'\n/,
+          :*, /\t 8: from \(irb\):1:in (`|')a12'\n/,
+          :*, /\t 7: from \(irb\):1:in (`|')a13'\n/,
+          :*, /\t 6: from \(irb\):1:in (`|')a14'\n/,
+          :*, /\t 5: from \(irb\):1:in (`|')a15'\n/,
+          :*, /\t 4: from \(irb\):1:in (`|')a16'\n/,
+          :*, /\t 3: from \(irb\):1:in (`|')a17'\n/,
+          :*, /\t 2: from \(irb\):1:in (`|')a18'\n/,
+          :*, /\t 1: from \(irb\):1:in (`|')a19'\n/,
+          :*, /\(irb\):1:in (`|')a20': unhandled exception\n/,
         ]
       else
         expected = [
-          :*, /\(irb\):1:in `a20': unhandled exception\n/,
-          :*, /\tfrom \(irb\):1:in `a19'\n/,
-          :*, /\tfrom \(irb\):1:in `a18'\n/,
-          :*, /\tfrom \(irb\):1:in `a17'\n/,
-          :*, /\tfrom \(irb\):1:in `a16'\n/,
-          :*, /\tfrom \(irb\):1:in `a15'\n/,
-          :*, /\tfrom \(irb\):1:in `a14'\n/,
-          :*, /\tfrom \(irb\):1:in `a13'\n/,
-          :*, /\tfrom \(irb\):1:in `a12'\n/,
-          :*, /\tfrom \(irb\):1:in `a11'\n/,
-          :*, /\tfrom \(irb\):1:in `a10'\n/,
-          :*, /\tfrom \(irb\):1:in `a9'\n/,
-          :*, /\tfrom \(irb\):1:in `a8'\n/,
-          :*, /\tfrom \(irb\):1:in `a7'\n/,
-          :*, /\tfrom \(irb\):1:in `a6'\n/,
-          :*, /\tfrom \(irb\):1:in `a5'\n/,
-          :*, /\tfrom \(irb\):1:in `a4'\n/,
+          :*, /\(irb\):1:in (`|')a20': unhandled exception\n/,
+          :*, /\tfrom \(irb\):1:in (`|')a19'\n/,
+          :*, /\tfrom \(irb\):1:in (`|')a18'\n/,
+          :*, /\tfrom \(irb\):1:in (`|')a17'\n/,
+          :*, /\tfrom \(irb\):1:in (`|')a16'\n/,
+          :*, /\tfrom \(irb\):1:in (`|')a15'\n/,
+          :*, /\tfrom \(irb\):1:in (`|')a14'\n/,
+          :*, /\tfrom \(irb\):1:in (`|')a13'\n/,
+          :*, /\tfrom \(irb\):1:in (`|')a12'\n/,
+          :*, /\tfrom \(irb\):1:in (`|')a11'\n/,
+          :*, /\tfrom \(irb\):1:in (`|')a10'\n/,
+          :*, /\tfrom \(irb\):1:in (`|')a9'\n/,
+          :*, /\tfrom \(irb\):1:in (`|')a8'\n/,
+          :*, /\tfrom \(irb\):1:in (`|')a7'\n/,
+          :*, /\tfrom \(irb\):1:in (`|')a6'\n/,
+          :*, /\tfrom \(irb\):1:in (`|')a5'\n/,
+          :*, /\tfrom \(irb\):1:in (`|')a4'\n/,
           :*, /\t... \d+ levels...\n/,
         ]
       end
@@ -641,6 +662,14 @@ module TestIRB
       assert_equal("irb(!ArgumentError)>", irb.send(:format_prompt, 'irb(%M)>', nil, 1, 1))
     end
 
+    def test_prompt_format
+      main = 'main'
+      irb = IRB::Irb.new(IRB::WorkSpace.new(main), TestInputMethod.new)
+      assert_equal('%% main %m %main %%m >', irb.send(:format_prompt, '%%%% %m %%m %%%m %%%%m %l', '>', 1, 1))
+      assert_equal('42,%i, 42,%3i,042,%03i', irb.send(:format_prompt, '%i,%%i,%3i,%%3i,%03i,%%03i', nil, 42, 1))
+      assert_equal('42,%n, 42,%3n,042,%03n', irb.send(:format_prompt, '%n,%%n,%3n,%%3n,%03n,%%03n', nil, 1, 42))
+    end
+
     def test_lineno
       input = TestInputMethod.new([
         "\n",
@@ -662,6 +691,18 @@ module TestIRB
         ], out)
     end
 
+    def test_irb_path_setter
+      @context.irb_path = __FILE__
+      assert_equal(__FILE__, @context.irb_path)
+      assert_equal("#{__FILE__}(irb)", @context.instance_variable_get(:@eval_path))
+      @context.irb_path = 'file/does/not/exist'
+      assert_equal('file/does/not/exist', @context.irb_path)
+      assert_equal('file/does/not/exist', @context.instance_variable_get(:@eval_path))
+      @context.irb_path = "#{__FILE__}(irb)"
+      assert_equal("#{__FILE__}(irb)", @context.irb_path)
+      assert_equal("#{__FILE__}(irb)", @context.instance_variable_get(:@eval_path))
+    end
+
     def test_build_completor
       verbose, $VERBOSE = $VERBOSE, nil
       original_completor = IRB.conf[:COMPLETOR]
diff --git a/test/irb/test_debug_cmd.rb b/test/irb/test_debugger_integration.rb
index 0fb45af478..8b1bddea17 100644
--- a/test/irb/test_debug_cmd.rb
+++ b/test/irb/test_debugger_integration.rb
@@ -6,7 +6,7 @@ require "tmpdir"
 require_relative "helper"
 
 module TestIRB
-  class DebugCommandTest < IntegrationTestCase
+  class DebuggerIntegrationTest < IntegrationTestCase
     def setup
       super
 
@@ -67,6 +67,22 @@ module TestIRB
       assert_match(/IRB is already running with a debug session/, output)
     end
 
+    def test_debug_command_can_only_be_called_from_binding_irb
+      write_ruby <<~'ruby'
+        require "irb"
+        # trick test framework
+        puts "binding.irb"
+        IRB.start
+      ruby
+
+      output = run_ruby_file do
+        type "debug"
+        type "exit"
+      end
+
+      assert_include(output, "Debugging commands are only available when IRB is started with binding.irb")
+    end
+
     def test_next
       write_ruby <<~'ruby'
         binding.irb
@@ -244,28 +260,46 @@ module TestIRB
     def test_exit
       write_ruby <<~'RUBY'
         binding.irb
-        puts "hello"
+        puts "he" + "llo"
       RUBY
 
       output = run_ruby_file do
-        type "next"
+        type "debug"
         type "exit"
       end
 
-      assert_match(/irb\(main\):001> next/, output)
+      assert_match(/irb:rdbg\(main\):002>/, output)
+      assert_match(/hello/, output)
+    end
+
+    def test_force_exit
+      write_ruby <<~'RUBY'
+        binding.irb
+        puts "he" + "llo"
+      RUBY
+
+      output = run_ruby_file do
+        type "debug"
+        type "exit!"
+      end
+
+      assert_match(/irb:rdbg\(main\):002>/, output)
+      assert_not_match(/hello/, output)
     end
 
     def test_quit
       write_ruby <<~'RUBY'
         binding.irb
+        puts "he" + "llo"
       RUBY
 
       output = run_ruby_file do
-        type "next"
+        type "debug"
         type "quit!"
       end
 
-      assert_match(/irb\(main\):001> next/, output)
+      assert_match(/irb:rdbg\(main\):002>/, output)
+      assert_not_match(/hello/, output)
     end
 
     def test_prompt_line_number_continues
@@ -345,19 +379,19 @@ module TestIRB
       assert_include(output, "### Frame control")
     end
 
-    def test_show_cmds_display_different_content_when_debugger_is_enabled
+    def test_help_display_different_content_when_debugger_is_enabled
       write_ruby <<~'ruby'
         binding.irb
       ruby
 
       output = run_ruby_file do
         type "debug"
-        type "show_cmds"
+        type "help"
         type "continue"
       end
 
       # IRB's commands should still be listed
-      assert_match(/show_cmds\s+List all available commands and their description\./, output)
+      assert_match(/help\s+List all available commands/, output)
       # debug gem's commands should be appended at the end
       assert_match(/Debugging \(from debug\.gem\)\s+### Control flow/, output)
     end
@@ -434,5 +468,29 @@ module TestIRB
       assert_match(/irb\(main\):001> next/, output)
       assert_include(output, "Multi-IRB commands are not available when the debugger is enabled.")
     end
+
+    def test_irb_passes_empty_input_to_debugger_to_repeat_the_last_command
+      write_ruby <<~'ruby'
+        binding.irb
+        puts "foo"
+        puts "bar"
+        puts "baz"
+      ruby
+
+      output = run_ruby_file do
+        type "next"
+        type ""
+        # Test that empty input doesn't repeat expressions
+        type "123"
+        type ""
+        type "next"
+        type ""
+        type ""
+      end
+
+      assert_include(output, "=>   2\| puts \"foo\"")
+      assert_include(output, "=>   3\| puts \"bar\"")
+      assert_include(output, "=>   4\| puts \"baz\"")
+    end
   end
 end
diff --git a/test/irb/test_eval_history.rb b/test/irb/test_eval_history.rb
index 0f9ec4811c..54913ceff5 100644
--- a/test/irb/test_eval_history.rb
+++ b/test/irb/test_eval_history.rb
@@ -30,14 +30,14 @@ module TestIRB
       end
     end
 
-    def test_eval_history_is_diabled_by_default
+    def test_eval_history_is_disabled_by_default
       out, err = execute_lines(
         "a = 1",
         "__"
       )
 
       assert_empty(err)
-      assert_match(/undefined local variable or method `__'/, out)
+      assert_match(/undefined local variable or method (`|')__'/, out)
     end
 
     def test_eval_history_can_be_retrieved_with_double_underscore
diff --git a/test/irb/test_helper_method.rb b/test/irb/test_helper_method.rb
new file mode 100644
index 0000000000..291278c16a
--- /dev/null
+++ b/test/irb/test_helper_method.rb
@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+require "irb"
+
+require_relative "helper"
+
+module TestIRB
+  class HelperMethodTestCase < TestCase
+    def setup
+      $VERBOSE = nil
+      @verbosity = $VERBOSE
+      save_encodings
+      IRB.instance_variable_get(:@CONF).clear
+    end
+
+    def teardown
+      $VERBOSE = @verbosity
+      restore_encodings
+    end
+
+    def execute_lines(*lines, conf: {}, main: self, irb_path: nil)
+      IRB.init_config(nil)
+      IRB.conf[:VERBOSE] = false
+      IRB.conf[:PROMPT_MODE] = :SIMPLE
+      IRB.conf.merge!(conf)
+      input = TestInputMethod.new(lines)
+      irb = IRB::Irb.new(IRB::WorkSpace.new(main), input)
+      irb.context.return_format = "=> %s\n"
+      irb.context.irb_path = irb_path if irb_path
+      IRB.conf[:MAIN_CONTEXT] = irb.context
+      IRB.conf[:USE_PAGER] = false
+      capture_output do
+        irb.eval_input
+      end
+    end
+  end
+
+  module TestHelperMethod
+    class ConfTest < HelperMethodTestCase
+      def test_conf_returns_the_context_object
+        out, err = execute_lines("conf.ap_name")
+
+        assert_empty err
+        assert_include out, "=> \"irb\""
+      end
+    end
+  end
+
+  class HelperMethodIntegrationTest < IntegrationTestCase
+    def test_arguments_propogation
+      write_ruby <<~RUBY
+        require "irb/helper_method"
+
+        class MyHelper < IRB::HelperMethod::Base
+          description "This is a test helper"
+
+          def execute(
+            required_arg, optional_arg = nil, *splat_arg, required_keyword_arg:,
+            optional_keyword_arg: nil, **double_splat_arg, &block_arg
+          )
+            puts [required_arg, optional_arg, splat_arg, required_keyword_arg, optional_keyword_arg, double_splat_arg, block_arg.call].to_s
+          end
+        end
+
+        IRB::HelperMethod.register(:my_helper, MyHelper)
+
+        binding.irb
+      RUBY
+
+      output = run_ruby_file do
+        type <<~INPUT
+          my_helper(
+            "required", "optional", "splat", required_keyword_arg: "required",
+            optional_keyword_arg: "optional", a: 1, b: 2
+          ) { "block" }
+        INPUT
+        type "exit"
+      end
+
+      assert_include(output, '["required", "optional", ["splat"], "required", "optional", {:a=>1, :b=>2}, "block"]')
+    end
+
+    def test_helper_method_injection_can_happen_after_irb_require
+      write_ruby <<~RUBY
+        require "irb"
+
+        class MyHelper < IRB::HelperMethod::Base
+          description "This is a test helper"
+
+          def execute
+            puts "Hello from MyHelper"
+          end
+        end
+
+        IRB::HelperMethod.register(:my_helper, MyHelper)
+
+        binding.irb
+      RUBY
+
+      output = run_ruby_file do
+        type "my_helper"
+        type "exit"
+      end
+
+      assert_include(output, 'Hello from MyHelper')
+    end
+
+    def test_helper_method_instances_are_memoized
+      write_ruby <<~RUBY
+        require "irb/helper_method"
+
+        class MyHelper < IRB::HelperMethod::Base
+          description "This is a test helper"
+
+          def execute(val)
+            @val ||= val
+          end
+        end
+
+        IRB::HelperMethod.register(:my_helper, MyHelper)
+
+        binding.irb
+      RUBY
+
+      output = run_ruby_file do
+        type "my_helper(100)"
+        type "my_helper(200)"
+        type "exit"
+      end
+
+      assert_include(output, '=> 100')
+      assert_not_include(output, '=> 200')
+    end
+  end
+end
diff --git a/test/irb/test_history.rb b/test/irb/test_history.rb
index f7ba2b9d33..63be35fdaa 100644
--- a/test/irb/test_history.rb
+++ b/test/irb/test_history.rb
@@ -10,11 +10,24 @@ return if RUBY_PLATFORM.match?(/solaris|mswin|mingw/i)
 module TestIRB
   class HistoryTest < TestCase
     def setup
-      IRB.conf[:RC_NAME_GENERATOR] = nil
+      @original_verbose, $VERBOSE = $VERBOSE, nil
+      @tmpdir = Dir.mktmpdir("test_irb_history_")
+      @backup_home = ENV["HOME"]
+      @backup_xdg_config_home = ENV.delete("XDG_CONFIG_HOME")
+      @backup_irbrc = ENV.delete("IRBRC")
+      @backup_default_external = Encoding.default_external
+      ENV["HOME"] = @tmpdir
+      IRB.instance_variable_set(:@existing_rc_name_generators, nil)
     end
 
     def teardown
-      IRB.conf[:RC_NAME_GENERATOR] = nil
+      IRB.instance_variable_set(:@existing_rc_name_generators, nil)
+      ENV["HOME"] = @backup_home
+      ENV["XDG_CONFIG_HOME"] = @backup_xdg_config_home
+      ENV["IRBRC"] = @backup_irbrc
+      Encoding.default_external = @backup_default_external
+      $VERBOSE = @original_verbose
+      FileUtils.rm_rf(@tmpdir)
     end
 
     class TestInputMethodWithRelineHistory < TestInputMethod
@@ -123,35 +136,23 @@ module TestIRB
     end
 
     def test_history_concurrent_use_not_present
-      backup_home = ENV["HOME"]
-      backup_xdg_config_home = ENV.delete("XDG_CONFIG_HOME")
-      backup_irbrc = ENV.delete("IRBRC")
       IRB.conf[:LC_MESSAGES] = IRB::Locale.new
       IRB.conf[:SAVE_HISTORY] = 1
-      Dir.mktmpdir("test_irb_history_") do |tmpdir|
-        ENV["HOME"] = tmpdir
-        io = TestInputMethodWithRelineHistory.new
-        io.class::HISTORY.clear
-        io.load_history
-        io.class::HISTORY << 'line1'
-        io.class::HISTORY << 'line2'
-
-        history_file = IRB.rc_file("_history")
-        assert_not_send [File, :file?, history_file]
-        File.write(history_file, "line0\n")
-        io.save_history
-        assert_equal(%w"line0 line1 line2", File.read(history_file).split)
-      end
-    ensure
-      ENV["HOME"] = backup_home
-      ENV["XDG_CONFIG_HOME"] = backup_xdg_config_home
-      ENV["IRBRC"] = backup_irbrc
+      io = TestInputMethodWithRelineHistory.new
+      io.class::HISTORY.clear
+      io.load_history
+      io.class::HISTORY << 'line1'
+      io.class::HISTORY << 'line2'
+
+      history_file = IRB.rc_file("_history")
+      assert_not_send [File, :file?, history_file]
+      File.write(history_file, "line0\n")
+      io.save_history
+      assert_equal(%w"line0 line1 line2", File.read(history_file).split)
     end
 
     def test_history_different_encodings
-      backup_default_external = Encoding.default_external
       IRB.conf[:SAVE_HISTORY] = 2
-      verbose_bak, $VERBOSE = $VERBOSE, nil
       Encoding.default_external = Encoding::US_ASCII
       locale = IRB::Locale.new("C")
       assert_history(<<~EXPECTED_HISTORY.encode(Encoding::US_ASCII), <<~INITIAL_HISTORY.encode(Encoding::UTF_8), <<~INPUT, locale: locale)
@@ -162,9 +163,34 @@ module TestIRB
       INITIAL_HISTORY
         exit
       INPUT
+    end
+
+    def test_history_does_not_raise_when_history_file_directory_does_not_exist
+      backup_history_file = IRB.conf[:HISTORY_FILE]
+      IRB.conf[:SAVE_HISTORY] = 1
+      IRB.conf[:HISTORY_FILE] = "fake/fake/fake/history_file"
+      io = TestInputMethodWithRelineHistory.new
+
+      assert_warn(/history file does not exist/) do
+        io.save_history
+      end
+
+      # assert_warn reverts $VERBOSE to EnvUtil.original_verbose, which is true in some cases
+      # We want to keep $VERBOSE as nil until teardown is called
+      # TODO: check if this is an assert_warn issue
+      $VERBOSE = nil
     ensure
-      Encoding.default_external = backup_default_external
-      $VERBOSE = verbose_bak
+      IRB.conf[:HISTORY_FILE] = backup_history_file
+    end
+
+    def test_no_home_no_history_file_does_not_raise_history_save
+      ENV['HOME'] = nil
+      io = TestInputMethodWithRelineHistory.new
+      assert_nil(IRB.rc_file('_history'))
+      assert_nothing_raised do
+        io.load_history
+        io.save_history
+      end
     end
 
     private
@@ -199,34 +225,30 @@ module TestIRB
     end
 
     def assert_history(expected_history, initial_irb_history, input, input_method = TestInputMethodWithRelineHistory, locale: IRB::Locale.new)
-      backup_verbose, $VERBOSE = $VERBOSE, nil
-      backup_home = ENV["HOME"]
-      backup_xdg_config_home = ENV.delete("XDG_CONFIG_HOME")
       IRB.conf[:LC_MESSAGES] = locale
       actual_history = nil
-      Dir.mktmpdir("test_irb_history_") do |tmpdir|
-        ENV["HOME"] = tmpdir
-        File.open(IRB.rc_file("_history"), "w") do |f|
-          f.write(initial_irb_history)
-        end
+      history_file = IRB.rc_file("_history")
+      ENV["HOME"] = @tmpdir
+      File.open(history_file, "w") do |f|
+        f.write(initial_irb_history)
+      end
 
-        io = input_method.new
+      io = input_method.new
+      io.class::HISTORY.clear
+      io.load_history
+      if block_given?
+        previous_history = []
+        io.class::HISTORY.each { |line| previous_history << line }
+        yield history_file
         io.class::HISTORY.clear
-        io.load_history
-        if block_given?
-          previous_history = []
-          io.class::HISTORY.each { |line| previous_history << line }
-          yield IRB.rc_file("_history")
-          io.class::HISTORY.clear
-          previous_history.each { |line| io.class::HISTORY << line }
-        end
-        input.split.each { |line| io.class::HISTORY << line }
-        io.save_history
+        previous_history.each { |line| io.class::HISTORY << line }
+      end
+      input.split.each { |line| io.class::HISTORY << line }
+      io.save_history
 
-        io.load_history
-        File.open(IRB.rc_file("_history"), "r") do |f|
-          actual_history = f.read
-        end
+      io.load_history
+      File.open(history_file, "r") do |f|
+        actual_history = f.read
       end
       assert_equal(expected_history, actual_history, <<~MESSAGE)
         expected:
@@ -234,10 +256,6 @@ module TestIRB
         but actual:
         #{actual_history}
       MESSAGE
-    ensure
-      $VERBOSE = backup_verbose
-      ENV["HOME"] = backup_home
-      ENV["XDG_CONFIG_HOME"] = backup_xdg_config_home
     end
 
     def with_temp_stdio
@@ -251,10 +269,6 @@ module TestIRB
 
   class IRBHistoryIntegrationTest < IntegrationTestCase
     def test_history_saving_with_debug
-      if ruby_core?
-        omit "This test works only under ruby/irb"
-      end
-
       write_history ""
 
       write_ruby <<~'RUBY'
@@ -293,6 +307,53 @@ module TestIRB
       HISTORY
     end
 
+    def test_history_saving_with_debug_without_prior_history
+      tmpdir = Dir.mktmpdir("test_irb_history_")
+      # Intentionally not creating the file so we test the reset counter logic
+      history_file = File.join(tmpdir, "irb_history")
+
+      write_rc <<~RUBY
+        IRB.conf[:HISTORY_FILE] = "#{history_file}"
+      RUBY
+
+      write_ruby <<~'RUBY'
+        def foo
+        end
+
+        binding.irb
+
+        foo
+      RUBY
+
+      output = run_ruby_file do
+        type "'irb session'"
+        type "next"
+        type "'irb:debug session'"
+        type "step"
+        type "irb_info"
+        type "puts Reline::HISTORY.to_a.to_s"
+        type "q!"
+      end
+
+      assert_include(output, "InputMethod: RelineInputMethod")
+      # check that in-memory history is preserved across sessions
+      assert_include output, %q(
+        ["'irb session'", "next", "'irb:debug session'", "step", "irb_info", "puts Reline::HISTORY.to_a.to_s"]
+      ).strip
+
+      assert_equal <<~HISTORY, File.read(history_file)
+        'irb session'
+        next
+        'irb:debug session'
+        step
+        irb_info
+        puts Reline::HISTORY.to_a.to_s
+        q!
+      HISTORY
+    ensure
+      FileUtils.rm_rf(tmpdir)
+    end
+
     def test_history_saving_with_nested_sessions
       write_history ""
 
@@ -323,6 +384,62 @@ module TestIRB
       HISTORY
     end
 
+    def test_nested_history_saving_from_inner_session_with_exit!
+      write_history ""
+
+      write_ruby <<~'RUBY'
+        def foo
+          binding.irb
+        end
+
+        binding.irb
+      RUBY
+
+      run_ruby_file do
+        type "'outer session'"
+        type "foo"
+        type "'inner session'"
+        type "exit!"
+      end
+
+      assert_equal <<~HISTORY, @history_file.open.read
+        'outer session'
+        foo
+        'inner session'
+        exit!
+      HISTORY
+    end
+
+    def test_nested_history_saving_from_outer_session_with_exit!
+      write_history ""
+
+      write_ruby <<~'RUBY'
+        def foo
+          binding.irb
+        end
+
+        binding.irb
+      RUBY
+
+      run_ruby_file do
+        type "'outer session'"
+        type "foo"
+        type "'inner session'"
+        type "exit"
+        type "'outer session again'"
+        type "exit!"
+      end
+
+      assert_equal <<~HISTORY, @history_file.open.read
+        'outer session'
+        foo
+        'inner session'
+        exit
+        'outer session again'
+        exit!
+      HISTORY
+    end
+
     def test_history_saving_with_nested_sessions_and_prior_history
       write_history <<~HISTORY
         old_history_1
diff --git a/test/irb/test_init.rb b/test/irb/test_init.rb
index 7d11b5b507..f11d7398c8 100644
--- a/test/irb/test_init.rb
+++ b/test/irb/test_init.rb
@@ -11,13 +11,18 @@ module TestIRB
       @backup_env = %w[HOME XDG_CONFIG_HOME IRBRC].each_with_object({}) do |env, hash|
         hash[env] = ENV.delete(env)
       end
-      ENV["HOME"] = @tmpdir = Dir.mktmpdir("test_irb_init_#{$$}")
+      ENV["HOME"] = @tmpdir = File.realpath(Dir.mktmpdir("test_irb_init_#{$$}"))
+    end
+
+    def reset_rc_name_generators
+      IRB.instance_variable_set(:@existing_rc_name_generators, nil)
     end
 
     def teardown
       ENV.update(@backup_env)
       FileUtils.rm_rf(@tmpdir)
       IRB.conf.delete(:SCRIPT)
+      reset_rc_name_generators
     end
 
     def test_setup_with_argv_preserves_global_argv
@@ -34,42 +39,80 @@ module TestIRB
       assert_equal orig, $0
     end
 
-    def test_rc_file
+    def test_rc_files
       tmpdir = @tmpdir
       Dir.chdir(tmpdir) do
-        ENV["XDG_CONFIG_HOME"] = "#{tmpdir}/xdg"
-        IRB.conf[:RC_NAME_GENERATOR] = nil
-        assert_equal(tmpdir+"/.irb#{IRB::IRBRC_EXT}", IRB.rc_file)
-        assert_equal(tmpdir+"/.irb_history", IRB.rc_file("_history"))
-        assert_file.not_exist?(tmpdir+"/xdg")
-        IRB.conf[:RC_NAME_GENERATOR] = nil
-        FileUtils.touch(tmpdir+"/.irb#{IRB::IRBRC_EXT}")
-        assert_equal(tmpdir+"/.irb#{IRB::IRBRC_EXT}", IRB.rc_file)
-        assert_equal(tmpdir+"/.irb_history", IRB.rc_file("_history"))
-        assert_file.not_exist?(tmpdir+"/xdg")
+        home = ENV['HOME'] = "#{tmpdir}/home"
+        xdg_config_home = ENV['XDG_CONFIG_HOME'] = "#{tmpdir}/xdg"
+        reset_rc_name_generators
+        assert_empty(IRB.irbrc_files)
+        assert_equal("#{home}/.irb_history", IRB.rc_file('_history'))
+        FileUtils.mkdir_p(home)
+        FileUtils.mkdir_p("#{xdg_config_home}/irb")
+        FileUtils.mkdir_p("#{home}/.config/irb")
+        reset_rc_name_generators
+        assert_empty(IRB.irbrc_files)
+        assert_equal("#{xdg_config_home}/irb/irb_history", IRB.rc_file('_history'))
+        home_irbrc = "#{home}/.irbrc"
+        config_irbrc = "#{home}/.config/irb/irbrc"
+        xdg_config_irbrc = "#{xdg_config_home}/irb/irbrc"
+        [home_irbrc, config_irbrc, xdg_config_irbrc].each do |file|
+          FileUtils.touch(file)
+        end
+        current_dir_irbrcs = %w[.irbrc irbrc _irbrc $irbrc].map { |file| "#{tmpdir}/#{file}" }
+        current_dir_irbrcs.each { |file| FileUtils.touch(file) }
+        reset_rc_name_generators
+        assert_equal([xdg_config_irbrc, home_irbrc, *current_dir_irbrcs], IRB.irbrc_files)
+        assert_equal(xdg_config_irbrc.sub(/rc$/, '_history'), IRB.rc_file('_history'))
+        ENV['XDG_CONFIG_HOME'] = nil
+        reset_rc_name_generators
+        assert_equal([home_irbrc, config_irbrc, *current_dir_irbrcs], IRB.irbrc_files)
+        assert_equal(home_irbrc.sub(/rc$/, '_history'), IRB.rc_file('_history'))
+        ENV['XDG_CONFIG_HOME'] = ''
+        reset_rc_name_generators
+        assert_equal([home_irbrc, config_irbrc] + current_dir_irbrcs, IRB.irbrc_files)
+        assert_equal(home_irbrc.sub(/rc$/, '_history'), IRB.rc_file('_history'))
+        ENV['XDG_CONFIG_HOME'] = xdg_config_home
+        ENV['IRBRC'] = "#{tmpdir}/.irbrc"
+        reset_rc_name_generators
+        assert_equal([ENV['IRBRC'], xdg_config_irbrc, home_irbrc] + (current_dir_irbrcs - [ENV['IRBRC']]), IRB.irbrc_files)
+        assert_equal(ENV['IRBRC'] + '_history', IRB.rc_file('_history'))
+        ENV['IRBRC'] = ENV['HOME'] = ENV['XDG_CONFIG_HOME'] = nil
+        reset_rc_name_generators
+        assert_equal(current_dir_irbrcs, IRB.irbrc_files)
+        assert_nil(IRB.rc_file('_history'))
       end
     end
 
-    def test_rc_file_in_subdir
+    def test_duplicated_rc_files
       tmpdir = @tmpdir
       Dir.chdir(tmpdir) do
-        FileUtils.mkdir_p("#{tmpdir}/mydir")
-        Dir.chdir("#{tmpdir}/mydir") do
-          IRB.conf[:RC_NAME_GENERATOR] = nil
-          assert_equal(tmpdir+"/.irb#{IRB::IRBRC_EXT}", IRB.rc_file)
-          assert_equal(tmpdir+"/.irb_history", IRB.rc_file("_history"))
-          IRB.conf[:RC_NAME_GENERATOR] = nil
-          FileUtils.touch(tmpdir+"/.irb#{IRB::IRBRC_EXT}")
-          assert_equal(tmpdir+"/.irb#{IRB::IRBRC_EXT}", IRB.rc_file)
-          assert_equal(tmpdir+"/.irb_history", IRB.rc_file("_history"))
+        ENV['XDG_CONFIG_HOME'] = "#{ENV['HOME']}/.config"
+        FileUtils.mkdir_p("#{ENV['XDG_CONFIG_HOME']}/irb")
+        env_irbrc = ENV['IRBRC'] = "#{tmpdir}/_irbrc"
+        xdg_config_irbrc = "#{ENV['XDG_CONFIG_HOME']}/irb/irbrc"
+        home_irbrc = "#{ENV['HOME']}/.irbrc"
+        current_dir_irbrc = "#{tmpdir}/irbrc"
+        [env_irbrc, xdg_config_irbrc, home_irbrc, current_dir_irbrc].each do |file|
+          FileUtils.touch(file)
         end
+        reset_rc_name_generators
+        assert_equal([env_irbrc, xdg_config_irbrc, home_irbrc, current_dir_irbrc], IRB.irbrc_files)
       end
     end
 
-    def test_recovery_sigint
+    def test_sigint_restore_default
       pend "This test gets stuck on Solaris for unknown reason; contribution is welcome" if RUBY_PLATFORM =~ /solaris/
       bundle_exec = ENV.key?('BUNDLE_GEMFILE') ? ['-rbundler/setup'] : []
-      status = assert_in_out_err(bundle_exec + %w[-W0 -rirb -e binding.irb;loop{Process.kill("SIGINT",$$)} -- -f --], "exit\n", //, //)
+      # IRB should restore SIGINT handler
+      status = assert_in_out_err(bundle_exec + %w[-W0 -rirb -e Signal.trap("SIGINT","DEFAULT");binding.irb;loop{Process.kill("SIGINT",$$)} -- -f --], "exit\n", //, //)
+      Process.kill("SIGKILL", status.pid) if !status.exited? && !status.stopped? && !status.signaled?
+    end
+
+    def test_sigint_restore_block
+      bundle_exec = ENV.key?('BUNDLE_GEMFILE') ? ['-rbundler/setup'] : []
+      # IRB should restore SIGINT handler
+      status = assert_in_out_err(bundle_exec + %w[-W0 -rirb -e x=false;Signal.trap("SIGINT"){x=true};binding.irb;loop{Process.kill("SIGINT",$$);if(x);break;end} -- -f --], "exit\n", //, //)
       Process.kill("SIGKILL", status.pid) if !status.exited? && !status.stopped? && !status.signaled?
     end
 
@@ -208,6 +251,12 @@ module TestIRB
       assert_equal(['-f'], argv)
     end
 
+    def test_option_tracer
+      argv = %w[--tracer]
+      IRB.setup(eval("__FILE__"), argv: argv)
+      assert_equal(true, IRB.conf[:USE_TRACER])
+    end
+
     private
 
     def with_argv(argv)
diff --git a/test/irb/test_input_method.rb b/test/irb/test_input_method.rb
index e6a1b06e82..ce317b4b32 100644
--- a/test/irb/test_input_method.rb
+++ b/test/irb/test_input_method.rb
@@ -15,7 +15,7 @@ module TestIRB
     def teardown
       IRB.conf.replace(@conf_backup)
       restore_encodings
-      # Reset Reline configuration overrided by RelineInputMethod.
+      # Reset Reline configuration overridden by RelineInputMethod.
       Reline.instance_variable_set(:@core, nil)
     end
   end
@@ -88,17 +88,18 @@ module TestIRB
       @driver = RDoc::RI::Driver.new(use_stdout: true)
     end
 
-    def display_document(target, bind)
+    def display_document(target, bind, driver = nil)
       input_method = IRB::RelineInputMethod.new(IRB::RegexpCompletor.new)
-      input_method.instance_variable_set(:@completion_params, [target, '', '', bind])
-      input_method.display_document(target, driver: @driver)
+      input_method.instance_variable_set(:@rdoc_ri_driver, driver) if driver
+      input_method.instance_variable_set(:@completion_params, ['', target, '', bind])
+      input_method.display_document(target)
     end
 
     def test_perfectly_matched_namespace_triggers_document_display
       omit unless has_rdoc_content?
 
       out, err = capture_output do
-        display_document("String", binding)
+        display_document("String", binding, @driver)
       end
 
       assert_empty(err)
@@ -109,7 +110,7 @@ module TestIRB
     def test_perfectly_matched_multiple_namespaces_triggers_document_display
       result = nil
       out, err = capture_output do
-        result = display_document("{}.nil?", binding)
+        result = display_document("{}.nil?", binding, @driver)
       end
 
       assert_empty(err)
@@ -131,7 +132,7 @@ module TestIRB
     def test_not_matched_namespace_triggers_nothing
       result = nil
       out, err = capture_output do
-        result = display_document("Stri", binding)
+        result = display_document("Stri", binding, @driver)
       end
 
       assert_empty(err)
@@ -156,7 +157,7 @@ module TestIRB
     def test_perfect_matching_handles_nil_namespace
       out, err = capture_output do
         # symbol literal has `nil` doc namespace so it's a good test subject
-        assert_nil(display_document(":aiueo", binding))
+        assert_nil(display_document(":aiueo", binding, @driver))
       end
 
       assert_empty(err)
@@ -170,4 +171,3 @@ module TestIRB
     end
   end
 end
-
diff --git a/test/irb/test_irb.rb b/test/irb/test_irb.rb
index fb8b5c2bfa..28be744088 100644
--- a/test/irb/test_irb.rb
+++ b/test/irb/test_irb.rb
@@ -42,6 +42,56 @@ module TestIRB
       assert_include output, "From: #{@ruby_file.path}:1"
     end
 
+    def test_underscore_stores_last_result
+      write_ruby <<~'RUBY'
+        binding.irb
+      RUBY
+
+      output = run_ruby_file do
+        type "1 + 1"
+        type "_ + 10"
+        type "exit!"
+      end
+
+      assert_include output, "=> 12"
+    end
+
+    def test_evaluate_with_encoding_error_without_lineno
+      if RUBY_ENGINE == 'truffleruby'
+        omit "Remove me after https://github.com/ruby/prism/issues/2129 is addressed and adopted in TruffleRuby"
+      end
+
+      if RUBY_VERSION >= "3.4."
+        omit "Now raises SyntaxError"
+      end
+
+      write_ruby <<~'RUBY'
+        binding.irb
+      RUBY
+
+      output = run_ruby_file do
+        type %q[:"\xAE"]
+        type "exit!"
+      end
+
+      assert_include output, 'invalid symbol in encoding UTF-8 :"\xAE"'
+      # EncodingError would be wrapped with ANSI escape sequences, so we assert it separately
+      assert_include output, "EncodingError"
+    end
+
+    def test_evaluate_still_emits_warning
+      write_ruby <<~'RUBY'
+        binding.irb
+      RUBY
+
+      output = run_ruby_file do
+        type %q[def foo; END {}; end]
+        type "exit!"
+      end
+
+      assert_include output, '(irb):1: warning: END in method; use at_exit'
+    end
+
     def test_symbol_aliases_dont_affect_ruby_syntax
       write_ruby <<~'RUBY'
         $foo = "It's a foo"
@@ -58,6 +108,41 @@ module TestIRB
       assert_include output, "=> \"It's a foo\""
       assert_include output, "=> \"It's a bar\""
     end
+
+    def test_empty_input_echoing_behaviour
+      write_ruby <<~'RUBY'
+        binding.irb
+      RUBY
+
+      output = run_ruby_file do
+        type ""
+        type "  "
+        type "exit"
+      end
+
+      assert_not_match(/irb\(main\):001> (\r*\n)?=> nil/, output)
+      assert_match(/irb\(main\):002>   (\r*\n)?=> nil/, output)
+    end
+  end
+
+  class NestedBindingIrbTest < IntegrationTestCase
+    def test_current_context_restore
+      write_ruby <<~'RUBY'
+        binding.irb
+      RUBY
+
+      output = run_ruby_file do
+        type '$ctx = IRB.CurrentContext'
+        type 'binding.irb'
+        type 'p context_changed: IRB.CurrentContext != $ctx'
+        type 'exit'
+        type 'p context_restored: IRB.CurrentContext == $ctx'
+        type 'exit'
+      end
+
+      assert_include output, '{:context_changed=>true}'
+      assert_include output, '{:context_restored=>true}'
+    end
   end
 
   class IrbIOConfigurationTest < TestCase
@@ -738,4 +823,95 @@ module TestIRB
       IRB::Irb.new(workspace, TestInputMethod.new)
     end
   end
+
+  class BacktraceFilteringTest < TestIRB::IntegrationTestCase
+    def test_backtrace_filtering
+      write_ruby <<~'RUBY'
+        def foo
+          raise "error"
+        end
+
+        def bar
+          foo
+        end
+
+        binding.irb
+      RUBY
+
+      output = run_ruby_file do
+        type "bar"
+        type "exit"
+      end
+
+      assert_match(/irbtest-.*\.rb:2:in (`|'Object#)foo': error \(RuntimeError\)/, output)
+      frame_traces = output.split("\n").select { |line| line.strip.match?(/from /) }.map(&:strip)
+
+      expected_traces = if RUBY_VERSION >= "3.3.0"
+        [
+          /from .*\/irbtest-.*.rb:6:in (`|'Object#)bar'/,
+          /from .*\/irbtest-.*.rb\(irb\):1:in [`']<main>'/,
+          /from <internal:kernel>:\d+:in (`|'Kernel#)loop'/,
+          /from <internal:prelude>:\d+:in (`|'Binding#)irb'/,
+          /from .*\/irbtest-.*.rb:9:in [`']<main>'/
+        ]
+      else
+        [
+          /from .*\/irbtest-.*.rb:6:in (`|'Object#)bar'/,
+          /from .*\/irbtest-.*.rb\(irb\):1:in [`']<main>'/,
+          /from <internal:prelude>:\d+:in (`|'Binding#)irb'/,
+          /from .*\/irbtest-.*.rb:9:in [`']<main>'/
+        ]
+      end
+
+      expected_traces.reverse! if RUBY_VERSION < "3.0.0"
+
+      expected_traces.each_with_index do |expected_trace, index|
+        assert_match(expected_trace, frame_traces[index])
+      end
+    end
+
+    def test_backtrace_filtering_with_backtrace_filter
+      write_rc <<~'RUBY'
+        class TestBacktraceFilter
+          def self.call(backtrace)
+            backtrace.reject { |line| line.include?("internal") }
+          end
+        end
+
+        IRB.conf[:BACKTRACE_FILTER] = TestBacktraceFilter
+      RUBY
+
+      write_ruby <<~'RUBY'
+        def foo
+          raise "error"
+        end
+
+        def bar
+          foo
+        end
+
+        binding.irb
+      RUBY
+
+      output = run_ruby_file do
+        type "bar"
+        type "exit"
+      end
+
+      assert_match(/irbtest-.*\.rb:2:in (`|'Object#)foo': error \(RuntimeError\)/, output)
+      frame_traces = output.split("\n").select { |line| line.strip.match?(/from /) }.map(&:strip)
+
+      expected_traces = [
+        /from .*\/irbtest-.*.rb:6:in (`|'Object#)bar'/,
+        /from .*\/irbtest-.*.rb\(irb\):1:in [`']<main>'/,
+        /from .*\/irbtest-.*.rb:9:in [`']<main>'/
+      ]
+
+      expected_traces.reverse! if RUBY_VERSION < "3.0.0"
+
+      expected_traces.each_with_index do |expected_trace, index|
+        assert_match(expected_trace, frame_traces[index])
+      end
+    end
+  end
 end
diff --git a/test/irb/test_nesting_parser.rb b/test/irb/test_nesting_parser.rb
index ea3a23aaf5..2482d40081 100644
--- a/test/irb/test_nesting_parser.rb
+++ b/test/irb/test_nesting_parser.rb
@@ -280,6 +280,44 @@ module TestIRB
       end
     end
 
+    def test_undef_alias
+      codes = [
+        'undef foo',
+        'alias foo bar',
+        'undef !',
+        'alias + -',
+        'alias $a $b',
+        'undef do',
+        'alias do do',
+        'undef :do',
+        'alias :do :do',
+        'undef :"#{alias do do}"',
+        'alias :"#{undef do}" do',
+        'alias do :"#{undef do}"'
+      ]
+      code_with_comment = <<~EOS
+        undef #
+        #
+        do #
+        alias #
+        #
+        do #
+        #
+        do #
+      EOS
+      code_with_heredoc = <<~EOS
+        <<~A; alias
+        A
+        :"#{<<~A}"
+        A
+        do
+      EOS
+      [*codes, code_with_comment, code_with_heredoc].each do |code|
+        opens = IRB::NestingParser.open_tokens(IRB::RubyLex.ripper_lex_without_warning('(' + code + "\nif"))
+        assert_equal(%w[( if], opens.map(&:tok))
+      end
+    end
+
     def test_case_in
       if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.7.0')
         pend 'This test requires ruby version that supports case-in syntax'
diff --git a/test/irb/test_raise_exception.rb b/test/irb/test_raise_exception.rb
index c373dd7335..44a5ae87e1 100644
--- a/test/irb/test_raise_exception.rb
+++ b/test/irb/test_raise_exception.rb
@@ -61,7 +61,7 @@ IRB
         # TruffleRuby warns when the locale does not exist
         env['TRUFFLERUBYOPT'] = "#{ENV['TRUFFLERUBYOPT']} --log.level=SEVERE" if RUBY_ENGINE == 'truffleruby'
         args = [env] + bundle_exec + %W[-rirb -C #{tmpdir} -W0 -e IRB.start(__FILE__) -- -f --]
-        error = /`raise_euc_with_invalid_byte_sequence': あ\\xFF \(RuntimeError\)/
+        error = /raise_euc_with_invalid_byte_sequence': あ\\xFF \(RuntimeError\)/
         assert_in_out_err(args, <<~IRB, error, [], encoding: "UTF-8")
           require_relative 'euc'
           raise_euc_with_invalid_byte_sequence
diff --git a/test/irb/test_ruby_lex.rb b/test/irb/test_ruby_lex.rb
index 5cfd81dbe8..4e406a8ce0 100644
--- a/test/irb/test_ruby_lex.rb
+++ b/test/irb/test_ruby_lex.rb
@@ -221,6 +221,10 @@ module TestIRB
     end
 
     def assert_code_block_open(lines, expected, local_variables: [])
+      if RUBY_ENGINE == 'truffleruby'
+        omit "Remove me after https://github.com/ruby/prism/issues/2129 is addressed and adopted in TruffleRuby"
+      end
+
       _indent_level, _continue, code_block_open = check_state(lines, local_variables: local_variables)
       error_message = "Wrong result of code_block_open for:\n #{lines.join("\n")}"
       assert_equal(expected, code_block_open, error_message)
diff --git a/test/irb/test_tracer.rb b/test/irb/test_tracer.rb
new file mode 100644
index 0000000000..540f8be131
--- /dev/null
+++ b/test/irb/test_tracer.rb
@@ -0,0 +1,90 @@
+# frozen_string_literal: false
+require 'tempfile'
+require 'irb'
+
+require_relative "helper"
+
+module TestIRB
+  class ContextWithTracerIntegrationTest < IntegrationTestCase
+    def setup
+      super
+
+      omit "Tracer gem is not available when running on TruffleRuby" if RUBY_ENGINE == "truffleruby"
+
+      @envs.merge!("NO_COLOR" => "true")
+    end
+
+    def example_ruby_file
+      <<~'RUBY'
+        class Foo
+          def self.foo
+            100
+          end
+        end
+
+        def bar(obj)
+          obj.foo
+        end
+
+        binding.irb
+      RUBY
+    end
+
+    def test_use_tracer_enabled_when_gem_is_unavailable
+      write_rc <<~RUBY
+        # Simulate the absence of the tracer gem
+        ::Kernel.send(:alias_method, :irb_original_require, :require)
+
+        ::Kernel.define_method(:require) do |name|
+          raise LoadError, "cannot load such file -- tracer (test)" if name.match?("tracer")
+          ::Kernel.send(:irb_original_require, name)
+        end
+
+        IRB.conf[:USE_TRACER] = true
+      RUBY
+
+      write_ruby example_ruby_file
+
+      output = run_ruby_file do
+        type "bar(Foo)"
+        type "exit"
+      end
+
+      assert_include(output, "Tracer extension of IRB is enabled but tracer gem wasn't found.")
+    end
+
+    def test_use_tracer_enabled_when_gem_is_available
+      write_rc <<~RUBY
+        IRB.conf[:USE_TRACER] = true
+      RUBY
+
+      write_ruby example_ruby_file
+
+      output = run_ruby_file do
+        type "bar(Foo)"
+        type "exit"
+      end
+
+      assert_include(output, "Object#bar at")
+      assert_include(output, "Foo.foo at")
+      assert_include(output, "Foo.foo #=> 100")
+      assert_include(output, "Object#bar #=> 100")
+
+      # Test that the tracer output does not include IRB's own files
+      assert_not_include(output, "irb/workspace.rb")
+    end
+
+    def test_use_tracer_is_disabled_by_default
+      write_ruby example_ruby_file
+
+      output = run_ruby_file do
+        type "bar(Foo)"
+        type "exit"
+      end
+
+      assert_not_include(output, "#depth:")
+      assert_not_include(output, "Foo.foo")
+    end
+
+  end
+end
diff --git a/test/irb/test_type_completor.rb b/test/irb/test_type_completor.rb
index cf4fc12c9f..5ed8988b34 100644
--- a/test/irb/test_type_completor.rb
+++ b/test/irb/test_type_completor.rb
@@ -9,7 +9,7 @@ rescue LoadError
   return
 end
 
-require 'irb/completion'
+require 'irb'
 require 'tempfile'
 require_relative './helper'
 
@@ -54,6 +54,11 @@ module TestIRB
       assert_equal [], candidates
       assert_doc_namespace('(', ')', nil)
     end
+
+    def test_command_completion
+      assert_include(@completor.completion_candidates('', 'show_s', '', bind: binding), 'show_source')
+      assert_not_include(@completor.completion_candidates(';', 'show_s', '', bind: binding), 'show_source')
+    end
   end
 
   class TypeCompletorIntegrationTest < IntegrationTestCase
diff --git a/test/irb/test_workspace.rb b/test/irb/test_workspace.rb
index ff17b1a22c..199ce95a37 100644
--- a/test/irb/test_workspace.rb
+++ b/test/irb/test_workspace.rb
@@ -1,6 +1,5 @@
 # frozen_string_literal: false
 require 'tempfile'
-require 'rubygems'
 require 'irb'
 require 'irb/workspace'
 require 'irb/color'
@@ -91,7 +90,7 @@ module TestIRB
         irb_path = "#{top_srcdir}/#{dir}/irb"
         File.exist?(irb_path)
       end or omit 'irb command not found'
-      assert_in_out_err(bundle_exec + ['-W0', "-C#{top_srcdir}", '-e', <<~RUBY , '--', '-f', '--'], 'binding.local_variables', /\[:_\]/, [], bug17623)
+      assert_in_out_err(bundle_exec + ['-W0', "-C#{top_srcdir}", '-e', <<~RUBY, '--', '-f', '--'], 'binding.local_variables', /\[:_\]/, [], bug17623)
         version = 'xyz' # typical rubygems loading file
         load('#{irb_path}')
       RUBY
diff --git a/test/irb/yamatanooroti/test_rendering.rb b/test/irb/yamatanooroti/test_rendering.rb
index b18b95bbbd..44e07a3a12 100644
--- a/test/irb/yamatanooroti/test_rendering.rb
+++ b/test/irb/yamatanooroti/test_rendering.rb
@@ -11,6 +11,8 @@ end
 class IRB::RenderingTest < Yamatanooroti::TestCase
   def setup
     @original_term = ENV['TERM']
+    @home_backup = ENV['HOME']
+    @xdg_config_home_backup = ENV['XDG_CONFIG_HOME']
     ENV['TERM'] = "xterm-256color"
     @pwd = Dir.pwd
     suffix = '%010d' % Random.rand(0..65535)
@@ -24,13 +26,16 @@ class IRB::RenderingTest < Yamatanooroti::TestCase
     @irbrc_backup = ENV['IRBRC']
     @irbrc_file = ENV['IRBRC'] = File.join(@tmpdir, 'temporaty_irbrc')
     File.unlink(@irbrc_file) if File.exist?(@irbrc_file)
+    ENV['HOME'] = File.join(@tmpdir, 'home')
+    ENV['XDG_CONFIG_HOME'] = File.join(@tmpdir, 'xdg_config_home')
   end
 
   def teardown
     FileUtils.rm_rf(@tmpdir)
     ENV['IRBRC'] = @irbrc_backup
     ENV['TERM'] = @original_term
-    ENV.delete('RELINE_TEST_PROMPT') if ENV['RELINE_TEST_PROMPT']
+    ENV['HOME'] = @home_backup
+    ENV['XDG_CONFIG_HOME'] = @xdg_config_home_backup
   end
 
   def test_launch
@@ -50,6 +55,42 @@ class IRB::RenderingTest < Yamatanooroti::TestCase
     EOC
   end
 
+  def test_configuration_file_is_skipped_with_dash_f
+    write_irbrc <<~'LINES'
+      puts '.irbrc file should be ignored when -f is used'
+    LINES
+    start_terminal(25, 80, %W{ruby -I#{@pwd}/lib #{@pwd}/exe/irb -f}, startup_message: '')
+    write(<<~EOC)
+      'Hello, World!'
+    EOC
+    close
+    assert_screen(<<~EOC)
+      irb(main):001> 'Hello, World!'
+      => "Hello, World!"
+      irb(main):002>
+    EOC
+  end
+
+  def test_configuration_file_is_skipped_with_dash_f_for_nested_sessions
+    write_irbrc <<~'LINES'
+      puts '.irbrc file should be ignored when -f is used'
+    LINES
+    start_terminal(25, 80, %W{ruby -I#{@pwd}/lib #{@pwd}/exe/irb -f}, startup_message: '')
+    write(<<~EOC)
+      'Hello, World!'
+      binding.irb
+      exit!
+    EOC
+    close
+    assert_screen(<<~EOC)
+      irb(main):001> 'Hello, World!'
+      => "Hello, World!"
+      irb(main):002> binding.irb
+      irb(main):003> exit!
+      irb(main):001>
+    EOC
+  end
+
   def test_nomultiline
     write_irbrc <<~'LINES'
       puts 'start IRB'
@@ -96,6 +137,7 @@ class IRB::RenderingTest < Yamatanooroti::TestCase
       a
        .a
        .b
+      .itself
     EOC
     close
     assert_screen(<<~EOC)
@@ -112,9 +154,10 @@ class IRB::RenderingTest < Yamatanooroti::TestCase
       irb(main):008>
       irb(main):009> a
       irb(main):010>  .a
-      irb(main):011> .b
+      irb(main):011>  .b
+      irb(main):012> .itself
       => true
-      irb(main):012>
+      irb(main):013>
     EOC
   end
 
@@ -140,7 +183,6 @@ class IRB::RenderingTest < Yamatanooroti::TestCase
       (a)
         &.b()
 
-
       class A def b; self; end; def c; true; end; end;
       a = A.new
       a
@@ -149,6 +191,7 @@ class IRB::RenderingTest < Yamatanooroti::TestCase
         .c
       (a)
         &.b()
+      .itself
     EOC
     close
     assert_screen(<<~EOC)
@@ -173,17 +216,17 @@ class IRB::RenderingTest < Yamatanooroti::TestCase
       irb(main):015>   &.b()
       => #<A>
       irb(main):016>
-      irb(main):017>
-      irb(main):018> class A def b; self; end; def c; true; end; end;
-      irb(main):019> a = A.new
+      irb(main):017> class A def b; self; end; def c; true; end; end;
+      irb(main):018> a = A.new
       => #<A>
-      irb(main):020> a
-      irb(main):021>   .b
-      irb(main):022>   # aaa
-      irb(main):023>   .c
+      irb(main):019> a
+      irb(main):020>   .b
+      irb(main):021>   # aaa
+      irb(main):022>   .c
       => true
-      irb(main):024> (a)
-      irb(main):025> &.b()
+      irb(main):023> (a)
+      irb(main):024>   &.b()
+      irb(main):025> .itself
       => #<A>
       irb(main):026>
     EOC
@@ -213,9 +256,9 @@ class IRB::RenderingTest < Yamatanooroti::TestCase
     start_terminal(3, 50, %W{ruby -I#{@pwd}/lib #{@pwd}/exe/irb}, startup_message: 'start IRB')
     write("{}.__id_")
     write("\C-i")
+    sleep 0.2
     close
     screen = result.join("\n").sub(/\n*\z/, "\n")
-    # This assertion passes whether showdoc dialog completed or not.
     assert_match(/start\ IRB\nirb\(main\):001> {}\.__id__\n                }\.__id__(?:Press )?/, screen)
   end
 
@@ -233,7 +276,9 @@ class IRB::RenderingTest < Yamatanooroti::TestCase
       puts 'start IRB'
     LINES
     start_terminal(4, 19, %W{ruby -I#{@pwd}/lib #{@pwd}/exe/irb}, startup_message: 'start IRB')
-    write("IR\C-i")
+    write("IR")
+    write("\C-i")
+    sleep 0.2
     close
 
     # This is because on macOS we display different shortcut for displaying the full doc
@@ -269,7 +314,9 @@ class IRB::RenderingTest < Yamatanooroti::TestCase
       puts 'start IRB'
     LINES
     start_terminal(4, 12, %W{ruby -I#{@pwd}/lib #{@pwd}/exe/irb}, startup_message: 'start IRB')
-    write("IR\C-i")
+    write("IR")
+    write("\C-i")
+    sleep 0.2
     close
     assert_screen(<<~EOC)
       start IRB
@@ -319,7 +366,7 @@ class IRB::RenderingTest < Yamatanooroti::TestCase
       puts 'start IRB'
     LINES
     start_terminal(40, 80, %W{ruby -I#{@pwd}/lib #{@pwd}/exe/irb}, startup_message: 'start IRB')
-    write("show_cmds\n")
+    write("help\n")
     write("G") # move to the end of the screen
     write("\C-c") # quit pager
     write("'foo' + 'bar'\n") # eval something to make sure IRB resumes
diff --git a/test/reline/helper.rb b/test/reline/helper.rb
index fb2262e7f5..26fe834482 100644
--- a/test/reline/helper.rb
+++ b/test/reline/helper.rb
@@ -29,12 +29,19 @@ module Reline
       else
         encoding = Encoding::UTF_8
       end
+      @original_get_screen_size = IOGate.method(:get_screen_size)
+      IOGate.singleton_class.remove_method(:get_screen_size)
+      def IOGate.get_screen_size
+        [24, 80]
+      end
       Reline::GeneralIO.reset(encoding: encoding) unless ansi
       core.config.instance_variable_set(:@test_mode, true)
       core.config.reset
     end
 
     def test_reset
+      IOGate.singleton_class.remove_method(:get_screen_size)
+      IOGate.define_singleton_method(:get_screen_size, @original_get_screen_size)
       remove_const('IOGate')
       const_set('IOGate', @original_iogate)
       Reline::GeneralIO.reset
@@ -71,14 +78,6 @@ module Reline
   end
 end
 
-def start_pasting
-  Reline::GeneralIO.start_pasting
-end
-
-def finish_pasting
-  Reline::GeneralIO.finish_pasting
-end
-
 class Reline::TestCase < Test::Unit::TestCase
   private def convert_str(input, options = {}, normalized = nil)
     return nil if input.nil?
@@ -129,9 +128,14 @@ class Reline::TestCase < Test::Unit::TestCase
     end
   end
 
-  def assert_line(expected)
-    expected = convert_str(expected)
-    assert_equal(expected, @line_editor.line)
+  def assert_line_around_cursor(before, after)
+    before = convert_str(before)
+    after = convert_str(after)
+    line = @line_editor.current_line
+    byte_pointer = @line_editor.instance_variable_get(:@byte_pointer)
+    actual_before = line.byteslice(0, byte_pointer)
+    actual_after = line.byteslice(byte_pointer..)
+    assert_equal([before, after], [actual_before, actual_after])
   end
 
   def assert_byte_pointer_size(expected)
@@ -146,14 +150,6 @@ class Reline::TestCase < Test::Unit::TestCase
       EOM
   end
 
-  def assert_cursor(expected)
-    assert_equal(expected, @line_editor.instance_variable_get(:@cursor))
-  end
-
-  def assert_cursor_max(expected)
-    assert_equal(expected, @line_editor.instance_variable_get(:@cursor_max))
-  end
-
   def assert_line_index(expected)
     assert_equal(expected, @line_editor.instance_variable_get(:@line_index))
   end
diff --git a/test/reline/test_ansi_with_terminfo.rb b/test/reline/test_ansi_with_terminfo.rb
index 1387460659..e1c56b9ee1 100644
--- a/test/reline/test_ansi_with_terminfo.rb
+++ b/test/reline/test_ansi_with_terminfo.rb
@@ -109,4 +109,4 @@ class Reline::ANSI::TestWithTerminfo < Reline::TestCase
     assert_key_binding("\e ", :em_set_mark, [:emacs])
     assert_key_binding("\C-x\C-x", :em_exchange_mark, [:emacs])
   end
-end if Reline::Terminfo.enabled?
+end if Reline::Terminfo.enabled? && Reline::Terminfo.term_supported?
diff --git a/test/reline/test_config.rb b/test/reline/test_config.rb
index 9ead047ce4..6068292847 100644
--- a/test/reline/test_config.rb
+++ b/test/reline/test_config.rb
@@ -216,6 +216,38 @@ class Reline::Config::Test < Reline::TestCase
     end
   end
 
+  def test_nested_if_else
+    @config.read_lines(<<~LINES.lines)
+      $if Ruby
+        "\x1": "O"
+        $if NotRuby
+          "\x2": "X"
+        $else
+          "\x3": "O"
+          $if Ruby
+            "\x4": "O"
+          $else
+            "\x5": "X"
+          $endif
+          "\x6": "O"
+        $endif
+        "\x7": "O"
+      $else
+        "\x8": "X"
+        $if NotRuby
+          "\x9": "X"
+        $else
+          "\xA": "X"
+        $endif
+        "\xB": "X"
+      $endif
+      "\xC": "O"
+    LINES
+    keys = [0x1, 0x3, 0x4, 0x6, 0x7, 0xC]
+    key_bindings = keys.to_h { |k| [[k.ord], ['O'.ord]] }
+    assert_equal(key_bindings, @config.instance_variable_get(:@additional_key_bindings)[:emacs])
+  end
+
   def test_unclosed_if
     e = assert_raise(Reline::Config::InvalidInputrc) do
       @config.read_lines(<<~LINES.lines, "INPUTRC")
@@ -243,6 +275,78 @@ class Reline::Config::Test < Reline::TestCase
     assert_equal "INPUTRC:1: unmatched endif", e.message
   end
 
+  def test_if_with_mode
+    @config.read_lines(<<~LINES.lines)
+      $if mode=emacs
+        "\C-e": history-search-backward # comment
+      $else
+        "\C-f": history-search-forward
+      $endif
+    LINES
+
+    assert_equal({[5] => :history_search_backward}, @config.instance_variable_get(:@additional_key_bindings)[:emacs])
+    assert_equal({}, @config.instance_variable_get(:@additional_key_bindings)[:vi_insert])
+    assert_equal({}, @config.instance_variable_get(:@additional_key_bindings)[:vi_command])
+  end
+
+  def test_else
+    @config.read_lines(<<~LINES.lines)
+      $if mode=vi
+        "\C-e": history-search-backward # comment
+      $else
+        "\C-f": history-search-forward
+      $endif
+    LINES
+
+    assert_equal({[6] => :history_search_forward}, @config.instance_variable_get(:@additional_key_bindings)[:emacs])
+    assert_equal({}, @config.instance_variable_get(:@additional_key_bindings)[:vi_insert])
+    assert_equal({}, @config.instance_variable_get(:@additional_key_bindings)[:vi_command])
+  end
+
+  def test_if_with_invalid_mode
+    @config.read_lines(<<~LINES.lines)
+      $if mode=vim
+        "\C-e": history-search-backward
+      $else
+        "\C-f": history-search-forward # comment
+      $endif
+    LINES
+
+    assert_equal({[6] => :history_search_forward}, @config.instance_variable_get(:@additional_key_bindings)[:emacs])
+    assert_equal({}, @config.instance_variable_get(:@additional_key_bindings)[:vi_insert])
+    assert_equal({}, @config.instance_variable_get(:@additional_key_bindings)[:vi_command])
+  end
+
+  def test_mode_label_differs_from_keymap_label
+    @config.read_lines(<<~LINES.lines)
+      # Sets mode_label and keymap_label to vi
+      set editing-mode vi
+      # Change keymap_label to emacs. mode_label is still vi.
+      set keymap emacs
+      # condition=true because current mode_label is vi
+      $if mode=vi
+        # sets keybinding to current keymap_label=emacs
+        "\C-e": history-search-backward
+      $endif
+    LINES
+    assert_equal({[5] => :history_search_backward}, @config.instance_variable_get(:@additional_key_bindings)[:emacs])
+    assert_equal({}, @config.instance_variable_get(:@additional_key_bindings)[:vi_insert])
+    assert_equal({}, @config.instance_variable_get(:@additional_key_bindings)[:vi_command])
+  end
+
+  def test_if_without_else_condition
+    @config.read_lines(<<~LINES.lines)
+      set editing-mode vi
+      $if mode=vi
+        "\C-e": history-search-backward
+      $endif
+    LINES
+
+    assert_equal({}, @config.instance_variable_get(:@additional_key_bindings)[:emacs])
+    assert_equal({[5] => :history_search_backward}, @config.instance_variable_get(:@additional_key_bindings)[:vi_insert])
+    assert_equal({}, @config.instance_variable_get(:@additional_key_bindings)[:vi_command])
+  end
+
   def test_default_key_bindings
     @config.add_default_key_binding('abcd'.bytes, 'EFGH'.bytes)
     @config.read_lines(<<~'LINES'.lines)
@@ -313,6 +417,18 @@ class Reline::Config::Test < Reline::TestCase
     assert_equal expected, @config.key_bindings
   end
 
+  def test_key_bindings_with_reset
+    # @config.reset is called after each readline.
+    # inputrc file is read once, so key binding shouldn't be cleared by @config.reset
+    @config.add_default_key_binding('default'.bytes, 'DEFAULT'.bytes)
+    @config.read_lines(<<~'LINES'.lines)
+      "additional": "ADDITIONAL"
+    LINES
+    @config.reset
+    expected = { 'default'.bytes => 'DEFAULT'.bytes, 'additional'.bytes => 'ADDITIONAL'.bytes }
+    assert_equal expected, @config.key_bindings
+  end
+
   def test_history_size
     @config.read_lines(<<~LINES.lines)
       set history-size 5000
diff --git a/test/reline/test_key_actor_emacs.rb b/test/reline/test_key_actor_emacs.rb
index 4575e51eb2..013ca2f7b3 100644
--- a/test/reline/test_key_actor_emacs.rb
+++ b/test/reline/test_key_actor_emacs.rb
@@ -19,1259 +19,699 @@ class Reline::KeyActor::Emacs::Test < Reline::TestCase
 
   def test_ed_insert_one
     input_keys('a')
-    assert_line('a')
-    assert_byte_pointer_size('a')
-    assert_cursor(1)
-    assert_cursor_max(1)
+    assert_line_around_cursor('a', '')
   end
 
   def test_ed_insert_two
     input_keys('ab')
-    assert_line('ab')
-    assert_byte_pointer_size('ab')
-    assert_cursor(2)
-    assert_cursor_max(2)
+    assert_line_around_cursor('ab', '')
   end
 
   def test_ed_insert_mbchar_one
     input_keys('か')
-    assert_line('か')
-    assert_byte_pointer_size('か')
-    assert_cursor(2)
-    assert_cursor_max(2)
+    assert_line_around_cursor('か', '')
   end
 
   def test_ed_insert_mbchar_two
     input_keys('かき')
-    assert_line('かき')
-    assert_byte_pointer_size('かき')
-    assert_cursor(4)
-    assert_cursor_max(4)
+    assert_line_around_cursor('かき', '')
   end
 
   def test_ed_insert_for_mbchar_by_plural_code_points
     input_keys("か\u3099")
-    assert_line("か\u3099")
-    assert_byte_pointer_size("か\u3099")
-    assert_cursor(2)
-    assert_cursor_max(2)
+    assert_line_around_cursor("か\u3099", '')
   end
 
   def test_ed_insert_for_plural_mbchar_by_plural_code_points
     input_keys("か\u3099き\u3099")
-    assert_line("か\u3099き\u3099")
-    assert_byte_pointer_size("か\u3099き\u3099")
-    assert_cursor(4)
-    assert_cursor_max(4)
+    assert_line_around_cursor("か\u3099き\u3099", '')
   end
 
   def test_move_next_and_prev
     input_keys('abd')
-    assert_byte_pointer_size('abd')
-    assert_cursor(3)
-    assert_cursor_max(3)
+    assert_line_around_cursor('abd', '')
     input_keys("\C-b", false)
-    assert_byte_pointer_size('ab')
-    assert_cursor(2)
-    assert_cursor_max(3)
+    assert_line_around_cursor('ab', 'd')
     input_keys("\C-b", false)
-    assert_byte_pointer_size('a')
-    assert_cursor(1)
-    assert_cursor_max(3)
+    assert_line_around_cursor('a', 'bd')
     input_keys("\C-f", false)
-    assert_byte_pointer_size('ab')
-    assert_cursor(2)
-    assert_cursor_max(3)
+    assert_line_around_cursor('ab', 'd')
     input_keys('c')
-    assert_byte_pointer_size('abc')
-    assert_cursor(3)
-    assert_cursor_max(4)
-    assert_line('abcd')
+    assert_line_around_cursor('abc', 'd')
   end
 
   def test_move_next_and_prev_for_mbchar
     input_keys('かきけ')
-    assert_byte_pointer_size('かきけ')
-    assert_cursor(6)
-    assert_cursor_max(6)
+    assert_line_around_cursor('かきけ', '')
     input_keys("\C-b", false)
-    assert_byte_pointer_size('かき')
-    assert_cursor(4)
-    assert_cursor_max(6)
+    assert_line_around_cursor('かき', 'け')
     input_keys("\C-b", false)
-    assert_byte_pointer_size('か')
-    assert_cursor(2)
-    assert_cursor_max(6)
+    assert_line_around_cursor('か', 'きけ')
     input_keys("\C-f", false)
-    assert_byte_pointer_size('かき')
-    assert_cursor(4)
-    assert_cursor_max(6)
+    assert_line_around_cursor('かき', 'け')
     input_keys('く')
-    assert_byte_pointer_size('かきく')
-    assert_cursor(6)
-    assert_cursor_max(8)
-    assert_line('かきくけ')
+    assert_line_around_cursor('かきく', 'け')
   end
 
   def test_move_next_and_prev_for_mbchar_by_plural_code_points
     input_keys("か\u3099き\u3099け\u3099")
-    assert_byte_pointer_size("か\u3099き\u3099け\u3099")
-    assert_cursor(6)
-    assert_cursor_max(6)
+    assert_line_around_cursor("か\u3099き\u3099け\u3099", '')
     input_keys("\C-b", false)
-    assert_byte_pointer_size("か\u3099き\u3099")
-    assert_cursor(4)
-    assert_cursor_max(6)
+    assert_line_around_cursor("か\u3099き\u3099", "け\u3099")
     input_keys("\C-b", false)
-    assert_byte_pointer_size("か\u3099")
-    assert_cursor(2)
-    assert_cursor_max(6)
+    assert_line_around_cursor("か\u3099", "き\u3099け\u3099")
     input_keys("\C-f", false)
-    assert_byte_pointer_size("か\u3099き\u3099")
-    assert_cursor(4)
-    assert_cursor_max(6)
+    assert_line_around_cursor("か\u3099き\u3099", "け\u3099")
     input_keys("く\u3099")
-    assert_byte_pointer_size("か\u3099き\u3099く\u3099")
-    assert_cursor(6)
-    assert_cursor_max(8)
-    assert_line("か\u3099き\u3099く\u3099け\u3099")
+    assert_line_around_cursor("か\u3099き\u3099く\u3099", "け\u3099")
   end
 
   def test_move_to_beg_end
     input_keys('bcd')
-    assert_byte_pointer_size('bcd')
-    assert_cursor(3)
-    assert_cursor_max(3)
+    assert_line_around_cursor('bcd', '')
     input_keys("\C-a", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(3)
+    assert_line_around_cursor('', 'bcd')
     input_keys('a')
-    assert_byte_pointer_size('a')
-    assert_cursor(1)
-    assert_cursor_max(4)
+    assert_line_around_cursor('a', 'bcd')
     input_keys("\C-e", false)
-    assert_byte_pointer_size('abcd')
-    assert_cursor(4)
-    assert_cursor_max(4)
+    assert_line_around_cursor('abcd', '')
     input_keys('e')
-    assert_byte_pointer_size('abcde')
-    assert_cursor(5)
-    assert_cursor_max(5)
-    assert_line('abcde')
+    assert_line_around_cursor('abcde', '')
   end
 
   def test_ed_newline_with_cr
     input_keys('ab')
-    assert_byte_pointer_size('ab')
-    assert_cursor(2)
-    assert_cursor_max(2)
+    assert_line_around_cursor('ab', '')
     refute(@line_editor.finished?)
     input_keys("\C-m", false)
-    assert_line('ab')
+    assert_line_around_cursor('ab', '')
     assert(@line_editor.finished?)
   end
 
   def test_ed_newline_with_lf
     input_keys('ab')
-    assert_byte_pointer_size('ab')
-    assert_cursor(2)
-    assert_cursor_max(2)
+    assert_line_around_cursor('ab', '')
     refute(@line_editor.finished?)
     input_keys("\C-j", false)
-    assert_line('ab')
+    assert_line_around_cursor('ab', '')
     assert(@line_editor.finished?)
   end
 
   def test_em_delete_prev_char
     input_keys('ab')
-    assert_byte_pointer_size('ab')
-    assert_cursor(2)
-    assert_cursor_max(2)
+    assert_line_around_cursor('ab', '')
     input_keys("\C-h", false)
-    assert_byte_pointer_size('a')
-    assert_cursor(1)
-    assert_cursor_max(1)
-    assert_line('a')
+    assert_line_around_cursor('a', '')
   end
 
   def test_em_delete_prev_char_for_mbchar
     input_keys('かき')
-    assert_byte_pointer_size('かき')
-    assert_cursor(4)
-    assert_cursor_max(4)
+    assert_line_around_cursor('かき', '')
     input_keys("\C-h", false)
-    assert_byte_pointer_size('か')
-    assert_cursor(2)
-    assert_cursor_max(2)
-    assert_line('か')
+    assert_line_around_cursor('か', '')
   end
 
   def test_em_delete_prev_char_for_mbchar_by_plural_code_points
     input_keys("か\u3099き\u3099")
-    assert_byte_pointer_size("か\u3099き\u3099")
-    assert_cursor(4)
-    assert_cursor_max(4)
+    assert_line_around_cursor("か\u3099き\u3099", '')
     input_keys("\C-h", false)
-    assert_byte_pointer_size("か\u3099")
-    assert_cursor(2)
-    assert_cursor_max(2)
-    assert_line("か\u3099")
+    assert_line_around_cursor("か\u3099", '')
   end
 
   def test_ed_quoted_insert
     input_keys("ab\C-v\C-acd")
-    assert_line("ab\C-acd")
-    assert_byte_pointer_size("ab\C-acd")
-    assert_cursor(6)
-    assert_cursor_max(6)
+    assert_line_around_cursor("ab\C-acd", '')
     input_keys("\C-q\C-b")
-    assert_line("ab\C-acd\C-b")
-    assert_byte_pointer_size("ab\C-acd\C-b")
-    assert_cursor(8)
-    assert_cursor_max(8)
+    assert_line_around_cursor("ab\C-acd\C-b", '')
   end
 
   def test_ed_kill_line
     input_keys("\C-k", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
-    assert_line('')
+    assert_line_around_cursor('', '')
     input_keys('abc')
-    assert_byte_pointer_size('abc')
-    assert_cursor(3)
-    assert_cursor_max(3)
+    assert_line_around_cursor('abc', '')
     input_keys("\C-k", false)
-    assert_byte_pointer_size('abc')
-    assert_cursor(3)
-    assert_cursor_max(3)
-    assert_line('abc')
+    assert_line_around_cursor('abc', '')
     input_keys("\C-b\C-k", false)
-    assert_byte_pointer_size('ab')
-    assert_cursor(2)
-    assert_cursor_max(2)
-    assert_line('ab')
+    assert_line_around_cursor('ab', '')
   end
 
   def test_em_kill_line
     @line_editor.input_key(Reline::Key.new(:em_kill_line, :em_kill_line, false))
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
-    assert_line('')
+    assert_line_around_cursor('', '')
     input_keys('abc')
     @line_editor.input_key(Reline::Key.new(:em_kill_line, :em_kill_line, false))
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
-    assert_line('')
+    assert_line_around_cursor('', '')
     input_keys('abc')
     input_keys("\C-b", false)
     @line_editor.input_key(Reline::Key.new(:em_kill_line, :em_kill_line, false))
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
-    assert_line('')
+    assert_line_around_cursor('', '')
     input_keys('abc')
     input_keys("\C-a", false)
     @line_editor.input_key(Reline::Key.new(:em_kill_line, :em_kill_line, false))
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
-    assert_line('')
+    assert_line_around_cursor('', '')
   end
 
   def test_ed_move_to_beg
     input_keys('abd')
-    assert_byte_pointer_size('abd')
-    assert_cursor(3)
-    assert_cursor_max(3)
+    assert_line_around_cursor('abd', '')
     input_keys("\C-b", false)
-    assert_byte_pointer_size('ab')
-    assert_cursor(2)
-    assert_cursor_max(3)
+    assert_line_around_cursor('ab', 'd')
     input_keys('c')
-    assert_byte_pointer_size('abc')
-    assert_cursor(3)
-    assert_cursor_max(4)
+    assert_line_around_cursor('abc', 'd')
     input_keys("\C-a", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(4)
+    assert_line_around_cursor('', 'abcd')
     input_keys('012')
-    assert_byte_pointer_size('012')
-    assert_cursor(3)
-    assert_cursor_max(7)
-    assert_line('012abcd')
+    assert_line_around_cursor('012', 'abcd')
     input_keys("\C-a", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(7)
+    assert_line_around_cursor('', '012abcd')
     input_keys('ABC')
-    assert_byte_pointer_size('ABC')
-    assert_cursor(3)
-    assert_cursor_max(10)
-    assert_line('ABC012abcd')
+    assert_line_around_cursor('ABC', '012abcd')
     input_keys("\C-f" * 10 + "\C-a", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(10)
+    assert_line_around_cursor('', 'ABC012abcd')
     input_keys('a')
-    assert_byte_pointer_size('a')
-    assert_cursor(1)
-    assert_cursor_max(11)
-    assert_line('aABC012abcd')
+    assert_line_around_cursor('a', 'ABC012abcd')
   end
 
   def test_ed_move_to_beg_with_blank
     input_keys('  abc')
-    assert_byte_pointer_size('  abc')
-    assert_cursor(5)
-    assert_cursor_max(5)
+    assert_line_around_cursor('  abc', '')
     input_keys("\C-a", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(5)
+    assert_line_around_cursor('', '  abc')
   end
 
   def test_ed_move_to_end
     input_keys('abd')
-    assert_byte_pointer_size('abd')
-    assert_cursor(3)
-    assert_cursor_max(3)
+    assert_line_around_cursor('abd', '')
     input_keys("\C-b", false)
-    assert_byte_pointer_size('ab')
-    assert_cursor(2)
-    assert_cursor_max(3)
+    assert_line_around_cursor('ab', 'd')
     input_keys('c')
-    assert_byte_pointer_size('abc')
-    assert_cursor(3)
-    assert_cursor_max(4)
+    assert_line_around_cursor('abc', 'd')
     input_keys("\C-e", false)
-    assert_byte_pointer_size('abcd')
-    assert_cursor(4)
-    assert_cursor_max(4)
+    assert_line_around_cursor('abcd', '')
     input_keys('012')
-    assert_byte_pointer_size('abcd012')
-    assert_cursor(7)
-    assert_cursor_max(7)
-    assert_line('abcd012')
+    assert_line_around_cursor('abcd012', '')
     input_keys("\C-e", false)
-    assert_byte_pointer_size('abcd012')
-    assert_cursor(7)
-    assert_cursor_max(7)
+    assert_line_around_cursor('abcd012', '')
     input_keys('ABC')
-    assert_byte_pointer_size('abcd012ABC')
-    assert_cursor(10)
-    assert_cursor_max(10)
-    assert_line('abcd012ABC')
+    assert_line_around_cursor('abcd012ABC', '')
     input_keys("\C-b" * 10 + "\C-e", false)
-    assert_byte_pointer_size('abcd012ABC')
-    assert_cursor(10)
-    assert_cursor_max(10)
+    assert_line_around_cursor('abcd012ABC', '')
     input_keys('a')
-    assert_byte_pointer_size('abcd012ABCa')
-    assert_cursor(11)
-    assert_cursor_max(11)
-    assert_line('abcd012ABCa')
+    assert_line_around_cursor('abcd012ABCa', '')
   end
 
   def test_em_delete
     input_keys('ab')
-    assert_byte_pointer_size('ab')
-    assert_cursor(2)
-    assert_cursor_max(2)
+    assert_line_around_cursor('ab', '')
     input_keys("\C-a", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(2)
+    assert_line_around_cursor('', 'ab')
     input_keys("\C-d", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(1)
-    assert_line('b')
+    assert_line_around_cursor('', 'b')
   end
 
   def test_em_delete_for_mbchar
     input_keys('かき')
-    assert_byte_pointer_size('かき')
-    assert_cursor(4)
-    assert_cursor_max(4)
+    assert_line_around_cursor('かき', '')
     input_keys("\C-a", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(4)
+    assert_line_around_cursor('', 'かき')
     input_keys("\C-d", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(2)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(2)
-    assert_line('き')
+    assert_line_around_cursor('', 'き')
   end
 
   def test_em_delete_for_mbchar_by_plural_code_points
     input_keys("か\u3099き\u3099")
-    assert_byte_pointer_size("か\u3099き\u3099")
-    assert_cursor(4)
-    assert_cursor_max(4)
+    assert_line_around_cursor("か\u3099き\u3099", '')
     input_keys("\C-a", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(4)
+    assert_line_around_cursor('', "か\u3099き\u3099")
     input_keys("\C-d", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(2)
-    assert_line("き\u3099")
+    assert_line_around_cursor('', "き\u3099")
   end
 
   def test_em_delete_ends_editing
     input_keys("\C-d") # quit from inputing
-    assert_line(nil)
+    assert_nil(@line_editor.line)
     assert(@line_editor.finished?)
   end
 
   def test_ed_clear_screen
-    refute(@line_editor.instance_variable_get(:@cleared))
+    @line_editor.instance_variable_get(:@rendered_screen).lines = [[]]
     input_keys("\C-l", false)
-    assert(@line_editor.instance_variable_get(:@cleared))
+    assert_empty(@line_editor.instance_variable_get(:@rendered_screen).lines)
   end
 
   def test_ed_clear_screen_with_inputed
     input_keys('abc')
     input_keys("\C-b", false)
-    refute(@line_editor.instance_variable_get(:@cleared))
-    assert_byte_pointer_size('ab')
-    assert_cursor(2)
-    assert_cursor_max(3)
+    @line_editor.instance_variable_get(:@rendered_screen).lines = [[]]
+    assert_line_around_cursor('ab', 'c')
     input_keys("\C-l", false)
-    assert(@line_editor.instance_variable_get(:@cleared))
-    assert_byte_pointer_size('ab')
-    assert_cursor(2)
-    assert_cursor_max(3)
-    assert_line('abc')
+    assert_empty(@line_editor.instance_variable_get(:@rendered_screen).lines)
+    assert_line_around_cursor('ab', 'c')
   end
 
   def test_key_delete
     input_keys('abc')
-    assert_cursor(3)
-    assert_cursor_max(3)
+    assert_line_around_cursor('abc', '')
     @line_editor.input_key(Reline::Key.new(:key_delete, :key_delete, false))
-    assert_cursor(3)
-    assert_cursor_max(3)
-    assert_line('abc')
+    assert_line_around_cursor('abc', '')
   end
 
   def test_key_delete_does_not_end_editing
     @line_editor.input_key(Reline::Key.new(:key_delete, :key_delete, false))
-    assert_cursor(0)
-    assert_cursor_max(0)
-    assert_line('')
+    assert_line_around_cursor('', '')
     refute(@line_editor.finished?)
   end
 
   def test_key_delete_preserves_cursor
     input_keys('abc')
     input_keys("\C-b", false)
-    assert_cursor(2)
-    assert_cursor_max(3)
+    assert_line_around_cursor('ab', 'c')
     @line_editor.input_key(Reline::Key.new(:key_delete, :key_delete, false))
-    assert_cursor(2)
-    assert_cursor_max(2)
-    assert_line('ab')
+    assert_line_around_cursor('ab', '')
   end
 
   def test_em_next_word
-    assert_byte_pointer_size('')
-    assert_cursor(0)
+    assert_line_around_cursor('', '')
     input_keys('abc def{bbb}ccc')
     input_keys("\C-a\M-F", false)
-    assert_byte_pointer_size('abc')
-    assert_cursor(3)
+    assert_line_around_cursor('abc', ' def{bbb}ccc')
     input_keys("\M-F", false)
-    assert_byte_pointer_size('abc def')
-    assert_cursor(7)
+    assert_line_around_cursor('abc def', '{bbb}ccc')
     input_keys("\M-F", false)
-    assert_byte_pointer_size('abc def{bbb')
-    assert_cursor(11)
+    assert_line_around_cursor('abc def{bbb', '}ccc')
     input_keys("\M-F", false)
-    assert_byte_pointer_size('abc def{bbb}ccc')
-    assert_cursor(15)
+    assert_line_around_cursor('abc def{bbb}ccc', '')
     input_keys("\M-F", false)
-    assert_byte_pointer_size('abc def{bbb}ccc')
-    assert_cursor(15)
+    assert_line_around_cursor('abc def{bbb}ccc', '')
   end
 
   def test_em_next_word_for_mbchar
-    assert_cursor(0)
+    assert_line_around_cursor('', '')
     input_keys('あいう かきく{さしす}たちつ')
     input_keys("\C-a\M-F", false)
-    assert_byte_pointer_size('あいう')
-    assert_cursor(6)
+    assert_line_around_cursor('あいう', ' かきく{さしす}たちつ')
     input_keys("\M-F", false)
-    assert_byte_pointer_size('あいう かきく')
-    assert_cursor(13)
+    assert_line_around_cursor('あいう かきく', '{さしす}たちつ')
     input_keys("\M-F", false)
-    assert_byte_pointer_size('あいう かきく{さしす')
-    assert_cursor(20)
+    assert_line_around_cursor('あいう かきく{さしす', '}たちつ')
     input_keys("\M-F", false)
-    assert_byte_pointer_size('あいう かきく{さしす}たちつ')
-    assert_cursor(27)
+    assert_line_around_cursor('あいう かきく{さしす}たちつ', '')
     input_keys("\M-F", false)
-    assert_byte_pointer_size('あいう かきく{さしす}たちつ')
-    assert_cursor(27)
+    assert_line_around_cursor('あいう かきく{さしす}たちつ', '')
   end
 
   def test_em_next_word_for_mbchar_by_plural_code_points
-    assert_cursor(0)
+    assert_line_around_cursor("", "")
     input_keys("あいう か\u3099き\u3099く\u3099{さしす}たちつ")
     input_keys("\C-a\M-F", false)
-    assert_byte_pointer_size("あいう")
-    assert_cursor(6)
+    assert_line_around_cursor("あいう", " か\u3099き\u3099く\u3099{さしす}たちつ")
     input_keys("\M-F", false)
-    assert_byte_pointer_size("あいう か\u3099き\u3099く\u3099")
-    assert_cursor(13)
+    assert_line_around_cursor("あいう か\u3099き\u3099く\u3099", "{さしす}たちつ")
     input_keys("\M-F", false)
-    assert_byte_pointer_size("あいう か\u3099き\u3099く\u3099{さしす")
-    assert_cursor(20)
+    assert_line_around_cursor("あいう か\u3099き\u3099く\u3099{さしす", "}たちつ")
     input_keys("\M-F", false)
-    assert_byte_pointer_size("あいう か\u3099き\u3099く\u3099{さしす}たちつ")
-    assert_cursor(27)
+    assert_line_around_cursor("あいう か\u3099き\u3099く\u3099{さしす}たちつ", "")
     input_keys("\M-F", false)
-    assert_byte_pointer_size("あいう か\u3099き\u3099く\u3099{さしす}たちつ")
-    assert_cursor(27)
+    assert_line_around_cursor("あいう か\u3099き\u3099く\u3099{さしす}たちつ", "")
   end
 
   def test_em_prev_word
     input_keys('abc def{bbb}ccc')
-    assert_byte_pointer_size('abc def{bbb}ccc')
-    assert_cursor(15)
+    assert_line_around_cursor('abc def{bbb}ccc', '')
     input_keys("\M-B", false)
-    assert_byte_pointer_size('abc def{bbb}')
-    assert_cursor(12)
+    assert_line_around_cursor('abc def{bbb}', 'ccc')
     input_keys("\M-B", false)
-    assert_byte_pointer_size('abc def{')
-    assert_cursor(8)
+    assert_line_around_cursor('abc def{', 'bbb}ccc')
     input_keys("\M-B", false)
-    assert_byte_pointer_size('abc ')
-    assert_cursor(4)
+    assert_line_around_cursor('abc ', 'def{bbb}ccc')
     input_keys("\M-B", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
+    assert_line_around_cursor('', 'abc def{bbb}ccc')
     input_keys("\M-B", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
+    assert_line_around_cursor('', 'abc def{bbb}ccc')
   end
 
   def test_em_prev_word_for_mbchar
     input_keys('あいう かきく{さしす}たちつ')
-    assert_byte_pointer_size('あいう かきく{さしす}たちつ')
-    assert_cursor(27)
+    assert_line_around_cursor('あいう かきく{さしす}たちつ', '')
     input_keys("\M-B", false)
-    assert_byte_pointer_size('あいう かきく{さしす}')
-    assert_cursor(21)
+    assert_line_around_cursor('あいう かきく{さしす}', 'たちつ')
     input_keys("\M-B", false)
-    assert_byte_pointer_size('あいう かきく{')
-    assert_cursor(14)
+    assert_line_around_cursor('あいう かきく{', 'さしす}たちつ')
     input_keys("\M-B", false)
-    assert_byte_pointer_size('あいう ')
-    assert_cursor(7)
+    assert_line_around_cursor('あいう ', 'かきく{さしす}たちつ')
     input_keys("\M-B", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
+    assert_line_around_cursor('', 'あいう かきく{さしす}たちつ')
     input_keys("\M-B", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
+    assert_line_around_cursor('', 'あいう かきく{さしす}たちつ')
   end
 
   def test_em_prev_word_for_mbchar_by_plural_code_points
     input_keys("あいう か\u3099き\u3099く\u3099{さしす}たちつ")
-    assert_byte_pointer_size("あいう か\u3099き\u3099く\u3099{さしす}たちつ")
-    assert_cursor(27)
+    assert_line_around_cursor("あいう か\u3099き\u3099く\u3099{さしす}たちつ", "")
     input_keys("\M-B", false)
-    assert_byte_pointer_size("あいう か\u3099き\u3099く\u3099{さしす}")
-    assert_cursor(21)
+    assert_line_around_cursor("あいう か\u3099き\u3099く\u3099{さしす}", "たちつ")
     input_keys("\M-B", false)
-    assert_byte_pointer_size("あいう か\u3099き\u3099く\u3099{")
-    assert_cursor(14)
+    assert_line_around_cursor("あいう か\u3099き\u3099く\u3099{", "さしす}たちつ")
     input_keys("\M-B", false)
-    assert_byte_pointer_size('あいう ')
-    assert_cursor(7)
+    assert_line_around_cursor("あいう ", "か\u3099き\u3099く\u3099{さしす}たちつ")
     input_keys("\M-B", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
+    assert_line_around_cursor("", "あいう か\u3099き\u3099く\u3099{さしす}たちつ")
     input_keys("\M-B", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
+    assert_line_around_cursor("", "あいう か\u3099き\u3099く\u3099{さしす}たちつ")
   end
 
   def test_em_delete_next_word
     input_keys('abc def{bbb}ccc')
     input_keys("\C-a", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(15)
+    assert_line_around_cursor('', 'abc def{bbb}ccc')
     input_keys("\M-d", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(12)
-    assert_line(' def{bbb}ccc')
+    assert_line_around_cursor('', ' def{bbb}ccc')
     input_keys("\M-d", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(8)
-    assert_line('{bbb}ccc')
+    assert_line_around_cursor('', '{bbb}ccc')
     input_keys("\M-d", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(4)
-    assert_line('}ccc')
+    assert_line_around_cursor('', '}ccc')
     input_keys("\M-d", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
-    assert_line('')
+    assert_line_around_cursor('', '')
   end
 
   def test_em_delete_next_word_for_mbchar
     input_keys('あいう かきく{さしす}たちつ')
     input_keys("\C-a", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(27)
+    assert_line_around_cursor('', 'あいう かきく{さしす}たちつ')
     input_keys("\M-d", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(21)
-    assert_line(' かきく{さしす}たちつ')
+    assert_line_around_cursor('', ' かきく{さしす}たちつ')
     input_keys("\M-d", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(14)
-    assert_line('{さしす}たちつ')
+    assert_line_around_cursor('', '{さしす}たちつ')
     input_keys("\M-d", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(7)
-    assert_line('}たちつ')
+    assert_line_around_cursor('', '}たちつ')
     input_keys("\M-d", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
-    assert_line('')
+    assert_line_around_cursor('', '')
   end
 
   def test_em_delete_next_word_for_mbchar_by_plural_code_points
     input_keys("あいう か\u3099き\u3099く\u3099{さしす}たちつ")
     input_keys("\C-a", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(27)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(27)
+    assert_line_around_cursor('', "あいう か\u3099き\u3099く\u3099{さしす}たちつ")
     input_keys("\M-d", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(21)
-    assert_line(" か\u3099き\u3099く\u3099{さしす}たちつ")
+    assert_line_around_cursor('', " か\u3099き\u3099く\u3099{さしす}たちつ")
     input_keys("\M-d", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(14)
-    assert_line('{さしす}たちつ')
+    assert_line_around_cursor('', '{さしす}たちつ')
     input_keys("\M-d", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(7)
-    assert_line('}たちつ')
+    assert_line_around_cursor('', '}たちつ')
     input_keys("\M-d", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
-    assert_line('')
+    assert_line_around_cursor('', '')
   end
 
   def test_ed_delete_prev_word
     input_keys('abc def{bbb}ccc')
-    assert_byte_pointer_size('abc def{bbb}ccc')
-    assert_cursor(15)
-    assert_cursor_max(15)
+    assert_line_around_cursor('abc def{bbb}ccc', '')
     input_keys("\M-\C-H", false)
-    assert_byte_pointer_size('abc def{bbb}')
-    assert_cursor(12)
-    assert_cursor_max(12)
-    assert_line('abc def{bbb}')
+    assert_line_around_cursor('abc def{bbb}', '')
     input_keys("\M-\C-H", false)
-    assert_byte_pointer_size('abc def{')
-    assert_cursor(8)
-    assert_cursor_max(8)
-    assert_line('abc def{')
+    assert_line_around_cursor('abc def{', '')
     input_keys("\M-\C-H", false)
-    assert_byte_pointer_size('abc ')
-    assert_cursor(4)
-    assert_cursor_max(4)
-    assert_line('abc ')
+    assert_line_around_cursor('abc ', '')
     input_keys("\M-\C-H", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
-    assert_line('')
+    assert_line_around_cursor('', '')
   end
 
   def test_ed_delete_prev_word_for_mbchar
     input_keys('あいう かきく{さしす}たちつ')
-    assert_byte_pointer_size('あいう かきく{さしす}たちつ')
-    assert_cursor(27)
-    assert_cursor_max(27)
+    assert_line_around_cursor('あいう かきく{さしす}たちつ', '')
     input_keys("\M-\C-H", false)
-    assert_byte_pointer_size('あいう かきく{さしす}')
-    assert_cursor(21)
-    assert_cursor_max(21)
-    assert_line('あいう かきく{さしす}')
+    assert_line_around_cursor('あいう かきく{さしす}', '')
     input_keys("\M-\C-H", false)
-    assert_byte_pointer_size('あいう かきく{')
-    assert_cursor(14)
-    assert_cursor_max(14)
-    assert_line('あいう かきく{')
+    assert_line_around_cursor('あいう かきく{', '')
     input_keys("\M-\C-H", false)
-    assert_byte_pointer_size('あいう ')
-    assert_cursor(7)
-    assert_cursor_max(7)
-    assert_line('あいう ')
+    assert_line_around_cursor('あいう ', '')
     input_keys("\M-\C-H", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
-    assert_line('')
+    assert_line_around_cursor('', '')
   end
 
   def test_ed_delete_prev_word_for_mbchar_by_plural_code_points
     input_keys("あいう か\u3099き\u3099く\u3099{さしす}たちつ")
-    assert_byte_pointer_size("あいう か\u3099き\u3099く\u3099{さしす}たちつ")
-    assert_cursor(27)
-    assert_cursor_max(27)
+    assert_line_around_cursor("あいう か\u3099き\u3099く\u3099{さしす}たちつ", '')
     input_keys("\M-\C-H", false)
-    assert_byte_pointer_size("あいう か\u3099き\u3099く\u3099{さしす}")
-    assert_cursor(21)
-    assert_cursor_max(21)
-    assert_line("あいう か\u3099き\u3099く\u3099{さしす}")
+    assert_line_around_cursor("あいう か\u3099き\u3099く\u3099{さしす}", '')
     input_keys("\M-\C-H", false)
-    assert_byte_pointer_size("あいう か\u3099き\u3099く\u3099{")
-    assert_cursor(14)
-    assert_cursor_max(14)
-    assert_line("あいう か\u3099き\u3099く\u3099{")
+    assert_line_around_cursor("あいう か\u3099き\u3099く\u3099{", '')
     input_keys("\M-\C-H", false)
-    assert_byte_pointer_size("あいう ")
-    assert_cursor(7)
-    assert_cursor_max(7)
-    assert_line('あいう ')
+    assert_line_around_cursor('あいう ', '')
     input_keys("\M-\C-H", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
-    assert_line('')
+    assert_line_around_cursor('', '')
   end
 
   def test_ed_transpose_chars
     input_keys('abc')
     input_keys("\C-a", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(3)
+    assert_line_around_cursor('', 'abc')
     input_keys("\C-t", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(3)
-    assert_line('abc')
+    assert_line_around_cursor('', 'abc')
     input_keys("\C-f\C-t", false)
-    assert_byte_pointer_size('ba')
-    assert_cursor(2)
-    assert_cursor_max(3)
-    assert_line('bac')
+    assert_line_around_cursor('ba', 'c')
     input_keys("\C-t", false)
-    assert_byte_pointer_size('bca')
-    assert_cursor(3)
-    assert_cursor_max(3)
-    assert_line('bca')
+    assert_line_around_cursor('bca', '')
     input_keys("\C-t", false)
-    assert_byte_pointer_size('bac')
-    assert_cursor(3)
-    assert_cursor_max(3)
-    assert_line('bac')
+    assert_line_around_cursor('bac', '')
   end
 
   def test_ed_transpose_chars_for_mbchar
     input_keys('あかさ')
     input_keys("\C-a", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(6)
+    assert_line_around_cursor('', 'あかさ')
     input_keys("\C-t", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(6)
-    assert_line('あかさ')
+    assert_line_around_cursor('', 'あかさ')
     input_keys("\C-f\C-t", false)
-    assert_byte_pointer_size('かあ')
-    assert_cursor(4)
-    assert_cursor_max(6)
-    assert_line('かあさ')
+    assert_line_around_cursor('かあ', 'さ')
     input_keys("\C-t", false)
-    assert_byte_pointer_size('かさあ')
-    assert_cursor(6)
-    assert_cursor_max(6)
-    assert_line('かさあ')
+    assert_line_around_cursor('かさあ', '')
     input_keys("\C-t", false)
-    assert_byte_pointer_size('かあさ')
-    assert_cursor(6)
-    assert_cursor_max(6)
-    assert_line('かあさ')
+    assert_line_around_cursor('かあさ', '')
   end
 
   def test_ed_transpose_chars_for_mbchar_by_plural_code_points
     input_keys("あか\u3099さ")
     input_keys("\C-a", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(6)
+    assert_line_around_cursor('', "あか\u3099さ")
     input_keys("\C-t", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(6)
-    assert_line("あか\u3099さ")
+    assert_line_around_cursor('', "あか\u3099さ")
     input_keys("\C-f\C-t", false)
-    assert_byte_pointer_size("か\u3099あ")
-    assert_cursor(4)
-    assert_cursor_max(6)
-    assert_line("か\u3099あさ")
+    assert_line_around_cursor("か\u3099あ", 'さ')
     input_keys("\C-t", false)
-    assert_byte_pointer_size("か\u3099さあ")
-    assert_cursor(6)
-    assert_cursor_max(6)
-    assert_line("か\u3099さあ")
+    assert_line_around_cursor("か\u3099さあ", '')
     input_keys("\C-t", false)
-    assert_byte_pointer_size("か\u3099あさ")
-    assert_cursor(6)
-    assert_cursor_max(6)
-    assert_line("か\u3099あさ")
+    assert_line_around_cursor("か\u3099あさ", '')
   end
 
   def test_ed_transpose_words
     input_keys('abc def')
-    assert_line('abc def')
-    assert_byte_pointer_size('abc def')
-    assert_cursor(7)
-    assert_cursor_max(7)
+    assert_line_around_cursor('abc def', '')
     input_keys("\M-t", false)
-    assert_line('def abc')
-    assert_byte_pointer_size('def abc')
-    assert_cursor(7)
-    assert_cursor_max(7)
+    assert_line_around_cursor('def abc', '')
     input_keys("\C-a\C-k", false)
     input_keys(' abc  def   ')
     input_keys("\C-b" * 4, false)
-    assert_line(' abc  def   ')
-    assert_byte_pointer_size(' abc  de')
-    assert_cursor(8)
-    assert_cursor_max(12)
+    assert_line_around_cursor(' abc  de', 'f   ')
     input_keys("\M-t", false)
-    assert_line(' def  abc   ')
-    assert_byte_pointer_size(' def  abc')
-    assert_cursor(9)
-    assert_cursor_max(12)
+    assert_line_around_cursor(' def  abc', '   ')
     input_keys("\C-a\C-k", false)
     input_keys(' abc  def   ')
     input_keys("\C-b" * 6, false)
-    assert_line(' abc  def   ')
-    assert_byte_pointer_size(' abc  ')
-    assert_cursor(6)
-    assert_cursor_max(12)
+    assert_line_around_cursor(' abc  ', 'def   ')
     input_keys("\M-t", false)
-    assert_line(' def  abc   ')
-    assert_byte_pointer_size(' def  abc')
-    assert_cursor(9)
-    assert_cursor_max(12)
+    assert_line_around_cursor(' def  abc', '   ')
     input_keys("\M-t", false)
-    assert_line(' abc     def')
-    assert_byte_pointer_size(' abc     def')
-    assert_cursor(12)
-    assert_cursor_max(12)
+    assert_line_around_cursor(' abc     def', '')
   end
 
   def test_ed_transpose_words_for_mbchar
     input_keys('あいう かきく')
-    assert_line('あいう かきく')
-    assert_byte_pointer_size('あいう かきく')
-    assert_cursor(13)
-    assert_cursor_max(13)
+    assert_line_around_cursor('あいう かきく', '')
     input_keys("\M-t", false)
-    assert_line('かきく あいう')
-    assert_byte_pointer_size('かきく あいう')
-    assert_cursor(13)
-    assert_cursor_max(13)
+    assert_line_around_cursor('かきく あいう', '')
     input_keys("\C-a\C-k", false)
     input_keys(' あいう  かきく   ')
     input_keys("\C-b" * 4, false)
-    assert_line(' あいう  かきく   ')
-    assert_byte_pointer_size(' あいう  かき')
-    assert_cursor(13)
-    assert_cursor_max(18)
+    assert_line_around_cursor(' あいう  かき', 'く   ')
     input_keys("\M-t", false)
-    assert_line(' かきく  あいう   ')
-    assert_byte_pointer_size(' かきく  あいう')
-    assert_cursor(15)
-    assert_cursor_max(18)
+    assert_line_around_cursor(' かきく  あいう', '   ')
     input_keys("\C-a\C-k", false)
     input_keys(' あいう  かきく   ')
     input_keys("\C-b" * 6, false)
-    assert_line(' あいう  かきく   ')
-    assert_byte_pointer_size(' あいう  ')
-    assert_cursor(9)
-    assert_cursor_max(18)
+    assert_line_around_cursor(' あいう  ', 'かきく   ')
     input_keys("\M-t", false)
-    assert_line(' かきく  あいう   ')
-    assert_byte_pointer_size(' かきく  あいう')
-    assert_cursor(15)
-    assert_cursor_max(18)
+    assert_line_around_cursor(' かきく  あいう', '   ')
     input_keys("\M-t", false)
-    assert_line(' あいう     かきく')
-    assert_byte_pointer_size(' あいう     かきく')
-    assert_cursor(18)
-    assert_cursor_max(18)
+    assert_line_around_cursor(' あいう     かきく', '')
   end
 
   def test_ed_transpose_words_with_one_word
     input_keys('abc  ')
-    assert_line('abc  ')
-    assert_byte_pointer_size('abc  ')
-    assert_cursor(5)
-    assert_cursor_max(5)
+    assert_line_around_cursor('abc  ', '')
     input_keys("\M-t", false)
-    assert_line('abc  ')
-    assert_byte_pointer_size('abc  ')
-    assert_cursor(5)
-    assert_cursor_max(5)
+    assert_line_around_cursor('abc  ', '')
     input_keys("\C-b", false)
-    assert_line('abc  ')
-    assert_byte_pointer_size('abc ')
-    assert_cursor(4)
-    assert_cursor_max(5)
+    assert_line_around_cursor('abc ', ' ')
     input_keys("\M-t", false)
-    assert_line('abc  ')
-    assert_byte_pointer_size('abc ')
-    assert_cursor(4)
-    assert_cursor_max(5)
+    assert_line_around_cursor('abc ', ' ')
     input_keys("\C-b" * 2, false)
-    assert_line('abc  ')
-    assert_byte_pointer_size('ab')
-    assert_cursor(2)
-    assert_cursor_max(5)
+    assert_line_around_cursor('ab', 'c  ')
     input_keys("\M-t", false)
-    assert_line('abc  ')
-    assert_byte_pointer_size('ab')
-    assert_cursor(2)
-    assert_cursor_max(5)
+    assert_line_around_cursor('ab', 'c  ')
     input_keys("\M-t", false)
-    assert_line('abc  ')
-    assert_byte_pointer_size('ab')
-    assert_cursor(2)
-    assert_cursor_max(5)
+    assert_line_around_cursor('ab', 'c  ')
   end
 
   def test_ed_transpose_words_with_one_word_for_mbchar
     input_keys('あいう  ')
-    assert_line('あいう  ')
-    assert_byte_pointer_size('あいう  ')
-    assert_cursor(8)
-    assert_cursor_max(8)
+    assert_line_around_cursor('あいう  ', '')
     input_keys("\M-t", false)
-    assert_line('あいう  ')
-    assert_byte_pointer_size('あいう  ')
-    assert_cursor(8)
-    assert_cursor_max(8)
+    assert_line_around_cursor('あいう  ', '')
     input_keys("\C-b", false)
-    assert_line('あいう  ')
-    assert_byte_pointer_size('あいう ')
-    assert_cursor(7)
-    assert_cursor_max(8)
+    assert_line_around_cursor('あいう ', ' ')
     input_keys("\M-t", false)
-    assert_line('あいう  ')
-    assert_byte_pointer_size('あいう ')
-    assert_cursor(7)
-    assert_cursor_max(8)
+    assert_line_around_cursor('あいう ', ' ')
     input_keys("\C-b" * 2, false)
-    assert_line('あいう  ')
-    assert_byte_pointer_size('あい')
-    assert_cursor(4)
-    assert_cursor_max(8)
+    assert_line_around_cursor('あい', 'う  ')
     input_keys("\M-t", false)
-    assert_line('あいう  ')
-    assert_byte_pointer_size('あい')
-    assert_cursor(4)
-    assert_cursor_max(8)
+    assert_line_around_cursor('あい', 'う  ')
     input_keys("\M-t", false)
-    assert_line('あいう  ')
-    assert_byte_pointer_size('あい')
-    assert_cursor(4)
-    assert_cursor_max(8)
+    assert_line_around_cursor('あい', 'う  ')
   end
 
   def test_ed_digit
     input_keys('0123')
-    assert_byte_pointer_size('0123')
-    assert_cursor(4)
-    assert_cursor_max(4)
-    assert_line('0123')
+    assert_line_around_cursor('0123', '')
   end
 
   def test_ed_next_and_prev_char
     input_keys('abc')
-    assert_byte_pointer_size('abc')
-    assert_cursor(3)
-    assert_cursor_max(3)
+    assert_line_around_cursor('abc', '')
     input_keys("\C-b", false)
-    assert_byte_pointer_size('ab')
-    assert_cursor(2)
-    assert_cursor_max(3)
+    assert_line_around_cursor('ab', 'c')
     input_keys("\C-b", false)
-    assert_byte_pointer_size('a')
-    assert_cursor(1)
-    assert_cursor_max(3)
+    assert_line_around_cursor('a', 'bc')
     input_keys("\C-b", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(3)
+    assert_line_around_cursor('', 'abc')
     input_keys("\C-b", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(3)
+    assert_line_around_cursor('', 'abc')
     input_keys("\C-f", false)
-    assert_byte_pointer_size('a')
-    assert_cursor(1)
-    assert_cursor_max(3)
+    assert_line_around_cursor('a', 'bc')
     input_keys("\C-f", false)
-    assert_byte_pointer_size('ab')
-    assert_cursor(2)
-    assert_cursor_max(3)
+    assert_line_around_cursor('ab', 'c')
     input_keys("\C-f", false)
-    assert_byte_pointer_size('abc')
-    assert_cursor(3)
-    assert_cursor_max(3)
+    assert_line_around_cursor('abc', '')
     input_keys("\C-f", false)
-    assert_byte_pointer_size('abc')
-    assert_cursor(3)
-    assert_cursor_max(3)
+    assert_line_around_cursor('abc', '')
   end
 
   def test_ed_next_and_prev_char_for_mbchar
     input_keys('あいう')
-    assert_byte_pointer_size('あいう')
-    assert_cursor(6)
-    assert_cursor_max(6)
+    assert_line_around_cursor('あいう', '')
     input_keys("\C-b", false)
-    assert_byte_pointer_size('あい')
-    assert_cursor(4)
-    assert_cursor_max(6)
+    assert_line_around_cursor('あい', 'う')
     input_keys("\C-b", false)
-    assert_byte_pointer_size('あ')
-    assert_cursor(2)
-    assert_cursor_max(6)
+    assert_line_around_cursor('あ', 'いう')
     input_keys("\C-b", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(6)
+    assert_line_around_cursor('', 'あいう')
     input_keys("\C-b", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(6)
+    assert_line_around_cursor('', 'あいう')
     input_keys("\C-f", false)
-    assert_byte_pointer_size('あ')
-    assert_cursor(2)
-    assert_cursor_max(6)
+    assert_line_around_cursor('あ', 'いう')
     input_keys("\C-f", false)
-    assert_byte_pointer_size('あい')
-    assert_cursor(4)
-    assert_cursor_max(6)
+    assert_line_around_cursor('あい', 'う')
     input_keys("\C-f", false)
-    assert_byte_pointer_size('あいう')
-    assert_cursor(6)
-    assert_cursor_max(6)
+    assert_line_around_cursor('あいう', '')
     input_keys("\C-f", false)
-    assert_byte_pointer_size('あいう')
-    assert_cursor(6)
-    assert_cursor_max(6)
+    assert_line_around_cursor('あいう', '')
   end
 
   def test_ed_next_and_prev_char_for_mbchar_by_plural_code_points
     input_keys("か\u3099き\u3099く\u3099")
-    assert_byte_pointer_size("か\u3099き\u3099く\u3099")
-    assert_cursor(6)
-    assert_cursor_max(6)
+    assert_line_around_cursor("か\u3099き\u3099く\u3099", '')
     input_keys("\C-b", false)
-    assert_byte_pointer_size("か\u3099き\u3099")
-    assert_cursor(4)
-    assert_cursor_max(6)
+    assert_line_around_cursor("か\u3099き\u3099", "く\u3099")
     input_keys("\C-b", false)
-    assert_byte_pointer_size("か\u3099")
-    assert_cursor(2)
-    assert_cursor_max(6)
+    assert_line_around_cursor("か\u3099", "き\u3099く\u3099")
     input_keys("\C-b", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(6)
+    assert_line_around_cursor('', "か\u3099き\u3099く\u3099")
     input_keys("\C-b", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(6)
+    assert_line_around_cursor('', "か\u3099き\u3099く\u3099")
     input_keys("\C-f", false)
-    assert_byte_pointer_size("か\u3099")
-    assert_cursor(2)
-    assert_cursor_max(6)
+    assert_line_around_cursor("か\u3099", "き\u3099く\u3099")
     input_keys("\C-f", false)
-    assert_byte_pointer_size("か\u3099き\u3099")
-    assert_cursor(4)
-    assert_cursor_max(6)
+    assert_line_around_cursor("か\u3099き\u3099", "く\u3099")
     input_keys("\C-f", false)
-    assert_byte_pointer_size("か\u3099き\u3099く\u3099")
-    assert_cursor(6)
-    assert_cursor_max(6)
+    assert_line_around_cursor("か\u3099き\u3099く\u3099", '')
     input_keys("\C-f", false)
-    assert_byte_pointer_size("か\u3099き\u3099く\u3099")
-    assert_cursor(6)
-    assert_cursor_max(6)
+    assert_line_around_cursor("か\u3099き\u3099く\u3099", '')
   end
 
   def test_em_capitol_case
     input_keys('abc def{bbb}ccc')
     input_keys("\C-a\M-c", false)
-    assert_byte_pointer_size('Abc')
-    assert_cursor(3)
-    assert_cursor_max(15)
-    assert_line('Abc def{bbb}ccc')
+    assert_line_around_cursor('Abc', ' def{bbb}ccc')
     input_keys("\M-c", false)
-    assert_byte_pointer_size('Abc Def')
-    assert_cursor(7)
-    assert_cursor_max(15)
-    assert_line('Abc Def{bbb}ccc')
+    assert_line_around_cursor('Abc Def', '{bbb}ccc')
     input_keys("\M-c", false)
-    assert_byte_pointer_size('Abc Def{Bbb')
-    assert_cursor(11)
-    assert_cursor_max(15)
-    assert_line('Abc Def{Bbb}ccc')
+    assert_line_around_cursor('Abc Def{Bbb', '}ccc')
     input_keys("\M-c", false)
-    assert_byte_pointer_size('Abc Def{Bbb}Ccc')
-    assert_cursor(15)
-    assert_cursor_max(15)
-    assert_line('Abc Def{Bbb}Ccc')
+    assert_line_around_cursor('Abc Def{Bbb}Ccc', '')
   end
 
   def test_em_capitol_case_with_complex_example
     input_keys('{}#*    AaA!!!cCc   ')
     input_keys("\C-a\M-c", false)
-    assert_byte_pointer_size('{}#*    Aaa')
-    assert_cursor(11)
-    assert_cursor_max(20)
-    assert_line('{}#*    Aaa!!!cCc   ')
+    assert_line_around_cursor('{}#*    Aaa', '!!!cCc   ')
     input_keys("\M-c", false)
-    assert_byte_pointer_size('{}#*    Aaa!!!Ccc')
-    assert_cursor(17)
-    assert_cursor_max(20)
-    assert_line('{}#*    Aaa!!!Ccc   ')
+    assert_line_around_cursor('{}#*    Aaa!!!Ccc', '   ')
     input_keys("\M-c", false)
-    assert_byte_pointer_size('{}#*    Aaa!!!Ccc   ')
-    assert_cursor(20)
-    assert_cursor_max(20)
-    assert_line('{}#*    Aaa!!!Ccc   ')
+    assert_line_around_cursor('{}#*    Aaa!!!Ccc   ', '')
   end
 
   def test_em_lower_case
     input_keys('AbC def{bBb}CCC')
     input_keys("\C-a\M-l", false)
-    assert_byte_pointer_size('abc')
-    assert_cursor(3)
-    assert_cursor_max(15)
-    assert_line('abc def{bBb}CCC')
+    assert_line_around_cursor('abc', ' def{bBb}CCC')
     input_keys("\M-l", false)
-    assert_byte_pointer_size('abc def')
-    assert_cursor(7)
-    assert_cursor_max(15)
-    assert_line('abc def{bBb}CCC')
+    assert_line_around_cursor('abc def', '{bBb}CCC')
     input_keys("\M-l", false)
-    assert_byte_pointer_size('abc def{bbb')
-    assert_cursor(11)
-    assert_cursor_max(15)
-    assert_line('abc def{bbb}CCC')
+    assert_line_around_cursor('abc def{bbb', '}CCC')
     input_keys("\M-l", false)
-    assert_byte_pointer_size('abc def{bbb}ccc')
-    assert_cursor(15)
-    assert_cursor_max(15)
-    assert_line('abc def{bbb}ccc')
+    assert_line_around_cursor('abc def{bbb}ccc', '')
   end
 
   def test_em_lower_case_with_complex_example
     input_keys('{}#*    AaA!!!cCc   ')
     input_keys("\C-a\M-l", false)
-    assert_byte_pointer_size('{}#*    aaa')
-    assert_cursor(11)
-    assert_cursor_max(20)
-    assert_line('{}#*    aaa!!!cCc   ')
+    assert_line_around_cursor('{}#*    aaa', '!!!cCc   ')
     input_keys("\M-l", false)
-    assert_byte_pointer_size('{}#*    aaa!!!ccc')
-    assert_cursor(17)
-    assert_cursor_max(20)
-    assert_line('{}#*    aaa!!!ccc   ')
+    assert_line_around_cursor('{}#*    aaa!!!ccc', '   ')
     input_keys("\M-l", false)
-    assert_byte_pointer_size('{}#*    aaa!!!ccc   ')
-    assert_cursor(20)
-    assert_cursor_max(20)
-    assert_line('{}#*    aaa!!!ccc   ')
+    assert_line_around_cursor('{}#*    aaa!!!ccc   ', '')
   end
 
   def test_em_upper_case
     input_keys('AbC def{bBb}CCC')
     input_keys("\C-a\M-u", false)
-    assert_byte_pointer_size('ABC')
-    assert_cursor(3)
-    assert_cursor_max(15)
-    assert_line('ABC def{bBb}CCC')
+    assert_line_around_cursor('ABC', ' def{bBb}CCC')
     input_keys("\M-u", false)
-    assert_byte_pointer_size('ABC DEF')
-    assert_cursor(7)
-    assert_cursor_max(15)
-    assert_line('ABC DEF{bBb}CCC')
+    assert_line_around_cursor('ABC DEF', '{bBb}CCC')
     input_keys("\M-u", false)
-    assert_byte_pointer_size('ABC DEF{BBB')
-    assert_cursor(11)
-    assert_cursor_max(15)
-    assert_line('ABC DEF{BBB}CCC')
+    assert_line_around_cursor('ABC DEF{BBB', '}CCC')
     input_keys("\M-u", false)
-    assert_byte_pointer_size('ABC DEF{BBB}CCC')
-    assert_cursor(15)
-    assert_cursor_max(15)
-    assert_line('ABC DEF{BBB}CCC')
+    assert_line_around_cursor('ABC DEF{BBB}CCC', '')
   end
 
   def test_em_upper_case_with_complex_example
     input_keys('{}#*    AaA!!!cCc   ')
     input_keys("\C-a\M-u", false)
-    assert_byte_pointer_size('{}#*    AAA')
-    assert_cursor(11)
-    assert_cursor_max(20)
-    assert_line('{}#*    AAA!!!cCc   ')
+    assert_line_around_cursor('{}#*    AAA', '!!!cCc   ')
     input_keys("\M-u", false)
-    assert_byte_pointer_size('{}#*    AAA!!!CCC')
-    assert_cursor(17)
-    assert_cursor_max(20)
-    assert_line('{}#*    AAA!!!CCC   ')
+    assert_line_around_cursor('{}#*    AAA!!!CCC', '   ')
     input_keys("\M-u", false)
-    assert_byte_pointer_size('{}#*    AAA!!!CCC   ')
-    assert_cursor(20)
-    assert_cursor_max(20)
-    assert_line('{}#*    AAA!!!CCC   ')
+    assert_line_around_cursor('{}#*    AAA!!!CCC   ', '')
   end
 
   def test_em_delete_or_list
@@ -1286,28 +726,16 @@ class Reline::KeyActor::Emacs::Test < Reline::TestCase
       }
     }
     input_keys('fooo')
-    assert_byte_pointer_size('fooo')
-    assert_cursor(4)
-    assert_cursor_max(4)
-    assert_line('fooo')
+    assert_line_around_cursor('fooo', '')
     assert_equal(nil, @line_editor.instance_variable_get(:@menu_info))
     input_keys("\C-b", false)
-    assert_byte_pointer_size('foo')
-    assert_cursor(3)
-    assert_cursor_max(4)
-    assert_line('fooo')
+    assert_line_around_cursor('foo', 'o')
     assert_equal(nil, @line_editor.instance_variable_get(:@menu_info))
     @line_editor.input_key(Reline::Key.new(:em_delete_or_list, :em_delete_or_list, false))
-    assert_byte_pointer_size('foo')
-    assert_cursor(3)
-    assert_cursor_max(3)
-    assert_line('foo')
+    assert_line_around_cursor('foo', '')
     assert_equal(nil, @line_editor.instance_variable_get(:@menu_info))
     @line_editor.input_key(Reline::Key.new(:em_delete_or_list, :em_delete_or_list, false))
-    assert_byte_pointer_size('foo')
-    assert_cursor(3)
-    assert_cursor_max(3)
-    assert_line('foo')
+    assert_line_around_cursor('foo', '')
     assert_equal(%w{foo_foo foo_bar foo_baz}, @line_editor.instance_variable_get(:@menu_info).list)
   end
 
@@ -1322,22 +750,13 @@ class Reline::KeyActor::Emacs::Test < Reline::TestCase
       }
     }
     input_keys('foo_')
-    assert_byte_pointer_size('foo_')
-    assert_cursor(4)
-    assert_cursor_max(4)
-    assert_line('foo_')
+    assert_line_around_cursor('foo_', '')
     assert_equal(nil, @line_editor.instance_variable_get(:@menu_info))
     input_keys("\C-i", false)
-    assert_byte_pointer_size('foo_')
-    assert_cursor(4)
-    assert_cursor_max(4)
-    assert_line('foo_')
+    assert_line_around_cursor('foo_', '')
     assert_equal(nil, @line_editor.instance_variable_get(:@menu_info))
     input_keys("\C-i", false)
-    assert_byte_pointer_size('foo_')
-    assert_cursor(4)
-    assert_cursor_max(4)
-    assert_line('foo_')
+    assert_line_around_cursor('foo_', '')
     assert_equal(%w{foo_foo foo_bar}, @line_editor.instance_variable_get(:@menu_info).list)
   end
 
@@ -1353,36 +772,63 @@ class Reline::KeyActor::Emacs::Test < Reline::TestCase
       }
     }
     input_keys('fo')
-    assert_byte_pointer_size('fo')
-    assert_cursor(2)
-    assert_cursor_max(2)
-    assert_line('fo')
+    assert_line_around_cursor('fo', '')
     assert_equal(nil, @line_editor.instance_variable_get(:@menu_info))
     input_keys("\C-i", false)
-    assert_byte_pointer_size('foo_')
-    assert_cursor(4)
-    assert_cursor_max(4)
-    assert_line('foo_')
+    assert_line_around_cursor('foo_', '')
     assert_equal(nil, @line_editor.instance_variable_get(:@menu_info))
     input_keys("\C-i", false)
-    assert_byte_pointer_size('foo_')
-    assert_cursor(4)
-    assert_cursor_max(4)
-    assert_line('foo_')
+    assert_line_around_cursor('foo_', '')
     assert_equal(%w{foo_foo foo_bar foo_baz}, @line_editor.instance_variable_get(:@menu_info).list)
     input_keys('a')
     input_keys("\C-i", false)
-    assert_byte_pointer_size('foo_a')
-    assert_cursor(5)
-    assert_cursor_max(5)
-    assert_line('foo_a')
+    assert_line_around_cursor('foo_a', '')
     input_keys("\C-h", false)
     input_keys('b')
     input_keys("\C-i", false)
-    assert_byte_pointer_size('foo_ba')
-    assert_cursor(6)
-    assert_cursor_max(6)
-    assert_line('foo_ba')
+    assert_line_around_cursor('foo_ba', '')
+    input_keys("\C-h")
+    input_key_by_symbol(:complete)
+    assert_line_around_cursor('foo_ba', '')
+    input_keys("\C-h", false)
+    input_key_by_symbol(:menu_complete)
+    assert_line_around_cursor('foo_bar', '')
+    input_key_by_symbol(:menu_complete)
+    assert_line_around_cursor('foo_baz', '')
+    input_keys("\C-h", false)
+    input_key_by_symbol(:menu_complete_backward)
+    assert_line_around_cursor('foo_baz', '')
+    input_key_by_symbol(:menu_complete_backward)
+    assert_line_around_cursor('foo_bar', '')
+  end
+
+  def test_autocompletion
+    @config.autocompletion = true
+    @line_editor.completion_proc = proc { |word|
+      %w{
+        Readline
+        Regexp
+        RegexpError
+      }.map { |i|
+        i.encode(@encoding)
+      }
+    }
+    input_keys('Re')
+    assert_line_around_cursor('Re', '')
+    input_keys("\C-i", false)
+    assert_line_around_cursor('Readline', '')
+    input_keys("\C-i", false)
+    assert_line_around_cursor('Regexp', '')
+    input_key_by_symbol(:completion_journey_up)
+    assert_line_around_cursor('Readline', '')
+    input_key_by_symbol(:complete)
+    assert_line_around_cursor('Regexp', '')
+    input_key_by_symbol(:menu_complete_backward)
+    assert_line_around_cursor('Readline', '')
+    input_key_by_symbol(:menu_complete)
+    assert_line_around_cursor('Regexp', '')
+  ensure
+    @config.autocompletion = false
   end
 
   def test_completion_with_indent
@@ -1397,22 +843,13 @@ class Reline::KeyActor::Emacs::Test < Reline::TestCase
       }
     }
     input_keys('  fo')
-    assert_byte_pointer_size('  fo')
-    assert_cursor(4)
-    assert_cursor_max(4)
-    assert_line('  fo')
+    assert_line_around_cursor('  fo', '')
     assert_equal(nil, @line_editor.instance_variable_get(:@menu_info))
     input_keys("\C-i", false)
-    assert_byte_pointer_size('  foo_')
-    assert_cursor(6)
-    assert_cursor_max(6)
-    assert_line('  foo_')
+    assert_line_around_cursor('  foo_', '')
     assert_equal(nil, @line_editor.instance_variable_get(:@menu_info))
     input_keys("\C-i", false)
-    assert_byte_pointer_size('  foo_')
-    assert_cursor(6)
-    assert_cursor_max(6)
-    assert_line('  foo_')
+    assert_line_around_cursor('  foo_', '')
     assert_equal(%w{foo_foo foo_bar foo_baz}, @line_editor.instance_variable_get(:@menu_info).list)
   end
 
@@ -1428,22 +865,13 @@ class Reline::KeyActor::Emacs::Test < Reline::TestCase
       }
     }
     input_keys('  "".fo')
-    assert_byte_pointer_size('  "".fo')
-    assert_cursor(7)
-    assert_cursor_max(7)
-    assert_line('  "".fo')
+    assert_line_around_cursor('  "".fo', '')
     assert_equal(nil, @line_editor.instance_variable_get(:@menu_info))
     input_keys("\C-i", false)
-    assert_byte_pointer_size('  "".foo_')
-    assert_cursor(9)
-    assert_cursor_max(9)
-    assert_line('  "".foo_')
+    assert_line_around_cursor('  "".foo_', '')
     assert_equal(nil, @line_editor.instance_variable_get(:@menu_info))
     input_keys("\C-i", false)
-    assert_byte_pointer_size('  "".foo_')
-    assert_cursor(9)
-    assert_cursor_max(9)
-    assert_line('  "".foo_')
+    assert_line_around_cursor('  "".foo_', '')
     assert_equal(%w{"".foo_foo "".foo_bar "".foo_baz}, @line_editor.instance_variable_get(:@menu_info).list)
   end
 
@@ -1461,54 +889,33 @@ class Reline::KeyActor::Emacs::Test < Reline::TestCase
       matched = m
     }
     input_keys('fo')
-    assert_byte_pointer_size('fo')
-    assert_cursor(2)
-    assert_cursor_max(2)
-    assert_line('fo')
+    assert_line_around_cursor('fo', '')
     assert_equal(Reline::LineEditor::CompletionState::NORMAL, @line_editor.instance_variable_get(:@completion_state))
     assert_equal(nil, matched)
     input_keys("\C-i", false)
-    assert_byte_pointer_size('foo')
-    assert_cursor(3)
-    assert_cursor_max(3)
-    assert_line('foo')
+    assert_line_around_cursor('foo', '')
     assert_equal(Reline::LineEditor::CompletionState::MENU_WITH_PERFECT_MATCH, @line_editor.instance_variable_get(:@completion_state))
     assert_equal(nil, matched)
     input_keys("\C-i", false)
-    assert_byte_pointer_size('foo')
-    assert_cursor(3)
-    assert_cursor_max(3)
-    assert_line('foo')
+    assert_line_around_cursor('foo', '')
     assert_equal(Reline::LineEditor::CompletionState::PERFECT_MATCH, @line_editor.instance_variable_get(:@completion_state))
     assert_equal(nil, matched)
     input_keys("\C-i", false)
-    assert_byte_pointer_size('foo')
-    assert_cursor(3)
-    assert_cursor_max(3)
-    assert_line('foo')
+    assert_line_around_cursor('foo', '')
     assert_equal(Reline::LineEditor::CompletionState::PERFECT_MATCH, @line_editor.instance_variable_get(:@completion_state))
     assert_equal('foo', matched)
     matched = nil
     input_keys('_')
     input_keys("\C-i", false)
-    assert_byte_pointer_size('foo_bar')
-    assert_cursor(7)
-    assert_cursor_max(7)
-    assert_line('foo_bar')
+    assert_line_around_cursor('foo_bar', '')
     assert_equal(Reline::LineEditor::CompletionState::MENU_WITH_PERFECT_MATCH, @line_editor.instance_variable_get(:@completion_state))
     assert_equal(nil, matched)
     input_keys("\C-i", false)
-    assert_byte_pointer_size('foo_bar')
-    assert_cursor(7)
-    assert_cursor_max(7)
-    assert_line('foo_bar')
+    assert_line_around_cursor('foo_bar', '')
     assert_equal(Reline::LineEditor::CompletionState::PERFECT_MATCH, @line_editor.instance_variable_get(:@completion_state))
     assert_equal(nil, matched)
     input_keys("\C-i", false)
-    assert_byte_pointer_size('foo_bar')
-    assert_cursor(7)
-    assert_cursor_max(7)
-    assert_line('foo_bar')
+    assert_line_around_cursor('foo_bar', '')
     assert_equal(Reline::LineEditor::CompletionState::PERFECT_MATCH, @line_editor.instance_variable_get(:@completion_state))
     assert_equal('foo_bar', matched)
   end
@@ -1525,43 +932,25 @@ class Reline::KeyActor::Emacs::Test < Reline::TestCase
       }
     }
     input_keys('fo')
-    assert_byte_pointer_size('fo')
-    assert_cursor(2)
-    assert_cursor_max(2)
-    assert_line('fo')
+    assert_line_around_cursor('fo', '')
     assert_equal(nil, @line_editor.instance_variable_get(:@menu_info))
     input_keys("\C-i", false)
-    assert_byte_pointer_size('foo_')
-    assert_cursor(4)
-    assert_cursor_max(4)
-    assert_line('foo_')
+    assert_line_around_cursor('foo_', '')
     assert_equal(nil, @line_editor.instance_variable_get(:@menu_info))
     input_keys("\C-i", false)
-    assert_byte_pointer_size('foo_')
-    assert_cursor(4)
-    assert_cursor_max(4)
-    assert_line('foo_')
+    assert_line_around_cursor('foo_', '')
     assert_equal(%w{foo_foo foo_bar}, @line_editor.instance_variable_get(:@menu_info).list)
     @config.completion_ignore_case = true
     input_keys("\C-i", false)
-    assert_byte_pointer_size('foo_')
-    assert_cursor(4)
-    assert_cursor_max(4)
-    assert_line('foo_')
+    assert_line_around_cursor('foo_', '')
     assert_equal(%w{foo_foo foo_bar Foo_baz}, @line_editor.instance_variable_get(:@menu_info).list)
     input_keys('a')
     input_keys("\C-i", false)
-    assert_byte_pointer_size('foo_a')
-    assert_cursor(5)
-    assert_cursor_max(5)
-    assert_line('foo_a')
+    assert_line_around_cursor('foo_a', '')
     input_keys("\C-h", false)
     input_keys('b')
     input_keys("\C-i", false)
-    assert_byte_pointer_size('foo_ba')
-    assert_cursor(6)
-    assert_cursor_max(6)
-    assert_line('foo_ba')
+    assert_line_around_cursor('foo_ba', '')
   end
 
   def test_completion_in_middle_of_line
@@ -1576,17 +965,11 @@ class Reline::KeyActor::Emacs::Test < Reline::TestCase
       }
     }
     input_keys('abcde fo ABCDE')
-    assert_line('abcde fo ABCDE')
+    assert_line_around_cursor('abcde fo ABCDE', '')
     input_keys("\C-b" * 6 + "\C-i", false)
-    assert_byte_pointer_size('abcde foo_')
-    assert_cursor(10)
-    assert_cursor_max(16)
-    assert_line('abcde foo_ ABCDE')
+    assert_line_around_cursor('abcde foo_', ' ABCDE')
     input_keys("\C-b" * 2 + "\C-i", false)
-    assert_byte_pointer_size('abcde foo_')
-    assert_cursor(10)
-    assert_cursor_max(18)
-    assert_line('abcde foo_o_ ABCDE')
+    assert_line_around_cursor('abcde foo_', 'o_ ABCDE')
   end
 
   def test_completion_with_nil_value
@@ -1602,125 +985,65 @@ class Reline::KeyActor::Emacs::Test < Reline::TestCase
     }
     @config.completion_ignore_case = true
     input_keys('fo')
-    assert_byte_pointer_size('fo')
-    assert_cursor(2)
-    assert_cursor_max(2)
-    assert_line('fo')
+    assert_line_around_cursor('fo', '')
     assert_equal(nil, @line_editor.instance_variable_get(:@menu_info))
     input_keys("\C-i", false)
-    assert_byte_pointer_size('foo_')
-    assert_cursor(4)
-    assert_cursor_max(4)
-    assert_line('foo_')
+    assert_line_around_cursor('foo_', '')
     assert_equal(nil, @line_editor.instance_variable_get(:@menu_info))
     input_keys("\C-i", false)
-    assert_byte_pointer_size('foo_')
-    assert_cursor(4)
-    assert_cursor_max(4)
-    assert_line('foo_')
+    assert_line_around_cursor('foo_', '')
     assert_equal(%w{foo_foo foo_bar Foo_baz}, @line_editor.instance_variable_get(:@menu_info).list)
     input_keys('a')
     input_keys("\C-i", false)
-    assert_byte_pointer_size('foo_a')
-    assert_cursor(5)
-    assert_cursor_max(5)
-    assert_line('foo_a')
+    assert_line_around_cursor('foo_a', '')
     input_keys("\C-h", false)
     input_keys('b')
     input_keys("\C-i", false)
-    assert_byte_pointer_size('foo_ba')
-    assert_cursor(6)
-    assert_cursor_max(6)
-    assert_line('foo_ba')
+    assert_line_around_cursor('foo_ba', '')
   end
 
   def test_em_kill_region
     input_keys('abc   def{bbb}ccc   ddd   ')
-    assert_byte_pointer_size('abc   def{bbb}ccc   ddd   ')
-    assert_cursor(26)
-    assert_cursor_max(26)
-    assert_line('abc   def{bbb}ccc   ddd   ')
+    assert_line_around_cursor('abc   def{bbb}ccc   ddd   ', '')
     input_keys("\C-w", false)
-    assert_byte_pointer_size('abc   def{bbb}ccc   ')
-    assert_cursor(20)
-    assert_cursor_max(20)
-    assert_line('abc   def{bbb}ccc   ')
+    assert_line_around_cursor('abc   def{bbb}ccc   ', '')
     input_keys("\C-w", false)
-    assert_byte_pointer_size('abc   ')
-    assert_cursor(6)
-    assert_cursor_max(6)
-    assert_line('abc   ')
+    assert_line_around_cursor('abc   ', '')
     input_keys("\C-w", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
-    assert_line('')
+    assert_line_around_cursor('', '')
     input_keys("\C-w", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
-    assert_line('')
+    assert_line_around_cursor('', '')
   end
 
   def test_em_kill_region_mbchar
     input_keys('あ   い   う{う}う   ')
-    assert_byte_pointer_size('あ   い   う{う}う   ')
-    assert_cursor(21)
-    assert_cursor_max(21)
-    assert_line('あ   い   う{う}う   ')
+    assert_line_around_cursor('あ   い   う{う}う   ', '')
     input_keys("\C-w", false)
-    assert_byte_pointer_size('あ   い   ')
-    assert_cursor(10)
-    assert_cursor_max(10)
-    assert_line('あ   い   ')
+    assert_line_around_cursor('あ   い   ', '')
     input_keys("\C-w", false)
-    assert_byte_pointer_size('あ   ')
-    assert_cursor(5)
-    assert_cursor_max(5)
-    assert_line('あ   ')
+    assert_line_around_cursor('あ   ', '')
     input_keys("\C-w", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
-    assert_line('')
+    assert_line_around_cursor('', '')
   end
 
   def test_vi_search_prev
     Reline::HISTORY.concat(%w{abc 123 AAA})
-    assert_line('')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
+    assert_line_around_cursor('', '')
     input_keys("\C-ra\C-j")
-    assert_line('abc')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(3)
+    assert_line_around_cursor('', 'abc')
   end
 
   def test_larger_histories_than_history_size
     history_size = @config.history_size
     @config.history_size = 2
     Reline::HISTORY.concat(%w{abc 123 AAA})
-    assert_line('')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
+    assert_line_around_cursor('', '')
     input_keys("\C-p")
-    assert_line('AAA')
-    assert_byte_pointer_size('AAA')
-    assert_cursor(3)
-    assert_cursor_max(3)
+    assert_line_around_cursor('AAA', '')
     input_keys("\C-p")
-    assert_line('123')
-    assert_byte_pointer_size('123')
-    assert_cursor(3)
-    assert_cursor_max(3)
+    assert_line_around_cursor('123', '')
     input_keys("\C-p")
-    assert_line('123')
-    assert_byte_pointer_size('123')
-    assert_cursor(3)
-    assert_cursor_max(3)
+    assert_line_around_cursor('123', '')
   ensure
     @config.history_size = history_size
   end
@@ -1731,25 +1054,13 @@ class Reline::KeyActor::Emacs::Test < Reline::TestCase
       '12aa',
       '1234' # new
     ])
-    assert_line('')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
+    assert_line_around_cursor('', '')
     input_keys("\C-r123")
-    assert_line('1234')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0) # doesn't determine yet
+    assert_line_around_cursor('1234', '')
     input_keys("\C-ha")
-    assert_line('12aa')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
+    assert_line_around_cursor('12aa', '')
     input_keys("\C-h3")
-    assert_line('1235')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
+    assert_line_around_cursor('1235', '')
   end
 
   def test_search_history_to_front
@@ -1758,25 +1069,13 @@ class Reline::KeyActor::Emacs::Test < Reline::TestCase
       '12aa',
       '1234' # new
     ])
-    assert_line('')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
+    assert_line_around_cursor('', '')
     input_keys("\C-s123")
-    assert_line('1235')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0) # doesn't determine yet
+    assert_line_around_cursor('1235', '')
     input_keys("\C-ha")
-    assert_line('12aa')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
+    assert_line_around_cursor('12aa', '')
     input_keys("\C-h3")
-    assert_line('1234')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
+    assert_line_around_cursor('1234', '')
   end
 
   def test_search_history_front_and_back
@@ -1785,30 +1084,15 @@ class Reline::KeyActor::Emacs::Test < Reline::TestCase
       '12aa',
       '1234' # new
     ])
-    assert_line('')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
+    assert_line_around_cursor('', '')
     input_keys("\C-s12")
-    assert_line('1235')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0) # doesn't determine yet
+    assert_line_around_cursor('1235', '')
     input_keys("\C-s")
-    assert_line('12aa')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
+    assert_line_around_cursor('12aa', '')
     input_keys("\C-r")
-    assert_line('12aa')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
+    assert_line_around_cursor('12aa', '')
     input_keys("\C-r")
-    assert_line('1235')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
+    assert_line_around_cursor('1235', '')
   end
 
   def test_search_history_back_and_front
@@ -1817,30 +1101,15 @@ class Reline::KeyActor::Emacs::Test < Reline::TestCase
       '12aa',
       '1234' # new
     ])
-    assert_line('')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
+    assert_line_around_cursor('', '')
     input_keys("\C-r12")
-    assert_line('1234')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0) # doesn't determine yet
+    assert_line_around_cursor('1234', '')
     input_keys("\C-r")
-    assert_line('12aa')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
+    assert_line_around_cursor('12aa', '')
     input_keys("\C-s")
-    assert_line('12aa')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
+    assert_line_around_cursor('12aa', '')
     input_keys("\C-s")
-    assert_line('1234')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
+    assert_line_around_cursor('1234', '')
   end
 
   def test_search_history_to_back_in_the_middle_of_histories
@@ -1849,20 +1118,11 @@ class Reline::KeyActor::Emacs::Test < Reline::TestCase
       '12aa',
       '1234' # new
     ])
-    assert_line('')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
+    assert_line_around_cursor('', '')
     input_keys("\C-p\C-p")
-    assert_line('12aa')
-    assert_byte_pointer_size('12aa')
-    assert_cursor(4)
-    assert_cursor_max(4)
+    assert_line_around_cursor('12aa', '')
     input_keys("\C-r123")
-    assert_line('1235')
-    assert_byte_pointer_size('1235')
-    assert_cursor(4)
-    assert_cursor_max(4)
+    assert_line_around_cursor('1235', '')
   end
 
   def test_search_history_twice
@@ -1871,20 +1131,11 @@ class Reline::KeyActor::Emacs::Test < Reline::TestCase
       '12aa',
       '1234' # new
     ])
-    assert_line('')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
+    assert_line_around_cursor('', '')
     input_keys("\C-r123")
-    assert_line('1234')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0) # doesn't determine yet
+    assert_line_around_cursor('1234', '')
     input_keys("\C-r")
-    assert_line('1235')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
+    assert_line_around_cursor('1235', '')
   end
 
   def test_search_history_by_last_determined
@@ -1893,35 +1144,17 @@ class Reline::KeyActor::Emacs::Test < Reline::TestCase
       '12aa',
       '1234' # new
     ])
-    assert_line('')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
+    assert_line_around_cursor('', '')
     input_keys("\C-r123")
-    assert_line('1234')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0) # doesn't determine yet
+    assert_line_around_cursor('1234', '')
     input_keys("\C-j")
-    assert_line('1234')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(4)
+    assert_line_around_cursor('', '1234')
     input_keys("\C-k") # delete
-    assert_line('')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
+    assert_line_around_cursor('', '')
     input_keys("\C-r")
-    assert_line('')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
+    assert_line_around_cursor('', '')
     input_keys("\C-r")
-    assert_line('1235')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
+    assert_line_around_cursor('1235', '')
   end
 
   def test_search_history_with_isearch_terminator
@@ -1933,76 +1166,40 @@ class Reline::KeyActor::Emacs::Test < Reline::TestCase
       '12aa',
       '1234' # new
     ])
-    assert_line('')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
+    assert_line_around_cursor('', '')
     input_keys("\C-r12a")
-    assert_line('12aa')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0) # doesn't determine yet
+    assert_line_around_cursor('12aa', '')
     input_keys('Y')
-    assert_line('12aa')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(4)
+    assert_line_around_cursor('', '12aa')
     input_keys('x')
-    assert_line('x12aa')
-    assert_byte_pointer_size('x')
-    assert_cursor(1)
-    assert_cursor_max(5)
+    assert_line_around_cursor('x', '12aa')
   end
 
   def test_em_set_mark_and_em_exchange_mark
     input_keys('aaa bbb ccc ddd')
-    assert_byte_pointer_size('aaa bbb ccc ddd')
-    assert_cursor(15)
-    assert_cursor_max(15)
-    assert_line('aaa bbb ccc ddd')
+    assert_line_around_cursor('aaa bbb ccc ddd', '')
     input_keys("\C-a\M-F\M-F", false)
-    assert_byte_pointer_size('aaa bbb')
-    assert_cursor(7)
-    assert_cursor_max(15)
-    assert_line('aaa bbb ccc ddd')
+    assert_line_around_cursor('aaa bbb', ' ccc ddd')
     assert_equal(nil, @line_editor.instance_variable_get(:@mark_pointer))
     input_keys("\x00", false) # C-Space
-    assert_byte_pointer_size('aaa bbb')
-    assert_cursor(7)
-    assert_cursor_max(15)
-    assert_line('aaa bbb ccc ddd')
+    assert_line_around_cursor('aaa bbb', ' ccc ddd')
     assert_equal([7, 0], @line_editor.instance_variable_get(:@mark_pointer))
     input_keys("\C-a", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(15)
-    assert_line('aaa bbb ccc ddd')
+    assert_line_around_cursor('', 'aaa bbb ccc ddd')
     assert_equal([7, 0], @line_editor.instance_variable_get(:@mark_pointer))
     input_key_by_symbol(:em_exchange_mark)
-    assert_byte_pointer_size('aaa bbb')
-    assert_cursor(7)
-    assert_cursor_max(15)
-    assert_line('aaa bbb ccc ddd')
+    assert_line_around_cursor('aaa bbb', ' ccc ddd')
     assert_equal([0, 0], @line_editor.instance_variable_get(:@mark_pointer))
   end
 
   def test_em_exchange_mark_without_mark
     input_keys('aaa bbb ccc ddd')
-    assert_byte_pointer_size('aaa bbb ccc ddd')
-    assert_cursor(15)
-    assert_cursor_max(15)
-    assert_line('aaa bbb ccc ddd')
+    assert_line_around_cursor('aaa bbb ccc ddd', '')
     input_keys("\C-a\M-f", false)
-    assert_byte_pointer_size('aaa')
-    assert_cursor(3)
-    assert_cursor_max(15)
-    assert_line('aaa bbb ccc ddd')
+    assert_line_around_cursor('aaa', ' bbb ccc ddd')
     assert_equal(nil, @line_editor.instance_variable_get(:@mark_pointer))
     input_key_by_symbol(:em_exchange_mark)
-    assert_byte_pointer_size('aaa')
-    assert_cursor(3)
-    assert_cursor_max(15)
-    assert_line('aaa bbb ccc ddd')
+    assert_line_around_cursor('aaa', ' bbb ccc ddd')
     assert_equal(nil, @line_editor.instance_variable_get(:@mark_pointer))
   end
 
@@ -2013,7 +1210,7 @@ class Reline::KeyActor::Emacs::Test < Reline::TestCase
     $VERBOSE = verbose
     @line_editor.output_modifier_proc = proc { |output| Reline::Unicode.escape_for_print(output) }
     input_keys("abcdef\n")
-    result = @line_editor.__send__(:modify_lines, @line_editor.whole_lines)
+    result = @line_editor.__send__(:modify_lines, @line_editor.whole_lines, @line_editor.finished?)
     $/ = nil
     assert_equal(['abcdef'], result)
   ensure
@@ -2031,20 +1228,11 @@ class Reline::KeyActor::Emacs::Test < Reline::TestCase
     input_keys('123')
     # The ed_search_prev_history doesn't have default binding
     @line_editor.__send__(:ed_search_prev_history, "\C-p".ord)
-    assert_byte_pointer_size('123')
-    assert_cursor(3)
-    assert_cursor_max(5)
-    assert_line('12345')
+    assert_line_around_cursor('123', '45')
     @line_editor.__send__(:ed_search_prev_history, "\C-p".ord)
-    assert_byte_pointer_size('123')
-    assert_cursor(3)
-    assert_cursor_max(5)
-    assert_line('12356')
+    assert_line_around_cursor('123', '56')
     @line_editor.__send__(:ed_search_prev_history, "\C-p".ord)
-    assert_byte_pointer_size('123')
-    assert_cursor(3)
-    assert_cursor_max(5)
-    assert_line('12356')
+    assert_line_around_cursor('123', '56')
   end
 
   def test_ed_search_prev_history_with_empty
@@ -2055,25 +1243,13 @@ class Reline::KeyActor::Emacs::Test < Reline::TestCase
     ])
     # The ed_search_prev_history doesn't have default binding
     @line_editor.__send__(:ed_search_prev_history, "\C-p".ord)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(5)
-    assert_line('12345')
+    assert_line_around_cursor('', '12345')
     @line_editor.__send__(:ed_search_prev_history, "\C-p".ord)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(5)
-    assert_line('12aaa')
+    assert_line_around_cursor('', '12aaa')
     @line_editor.__send__(:ed_search_prev_history, "\C-p".ord)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(5)
-    assert_line('12356')
+    assert_line_around_cursor('', '12356')
     @line_editor.__send__(:ed_search_prev_history, "\C-p".ord)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(5)
-    assert_line('12356')
+    assert_line_around_cursor('', '12356')
   end
 
   def test_ed_search_prev_history_without_match
@@ -2085,10 +1261,7 @@ class Reline::KeyActor::Emacs::Test < Reline::TestCase
     input_keys('ABC')
     # The ed_search_prev_history doesn't have default binding
     @line_editor.__send__(:ed_search_prev_history, "\C-p".ord)
-    assert_byte_pointer_size('ABC')
-    assert_cursor(3)
-    assert_cursor_max(3)
-    assert_line('ABC')
+    assert_line_around_cursor('ABC', '')
   end
 
   def test_ed_search_next_history
@@ -2100,30 +1273,15 @@ class Reline::KeyActor::Emacs::Test < Reline::TestCase
     input_keys('123')
     # The ed_search_prev_history and ed_search_next_history doesn't have default binding
     @line_editor.__send__(:ed_search_prev_history, "\C-p".ord)
-    assert_byte_pointer_size('123')
-    assert_cursor(3)
-    assert_cursor_max(5)
-    assert_line('12345')
+    assert_line_around_cursor('123', '45')
     @line_editor.__send__(:ed_search_prev_history, "\C-p".ord)
-    assert_byte_pointer_size('123')
-    assert_cursor(3)
-    assert_cursor_max(5)
-    assert_line('12356')
+    assert_line_around_cursor('123', '56')
     @line_editor.__send__(:ed_search_prev_history, "\C-p".ord)
-    assert_byte_pointer_size('123')
-    assert_cursor(3)
-    assert_cursor_max(5)
-    assert_line('12356')
+    assert_line_around_cursor('123', '56')
     @line_editor.__send__(:ed_search_next_history, "\C-n".ord)
-    assert_byte_pointer_size('123')
-    assert_cursor(3)
-    assert_cursor_max(5)
-    assert_line('12345')
+    assert_line_around_cursor('123', '45')
     @line_editor.__send__(:ed_search_next_history, "\C-n".ord)
-    assert_byte_pointer_size('123')
-    assert_cursor(3)
-    assert_cursor_max(5)
-    assert_line('12345')
+    assert_line_around_cursor('123', '45')
   end
 
   def test_ed_search_next_history_with_empty
@@ -2134,35 +1292,25 @@ class Reline::KeyActor::Emacs::Test < Reline::TestCase
     ])
     # The ed_search_prev_history and ed_search_next_history doesn't have default binding
     @line_editor.__send__(:ed_search_prev_history, "\C-p".ord)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(5)
-    assert_line('12345')
+    assert_line_around_cursor('', '12345')
     @line_editor.__send__(:ed_search_prev_history, "\C-p".ord)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(5)
-    assert_line('12aaa')
+    assert_line_around_cursor('', '12aaa')
     @line_editor.__send__(:ed_search_prev_history, "\C-p".ord)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(5)
-    assert_line('12356')
+    assert_line_around_cursor('', '12356')
     @line_editor.__send__(:ed_search_next_history, "\C-n".ord)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(5)
-    assert_line('12aaa')
+    assert_line_around_cursor('', '12aaa')
     @line_editor.__send__(:ed_search_next_history, "\C-n".ord)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(5)
-    assert_line('12345')
+    assert_line_around_cursor('', '12345')
     @line_editor.__send__(:ed_search_next_history, "\C-n".ord)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
-    assert_line('')
+    assert_line_around_cursor('', '')
+  end
+
+  def test_incremental_search_history_cancel_by_symbol_key
+    # ed_prev_char should move cursor left and cancel incremental search
+    input_keys("abc\C-r")
+    input_key_by_symbol(:ed_prev_char)
+    input_keys('d')
+    assert_line_around_cursor('abd', 'c')
   end
 
   # Unicode emoji test
@@ -2170,97 +1318,49 @@ class Reline::KeyActor::Emacs::Test < Reline::TestCase
     omit "This test is for UTF-8 but the locale is #{Reline.core.encoding}" if Reline.core.encoding != Encoding::UTF_8
     # U+1F468 U+200D U+1F469 U+200D U+1F467 U+200D U+1F466 is family: man, woman, girl, boy "👨‍👩‍👧‍👦"
     input_keys("\u{1F468}") # U+1F468 is man "👨"
-    assert_line("\u{1F468}")
-    assert_byte_pointer_size("\u{1F468}")
-    assert_cursor(2)
-    assert_cursor_max(2)
+    assert_line_around_cursor('👨', '')
     input_keys("\u200D") # U+200D is ZERO WIDTH JOINER
-    assert_line("\u{1F468 200D}")
-    assert_byte_pointer_size("\u{1F468 200D}")
-    assert_cursor(2)
-    assert_cursor_max(2)
+    assert_line_around_cursor('👨‍', '')
     input_keys("\u{1F469}") # U+1F469 is woman "👩"
-    assert_line("\u{1F468 200D 1F469}")
-    assert_byte_pointer_size("\u{1F468 200D 1F469}")
-    assert_cursor(2)
-    assert_cursor_max(2)
+    assert_line_around_cursor('👨‍👩', '')
     input_keys("\u200D") # U+200D is ZERO WIDTH JOINER
-    assert_line("\u{1F468 200D 1F469 200D}")
-    assert_byte_pointer_size("\u{1F468 200D 1F469 200D}")
-    assert_cursor(2)
-    assert_cursor_max(2)
+    assert_line_around_cursor('👨‍👩‍', '')
     input_keys("\u{1F467}") # U+1F467 is girl "👧"
-    assert_line("\u{1F468 200D 1F469 200D 1F467}")
-    assert_byte_pointer_size("\u{1F468 200D 1F469 200D 1F467}")
-    assert_cursor(2)
-    assert_cursor_max(2)
+    assert_line_around_cursor('👨‍👩‍👧', '')
     input_keys("\u200D") # U+200D is ZERO WIDTH JOINER
-    assert_line("\u{1F468 200D 1F469 200D 1F467 200D}")
-    assert_byte_pointer_size("\u{1F468 200D 1F469 200D 1F467 200D}")
-    assert_cursor(2)
-    assert_cursor_max(2)
+    assert_line_around_cursor('👨‍👩‍👧‍', '')
     input_keys("\u{1F466}") # U+1F466 is boy "👦"
-    assert_line("\u{1F468 200D 1F469 200D 1F467 200D 1F466}")
-    assert_byte_pointer_size("\u{1F468 200D 1F469 200D 1F467 200D 1F466}")
-    assert_cursor(2)
-    assert_cursor_max(2)
+    assert_line_around_cursor('👨‍👩‍👧‍👦', '')
     # U+1F468 U+200D U+1F469 U+200D U+1F467 U+200D U+1F466 is family: man, woman, girl, boy "👨‍👩‍👧‍👦"
     input_keys("\u{1F468 200D 1F469 200D 1F467 200D 1F466}")
-    assert_line("\u{1F468 200D 1F469 200D 1F467 200D 1F466 1F468 200D 1F469 200D 1F467 200D 1F466}")
-    assert_byte_pointer_size("\u{1F468 200D 1F469 200D 1F467 200D 1F466 1F468 200D 1F469 200D 1F467 200D 1F466}")
-    assert_cursor(4)
-    assert_cursor_max(4)
+    assert_line_around_cursor('👨‍👩‍👧‍👦👨‍👩‍👧‍👦', '')
   end
 
   def test_ed_insert_for_include_valiation_selector
     omit "This test is for UTF-8 but the locale is #{Reline.core.encoding}" if Reline.core.encoding != Encoding::UTF_8
     # U+0030 U+FE00 is DIGIT ZERO + VARIATION SELECTOR-1 "0︀"
     input_keys("\u0030") # U+0030 is DIGIT ZERO
-    assert_line("\u0030")
-    assert_byte_pointer_size("\u0030")
-    assert_cursor(1)
-    assert_cursor_max(1)
+    assert_line_around_cursor('0', '')
     input_keys("\uFE00") # U+FE00 is VARIATION SELECTOR-1
-    assert_line("\u{0030 FE00}")
-    assert_byte_pointer_size("\u{0030 FE00}")
-    assert_cursor(1)
-    assert_cursor_max(1)
+    assert_line_around_cursor('0︀', '')
   end
 
   def test_em_yank_pop
     input_keys("def hoge\C-w\C-b\C-f\C-w", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
-    assert_line('')
+    assert_line_around_cursor('', '')
     input_keys("\C-y", false)
-    assert_byte_pointer_size('def ')
-    assert_cursor(4)
-    assert_cursor_max(4)
-    assert_line('def ')
+    assert_line_around_cursor('def ', '')
     input_keys("\M-\C-y", false)
-    assert_byte_pointer_size('hoge')
-    assert_cursor(4)
-    assert_cursor_max(4)
-    assert_line('hoge')
+    assert_line_around_cursor('hoge', '')
   end
 
   def test_em_kill_region_with_kill_ring
     input_keys("def hoge\C-b\C-b\C-b\C-b", false)
-    assert_byte_pointer_size('def ')
-    assert_cursor(4)
-    assert_cursor_max(8)
-    assert_line('def hoge')
+    assert_line_around_cursor('def ', 'hoge')
     input_keys("\C-k\C-w", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
-    assert_line('')
+    assert_line_around_cursor('', '')
     input_keys("\C-y", false)
-    assert_byte_pointer_size('def hoge')
-    assert_cursor(8)
-    assert_cursor_max(8)
-    assert_line('def hoge')
+    assert_line_around_cursor('def hoge', '')
   end
 
   def test_ed_search_prev_next_history_in_multibyte
@@ -2276,104 +1376,133 @@ class Reline::KeyActor::Emacs::Test < Reline::TestCase
     assert_whole_lines(['def foo', '  12345', 'end'])
     assert_line_index(1)
     assert_whole_lines(['def foo', '  12345', 'end'])
-    assert_byte_pointer_size('  123')
-    assert_cursor(5)
-    assert_cursor_max(7)
-    assert_line('  12345')
+    assert_line_around_cursor('  123', '45')
     @line_editor.__send__(:ed_search_prev_history, "\C-p".ord)
     assert_line_index(2)
     assert_whole_lines(['def hoge', '  67890', '  12345', 'end'])
-    assert_byte_pointer_size('  123')
-    assert_cursor(5)
-    assert_cursor_max(7)
-    assert_line('  12345')
+    assert_line_around_cursor('  123', '45')
     @line_editor.__send__(:ed_search_prev_history, "\C-p".ord)
     assert_line_index(2)
     assert_whole_lines(['def hoge', '  67890', '  12345', 'end'])
-    assert_byte_pointer_size('  123')
-    assert_cursor(5)
-    assert_cursor_max(7)
-    assert_line('  12345')
+    assert_line_around_cursor('  123', '45')
     @line_editor.__send__(:ed_search_next_history, "\C-n".ord)
     assert_line_index(1)
     assert_whole_lines(['def foo', '  12345', 'end'])
-    assert_byte_pointer_size('  123')
-    assert_cursor(5)
-    assert_cursor_max(7)
-    assert_line('  12345')
+    assert_line_around_cursor('  123', '45')
     @line_editor.__send__(:ed_search_next_history, "\C-n".ord)
     assert_line_index(1)
     assert_whole_lines(['def foo', '  12345', 'end'])
-    assert_byte_pointer_size('  123')
-    assert_cursor(5)
-    assert_cursor_max(7)
-    assert_line('  12345')
+    assert_line_around_cursor('  123', '45')
   end
 
   def test_ignore_NUL_by_ed_quoted_insert
     input_keys(%Q{"\C-v\C-@"}, false)
-    assert_byte_pointer_size('""')
-    assert_cursor(2)
-    assert_cursor_max(2)
+    assert_line_around_cursor('""', '')
   end
 
   def test_ed_argument_digit_by_meta_num
     input_keys('abcdef')
-    assert_byte_pointer_size('abcdef')
-    assert_cursor(6)
-    assert_cursor_max(6)
-    assert_line('abcdef')
+    assert_line_around_cursor('abcdef', '')
     input_keys("\M-2", false)
     input_keys("\C-h", false)
-    assert_byte_pointer_size('abcd')
-    assert_cursor(4)
-    assert_cursor_max(4)
-    assert_line('abcd')
+    assert_line_around_cursor('abcd', '')
   end
 
   def test_halfwidth_kana_width_dakuten
     input_raw_keys('ｶﾞｷﾞｹﾞｺﾞ')
-    assert_byte_pointer_size('ｶﾞｷﾞｹﾞｺﾞ')
-    assert_cursor(8)
-    assert_cursor_max(8)
+    assert_line_around_cursor('ｶﾞｷﾞｹﾞｺﾞ', '')
     input_keys("\C-b\C-b", false)
-    assert_byte_pointer_size('ｶﾞｷﾞ')
-    assert_cursor(4)
-    assert_cursor_max(8)
+    assert_line_around_cursor('ｶﾞｷﾞ', 'ｹﾞｺﾞ')
     input_raw_keys('ｸﾞ', false)
-    assert_byte_pointer_size('ｶﾞｷﾞｸﾞ')
-    assert_cursor(6)
-    assert_cursor_max(10)
-    assert_line('ｶﾞｷﾞｸﾞｹﾞｺﾞ')
+    assert_line_around_cursor('ｶﾞｷﾞｸﾞ', 'ｹﾞｺﾞ')
   end
 
   def test_input_unknown_char
     input_keys('͸') # U+0378 (unassigned)
-    assert_line('͸')
-    assert_byte_pointer_size('͸')
-    assert_cursor(1)
-    assert_cursor_max(1)
+    assert_line_around_cursor('͸', '')
   end
 
   def test_unix_line_discard
     input_keys("\C-u", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
-    assert_line('')
+    assert_line_around_cursor('', '')
     input_keys('abc')
-    assert_byte_pointer_size('abc')
-    assert_cursor(3)
-    assert_cursor_max(3)
+    assert_line_around_cursor('abc', '')
     input_keys("\C-b\C-u", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(1)
-    assert_line('c')
+    assert_line_around_cursor('', 'c')
     input_keys("\C-f\C-u", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
-    assert_line('')
+    assert_line_around_cursor('', '')
+  end
+
+  def test_vi_editing_mode
+    @line_editor.__send__(:vi_editing_mode, nil)
+    assert(@config.editing_mode_is?(:vi_insert))
+  end
+
+  def test_undo
+    input_keys("\C-_", false)
+    assert_line_around_cursor('', '')
+    input_keys("aあb\C-h\C-h\C-h", false)
+    assert_line_around_cursor('', '')
+    input_keys("\C-_", false)
+    assert_line_around_cursor('a', '')
+    input_keys("\C-_", false)
+    assert_line_around_cursor('aあ', '')
+    input_keys("\C-_", false)
+    assert_line_around_cursor('aあb', '')
+    input_keys("\C-_", false)
+    assert_line_around_cursor('aあ', '')
+    input_keys("\C-_", false)
+    assert_line_around_cursor('a', '')
+    input_keys("\C-_", false)
+    assert_line_around_cursor('', '')
+  end
+
+  def test_undo_with_cursor_position
+    input_keys("abc\C-b\C-h", false)
+    assert_line_around_cursor('a', 'c')
+    input_keys("\C-_", false)
+    assert_line_around_cursor('ab', 'c')
+    input_keys("あいう\C-b\C-h", false)
+    assert_line_around_cursor('abあ', 'うc')
+    input_keys("\C-_", false)
+    assert_line_around_cursor('abあい', 'うc')
+  end
+
+  def test_undo_with_multiline
+    @line_editor.multiline_on
+    @line_editor.confirm_multiline_termination_proc = proc {}
+    input_keys("1\n2\n3", false)
+    assert_whole_lines(["1", "2", "3"])
+    assert_line_index(2)
+    assert_line_around_cursor('3', '')
+    input_keys("\C-p\C-h\C-h", false)
+    assert_whole_lines(["1", "3"])
+    assert_line_index(0)
+    assert_line_around_cursor('1', '')
+    input_keys("\C-_", false)
+    assert_whole_lines(["1", "", "3"])
+    assert_line_index(1)
+    assert_line_around_cursor('', '')
+    input_keys("\C-_", false)
+    assert_whole_lines(["1", "2", "3"])
+    assert_line_index(1)
+    assert_line_around_cursor('2', '')
+    input_keys("\C-_", false)
+    assert_whole_lines(["1", "2", ""])
+    assert_line_index(2)
+    assert_line_around_cursor('', '')
+    input_keys("\C-_", false)
+    assert_whole_lines(["1", "2"])
+    assert_line_index(1)
+    assert_line_around_cursor('2', '')
+  end
+
+  def test_undo_with_many_times
+    str = "a" + "b" * 100
+    input_keys(str, false)
+    100.times { input_keys("\C-_", false) }
+    assert_line_around_cursor('a', '')
+    input_keys("\C-_", false)
+    assert_line_around_cursor('a', '')
   end
 end
diff --git a/test/reline/test_key_actor_vi.rb b/test/reline/test_key_actor_vi.rb
index 20630e5809..4deae2dd83 100644
--- a/test/reline/test_key_actor_vi.rb
+++ b/test/reline/test_key_actor_vi.rb
@@ -25,950 +25,513 @@ class Reline::KeyActor::ViInsert::Test < Reline::TestCase
   def test_vi_command_mode_with_input
     input_keys("abc\C-[")
     assert_instance_of(Reline::KeyActor::ViCommand, @config.editing_mode)
-    assert_line('abc')
+    assert_line_around_cursor('ab', 'c')
   end
 
   def test_vi_insert
     assert_instance_of(Reline::KeyActor::ViInsert, @config.editing_mode)
     input_keys('i')
-    assert_line('i')
-    assert_cursor(1)
+    assert_line_around_cursor('i', '')
     assert_instance_of(Reline::KeyActor::ViInsert, @config.editing_mode)
     input_keys("\C-[")
-    assert_line('i')
-    assert_cursor(0)
+    assert_line_around_cursor('', 'i')
     assert_instance_of(Reline::KeyActor::ViCommand, @config.editing_mode)
     input_keys('i')
-    assert_line('i')
-    assert_cursor(0)
+    assert_line_around_cursor('', 'i')
     assert_instance_of(Reline::KeyActor::ViInsert, @config.editing_mode)
   end
 
   def test_vi_add
     assert_instance_of(Reline::KeyActor::ViInsert, @config.editing_mode)
     input_keys('a')
-    assert_line('a')
-    assert_cursor(1)
+    assert_line_around_cursor('a', '')
     assert_instance_of(Reline::KeyActor::ViInsert, @config.editing_mode)
     input_keys("\C-[")
-    assert_line('a')
-    assert_cursor(0)
+    assert_line_around_cursor('', 'a')
     assert_instance_of(Reline::KeyActor::ViCommand, @config.editing_mode)
     input_keys('a')
-    assert_line('a')
-    assert_cursor(1)
+    assert_line_around_cursor('a', '')
     assert_instance_of(Reline::KeyActor::ViInsert, @config.editing_mode)
   end
 
   def test_vi_insert_at_bol
     input_keys('I')
-    assert_line('I')
+    assert_line_around_cursor('I', '')
     assert_instance_of(Reline::KeyActor::ViInsert, @config.editing_mode)
     input_keys("12345\C-[hh")
-    assert_line('I12345')
-    assert_byte_pointer_size('I12')
-    assert_cursor(3)
-    assert_cursor_max(6)
+    assert_line_around_cursor('I12', '345')
     assert_instance_of(Reline::KeyActor::ViCommand, @config.editing_mode)
     input_keys('I')
-    assert_line('I12345')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(6)
+    assert_line_around_cursor('', 'I12345')
     assert_instance_of(Reline::KeyActor::ViInsert, @config.editing_mode)
   end
 
   def test_vi_add_at_eol
     input_keys('A')
-    assert_line('A')
+    assert_line_around_cursor('A', '')
     assert_instance_of(Reline::KeyActor::ViInsert, @config.editing_mode)
     input_keys("12345\C-[hh")
-    assert_line('A12345')
-    assert_byte_pointer_size('A12')
-    assert_cursor(3)
-    assert_cursor_max(6)
+    assert_line_around_cursor('A12', '345')
     assert_instance_of(Reline::KeyActor::ViCommand, @config.editing_mode)
     input_keys('A')
-    assert_line('A12345')
-    assert_byte_pointer_size('A12345')
-    assert_cursor(6)
-    assert_cursor_max(6)
+    assert_line_around_cursor('A12345', '')
     assert_instance_of(Reline::KeyActor::ViInsert, @config.editing_mode)
   end
 
   def test_ed_insert_one
     input_keys('a')
-    assert_line('a')
-    assert_byte_pointer_size('a')
-    assert_cursor(1)
-    assert_cursor_max(1)
+    assert_line_around_cursor('a', '')
   end
 
   def test_ed_insert_two
     input_keys('ab')
-    assert_line('ab')
-    assert_byte_pointer_size('ab')
-    assert_cursor(2)
-    assert_cursor_max(2)
+    assert_line_around_cursor('ab', '')
   end
 
   def test_ed_insert_mbchar_one
     input_keys('か')
-    assert_line('か')
-    assert_byte_pointer_size('か')
-    assert_cursor(2)
-    assert_cursor_max(2)
+    assert_line_around_cursor('か', '')
   end
 
   def test_ed_insert_mbchar_two
     input_keys('かき')
-    assert_line('かき')
-    assert_byte_pointer_size('かき')
-    assert_cursor(4)
-    assert_cursor_max(4)
+    assert_line_around_cursor('かき', '')
   end
 
   def test_ed_insert_for_mbchar_by_plural_code_points
     input_keys("か\u3099")
-    assert_line("か\u3099")
-    assert_byte_pointer_size("か\u3099")
-    assert_cursor(2)
-    assert_cursor_max(2)
+    assert_line_around_cursor("か\u3099", '')
   end
 
   def test_ed_insert_for_plural_mbchar_by_plural_code_points
     input_keys("か\u3099き\u3099")
-    assert_line("か\u3099き\u3099")
-    assert_byte_pointer_size("か\u3099き\u3099")
-    assert_cursor(4)
-    assert_cursor_max(4)
+    assert_line_around_cursor("か\u3099き\u3099", '')
   end
 
   def test_ed_next_char
     input_keys("abcdef\C-[0")
-    assert_line('abcdef')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(6)
+    assert_line_around_cursor('', 'abcdef')
     input_keys('l')
-    assert_line('abcdef')
-    assert_byte_pointer_size('a')
-    assert_cursor(1)
-    assert_cursor_max(6)
+    assert_line_around_cursor('a', 'bcdef')
     input_keys('2l')
-    assert_line('abcdef')
-    assert_byte_pointer_size('abc')
-    assert_cursor(3)
-    assert_cursor_max(6)
+    assert_line_around_cursor('abc', 'def')
   end
 
   def test_ed_prev_char
     input_keys("abcdef\C-[")
-    assert_line('abcdef')
-    assert_byte_pointer_size('abcde')
-    assert_cursor(5)
-    assert_cursor_max(6)
+    assert_line_around_cursor('abcde', 'f')
     input_keys('h')
-    assert_line('abcdef')
-    assert_byte_pointer_size('abcd')
-    assert_cursor(4)
-    assert_cursor_max(6)
+    assert_line_around_cursor('abcd', 'ef')
     input_keys('2h')
-    assert_line('abcdef')
-    assert_byte_pointer_size('ab')
-    assert_cursor(2)
-    assert_cursor_max(6)
+    assert_line_around_cursor('ab', 'cdef')
   end
 
   def test_history
     Reline::HISTORY.concat(%w{abc 123 AAA})
     input_keys("\C-[")
-    assert_line('')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
+    assert_line_around_cursor('', '')
     input_keys('k')
-    assert_line('AAA')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(3)
+    assert_line_around_cursor('', 'AAA')
     input_keys('2k')
-    assert_line('abc')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(3)
+    assert_line_around_cursor('', 'abc')
     input_keys('j')
-    assert_line('123')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(3)
+    assert_line_around_cursor('', '123')
     input_keys('2j')
-    assert_line('')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
+    assert_line_around_cursor('', '')
   end
 
   def test_vi_paste_prev
     input_keys("abcde\C-[3h")
-    assert_line('abcde')
-    assert_byte_pointer_size('a')
-    assert_cursor(1)
-    assert_cursor_max(5)
+    assert_line_around_cursor('a', 'bcde')
     input_keys('P')
-    assert_line('abcde')
-    assert_byte_pointer_size('a')
-    assert_cursor(1)
-    assert_cursor_max(5)
+    assert_line_around_cursor('a', 'bcde')
     input_keys('d$')
-    assert_line('a')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(1)
+    assert_line_around_cursor('', 'a')
     input_keys('P')
-    assert_line('bcdea')
-    assert_byte_pointer_size('bcd')
-    assert_cursor(3)
-    assert_cursor_max(5)
+    assert_line_around_cursor('bcd', 'ea')
     input_keys('2P')
-    assert_line('bcdbcdbcdeeea')
-    assert_byte_pointer_size('bcdbcdbcd')
-    assert_cursor(9)
-    assert_cursor_max(13)
+    assert_line_around_cursor('bcdbcdbcd', 'eeea')
   end
 
   def test_vi_paste_next
     input_keys("abcde\C-[3h")
-    assert_line('abcde')
-    assert_byte_pointer_size('a')
-    assert_cursor(1)
-    assert_cursor_max(5)
+    assert_line_around_cursor('a', 'bcde')
     input_keys('p')
-    assert_line('abcde')
-    assert_byte_pointer_size('a')
-    assert_cursor(1)
-    assert_cursor_max(5)
+    assert_line_around_cursor('a', 'bcde')
     input_keys('d$')
-    assert_line('a')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(1)
+    assert_line_around_cursor('', 'a')
     input_keys('p')
-    assert_line('abcde')
-    assert_byte_pointer_size('abcd')
-    assert_cursor(4)
-    assert_cursor_max(5)
+    assert_line_around_cursor('abcd', 'e')
     input_keys('2p')
-    assert_line('abcdebcdebcde')
-    assert_byte_pointer_size('abcdebcdebcd')
-    assert_cursor(12)
-    assert_cursor_max(13)
+    assert_line_around_cursor('abcdebcdebcd', 'e')
   end
 
   def test_vi_paste_prev_for_mbchar
     input_keys("あいうえお\C-[3h")
-    assert_line('あいうえお')
-    assert_byte_pointer_size('あ')
-    assert_cursor(2)
-    assert_cursor_max(10)
+    assert_line_around_cursor('あ', 'いうえお')
     input_keys('P')
-    assert_line('あいうえお')
-    assert_byte_pointer_size('あ')
-    assert_cursor(2)
-    assert_cursor_max(10)
+    assert_line_around_cursor('あ', 'いうえお')
     input_keys('d$')
-    assert_line('あ')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(2)
+    assert_line_around_cursor('', 'あ')
     input_keys('P')
-    assert_line('いうえおあ')
-    assert_byte_pointer_size('いうえ')
-    assert_cursor(6)
-    assert_cursor_max(10)
+    assert_line_around_cursor('いうえ', 'おあ')
     input_keys('2P')
-    assert_line('いうえいうえいうえおおおあ')
-    assert_byte_pointer_size('いうえいうえいうえ')
-    assert_cursor(18)
-    assert_cursor_max(26)
+    assert_line_around_cursor('いうえいうえいうえ', 'おおおあ')
   end
 
   def test_vi_paste_next_for_mbchar
     input_keys("あいうえお\C-[3h")
-    assert_line('あいうえお')
-    assert_byte_pointer_size('あ')
-    assert_cursor(2)
-    assert_cursor_max(10)
+    assert_line_around_cursor('あ', 'いうえお')
     input_keys('p')
-    assert_line('あいうえお')
-    assert_byte_pointer_size('あ')
-    assert_cursor(2)
-    assert_cursor_max(10)
+    assert_line_around_cursor('あ', 'いうえお')
     input_keys('d$')
-    assert_line('あ')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(2)
+    assert_line_around_cursor('', 'あ')
     input_keys('p')
-    assert_line('あいうえお')
-    assert_byte_pointer_size('あいうえ')
-    assert_cursor(8)
-    assert_cursor_max(10)
+    assert_line_around_cursor('あいうえ', 'お')
     input_keys('2p')
-    assert_line('あいうえおいうえおいうえお')
-    assert_byte_pointer_size('あいうえおいうえおいうえ')
-    assert_cursor(24)
-    assert_cursor_max(26)
+    assert_line_around_cursor('あいうえおいうえおいうえ', 'お')
   end
 
   def test_vi_paste_prev_for_mbchar_by_plural_code_points
     input_keys("か\u3099き\u3099く\u3099け\u3099こ\u3099\C-[3h")
-    assert_line("か\u3099き\u3099く\u3099け\u3099こ\u3099")
-    assert_byte_pointer_size("か\u3099")
-    assert_cursor(2)
-    assert_cursor_max(10)
+    assert_line_around_cursor("か\u3099", "き\u3099く\u3099け\u3099こ\u3099")
     input_keys('P')
-    assert_line("か\u3099き\u3099く\u3099け\u3099こ\u3099")
-    assert_byte_pointer_size("か\u3099")
-    assert_cursor(2)
-    assert_cursor_max(10)
+    assert_line_around_cursor("か\u3099", "き\u3099く\u3099け\u3099こ\u3099")
     input_keys('d$')
-    assert_line("か\u3099")
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(2)
+    assert_line_around_cursor('', "か\u3099")
     input_keys('P')
-    assert_line("き\u3099く\u3099け\u3099こ\u3099か\u3099")
-    assert_byte_pointer_size("き\u3099く\u3099け\u3099")
-    assert_cursor(6)
-    assert_cursor_max(10)
+    assert_line_around_cursor("き\u3099く\u3099け\u3099", "こ\u3099か\u3099")
     input_keys('2P')
-    assert_line("き\u3099く\u3099け\u3099き\u3099く\u3099け\u3099き\u3099く\u3099け\u3099こ\u3099こ\u3099こ\u3099か\u3099")
-    assert_byte_pointer_size("き\u3099く\u3099け\u3099き\u3099く\u3099け\u3099き\u3099く\u3099け\u3099")
-    assert_cursor(18)
-    assert_cursor_max(26)
+    assert_line_around_cursor("き\u3099く\u3099け\u3099き\u3099く\u3099け\u3099き\u3099く\u3099け\u3099", "こ\u3099こ\u3099こ\u3099か\u3099")
   end
 
   def test_vi_paste_next_for_mbchar_by_plural_code_points
     input_keys("か\u3099き\u3099く\u3099け\u3099こ\u3099\C-[3h")
-    assert_line("か\u3099き\u3099く\u3099け\u3099こ\u3099")
-    assert_byte_pointer_size("か\u3099")
-    assert_cursor(2)
-    assert_cursor_max(10)
+    assert_line_around_cursor("か\u3099", "き\u3099く\u3099け\u3099こ\u3099")
     input_keys('p')
-    assert_line("か\u3099き\u3099く\u3099け\u3099こ\u3099")
-    assert_byte_pointer_size("か\u3099")
-    assert_cursor(2)
-    assert_cursor_max(10)
+    assert_line_around_cursor("か\u3099", "き\u3099く\u3099け\u3099こ\u3099")
     input_keys('d$')
-    assert_line("か\u3099")
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(2)
+    assert_line_around_cursor('', "か\u3099")
     input_keys('p')
-    assert_line("か\u3099き\u3099く\u3099け\u3099こ\u3099")
-    assert_byte_pointer_size("か\u3099き\u3099く\u3099け\u3099")
-    assert_cursor(8)
-    assert_cursor_max(10)
+    assert_line_around_cursor("か\u3099き\u3099く\u3099け\u3099", "こ\u3099")
     input_keys('2p')
-    assert_line("か\u3099き\u3099く\u3099け\u3099こ\u3099き\u3099く\u3099け\u3099こ\u3099き\u3099く\u3099け\u3099こ\u3099")
-    assert_byte_pointer_size("か\u3099き\u3099く\u3099け\u3099こ\u3099き\u3099く\u3099け\u3099こ\u3099き\u3099く\u3099け\u3099")
-    assert_cursor(24)
-    assert_cursor_max(26)
+    assert_line_around_cursor("か\u3099き\u3099く\u3099け\u3099こ\u3099き\u3099く\u3099け\u3099こ\u3099き\u3099く\u3099け\u3099", "こ\u3099")
   end
 
   def test_vi_prev_next_word
     input_keys("aaa b{b}b ccc\C-[0")
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(13)
+    assert_line_around_cursor('', 'aaa b{b}b ccc')
     input_keys('w')
-    assert_byte_pointer_size('aaa ')
-    assert_cursor(4)
-    assert_cursor_max(13)
+    assert_line_around_cursor('aaa ', 'b{b}b ccc')
     input_keys('w')
-    assert_byte_pointer_size('aaa b')
-    assert_cursor(5)
-    assert_cursor_max(13)
+    assert_line_around_cursor('aaa b', '{b}b ccc')
     input_keys('w')
-    assert_byte_pointer_size('aaa b{')
-    assert_cursor(6)
-    assert_cursor_max(13)
+    assert_line_around_cursor('aaa b{', 'b}b ccc')
     input_keys('w')
-    assert_byte_pointer_size('aaa b{b')
-    assert_cursor(7)
-    assert_cursor_max(13)
+    assert_line_around_cursor('aaa b{b', '}b ccc')
     input_keys('w')
-    assert_byte_pointer_size('aaa b{b}')
-    assert_cursor(8)
-    assert_cursor_max(13)
+    assert_line_around_cursor('aaa b{b}', 'b ccc')
     input_keys('w')
-    assert_byte_pointer_size('aaa b{b}b ')
-    assert_cursor(10)
-    assert_cursor_max(13)
+    assert_line_around_cursor('aaa b{b}b ', 'ccc')
     input_keys('w')
-    assert_byte_pointer_size('aaa b{b}b cc')
-    assert_cursor(12)
-    assert_cursor_max(13)
+    assert_line_around_cursor('aaa b{b}b cc', 'c')
     input_keys('b')
-    assert_byte_pointer_size('aaa b{b}b ')
-    assert_cursor(10)
-    assert_cursor_max(13)
+    assert_line_around_cursor('aaa b{b}b ', 'ccc')
     input_keys('b')
-    assert_byte_pointer_size('aaa b{b}')
-    assert_cursor(8)
-    assert_cursor_max(13)
+    assert_line_around_cursor('aaa b{b}', 'b ccc')
     input_keys('b')
-    assert_byte_pointer_size('aaa b{b')
-    assert_cursor(7)
-    assert_cursor_max(13)
+    assert_line_around_cursor('aaa b{b', '}b ccc')
     input_keys('b')
-    assert_byte_pointer_size('aaa b{')
-    assert_cursor(6)
-    assert_cursor_max(13)
+    assert_line_around_cursor('aaa b{', 'b}b ccc')
     input_keys('b')
-    assert_byte_pointer_size('aaa b')
-    assert_cursor(5)
-    assert_cursor_max(13)
+    assert_line_around_cursor('aaa b', '{b}b ccc')
     input_keys('b')
-    assert_byte_pointer_size('aaa ')
-    assert_cursor(4)
-    assert_cursor_max(13)
+    assert_line_around_cursor('aaa ', 'b{b}b ccc')
     input_keys('b')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(13)
+    assert_line_around_cursor('', 'aaa b{b}b ccc')
     input_keys('3w')
-    assert_byte_pointer_size('aaa b{')
-    assert_cursor(6)
-    assert_cursor_max(13)
+    assert_line_around_cursor('aaa b{', 'b}b ccc')
     input_keys('3w')
-    assert_byte_pointer_size('aaa b{b}b ')
-    assert_cursor(10)
-    assert_cursor_max(13)
+    assert_line_around_cursor('aaa b{b}b ', 'ccc')
     input_keys('3w')
-    assert_byte_pointer_size('aaa b{b}b cc')
-    assert_cursor(12)
-    assert_cursor_max(13)
+    assert_line_around_cursor('aaa b{b}b cc', 'c')
     input_keys('3b')
-    assert_byte_pointer_size('aaa b{b')
-    assert_cursor(7)
-    assert_cursor_max(13)
+    assert_line_around_cursor('aaa b{b', '}b ccc')
     input_keys('3b')
-    assert_byte_pointer_size('aaa ')
-    assert_cursor(4)
-    assert_cursor_max(13)
+    assert_line_around_cursor('aaa ', 'b{b}b ccc')
     input_keys('3b')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(13)
+    assert_line_around_cursor('', 'aaa b{b}b ccc')
   end
 
   def test_vi_end_word
     input_keys("aaa   b{b}}}b   ccc\C-[0")
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(19)
+    assert_line_around_cursor('', 'aaa   b{b}}}b   ccc')
     input_keys('e')
-    assert_byte_pointer_size('aa')
-    assert_cursor(2)
-    assert_cursor_max(19)
+    assert_line_around_cursor('aa', 'a   b{b}}}b   ccc')
     input_keys('e')
-    assert_byte_pointer_size('aaa   ')
-    assert_cursor(6)
-    assert_cursor_max(19)
+    assert_line_around_cursor('aaa   ', 'b{b}}}b   ccc')
     input_keys('e')
-    assert_byte_pointer_size('aaa   b')
-    assert_cursor(7)
-    assert_cursor_max(19)
+    assert_line_around_cursor('aaa   b', '{b}}}b   ccc')
     input_keys('e')
-    assert_byte_pointer_size('aaa   b{')
-    assert_cursor(8)
-    assert_cursor_max(19)
+    assert_line_around_cursor('aaa   b{', 'b}}}b   ccc')
     input_keys('e')
-    assert_byte_pointer_size('aaa   b{b}}')
-    assert_cursor(11)
-    assert_cursor_max(19)
+    assert_line_around_cursor('aaa   b{b}}', '}b   ccc')
     input_keys('e')
-    assert_byte_pointer_size('aaa   b{b}}}')
-    assert_cursor(12)
-    assert_cursor_max(19)
+    assert_line_around_cursor('aaa   b{b}}}', 'b   ccc')
     input_keys('e')
-    assert_byte_pointer_size('aaa   b{b}}}b   cc')
-    assert_cursor(18)
-    assert_cursor_max(19)
+    assert_line_around_cursor('aaa   b{b}}}b   cc', 'c')
     input_keys('e')
-    assert_byte_pointer_size('aaa   b{b}}}b   cc')
-    assert_cursor(18)
-    assert_cursor_max(19)
+    assert_line_around_cursor('aaa   b{b}}}b   cc', 'c')
     input_keys('03e')
-    assert_byte_pointer_size('aaa   b')
-    assert_cursor(7)
-    assert_cursor_max(19)
+    assert_line_around_cursor('aaa   b', '{b}}}b   ccc')
     input_keys('3e')
-    assert_byte_pointer_size('aaa   b{b}}}')
-    assert_cursor(12)
-    assert_cursor_max(19)
+    assert_line_around_cursor('aaa   b{b}}}', 'b   ccc')
     input_keys('3e')
-    assert_byte_pointer_size('aaa   b{b}}}b   cc')
-    assert_cursor(18)
-    assert_cursor_max(19)
+    assert_line_around_cursor('aaa   b{b}}}b   cc', 'c')
   end
 
   def test_vi_prev_next_big_word
     input_keys("aaa b{b}b ccc\C-[0")
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(13)
+    assert_line_around_cursor('', 'aaa b{b}b ccc')
     input_keys('W')
-    assert_byte_pointer_size('aaa ')
-    assert_cursor(4)
-    assert_cursor_max(13)
+    assert_line_around_cursor('aaa ', 'b{b}b ccc')
     input_keys('W')
-    assert_byte_pointer_size('aaa b{b}b ')
-    assert_cursor(10)
-    assert_cursor_max(13)
+    assert_line_around_cursor('aaa b{b}b ', 'ccc')
     input_keys('W')
-    assert_byte_pointer_size('aaa b{b}b cc')
-    assert_cursor(12)
-    assert_cursor_max(13)
+    assert_line_around_cursor('aaa b{b}b cc', 'c')
     input_keys('B')
-    assert_byte_pointer_size('aaa b{b}b ')
-    assert_cursor(10)
-    assert_cursor_max(13)
+    assert_line_around_cursor('aaa b{b}b ', 'ccc')
     input_keys('B')
-    assert_byte_pointer_size('aaa ')
-    assert_cursor(4)
-    assert_cursor_max(13)
+    assert_line_around_cursor('aaa ', 'b{b}b ccc')
     input_keys('B')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(13)
+    assert_line_around_cursor('', 'aaa b{b}b ccc')
     input_keys('2W')
-    assert_byte_pointer_size('aaa b{b}b ')
-    assert_cursor(10)
-    assert_cursor_max(13)
+    assert_line_around_cursor('aaa b{b}b ', 'ccc')
     input_keys('2W')
-    assert_byte_pointer_size('aaa b{b}b cc')
-    assert_cursor(12)
-    assert_cursor_max(13)
+    assert_line_around_cursor('aaa b{b}b cc', 'c')
     input_keys('2B')
-    assert_byte_pointer_size('aaa ')
-    assert_cursor(4)
-    assert_cursor_max(13)
+    assert_line_around_cursor('aaa ', 'b{b}b ccc')
     input_keys('2B')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(13)
+    assert_line_around_cursor('', 'aaa b{b}b ccc')
   end
 
   def test_vi_end_big_word
     input_keys("aaa   b{b}}}b   ccc\C-[0")
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(19)
+    assert_line_around_cursor('', 'aaa   b{b}}}b   ccc')
     input_keys('E')
-    assert_byte_pointer_size('aa')
-    assert_cursor(2)
-    assert_cursor_max(19)
+    assert_line_around_cursor('aa', 'a   b{b}}}b   ccc')
     input_keys('E')
-    assert_byte_pointer_size('aaa   b{b}}}')
-    assert_cursor(12)
-    assert_cursor_max(19)
+    assert_line_around_cursor('aaa   b{b}}}', 'b   ccc')
     input_keys('E')
-    assert_byte_pointer_size('aaa   b{b}}}b   cc')
-    assert_cursor(18)
-    assert_cursor_max(19)
+    assert_line_around_cursor('aaa   b{b}}}b   cc', 'c')
     input_keys('E')
-    assert_byte_pointer_size('aaa   b{b}}}b   cc')
-    assert_cursor(18)
-    assert_cursor_max(19)
+    assert_line_around_cursor('aaa   b{b}}}b   cc', 'c')
   end
 
   def test_ed_quoted_insert
     input_keys("ab\C-v\C-acd")
-    assert_line("ab\C-acd")
-    assert_byte_pointer_size("ab\C-acd")
-    assert_cursor(6)
-    assert_cursor_max(6)
+    assert_line_around_cursor("ab\C-acd", '')
   end
 
   def test_ed_quoted_insert_with_vi_arg
     input_keys("ab\C-[3\C-v\C-aacd")
-    assert_line("a\C-a\C-a\C-abcd")
-    assert_byte_pointer_size("a\C-a\C-a\C-abcd")
-    assert_cursor(10)
-    assert_cursor_max(10)
+    assert_line_around_cursor("a\C-a\C-a\C-abcd", '')
   end
 
   def test_vi_replace_char
     input_keys("abcdef\C-[03l")
-    assert_line('abcdef')
-    assert_byte_pointer_size('abc')
-    assert_cursor(3)
-    assert_cursor_max(6)
+    assert_line_around_cursor('abc', 'def')
     input_keys('rz')
-    assert_line('abczef')
-    assert_byte_pointer_size('abc')
-    assert_cursor(3)
-    assert_cursor_max(6)
+    assert_line_around_cursor('abc', 'zef')
     input_keys('2rx')
-    assert_line('abcxxf')
-    assert_byte_pointer_size('abcxx')
-    assert_cursor(5)
-    assert_cursor_max(6)
+    assert_line_around_cursor('abcxx', 'f')
   end
 
   def test_vi_replace_char_with_mbchar
     input_keys("あいうえお\C-[0l")
-    assert_line('あいうえお')
-    assert_byte_pointer_size('あ')
-    assert_cursor(2)
-    assert_cursor_max(10)
+    assert_line_around_cursor('あ', 'いうえお')
     input_keys('rx')
-    assert_line('あxうえお')
-    assert_byte_pointer_size('あ')
-    assert_cursor(2)
-    assert_cursor_max(9)
+    assert_line_around_cursor('あ', 'xうえお')
     input_keys('l2ry')
-    assert_line('あxyyお')
-    assert_byte_pointer_size('あxyy')
-    assert_cursor(5)
-    assert_cursor_max(7)
+    assert_line_around_cursor('あxyy', 'お')
   end
 
   def test_vi_next_char
     input_keys("abcdef\C-[0")
-    assert_line('abcdef')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(6)
+    assert_line_around_cursor('', 'abcdef')
     input_keys('fz')
-    assert_line('abcdef')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(6)
+    assert_line_around_cursor('', 'abcdef')
     input_keys('fe')
-    assert_line('abcdef')
-    assert_byte_pointer_size('abcd')
-    assert_cursor(4)
-    assert_cursor_max(6)
+    assert_line_around_cursor('abcd', 'ef')
   end
 
   def test_vi_to_next_char
     input_keys("abcdef\C-[0")
-    assert_line('abcdef')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(6)
+    assert_line_around_cursor('', 'abcdef')
     input_keys('tz')
-    assert_line('abcdef')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(6)
+    assert_line_around_cursor('', 'abcdef')
     input_keys('te')
-    assert_line('abcdef')
-    assert_byte_pointer_size('abc')
-    assert_cursor(3)
-    assert_cursor_max(6)
+    assert_line_around_cursor('abc', 'def')
   end
 
   def test_vi_prev_char
     input_keys("abcdef\C-[")
-    assert_line('abcdef')
-    assert_byte_pointer_size('abcde')
-    assert_cursor(5)
-    assert_cursor_max(6)
+    assert_line_around_cursor('abcde', 'f')
     input_keys('Fz')
-    assert_line('abcdef')
-    assert_byte_pointer_size('abcde')
-    assert_cursor(5)
-    assert_cursor_max(6)
+    assert_line_around_cursor('abcde', 'f')
     input_keys('Fa')
-    assert_line('abcdef')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(6)
+    assert_line_around_cursor('', 'abcdef')
   end
 
   def test_vi_to_prev_char
     input_keys("abcdef\C-[")
-    assert_line('abcdef')
-    assert_byte_pointer_size('abcde')
-    assert_cursor(5)
-    assert_cursor_max(6)
+    assert_line_around_cursor('abcde', 'f')
     input_keys('Tz')
-    assert_line('abcdef')
-    assert_byte_pointer_size('abcde')
-    assert_cursor(5)
-    assert_cursor_max(6)
+    assert_line_around_cursor('abcde', 'f')
     input_keys('Ta')
-    assert_line('abcdef')
-    assert_byte_pointer_size('a')
-    assert_cursor(1)
-    assert_cursor_max(6)
+    assert_line_around_cursor('a', 'bcdef')
   end
 
   def test_vi_delete_next_char
     input_keys("abc\C-[h")
-    assert_byte_pointer_size('a')
-    assert_cursor(1)
-    assert_cursor_max(3)
-    assert_line('abc')
+    assert_line_around_cursor('a', 'bc')
     input_keys('x')
-    assert_byte_pointer_size('a')
-    assert_cursor(1)
-    assert_cursor_max(2)
-    assert_line('ac')
+    assert_line_around_cursor('a', 'c')
     input_keys('x')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(1)
-    assert_line('a')
+    assert_line_around_cursor('', 'a')
     input_keys('x')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
-    assert_line('')
+    assert_line_around_cursor('', '')
     input_keys('x')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
-    assert_line('')
+    assert_line_around_cursor('', '')
   end
 
   def test_vi_delete_next_char_for_mbchar
     input_keys("あいう\C-[h")
-    assert_byte_pointer_size('あ')
-    assert_cursor(2)
-    assert_cursor_max(6)
-    assert_line('あいう')
+    assert_line_around_cursor('あ', 'いう')
     input_keys('x')
-    assert_byte_pointer_size('あ')
-    assert_cursor(2)
-    assert_cursor_max(4)
-    assert_line('あう')
+    assert_line_around_cursor('あ', 'う')
     input_keys('x')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(2)
-    assert_line('あ')
+    assert_line_around_cursor('', 'あ')
     input_keys('x')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
-    assert_line('')
+    assert_line_around_cursor('', '')
     input_keys('x')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
-    assert_line('')
+    assert_line_around_cursor('', '')
   end
 
   def test_vi_delete_next_char_for_mbchar_by_plural_code_points
     input_keys("か\u3099き\u3099く\u3099\C-[h")
-    assert_byte_pointer_size("か\u3099")
-    assert_cursor(2)
-    assert_cursor_max(6)
-    assert_line("か\u3099き\u3099く\u3099")
+    assert_line_around_cursor("か\u3099", "き\u3099く\u3099")
     input_keys('x')
-    assert_byte_pointer_size("か\u3099")
-    assert_cursor(2)
-    assert_cursor_max(4)
-    assert_line("か\u3099く\u3099")
+    assert_line_around_cursor("か\u3099", "く\u3099")
     input_keys('x')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(2)
-    assert_line("か\u3099")
+    assert_line_around_cursor('', "か\u3099")
     input_keys('x')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
-    assert_line('')
+    assert_line_around_cursor('', '')
     input_keys('x')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
-    assert_line('')
+    assert_line_around_cursor('', '')
   end
 
   def test_vi_delete_prev_char
     input_keys('ab')
-    assert_byte_pointer_size('ab')
-    assert_cursor(2)
-    assert_cursor_max(2)
+    assert_line_around_cursor('ab', '')
     input_keys("\C-h")
-    assert_byte_pointer_size('a')
-    assert_cursor(1)
-    assert_cursor_max(1)
-    assert_line('a')
+    assert_line_around_cursor('a', '')
   end
 
   def test_vi_delete_prev_char_for_mbchar
     input_keys('かき')
-    assert_byte_pointer_size('かき')
-    assert_cursor(4)
-    assert_cursor_max(4)
+    assert_line_around_cursor('かき', '')
     input_keys("\C-h")
-    assert_byte_pointer_size('か')
-    assert_cursor(2)
-    assert_cursor_max(2)
-    assert_line('か')
+    assert_line_around_cursor('か', '')
   end
 
   def test_vi_delete_prev_char_for_mbchar_by_plural_code_points
     input_keys("か\u3099き\u3099")
-    assert_byte_pointer_size("か\u3099き\u3099")
-    assert_cursor(4)
-    assert_cursor_max(4)
+    assert_line_around_cursor("か\u3099き\u3099", '')
     input_keys("\C-h")
-    assert_byte_pointer_size("か\u3099")
-    assert_cursor(2)
-    assert_cursor_max(2)
-    assert_line("か\u3099")
+    assert_line_around_cursor("か\u3099", '')
   end
 
   def test_ed_delete_prev_char
     input_keys("abcdefg\C-[h")
-    assert_byte_pointer_size('abcde')
-    assert_cursor(5)
-    assert_cursor_max(7)
-    assert_line('abcdefg')
+    assert_line_around_cursor('abcde', 'fg')
     input_keys('X')
-    assert_byte_pointer_size('abcd')
-    assert_cursor(4)
-    assert_cursor_max(6)
-    assert_line('abcdfg')
+    assert_line_around_cursor('abcd', 'fg')
     input_keys('3X')
-    assert_byte_pointer_size('a')
-    assert_cursor(1)
-    assert_cursor_max(3)
-    assert_line('afg')
+    assert_line_around_cursor('a', 'fg')
     input_keys('p')
-    assert_byte_pointer_size('abcd')
-    assert_cursor(4)
-    assert_cursor_max(6)
-    assert_line('afbcdg')
+    assert_line_around_cursor('afbc', 'dg')
   end
 
   def test_ed_delete_prev_word
     input_keys('abc def{bbb}ccc')
-    assert_byte_pointer_size('abc def{bbb}ccc')
-    assert_cursor(15)
-    assert_cursor_max(15)
+    assert_line_around_cursor('abc def{bbb}ccc', '')
     input_keys("\C-w")
-    assert_byte_pointer_size('abc def{bbb}')
-    assert_cursor(12)
-    assert_cursor_max(12)
-    assert_line('abc def{bbb}')
+    assert_line_around_cursor('abc def{bbb}', '')
     input_keys("\C-w")
-    assert_byte_pointer_size('abc def{')
-    assert_cursor(8)
-    assert_cursor_max(8)
-    assert_line('abc def{')
+    assert_line_around_cursor('abc def{', '')
     input_keys("\C-w")
-    assert_byte_pointer_size('abc ')
-    assert_cursor(4)
-    assert_cursor_max(4)
-    assert_line('abc ')
+    assert_line_around_cursor('abc ', '')
     input_keys("\C-w")
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
-    assert_line('')
+    assert_line_around_cursor('', '')
   end
 
   def test_ed_delete_prev_word_for_mbchar
     input_keys('あいう かきく{さしす}たちつ')
-    assert_byte_pointer_size('あいう かきく{さしす}たちつ')
-    assert_cursor(27)
-    assert_cursor_max(27)
+    assert_line_around_cursor('あいう かきく{さしす}たちつ', '')
     input_keys("\C-w")
-    assert_byte_pointer_size('あいう かきく{さしす}')
-    assert_cursor(21)
-    assert_cursor_max(21)
-    assert_line('あいう かきく{さしす}')
+    assert_line_around_cursor('あいう かきく{さしす}', '')
     input_keys("\C-w")
-    assert_byte_pointer_size('あいう かきく{')
-    assert_cursor(14)
-    assert_cursor_max(14)
-    assert_line('あいう かきく{')
+    assert_line_around_cursor('あいう かきく{', '')
     input_keys("\C-w")
-    assert_byte_pointer_size('あいう ')
-    assert_cursor(7)
-    assert_cursor_max(7)
-    assert_line('あいう ')
+    assert_line_around_cursor('あいう ', '')
     input_keys("\C-w")
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
-    assert_line('')
+    assert_line_around_cursor('', '')
   end
 
   def test_ed_delete_prev_word_for_mbchar_by_plural_code_points
     input_keys("あいう か\u3099き\u3099く\u3099{さしす}たちつ")
-    assert_byte_pointer_size("あいう か\u3099き\u3099く\u3099{さしす}たちつ")
-    assert_cursor(27)
-    assert_cursor_max(27)
+    assert_line_around_cursor("あいう か\u3099き\u3099く\u3099{さしす}たちつ", '')
     input_keys("\C-w")
-    assert_byte_pointer_size("あいう か\u3099き\u3099く\u3099{さしす}")
-    assert_cursor(21)
-    assert_cursor_max(21)
-    assert_line("あいう か\u3099き\u3099く\u3099{さしす}")
+    assert_line_around_cursor("あいう か\u3099き\u3099く\u3099{さしす}", '')
     input_keys("\C-w")
-    assert_byte_pointer_size("あいう か\u3099き\u3099く\u3099{")
-    assert_cursor(14)
-    assert_cursor_max(14)
-    assert_line("あいう か\u3099き\u3099く\u3099{")
+    assert_line_around_cursor("あいう か\u3099き\u3099く\u3099{", '')
     input_keys("\C-w")
-    assert_byte_pointer_size('あいう ')
-    assert_cursor(7)
-    assert_cursor_max(7)
-    assert_line('あいう ')
+    assert_line_around_cursor('あいう ', '')
     input_keys("\C-w")
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
-    assert_line('')
+    assert_line_around_cursor('', '')
   end
 
   def test_ed_newline_with_cr
     input_keys('ab')
-    assert_byte_pointer_size('ab')
-    assert_cursor(2)
-    assert_cursor_max(2)
+    assert_line_around_cursor('ab', '')
     refute(@line_editor.finished?)
     input_keys("\C-m")
-    assert_line('ab')
+    assert_line_around_cursor('ab', '')
     assert(@line_editor.finished?)
   end
 
   def test_ed_newline_with_lf
     input_keys('ab')
-    assert_byte_pointer_size('ab')
-    assert_cursor(2)
-    assert_cursor_max(2)
+    assert_line_around_cursor('ab', '')
     refute(@line_editor.finished?)
     input_keys("\C-j")
-    assert_line('ab')
+    assert_line_around_cursor('ab', '')
     assert(@line_editor.finished?)
   end
 
   def test_vi_list_or_eof
     input_keys("\C-d") # quit from inputing
-    assert_line(nil)
+    assert_nil(@line_editor.line)
     assert(@line_editor.finished?)
   end
 
   def test_vi_list_or_eof_with_non_empty_line
     input_keys('ab')
-    assert_byte_pointer_size('ab')
-    assert_cursor(2)
-    assert_cursor_max(2)
+    assert_line_around_cursor('ab', '')
     refute(@line_editor.finished?)
     input_keys("\C-d")
-    assert_line('ab')
+    assert_line_around_cursor('ab', '')
     assert(@line_editor.finished?)
   end
 
@@ -982,40 +545,19 @@ class Reline::KeyActor::ViInsert::Test < Reline::TestCase
       }
     }
     input_keys('foo')
-    assert_byte_pointer_size('foo')
-    assert_cursor(3)
-    assert_cursor_max(3)
-    assert_line('foo')
+    assert_line_around_cursor('foo', '')
     input_keys("\C-n")
-    assert_byte_pointer_size('foo_bar')
-    assert_cursor(7)
-    assert_cursor_max(7)
-    assert_line('foo_bar')
+    assert_line_around_cursor('foo_bar', '')
     input_keys("\C-n")
-    assert_byte_pointer_size('foo_bar_baz')
-    assert_cursor(11)
-    assert_cursor_max(11)
-    assert_line('foo_bar_baz')
+    assert_line_around_cursor('foo_bar_baz', '')
     input_keys("\C-n")
-    assert_byte_pointer_size('foo')
-    assert_cursor(3)
-    assert_cursor_max(3)
-    assert_line('foo')
+    assert_line_around_cursor('foo', '')
     input_keys("\C-n")
-    assert_byte_pointer_size('foo_bar')
-    assert_cursor(7)
-    assert_cursor_max(7)
-    assert_line('foo_bar')
+    assert_line_around_cursor('foo_bar', '')
     input_keys("_\C-n")
-    assert_byte_pointer_size('foo_bar_baz')
-    assert_cursor(11)
-    assert_cursor_max(11)
-    assert_line('foo_bar_baz')
+    assert_line_around_cursor('foo_bar_baz', '')
     input_keys("\C-n")
-    assert_byte_pointer_size('foo_bar_')
-    assert_cursor(8)
-    assert_cursor_max(8)
-    assert_line('foo_bar_')
+    assert_line_around_cursor('foo_bar_', '')
   end
 
   def test_completion_journey_reverse
@@ -1028,40 +570,19 @@ class Reline::KeyActor::ViInsert::Test < Reline::TestCase
       }
     }
     input_keys('foo')
-    assert_byte_pointer_size('foo')
-    assert_cursor(3)
-    assert_cursor_max(3)
-    assert_line('foo')
+    assert_line_around_cursor('foo', '')
     input_keys("\C-p")
-    assert_byte_pointer_size('foo_bar_baz')
-    assert_cursor(11)
-    assert_cursor_max(11)
-    assert_line('foo_bar_baz')
+    assert_line_around_cursor('foo_bar_baz', '')
     input_keys("\C-p")
-    assert_byte_pointer_size('foo_bar')
-    assert_cursor(7)
-    assert_cursor_max(7)
-    assert_line('foo_bar')
+    assert_line_around_cursor('foo_bar', '')
     input_keys("\C-p")
-    assert_byte_pointer_size('foo')
-    assert_cursor(3)
-    assert_cursor_max(3)
-    assert_line('foo')
+    assert_line_around_cursor('foo', '')
     input_keys("\C-p")
-    assert_byte_pointer_size('foo_bar_baz')
-    assert_cursor(11)
-    assert_cursor_max(11)
-    assert_line('foo_bar_baz')
+    assert_line_around_cursor('foo_bar_baz', '')
     input_keys("\C-h\C-p")
-    assert_byte_pointer_size('foo_bar_baz')
-    assert_cursor(11)
-    assert_cursor_max(11)
-    assert_line('foo_bar_baz')
+    assert_line_around_cursor('foo_bar_baz', '')
     input_keys("\C-p")
-    assert_byte_pointer_size('foo_bar_ba')
-    assert_cursor(10)
-    assert_cursor_max(10)
-    assert_line('foo_bar_ba')
+    assert_line_around_cursor('foo_bar_ba', '')
   end
 
   def test_completion_journey_in_middle_of_line
@@ -1074,42 +595,21 @@ class Reline::KeyActor::ViInsert::Test < Reline::TestCase
       }
     }
     input_keys('abcde fo ABCDE')
-    assert_line('abcde fo ABCDE')
+    assert_line_around_cursor('abcde fo ABCDE', '')
     input_keys("\C-[" + 'h' * 5 + "i\C-n")
-    assert_byte_pointer_size('abcde foo_bar')
-    assert_cursor(13)
-    assert_cursor_max(19)
-    assert_line('abcde foo_bar ABCDE')
+    assert_line_around_cursor('abcde foo_bar', ' ABCDE')
     input_keys("\C-n")
-    assert_byte_pointer_size('abcde foo_bar_baz')
-    assert_cursor(17)
-    assert_cursor_max(23)
-    assert_line('abcde foo_bar_baz ABCDE')
+    assert_line_around_cursor('abcde foo_bar_baz', ' ABCDE')
     input_keys("\C-n")
-    assert_byte_pointer_size('abcde fo')
-    assert_cursor(8)
-    assert_cursor_max(14)
-    assert_line('abcde fo ABCDE')
+    assert_line_around_cursor('abcde fo', ' ABCDE')
     input_keys("\C-n")
-    assert_byte_pointer_size('abcde foo_bar')
-    assert_cursor(13)
-    assert_cursor_max(19)
-    assert_line('abcde foo_bar ABCDE')
+    assert_line_around_cursor('abcde foo_bar', ' ABCDE')
     input_keys("_\C-n")
-    assert_byte_pointer_size('abcde foo_bar_baz')
-    assert_cursor(17)
-    assert_cursor_max(23)
-    assert_line('abcde foo_bar_baz ABCDE')
+    assert_line_around_cursor('abcde foo_bar_baz', ' ABCDE')
     input_keys("\C-n")
-    assert_byte_pointer_size('abcde foo_bar_')
-    assert_cursor(14)
-    assert_cursor_max(20)
-    assert_line('abcde foo_bar_ ABCDE')
+    assert_line_around_cursor('abcde foo_bar_', ' ABCDE')
     input_keys("\C-n")
-    assert_byte_pointer_size('abcde foo_bar_baz')
-    assert_cursor(17)
-    assert_cursor_max(23)
-    assert_line('abcde foo_bar_baz ABCDE')
+    assert_line_around_cursor('abcde foo_bar_baz', ' ABCDE')
   end
 
   def test_completion
@@ -1122,15 +622,55 @@ class Reline::KeyActor::ViInsert::Test < Reline::TestCase
       }
     }
     input_keys('foo')
-    assert_byte_pointer_size('foo')
-    assert_cursor(3)
-    assert_cursor_max(3)
-    assert_line('foo')
+    assert_line_around_cursor('foo', '')
     input_keys("\C-i")
-    assert_byte_pointer_size('foo_bar')
-    assert_cursor(7)
-    assert_cursor_max(7)
-    assert_line('foo_bar')
+    assert_line_around_cursor('foo_bar', '')
+  end
+
+  def test_autocompletion_with_upward_navigation
+    @config.autocompletion = true
+    @line_editor.completion_proc = proc { |word|
+      %w{
+        Readline
+        Regexp
+        RegexpError
+      }.map { |i|
+        i.encode(@encoding)
+      }
+    }
+    input_keys('Re')
+    assert_line_around_cursor('Re', '')
+    input_keys("\C-i", false)
+    assert_line_around_cursor('Readline', '')
+    input_keys("\C-i", false)
+    assert_line_around_cursor('Regexp', '')
+    @line_editor.input_key(Reline::Key.new(:completion_journey_up, :completion_journey_up, false))
+    assert_line_around_cursor('Readline', '')
+  ensure
+    @config.autocompletion = false
+  end
+
+  def test_autocompletion_with_upward_navigation_and_menu_complete_backward
+    @config.autocompletion = true
+    @line_editor.completion_proc = proc { |word|
+      %w{
+        Readline
+        Regexp
+        RegexpError
+      }.map { |i|
+        i.encode(@encoding)
+      }
+    }
+    input_keys('Re')
+    assert_line_around_cursor('Re', '')
+    input_keys("\C-i", false)
+    assert_line_around_cursor('Readline', '')
+    input_keys("\C-i", false)
+    assert_line_around_cursor('Regexp', '')
+    @line_editor.input_key(Reline::Key.new(:menu_complete_backward, :menu_complete_backward, false))
+    assert_line_around_cursor('Readline', '')
+  ensure
+    @config.autocompletion = false
   end
 
   def test_completion_with_disable_completion
@@ -1144,315 +684,224 @@ class Reline::KeyActor::ViInsert::Test < Reline::TestCase
       }
     }
     input_keys('foo')
-    assert_byte_pointer_size('foo')
-    assert_cursor(3)
-    assert_cursor_max(3)
-    assert_line('foo')
+    assert_line_around_cursor('foo', '')
     input_keys("\C-i")
-    assert_byte_pointer_size('foo')
-    assert_cursor(3)
-    assert_cursor_max(3)
-    assert_line('foo')
+    assert_line_around_cursor('foo', '')
   end
 
   def test_vi_first_print
     input_keys("abcde\C-[^")
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(5)
+    assert_line_around_cursor('', 'abcde')
     input_keys("0\C-ki")
     input_keys(" abcde\C-[^")
-    assert_byte_pointer_size(' ')
-    assert_cursor(1)
-    assert_cursor_max(6)
+    assert_line_around_cursor(' ', 'abcde')
     input_keys("0\C-ki")
     input_keys("   abcde  ABCDE  \C-[^")
-    assert_byte_pointer_size('   ')
-    assert_cursor(3)
-    assert_cursor_max(17)
+    assert_line_around_cursor('   ', 'abcde  ABCDE  ')
   end
 
   def test_ed_move_to_beg
     input_keys("abcde\C-[0")
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(5)
+    assert_line_around_cursor('', 'abcde')
     input_keys("0\C-ki")
     input_keys(" abcde\C-[0")
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(6)
+    assert_line_around_cursor('', ' abcde')
     input_keys("0\C-ki")
     input_keys("   abcde  ABCDE  \C-[0")
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(17)
+    assert_line_around_cursor('', '   abcde  ABCDE  ')
+  end
+
+  def test_vi_to_column
+    input_keys("a一二三\C-[0")
+    input_keys('1|')
+    assert_line_around_cursor('', 'a一二三')
+    input_keys('2|')
+    assert_line_around_cursor('a', '一二三')
+    input_keys('3|')
+    assert_line_around_cursor('a', '一二三')
+    input_keys('4|')
+    assert_line_around_cursor('a一', '二三')
+    input_keys('9|')
+    assert_line_around_cursor('a一二', '三')
   end
 
   def test_vi_delete_meta
     input_keys("aaa bbb ccc ddd eee\C-[02w")
-    assert_byte_pointer_size('aaa bbb ')
-    assert_cursor(8)
-    assert_cursor_max(19)
-    assert_line('aaa bbb ccc ddd eee')
+    assert_line_around_cursor('aaa bbb ', 'ccc ddd eee')
     input_keys('dw')
-    assert_byte_pointer_size('aaa bbb ')
-    assert_cursor(8)
-    assert_cursor_max(15)
-    assert_line('aaa bbb ddd eee')
+    assert_line_around_cursor('aaa bbb ', 'ddd eee')
     input_keys('db')
-    assert_byte_pointer_size('aaa ')
-    assert_cursor(4)
-    assert_cursor_max(11)
-    assert_line('aaa ddd eee')
+    assert_line_around_cursor('aaa ', 'ddd eee')
   end
 
   def test_vi_delete_meta_with_vi_next_word_at_eol
     input_keys("foo bar\C-[0w")
-    assert_byte_pointer_size('foo ')
-    assert_cursor(4)
-    assert_cursor_max(7)
-    assert_line('foo bar')
+    assert_line_around_cursor('foo ', 'bar')
     input_keys('w')
-    assert_byte_pointer_size('foo ba')
-    assert_cursor(6)
-    assert_cursor_max(7)
-    assert_line('foo bar')
+    assert_line_around_cursor('foo ba', 'r')
     input_keys('0dw')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(3)
-    assert_line('bar')
+    assert_line_around_cursor('', 'bar')
     input_keys('dw')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
-    assert_line('')
+    assert_line_around_cursor('', '')
   end
 
   def test_vi_delete_meta_with_vi_next_char
     input_keys("aaa bbb ccc ___ ddd\C-[02w")
-    assert_byte_pointer_size('aaa bbb ')
-    assert_cursor(8)
-    assert_cursor_max(19)
-    assert_line('aaa bbb ccc ___ ddd')
+    assert_line_around_cursor('aaa bbb ', 'ccc ___ ddd')
     input_keys('df_')
-    assert_byte_pointer_size('aaa bbb ')
-    assert_cursor(8)
-    assert_cursor_max(14)
-    assert_line('aaa bbb __ ddd')
+    assert_line_around_cursor('aaa bbb ', '__ ddd')
   end
 
   def test_vi_delete_meta_with_arg
-    input_keys("aaa bbb ccc\C-[02w")
-    assert_byte_pointer_size('aaa bbb ')
-    assert_cursor(8)
-    assert_cursor_max(11)
-    assert_line('aaa bbb ccc')
+    input_keys("aaa bbb ccc ddd\C-[03w")
+    assert_line_around_cursor('aaa bbb ccc ', 'ddd')
     input_keys('2dl')
-    assert_byte_pointer_size('aaa bbb ')
-    assert_cursor(8)
-    assert_cursor_max(9)
-    assert_line('aaa bbb c')
+    assert_line_around_cursor('aaa bbb ccc ', 'd')
+    input_keys('d2h')
+    assert_line_around_cursor('aaa bbb cc', 'd')
+    input_keys('2d3h')
+    assert_line_around_cursor('aaa ', 'd')
+    input_keys('dd')
+    assert_line_around_cursor('', '')
   end
 
   def test_vi_change_meta
     input_keys("aaa bbb ccc ddd eee\C-[02w")
-    assert_byte_pointer_size('aaa bbb ')
-    assert_cursor(8)
-    assert_cursor_max(19)
-    assert_line('aaa bbb ccc ddd eee')
+    assert_line_around_cursor('aaa bbb ', 'ccc ddd eee')
     input_keys('cwaiueo')
-    assert_byte_pointer_size('aaa bbb aiueo')
-    assert_cursor(13)
-    assert_cursor_max(21)
-    assert_line('aaa bbb aiueo ddd eee')
+    assert_line_around_cursor('aaa bbb aiueo', ' ddd eee')
     input_keys("\C-[")
-    assert_byte_pointer_size('aaa bbb aiue')
-    assert_cursor(12)
-    assert_cursor_max(21)
-    assert_line('aaa bbb aiueo ddd eee')
+    assert_line_around_cursor('aaa bbb aiue', 'o ddd eee')
     input_keys('cb')
-    assert_byte_pointer_size('aaa bbb ')
-    assert_cursor(8)
-    assert_cursor_max(17)
-    assert_line('aaa bbb o ddd eee')
+    assert_line_around_cursor('aaa bbb ', 'o ddd eee')
   end
 
   def test_vi_change_meta_with_vi_next_word
     input_keys("foo  bar  baz\C-[0w")
-    assert_byte_pointer_size('foo  ')
-    assert_cursor(5)
-    assert_cursor_max(13)
-    assert_line('foo  bar  baz')
+    assert_line_around_cursor('foo  ', 'bar  baz')
     input_keys('cwhoge')
-    assert_byte_pointer_size('foo  hoge')
-    assert_cursor(9)
-    assert_cursor_max(14)
-    assert_line('foo  hoge  baz')
+    assert_line_around_cursor('foo  hoge', '  baz')
     input_keys("\C-[")
-    assert_byte_pointer_size('foo  hog')
-    assert_cursor(8)
-    assert_cursor_max(14)
-    assert_line('foo  hoge  baz')
+    assert_line_around_cursor('foo  hog', 'e  baz')
+  end
+
+  def test_vi_waiting_operator_with_waiting_proc
+    input_keys("foo foo foo foo foo\C-[0")
+    input_keys('2d3fo')
+    assert_line_around_cursor('', ' foo foo')
+    input_keys('fo')
+    assert_line_around_cursor(' f', 'oo foo')
+  end
+
+  def test_vi_waiting_operator_cancel
+    input_keys("aaa bbb ccc\C-[02w")
+    assert_line_around_cursor('aaa bbb ', 'ccc')
+    # dc dy should cancel delete_meta
+    input_keys('dch')
+    input_keys('dyh')
+    # cd cy should cancel change_meta
+    input_keys('cdh')
+    input_keys('cyh')
+    # yd yc should cancel yank_meta
+    # P should not paste yanked text because yank_meta is canceled
+    input_keys('ydhP')
+    input_keys('ychP')
+    assert_line_around_cursor('aa', 'a bbb ccc')
+  end
+
+  def test_cancel_waiting_with_symbol_key
+    input_keys("aaa bbb lll\C-[0")
+    assert_line_around_cursor('', 'aaa bbb lll')
+    # ed_next_char should move cursor right and cancel vi_next_char
+    input_keys('f')
+    input_key_by_symbol(:ed_next_char)
+    input_keys('l')
+    assert_line_around_cursor('aa', 'a bbb lll')
+    # ed_next_char should move cursor right and cancel delete_meta
+    input_keys('d')
+    input_key_by_symbol(:ed_next_char)
+    input_keys('l')
+    assert_line_around_cursor('aaa ', 'bbb lll')
   end
 
   def test_unimplemented_vi_command_should_be_no_op
     input_keys("abc\C-[h")
-    assert_byte_pointer_size('a')
-    assert_cursor(1)
-    assert_cursor_max(3)
-    assert_line('abc')
+    assert_line_around_cursor('a', 'bc')
     input_keys('@')
-    assert_byte_pointer_size('a')
-    assert_cursor(1)
-    assert_cursor_max(3)
-    assert_line('abc')
+    assert_line_around_cursor('a', 'bc')
   end
 
   def test_vi_yank
-    input_keys("foo bar\C-[0")
-    assert_line('foo bar')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(7)
+    input_keys("foo bar\C-[2h")
+    assert_line_around_cursor('foo ', 'bar')
     input_keys('y3l')
-    assert_line('foo bar')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(7)
+    assert_line_around_cursor('foo ', 'bar')
     input_keys('P')
-    assert_line('foofoo bar')
-    assert_byte_pointer_size('fo')
-    assert_cursor(2)
-    assert_cursor_max(10)
+    assert_line_around_cursor('foo ba', 'rbar')
+    input_keys('3h3yhP')
+    assert_line_around_cursor('foofo', 'o barbar')
+    input_keys('yyP')
+    assert_line_around_cursor('foofofoofoo barba', 'ro barbar')
   end
 
   def test_vi_end_word_with_operator
     input_keys("foo bar\C-[0")
-    assert_line('foo bar')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(7)
+    assert_line_around_cursor('', 'foo bar')
     input_keys('de')
-    assert_line(' bar')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(4)
+    assert_line_around_cursor('', ' bar')
     input_keys('de')
-    assert_line('')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
+    assert_line_around_cursor('', '')
     input_keys('de')
-    assert_line('')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
+    assert_line_around_cursor('', '')
   end
 
   def test_vi_end_big_word_with_operator
     input_keys("aaa   b{b}}}b\C-[0")
-    assert_line('aaa   b{b}}}b')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(13)
+    assert_line_around_cursor('', 'aaa   b{b}}}b')
     input_keys('dE')
-    assert_line('   b{b}}}b')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(10)
+    assert_line_around_cursor('', '   b{b}}}b')
     input_keys('dE')
-    assert_line('')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
+    assert_line_around_cursor('', '')
     input_keys('dE')
-    assert_line('')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
+    assert_line_around_cursor('', '')
   end
 
   def test_vi_next_char_with_operator
     input_keys("foo bar\C-[0")
-    assert_line('foo bar')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(7)
+    assert_line_around_cursor('', 'foo bar')
     input_keys('df ')
-    assert_line('bar')
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(3)
-  end
-
-  def test_pasting
-    start_pasting
-    input_keys('ab')
-    finish_pasting
-    input_keys('c')
-    assert_line('abc')
-    assert_byte_pointer_size('abc')
-    assert_cursor(3)
-    assert_cursor_max(3)
-  end
-
-  def test_pasting_fullwidth
-    start_pasting
-    input_keys('あ')
-    finish_pasting
-    input_keys('い')
-    assert_line('あい')
-    assert_byte_pointer_size('あい')
-    assert_cursor(4)
-    assert_cursor_max(4)
+    assert_line_around_cursor('', 'bar')
   end
 
   def test_ed_delete_next_char_at_eol
     input_keys('"あ"')
-    assert_line('"あ"')
-    assert_byte_pointer_size('"あ"')
-    assert_cursor(4)
-    assert_cursor_max(4)
+    assert_line_around_cursor('"あ"', '')
     input_keys("\C-[")
-    assert_line('"あ"')
-    assert_byte_pointer_size('"あ')
-    assert_cursor(3)
-    assert_cursor_max(4)
+    assert_line_around_cursor('"あ', '"')
     input_keys('xa"')
-    assert_line('"あ"')
-    assert_byte_pointer_size('"あ"')
-    assert_cursor(4)
-    assert_cursor_max(4)
+    assert_line_around_cursor('"あ"', '')
   end
 
   def test_vi_kill_line_prev
     input_keys("\C-u", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
-    assert_line('')
+    assert_line_around_cursor('', '')
     input_keys('abc')
-    assert_byte_pointer_size('abc')
-    assert_cursor(3)
-    assert_cursor_max(3)
+    assert_line_around_cursor('abc', '')
     input_keys("\C-u", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(0)
-    assert_line('')
+    assert_line_around_cursor('', '')
     input_keys('abc')
     input_keys("\C-[\C-u", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(1)
-    assert_line('c')
+    assert_line_around_cursor('', 'c')
     input_keys("\C-u", false)
-    assert_byte_pointer_size('')
-    assert_cursor(0)
-    assert_cursor_max(1)
-    assert_line('c')
+    assert_line_around_cursor('', 'c')
+  end
+
+  def test_vi_change_to_eol
+    input_keys("abcdef\C-[2hC")
+    assert_line_around_cursor('abc', '')
+    input_keys("\C-[0C")
+    assert_line_around_cursor('', '')
+    assert_instance_of(Reline::KeyActor::ViInsert, @config.editing_mode)
   end
 
   def test_vi_motion_operators
@@ -1462,4 +911,9 @@ class Reline::KeyActor::ViInsert::Test < Reline::TestCase
       input_keys("test = { foo: bar }\C-[BBBldt}b")
     end
   end
+
+  def test_emacs_editing_mode
+    @line_editor.__send__(:emacs_editing_mode, nil)
+    assert(@config.editing_mode_is?(:emacs))
+  end
 end
diff --git a/test/reline/test_line_editor.rb b/test/reline/test_line_editor.rb
index 8399e76e92..7a38ecd596 100644
--- a/test/reline/test_line_editor.rb
+++ b/test/reline/test_line_editor.rb
@@ -1,13 +1,185 @@
 require_relative 'helper'
 require 'reline/line_editor'
+require 'stringio'
 
-class Reline::LineEditor::Test < Reline::TestCase
-  def test_range_subtract
-    dummy_config = nil
-    editor = Reline::LineEditor.new(dummy_config, 'ascii-8bit')
-    base_ranges = [3...5, 4...10, 6...8, 12...15, 15...20]
-    subtract_ranges = [5...7, 8...9, 11...13, 17...18, 18...19]
-    expected_result = [3...5, 7...8, 9...10, 13...17, 19...20]
-    assert_equal expected_result, editor.send(:range_subtract, base_ranges, subtract_ranges)
+class Reline::LineEditor
+  class RenderLineDifferentialTest < Reline::TestCase
+    module TestIO
+      RESET_COLOR = "\e[0m"
+
+      def self.move_cursor_column(col)
+        @output << "[COL_#{col}]"
+      end
+
+      def self.erase_after_cursor
+        @output << '[ERASE]'
+      end
+    end
+
+    def setup
+      verbose, $VERBOSE = $VERBOSE, nil
+      @line_editor = Reline::LineEditor.new(nil, Encoding::UTF_8)
+      @original_iogate = Reline::IOGate
+      @output = StringIO.new
+      @line_editor.instance_variable_set(:@screen_size, [24, 80])
+      @line_editor.instance_variable_set(:@output, @output)
+      Reline.send(:remove_const, :IOGate)
+      Reline.const_set(:IOGate, TestIO)
+      Reline::IOGate.instance_variable_set(:@output, @output)
+    ensure
+      $VERBOSE = verbose
+    end
+
+    def assert_output(expected)
+      @output.reopen(+'')
+      yield
+      actual = @output.string
+      assert_equal(expected, actual.gsub("\e[0m", ''))
+    end
+
+    def teardown
+      Reline.send(:remove_const, :IOGate)
+      Reline.const_set(:IOGate, @original_iogate)
+    end
+
+    def test_line_increase_decrease
+      assert_output '[COL_0]bb' do
+        @line_editor.render_line_differential([[0, 1, 'a']], [[0, 2, 'bb']])
+      end
+
+      assert_output '[COL_0]b[COL_1][ERASE]' do
+        @line_editor.render_line_differential([[0, 2, 'aa']], [[0, 1, 'b']])
+      end
+    end
+
+    def test_dialog_appear_disappear
+      assert_output '[COL_3]dialog' do
+        @line_editor.render_line_differential([[0, 1, 'a']], [[0, 1, 'a'], [3, 6, 'dialog']])
+      end
+
+      assert_output '[COL_3]dialog' do
+        @line_editor.render_line_differential([[0, 10, 'a' * 10]], [[0, 10, 'a' * 10], [3, 6, 'dialog']])
+      end
+
+      assert_output '[COL_1][ERASE]' do
+        @line_editor.render_line_differential([[0, 1, 'a'], [3, 6, 'dialog']], [[0, 1, 'a']])
+      end
+
+      assert_output '[COL_3]aaaaaa' do
+        @line_editor.render_line_differential([[0, 10, 'a' * 10], [3, 6, 'dialog']], [[0, 10, 'a' * 10]])
+      end
+    end
+
+    def test_dialog_change
+      assert_output '[COL_3]DIALOG' do
+        @line_editor.render_line_differential([[0, 2, 'a'], [3, 6, 'dialog']], [[0, 2, 'a'], [3, 6, 'DIALOG']])
+      end
+
+      assert_output '[COL_3]DIALOG' do
+        @line_editor.render_line_differential([[0, 10, 'a' * 10], [3, 6, 'dialog']], [[0, 10, 'a' * 10], [3, 6, 'DIALOG']])
+      end
+    end
+
+    def test_update_under_dialog
+      assert_output '[COL_0]b[COL_1] ' do
+        @line_editor.render_line_differential([[0, 2, 'aa'], [4, 6, 'dialog']], [[0, 1, 'b'], [4, 6, 'dialog']])
+      end
+
+      assert_output '[COL_0]bbb[COL_9]b' do
+        @line_editor.render_line_differential([[0, 10, 'a' * 10], [3, 6, 'dialog']], [[0, 10, 'b' * 10], [3, 6, 'dialog']])
+      end
+
+      assert_output '[COL_0]b[COL_1]  [COL_9][ERASE]' do
+        @line_editor.render_line_differential([[0, 10, 'a' * 10], [3, 6, 'dialog']], [[0, 1, 'b'], [3, 6, 'dialog']])
+      end
+    end
+
+    def test_dialog_move
+      assert_output '[COL_3]dialog[COL_9][ERASE]' do
+        @line_editor.render_line_differential([[0, 1, 'a'], [4, 6, 'dialog']], [[0, 1, 'a'], [3, 6, 'dialog']])
+      end
+
+      assert_output '[COL_4] [COL_5]dialog' do
+        @line_editor.render_line_differential([[0, 1, 'a'], [4, 6, 'dialog']], [[0, 1, 'a'], [5, 6, 'dialog']])
+      end
+
+      assert_output '[COL_2]dialog[COL_8]a' do
+        @line_editor.render_line_differential([[0, 10, 'a' * 10], [3, 6, 'dialog']], [[0, 10, 'a' * 10], [2, 6, 'dialog']])
+      end
+
+      assert_output '[COL_2]a[COL_3]dialog' do
+        @line_editor.render_line_differential([[0, 10, 'a' * 10], [2, 6, 'dialog']], [[0, 10, 'a' * 10], [3, 6, 'dialog']])
+      end
+    end
+
+    def test_multibyte
+      base = [0, 12, '一二三一二三']
+      left = [0, 3, 'LLL']
+      right = [9, 3, 'RRR']
+      front = [3, 6, 'FFFFFF']
+      # 一 FFFFFF 三
+      # 一二三一二三
+      assert_output '[COL_2]二三一二' do
+        @line_editor.render_line_differential([base, front], [base, nil])
+      end
+
+      # LLLFFFFFF 三
+      # LLL 三一二三
+      assert_output '[COL_3] 三一二' do
+        @line_editor.render_line_differential([base, left, front], [base, left, nil])
+      end
+
+      # 一 FFFFFFRRR
+      # 一二三一 RRR
+      assert_output '[COL_2]二三一 ' do
+        @line_editor.render_line_differential([base, right, front], [base, right, nil])
+      end
+
+      # LLLFFFFFFRRR
+      # LLL 三一 RRR
+      assert_output '[COL_3] 三一 ' do
+        @line_editor.render_line_differential([base, left, right, front], [base, left, right, nil])
+      end
+    end
+
+    def test_complicated
+      state_a = [nil, [19, 7, 'bbbbbbb'], [15, 8, 'cccccccc'], [10, 5, 'ddddd'], [18, 4, 'eeee'], [1, 3, 'fff'], [17, 2, 'gg'], [7, 1, 'h']]
+      state_b = [[5, 9, 'aaaaaaaaa'], nil, [15, 8, 'cccccccc'], nil, [18, 4, 'EEEE'], [25, 4, 'ffff'], [17, 2, 'gg'], [2, 2, 'hh']]
+      # state_a: " fff   h  dddddccggeeecbbb"
+      # state_b: "  hh aaaaaaaaa ccggEEEc  ffff"
+
+      assert_output '[COL_1] [COL_2]hh[COL_5]aaaaaaaaa[COL_14] [COL_19]EEE[COL_23]  [COL_25]ffff' do
+        @line_editor.render_line_differential(state_a, state_b)
+      end
+
+      assert_output '[COL_1]fff[COL_5]  [COL_7]h[COL_8]  [COL_10]ddddd[COL_19]eee[COL_23]bbb[COL_26][ERASE]' do
+        @line_editor.render_line_differential(state_b, state_a)
+      end
+    end
+  end
+
+  def test_menu_info_format
+    list = %w[aa b c d e f g hhh i j k]
+    col3 = [
+      'aa   e    i',
+      'b    f    j',
+      'c    g    k',
+      'd    hhh'
+    ]
+    col2 = [
+      'aa   g',
+      'b    hhh',
+      'c    i',
+      'd    j',
+      'e    k',
+      'f'
+    ]
+    assert_equal(col3, Reline::LineEditor::MenuInfo.new(list).lines(19))
+    assert_equal(col3, Reline::LineEditor::MenuInfo.new(list).lines(15))
+    assert_equal(col2, Reline::LineEditor::MenuInfo.new(list).lines(14))
+    assert_equal(col2, Reline::LineEditor::MenuInfo.new(list).lines(10))
+    assert_equal(list, Reline::LineEditor::MenuInfo.new(list).lines(9))
+    assert_equal(list, Reline::LineEditor::MenuInfo.new(list).lines(0))
+    assert_equal([], Reline::LineEditor::MenuInfo.new([]).lines(10))
   end
 end
diff --git a/test/reline/test_macro.rb b/test/reline/test_macro.rb
index 3096930830..04aa6474b4 100644
--- a/test/reline/test_macro.rb
+++ b/test/reline/test_macro.rb
@@ -6,7 +6,6 @@ class Reline::MacroTest < Reline::TestCase
     @config = Reline::Config.new
     @encoding = Reline.core.encoding
     @line_editor = Reline::LineEditor.new(@config, @encoding)
-    @line_editor.instance_variable_set(:@screen_size, [24, 80])
     @output = @line_editor.output = File.open(IO::NULL, "w")
   end
 
diff --git a/test/reline/test_reline.rb b/test/reline/test_reline.rb
index 40c880c11f..a20a5c9f44 100644
--- a/test/reline/test_reline.rb
+++ b/test/reline/test_reline.rb
@@ -378,10 +378,28 @@ class Reline::Test < Reline::TestCase
     assert_equal("Reline::GeneralIO", out.chomp)
   end
 
+  def test_require_reline_should_not_trigger_winsize
+    pend if win?
+    lib = File.expand_path("../../lib", __dir__)
+    code = <<~RUBY
+      require "io/console"
+      def STDIN.tty?; true; end
+      def STDOUT.tty?; true; end
+      def STDIN.winsize; raise; end
+      require("reline") && p(Reline.core.io_gate)
+    RUBY
+    out = IO.popen([{}, Reline.test_rubybin, "-I#{lib}", "-e", code], &:read)
+    assert_equal("Reline::ANSI", out.chomp)
+  end
+
+  def win?
+    /mswin|mingw/.match?(RUBY_PLATFORM)
+  end
+
   def get_reline_encoding
     if encoding = Reline.core.encoding
       encoding
-    elsif RUBY_PLATFORM =~ /mswin|mingw/
+    elsif win?
       Encoding::UTF_8
     else
       Encoding::default_external
diff --git a/test/reline/test_string_processing.rb b/test/reline/test_string_processing.rb
index 2e5d27dc4f..c9b9e38643 100644
--- a/test/reline/test_string_processing.rb
+++ b/test/reline/test_string_processing.rb
@@ -30,10 +30,7 @@ class Reline::LineEditor::StringProcessingTest < Reline::TestCase
 
     @line_editor.instance_variable_set(:@is_multiline, true)
     @line_editor.instance_variable_set(:@buffer_of_lines, buf)
-    @line_editor.instance_variable_set(:@line, buf[1])
     @line_editor.instance_variable_set(:@byte_pointer, 3)
-    @line_editor.instance_variable_set(:@cursor, 3)
-    @line_editor.instance_variable_set(:@cursor_max, 11)
     @line_editor.instance_variable_set(:@line_index, 1)
     @line_editor.instance_variable_set(:@completion_proc, proc { |target|
       assert_equal('p', target)
@@ -42,10 +39,7 @@ class Reline::LineEditor::StringProcessingTest < Reline::TestCase
 
     @line_editor.instance_variable_set(:@is_multiline, true)
     @line_editor.instance_variable_set(:@buffer_of_lines, buf)
-    @line_editor.instance_variable_set(:@line, buf[1])
     @line_editor.instance_variable_set(:@byte_pointer, 6)
-    @line_editor.instance_variable_set(:@cursor, 6)
-    @line_editor.instance_variable_set(:@cursor_max, 11)
     @line_editor.instance_variable_set(:@line_index, 1)
     @line_editor.instance_variable_set(:@completion_proc, proc { |target, pre, post|
       assert_equal('puts', target)
@@ -54,10 +48,7 @@ class Reline::LineEditor::StringProcessingTest < Reline::TestCase
     })
     @line_editor.__send__(:call_completion_proc)
 
-    @line_editor.instance_variable_set(:@line, buf[0])
     @line_editor.instance_variable_set(:@byte_pointer, 6)
-    @line_editor.instance_variable_set(:@cursor, 6)
-    @line_editor.instance_variable_set(:@cursor_max, 8)
     @line_editor.instance_variable_set(:@line_index, 0)
     @line_editor.instance_variable_set(:@completion_proc, proc { |target, pre, post|
       assert_equal('ho', target)
@@ -66,10 +57,7 @@ class Reline::LineEditor::StringProcessingTest < Reline::TestCase
     })
     @line_editor.__send__(:call_completion_proc)
 
-    @line_editor.instance_variable_set(:@line, buf[2])
     @line_editor.instance_variable_set(:@byte_pointer, 1)
-    @line_editor.instance_variable_set(:@cursor, 1)
-    @line_editor.instance_variable_set(:@cursor_max, 3)
     @line_editor.instance_variable_set(:@line_index, 2)
     @line_editor.instance_variable_set(:@completion_proc, proc { |target, pre, post|
       assert_equal('e', target)
diff --git a/test/reline/test_terminfo.rb b/test/reline/test_terminfo.rb
index dda9b32495..4e59c54838 100644
--- a/test/reline/test_terminfo.rb
+++ b/test/reline/test_terminfo.rb
@@ -58,4 +58,4 @@ class Reline::Terminfo::Test < Reline::TestCase
     assert_raise(Reline::Terminfo::TerminfoError) { Reline::Terminfo.tigetnum('unknown') }
     assert_raise(Reline::Terminfo::TerminfoError) { Reline::Terminfo.tigetnum(nil) }
   end
-end if Reline::Terminfo.enabled?
+end if Reline::Terminfo.enabled? && Reline::Terminfo.term_supported?
diff --git a/test/reline/test_unicode.rb b/test/reline/test_unicode.rb
index 834f7114c4..deba4d4681 100644
--- a/test/reline/test_unicode.rb
+++ b/test/reline/test_unicode.rb
@@ -38,11 +38,16 @@ class Reline::Unicode::Test < Reline::TestCase
     assert_equal [["ab\e]0;1\ac", nil, "\e]0;1\ad"], 2], Reline::Unicode.split_by_width("ab\e]0;1\acd", 3)
   end
 
+  def test_split_by_width_csi_reset_sgr_optimization
+    assert_equal [["\e[1ma\e[mb\e[2mc", nil, "\e[2md\e[0me\e[3mf", nil, "\e[3mg"], 3], Reline::Unicode.split_by_width("\e[1ma\e[mb\e[2mcd\e[0me\e[3mfg", 3)
+    assert_equal [["\e[1ma\1\e[mzero\e[0m\2\e[2mb", nil, "\e[1m\e[2mc"], 2], Reline::Unicode.split_by_width("\e[1ma\1\e[mzero\e[0m\2\e[2mbc", 2)
+  end
+
   def test_take_range
     assert_equal 'cdef', Reline::Unicode.take_range('abcdefghi', 2, 4)
     assert_equal 'あde', Reline::Unicode.take_range('abあdef', 2, 4)
-    assert_equal 'zerocdef', Reline::Unicode.take_range("ab\1zero\2cdef", 2, 4)
-    assert_equal 'bzerocde', Reline::Unicode.take_range("ab\1zero\2cdef", 1, 4)
+    assert_equal "\1zero\2cdef", Reline::Unicode.take_range("ab\1zero\2cdef", 2, 4)
+    assert_equal "b\1zero\2cde", Reline::Unicode.take_range("ab\1zero\2cdef", 1, 4)
     assert_equal "\e[31mcd\e[42mef", Reline::Unicode.take_range("\e[31mabcd\e[42mefg", 2, 4)
     assert_equal "\e]0;1\acd", Reline::Unicode.take_range("ab\e]0;1\acd", 2, 3)
     assert_equal 'いう', Reline::Unicode.take_range('あいうえお', 2, 4)
@@ -62,4 +67,26 @@ class Reline::Unicode::Test < Reline::TestCase
     assert_equal 10, Reline::Unicode.calculate_width('あいうえお')
     assert_equal 10, Reline::Unicode.calculate_width('あいうえお', true)
   end
+
+  def test_take_mbchar_range
+    assert_equal ['cdef', 2, 4], Reline::Unicode.take_mbchar_range('abcdefghi', 2, 4)
+    assert_equal ['cdef', 2, 4], Reline::Unicode.take_mbchar_range('abcdefghi', 2, 4, padding: true)
+    assert_equal ['cdef', 2, 4], Reline::Unicode.take_mbchar_range('abcdefghi', 2, 4, cover_begin: true)
+    assert_equal ['cdef', 2, 4], Reline::Unicode.take_mbchar_range('abcdefghi', 2, 4, cover_end: true)
+    assert_equal ['いう', 2, 4], Reline::Unicode.take_mbchar_range('あいうえお', 2, 4)
+    assert_equal ['いう', 2, 4], Reline::Unicode.take_mbchar_range('あいうえお', 2, 4, padding: true)
+    assert_equal ['いう', 2, 4], Reline::Unicode.take_mbchar_range('あいうえお', 2, 4, cover_begin: true)
+    assert_equal ['いう', 2, 4], Reline::Unicode.take_mbchar_range('あいうえお', 2, 4, cover_end: true)
+    assert_equal ['う', 4, 2], Reline::Unicode.take_mbchar_range('あいうえお', 3, 4)
+    assert_equal [' う ', 3, 4], Reline::Unicode.take_mbchar_range('あいうえお', 3, 4, padding: true)
+    assert_equal ['いう', 2, 4], Reline::Unicode.take_mbchar_range('あいうえお', 3, 4, cover_begin: true)
+    assert_equal ['うえ', 4, 4], Reline::Unicode.take_mbchar_range('あいうえお', 3, 4, cover_end: true)
+    assert_equal ['いう ', 2, 5], Reline::Unicode.take_mbchar_range('あいうえお', 3, 4, cover_begin: true, padding: true)
+    assert_equal [' うえ', 3, 5], Reline::Unicode.take_mbchar_range('あいうえお', 3, 4, cover_end: true, padding: true)
+    assert_equal [' うえお   ', 3, 10], Reline::Unicode.take_mbchar_range('あいうえお', 3, 10, padding: true)
+    assert_equal [" \e[41mうえお\e[0m   ", 3, 10], Reline::Unicode.take_mbchar_range("あい\e[41mうえお", 3, 10, padding: true)
+    assert_equal ["\e[41m \e[42mい\e[43m ", 1, 4], Reline::Unicode.take_mbchar_range("\e[41mあ\e[42mい\e[43mう", 1, 4, padding: true)
+    assert_equal ["\e[31mc\1ABC\2d\e[0mef", 2, 4], Reline::Unicode.take_mbchar_range("\e[31mabc\1ABC\2d\e[0mefghi", 2, 4)
+    assert_equal ["\e[41m \e[42mい\e[43m ", 1, 4], Reline::Unicode.take_mbchar_range("\e[41mあ\e[42mい\e[43mう", 1, 4, padding: true)
+  end
 end
diff --git a/test/reline/test_within_pipe.rb b/test/reline/test_within_pipe.rb
index a42ca755fc..4f05255301 100644
--- a/test/reline/test_within_pipe.rb
+++ b/test/reline/test_within_pipe.rb
@@ -23,7 +23,6 @@ class Reline::WithinPipeTest < Reline::TestCase
     @reader.close
     @output_writer.close
     @config.reset
-    @config.reset_default_key_bindings
     Reline.test_reset
   end
 
diff --git a/test/reline/yamatanooroti/multiline_repl b/test/reline/yamatanooroti/multiline_repl
index e2a900b251..8b82be60f4 100755
--- a/test/reline/yamatanooroti/multiline_repl
+++ b/test/reline/yamatanooroti/multiline_repl
@@ -9,14 +9,10 @@ require 'optparse'
 require_relative 'termination_checker'
 
 opt = OptionParser.new
-opt.on('--prompt-list-cache-timeout VAL') { |v|
-  Reline::LineEditor.__send__(:remove_const, :PROMPT_LIST_CACHE_TIMEOUT)
-  Reline::LineEditor::PROMPT_LIST_CACHE_TIMEOUT = v.to_f
-}
 opt.on('--dynamic-prompt') {
   Reline.prompt_proc = proc { |lines|
     lines.each_with_index.map { |l, i|
-      '[%04d]> ' % i
+      "\e[1m[%04d]>\e[m " % i
     }
   }
 }
@@ -147,12 +143,21 @@ opt.on('--complete') {
     %w{String ScriptError SyntaxError Signal}.select{ |c| c.start_with?(target) }
   }
 }
+opt.on('--complete-menu-with-perfect-match') {
+  Reline.completion_proc = lambda { |target, preposing = nil, postposing = nil|
+    %w{abs abs2}.select{ |c| c.start_with?(target) }
+  }
+}
 opt.on('--autocomplete') {
   Reline.autocompletion = true
   Reline.completion_proc = lambda { |target, preposing = nil, postposing = nil|
     %w{String Struct Symbol ScriptError SyntaxError Signal}.select{ |c| c.start_with?(target) }
   }
 }
+opt.on('--autocomplete-empty') {
+  Reline.autocompletion = true
+  Reline.completion_proc = lambda { |target, preposing = nil, postposing = nil| [] }
+}
 opt.on('--autocomplete-long') {
   Reline.autocompletion = true
   Reline.completion_proc = lambda { |target, preposing = nil, postposing = nil|
@@ -183,7 +188,7 @@ opt.on('--autocomplete-long') {
 opt.on('--autocomplete-super-long') {
   Reline.autocompletion = true
   Reline.completion_proc = lambda { |target, preposing = nil, postposing = nil|
-    c = 'A'
+    c = +'A'
     2000.times.map{ s = "Str_#{c}"; c.succ!; s }.select{ |c| c.start_with?(target) }
   }
 }
@@ -217,7 +222,7 @@ rescue
 end
 
 begin
-  prompt = ENV['RELINE_TEST_PROMPT'] || 'prompt> '
+  prompt = ENV['RELINE_TEST_PROMPT'] || "\e[1mprompt>\e[m "
   puts 'Multiline REPL.'
   while code = Reline.readmultiline(prompt, true) { |code| TerminationChecker.terminated?(code) }
     case code.chomp
diff --git a/test/reline/yamatanooroti/test_rendering.rb b/test/reline/yamatanooroti/test_rendering.rb
index 670432d86b..37a1c1a193 100644
--- a/test/reline/yamatanooroti/test_rendering.rb
+++ b/test/reline/yamatanooroti/test_rendering.rb
@@ -197,9 +197,12 @@ begin
       LINES
       start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
       write(":a\n\C-[k")
+      write("i\n:a")
+      write("\C-[h")
       close
       assert_screen(<<~EOC)
-        Multiline REPL.
+        (ins)prompt> :a
+        => :a
         (ins)prompt> :a
         => :a
         (cmd)prompt> :a
@@ -306,6 +309,21 @@ begin
       EOC
     end
 
+    def test_readline_with_multiline_input
+      start_terminal(5, 50, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --dynamic-prompt}, startup_message: 'Multiline REPL.')
+      write("def foo\n  bar\nend\n")
+      write("Reline.readline('prompt> ')\n")
+      write("\C-p\C-p")
+      close
+      assert_screen(<<~EOC)
+        => :foo
+        [0000]> Reline.readline('prompt> ')
+        prompt> def foo
+          bar
+        end
+      EOC
+    end
+
     def test_multiline_and_autowrap
       start_terminal(10, 20, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
       write("def aaaaaaaaaa\n  33333333\n           end\C-a\C-pputs\C-e\e\C-m888888888888888")
@@ -464,6 +482,9 @@ begin
       write("def a\n  8\nend\ndef b\n  3\nend\C-s8")
       close
       assert_screen(<<~EOC)
+        prompt>   8
+        prompt> end
+        => :a
         (i-search)`8'def a
         (i-search)`8'  8
         (i-search)`8'end
@@ -475,6 +496,9 @@ begin
       write("def a\n  8\nend\ndef b\n  3\nend\C-r8\C-j")
       close
       assert_screen(<<~EOC)
+        prompt>   8
+        prompt> end
+        => :a
         prompt> def a
         prompt>   8
         prompt> end
@@ -495,18 +519,6 @@ begin
       EOC
     end
 
-    def test_prompt_list_caching
-      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --prompt-list-cache-timeout 10 --dynamic-prompt}, startup_message: 'Multiline REPL.')
-      write("def hoge\n  3\nend")
-      close
-      assert_screen(<<~EOC)
-        Multiline REPL.
-        [0000]> def hoge
-        [0001]>   3
-        [0002]> end
-      EOC
-    end
-
     def test_broken_prompt_list
       start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --broken-dynamic-prompt}, startup_message: 'Multiline REPL.')
       write("def hoge\n  3\nend")
@@ -531,15 +543,10 @@ begin
       EOC
     end
 
-    def test_enable_bracketed_paste
+    def test_bracketed_paste
       omit if Reline.core.io_gate.win?
-      write_inputrc <<~LINES
-        set enable-bracketed-paste on
-      LINES
       start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
-      write("\e[200~,")
-      write("def hoge\n  3\nend")
-      write("\e[200~.")
+      write("\e[200~def hoge\r\t3\rend\e[201~")
       close
       assert_screen(<<~EOC)
         Multiline REPL.
@@ -549,6 +556,19 @@ begin
       EOC
     end
 
+    def test_bracketed_paste_with_undo
+      omit if Reline.core.io_gate.win?
+      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
+      write("abc")
+      write("\e[200~def hoge\r\t3\rend\e[201~")
+      write("\C-_")
+      close
+      assert_screen(<<~EOC)
+        Multiline REPL.
+        prompt> abc
+      EOC
+    end
+
     def test_backspace_until_returns_to_initial
       start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
       write("ABC")
@@ -834,6 +854,20 @@ begin
       EOC
     end
 
+    def test_auto_indent_with_various_spaces
+      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --auto-indent}, startup_message: 'Multiline REPL.')
+      write "(\n\C-v"
+      write "\C-k\n\C-v"
+      write "\C-k)"
+      close
+      assert_screen(<<~EOC)
+        Multiline REPL.
+        prompt> (
+        prompt> ^K
+        prompt> )
+      EOC
+    end
+
     def test_autowrap_in_the_middle_of_a_line
       start_terminal(5, 20, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
       write("def abcdefg; end\C-b\C-b\C-b\C-b\C-b")
@@ -919,18 +953,30 @@ begin
       EOC
     end
 
-    def test_with_newline
+    def test_eof_with_newline
       omit if Reline.core.io_gate.win?
       cmd = %Q{ruby -e 'print(%Q{abc def \\e\\r})' | ruby -I#{@pwd}/lib -rreline -e 'p Reline.readline(%{> })'}
       start_terminal(40, 50, ['bash', '-c', cmd])
       sleep 1
-      close
+      close rescue nil
       assert_screen(<<~'EOC')
         > abc def
         "abc def "
       EOC
     end
 
+    def test_eof_without_newline
+      omit if Reline.core.io_gate.win?
+      cmd = %Q{ruby -e 'print(%{hello})' | ruby -I#{@pwd}/lib -rreline -e 'p Reline.readline(%{> })'}
+      start_terminal(40, 50, ['bash', '-c', cmd])
+      sleep 1
+      close rescue nil
+      assert_screen(<<~'EOC')
+        > hello
+        "hello"
+      EOC
+    end
+
     def test_em_set_mark_and_em_exchange_mark
       start_terminal(10, 50, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
       write("aaa bbb ccc ddd\M-b\M-b\M-\x20\M-b\C-x\C-xX\C-x\C-xY")
@@ -980,6 +1026,47 @@ begin
       EOC
     end
 
+    def test_completion_menu_is_displayed_horizontally
+      start_terminal(20, 50, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --complete}, startup_message: 'Multiline REPL.')
+      write("S\t\t")
+      close
+      assert_screen(<<~'EOC')
+        Multiline REPL.
+        prompt> S
+        ScriptError  String
+        Signal       SyntaxError
+      EOC
+    end
+
+    def test_show_all_if_ambiguous_on
+      write_inputrc <<~LINES
+        set show-all-if-ambiguous on
+      LINES
+      start_terminal(20, 50, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --complete}, startup_message: 'Multiline REPL.')
+      write("S\t")
+      close
+      assert_screen(<<~'EOC')
+        Multiline REPL.
+        prompt> S
+        ScriptError  String
+        Signal       SyntaxError
+      EOC
+    end
+
+    def test_show_all_if_ambiguous_on_and_menu_with_perfect_match
+      write_inputrc <<~LINES
+        set show-all-if-ambiguous on
+      LINES
+      start_terminal(20, 50, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --complete-menu-with-perfect-match}, startup_message: 'Multiline REPL.')
+      write("a\t")
+      close
+      assert_screen(<<~'EOC')
+        Multiline REPL.
+        prompt> abs
+        abs   abs2
+      EOC
+    end
+
     def test_simple_dialog
       iterate_over_face_configs do |config_name, config_file|
         start_terminal(20, 50, %W{ruby -I#{@pwd}/lib -r#{config_file.path} #{@pwd}/test/reline/yamatanooroti/multiline_repl --dialog simple}, startup_message: 'Multiline REPL.')
@@ -1026,8 +1113,8 @@ begin
       iterate_over_face_configs do |config_name, config_file|
         start_terminal(10, 50, %W{ruby -I#{@pwd}/lib -r#{config_file.path} #{@pwd}/test/reline/yamatanooroti/multiline_repl --autocomplete}, startup_message: 'Multiline REPL.')
         write("\n" * 10)
-        write("if 1\n  sSt\nend")
-        write("\C-p\C-h\C-e")
+        write("if 1\n  sSts\nend")
+        write("\C-p\C-h\C-e\C-h")
         close
         assert_screen(<<~'EOC')
           prompt>
@@ -1054,8 +1141,8 @@ begin
           prompt>   2
           prompt>   3#
           prompt>   4
-          prompt>   5
-          prompt>   6 Ruby is...
+          prompt>   5 Ruby is...
+          prompt>   6 A dynamic, open source programming
         EOC
       end
     end
@@ -1106,11 +1193,53 @@ begin
       assert_screen(<<~'EOC')
         Multiline REPL.
         prompt>           St
-        r             String
+        r
+        String
+        Struct
+      EOC
+    end
+
+    def test_autocomplete_target_at_end_of_line
+      start_terminal(20, 20, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --autocomplete}, startup_message: 'Multiline REPL.')
+      write('         ')
+      write('Str')
+      write("\C-i")
+      close
+      assert_screen(<<~'EOC')
+        Multiline REPL.
+        prompt>          Str
+        ing           String
                       Struct
       EOC
     end
 
+    def test_autocomplete_completed_input_is_wrapped
+      start_terminal(20, 20, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --autocomplete}, startup_message: 'Multiline REPL.')
+      write('        ')
+      write('Str')
+      write("\C-i")
+      close
+      assert_screen(<<~'EOC')
+        Multiline REPL.
+        prompt>         Stri
+        ng            String
+                      Struct
+      EOC
+    end
+
+    def test_force_insert_before_autocomplete
+      start_terminal(20, 20, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --autocomplete}, startup_message: 'Multiline REPL.')
+      write('Sy')
+      write(";St\t\t")
+      close
+      assert_screen(<<~'EOC')
+        Multiline REPL.
+        prompt> Sy;Struct
+                   String
+                   Struct
+      EOC
+    end
+
     def test_simple_dialog_with_scroll_key
       start_terminal(20, 50, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --dialog long,scrollkey}, startup_message: 'Multiline REPL.')
       write('a')
@@ -1213,6 +1342,32 @@ begin
       EOC
     end
 
+    def test_autocomplete_empty_string
+      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --autocomplete}, startup_message: 'Multiline REPL.')
+      write("\C-i")
+      close
+      assert_screen(<<~'EOC')
+        Multiline REPL.
+        prompt> String
+                String     █
+                Struct     ▀
+                Symbol
+      EOC
+    end
+
+    def test_paste_code_with_tab_indent_does_not_fail
+      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --autocomplete-empty}, startup_message: 'Multiline REPL.')
+      write("2.times do\n\tputs\n\tputs\nend")
+      close
+      assert_screen(<<~'EOC')
+        Multiline REPL.
+        prompt> 2.times do
+        prompt> puts
+        prompt> puts
+        prompt> end
+      EOC
+    end
+
     def test_autocomplete_after_2nd_line
       start_terminal(20, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --autocomplete}, startup_message: 'Multiline REPL.')
       write("def hoge\n  Str")
@@ -1640,6 +1795,23 @@ begin
       EOC
     end
 
+    def test_thread_safe
+      start_terminal(6, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl --auto-indent}, startup_message: 'Multiline REPL.')
+      write("[Thread.new{Reline.readline'>'},Thread.new{Reline.readmultiline('>'){true}}].map(&:join).size\n")
+      write("exit\n")
+      write("exit\n")
+      write("42\n")
+      close
+      assert_screen(<<~EOC)
+        >exit
+        >exit
+        => 2
+        prompt> 42
+        => 42
+        prompt>
+      EOC
+    end
+
     def write_inputrc(content)
       File.open(@inputrc_file, 'w') do |f|
         f.write content