local t = require('test.testutil')
local n = require('test.functional.testnvim')()
local Screen = require('test.functional.ui.screen')

local clear = n.clear
local insert = n.insert
local feed = n.feed
local expect = n.expect
local eq = t.eq
local map = vim.tbl_map
local filter = vim.tbl_filter
local command = n.command
local curbuf_contents = n.curbuf_contents
local fn = n.fn
local dedent = t.dedent

local function reset()
  command('bwipe! | new')
  insert([[
  Line of words 1
  Line of words 2]])
  command('goto 1')
  feed('itest_string.<esc>u')
  fn.setreg('a', 'test_stringa', 'V')
  fn.setreg('b', 'test_stringb\ntest_stringb\ntest_stringb', 'b')
  fn.setreg('"', 'test_string"', 'v')
end

-- We check the last inserted register ". in each of these tests because it is
-- implemented completely differently in do_put().
-- It is implemented differently so that control characters and imap'ped
-- characters work in the same manner when pasted as when inserted.
describe('put command', function()
  clear()
  before_each(reset)

  local function visual_marks_zero()
    for _, v in pairs(fn.getpos("'<")) do
      if v ~= 0 then
        return false
      end
    end
    for _, v in pairs(fn.getpos("'>")) do
      if v ~= 0 then
        return false
      end
    end
    return true
  end

  -- {{{ Where test definitions are run
  local function run_test_variations(test_variations, extra_setup)
    reset()
    if extra_setup then
      extra_setup()
    end
    local init_contents = curbuf_contents()
    local init_cursorpos = fn.getcurpos()
    local assert_no_change = function(exception_table, after_undo)
      expect(init_contents)
      -- When putting the ". register forwards, undo doesn't move
      -- the cursor back to where it was before.
      -- This is because it uses the command character 'a' to
      -- start the insert, and undo after that leaves the cursor
      -- one place to the right (unless we were at the end of the
      -- line when we pasted).
      if not (exception_table.undo_position and after_undo) then
        eq(init_cursorpos, fn.getcurpos())
      end
    end

    for _, test in pairs(test_variations) do
      it(test.description, function()
        if extra_setup then
          extra_setup()
        end
        local orig_dotstr = fn.getreg('.')
        t.ok(visual_marks_zero())
        -- Make sure every test starts from the same conditions
        assert_no_change(test.exception_table, false)
        local was_cli = test.test_action()
        test.test_assertions(test.exception_table, false)
        -- Check that undo twice puts us back to the original conditions
        -- (i.e. puts the cursor and text back to before)
        feed('u')
        assert_no_change(test.exception_table, true)

        -- Should not have changed the ". register
        -- If we paste the ". register with a count we can't avoid
        -- changing this register, hence avoid this check.
        if not test.exception_table.dot_reg_changed then
          eq(orig_dotstr, fn.getreg('.'))
        end

        -- Doing something, undoing it, and then redoing it should
        -- leave us in the same state as just doing it once.
        -- For :ex actions we want '@:', for normal actions we want '.'

        -- The '.' redo doesn't work for visual put so just exit if
        -- it was tested.
        -- We check that visual put was used by checking if the '< and
        -- '> marks were changed.
        if not visual_marks_zero() then
          return
        end

        if test.exception_table.undo_position then
          fn.setpos('.', init_cursorpos)
        end
        if was_cli then
          feed('@:')
        else
          feed('.')
        end

        test.test_assertions(test.exception_table, true)
      end)
    end
  end -- run_test_variations()
  -- }}}

  local function create_test_defs(
    test_defs,
    command_base,
    command_creator, -- {{{
    expect_base,
    expect_creator
  )
    local rettab = {}
    local exceptions
    for _, v in pairs(test_defs) do
      if v[4] then
        exceptions = v[4]
      else
        exceptions = {}
      end
      table.insert(rettab, {
        test_action = command_creator(command_base, v[1]),
        test_assertions = expect_creator(expect_base, v[2]),
        description = v[3],
        exception_table = exceptions,
      })
    end
    return rettab
  end -- create_test_defs() }}}

  local function find_cursor_position(expect_string) -- {{{
    -- There must only be one occurrence of the character 'x' in
    -- expect_string.
    -- This function removes that occurrence, and returns the position that
    -- it was in.
    -- This returns the cursor position that would leave the 'x' in that
    -- place if we feed 'ix<esc>' and the string existed before it.
    for linenum, line in pairs(fn.split(expect_string, '\n', 1)) do
      local column = line:find('x')
      if column then
        return { linenum, column }, expect_string:gsub('x', '')
      end
    end
  end -- find_cursor_position() }}}

  -- Action function creators {{{
  local function create_p_action(test_map, substitution)
    local temp_val = test_map:gsub('p', substitution)
    return function()
      feed(temp_val)
      return false
    end
  end

  local function create_put_action(command_base, substitution)
    local temp_val = command_base:gsub('put', substitution)
    return function()
      feed(':' .. temp_val .. '<CR>')
      return true
    end
  end
  -- }}}

  -- Expect function creator {{{
  local function expect_creator(conversion_function, expect_base, conversion_table)
    local temp_expect_string = conversion_function(expect_base, conversion_table)
    local cursor_position, expect_string = find_cursor_position(temp_expect_string)
    return function(exception_table, after_redo)
      expect(expect_string)

      -- Have to use getcurpos() instead of api.nvim_win_get_cursor(0) in
      -- order to account for virtualedit.
      -- We always want the curswant element in getcurpos(), which is
      -- sometimes different to the column element in
      -- api.nvim_win_get_cursor(0).
      -- NOTE: The ".gp command leaves the cursor after the pasted text
      -- when running, but does not when the command is redone with the
      -- '.' command.
      if not (exception_table.redo_position and after_redo) then
        local actual_position = fn.getcurpos()
        eq(cursor_position, { actual_position[2], actual_position[5] })
      end
    end
  end -- expect_creator() }}}

  -- Test definitions {{{
  local function copy_def(def)
    local rettab = { '', {}, '', nil }
    rettab[1] = def[1]
    for k, v in pairs(def[2]) do
      rettab[2][k] = v
    end
    rettab[3] = def[3]
    if def[4] then
      rettab[4] = {}
      for k, v in pairs(def[4]) do
        rettab[4][k] = v
      end
    end
    return rettab
  end

  local normal_command_defs = {
    {
      'p',
      { cursor_after = false, put_backwards = false, dot_register = false },
      'pastes after cursor with p',
    },
    {
      'gp',
      { cursor_after = true, put_backwards = false, dot_register = false },
      'leaves cursor after text with gp',
    },
    {
      '".p',
      { cursor_after = false, put_backwards = false, dot_register = true },
      'works with the ". register',
    },
    {
      '".gp',
      { cursor_after = true, put_backwards = false, dot_register = true },
      'gp works with the ". register',
      { redo_position = true },
    },
    {
      'P',
      { cursor_after = false, put_backwards = true, dot_register = false },
      'pastes before cursor with P',
    },
    {
      'gP',
      { cursor_after = true, put_backwards = true, dot_register = false },
      'gP pastes before cursor and leaves cursor after text',
    },
    {
      '".P',
      { cursor_after = false, put_backwards = true, dot_register = true },
      'P works with ". register',
    },
    {
      '".gP',
      { cursor_after = true, put_backwards = true, dot_register = true },
      'gP works with ". register',
      { redo_position = true },
    },
  }

  -- Add a definition applying a count for each definition above.
  -- Could do this for each transformation (p -> P, p -> gp etc), but I think
  -- it's neater this way (balance between being explicit and too verbose).
  for i = 1, #normal_command_defs do
    local cur = normal_command_defs[i]

    -- Make modified copy of current definition that includes a count.
    local newdef = copy_def(cur)
    newdef[2].count = 2
    cur[2].count = 1
    newdef[1] = '2' .. newdef[1]
    newdef[3] = 'double ' .. newdef[3]

    if cur[2].dot_register then
      if not cur[4] then
        newdef[4] = {}
      end
      newdef[4].dot_reg_changed = true
    end

    normal_command_defs[#normal_command_defs + 1] = newdef
  end

  local ex_command_defs = {
    {
      'put',
      { put_backwards = false, dot_register = false },
      'pastes linewise forwards with :put',
    },
    {
      'put!',
      { put_backwards = true, dot_register = false },
      'pastes linewise backwards with :put!',
    },
    {
      'put .',
      { put_backwards = false, dot_register = true },
      'pastes linewise with the dot register',
    },
    {
      'put! .',
      { put_backwards = true, dot_register = true },
      'pastes linewise backwards with the dot register',
    },
  }

  local function non_dotdefs(def_table)
    return filter(function(d)
      return not d[2].dot_register
    end, def_table)
  end

  -- }}}

  -- Conversion functions {{{
  local function convert_charwise(expect_base, conversion_table, virtualedit_end, visual_put)
    expect_base = dedent(expect_base)
    -- There is no difference between 'P' and 'p' when VIsual_active
    if not visual_put then
      if conversion_table.put_backwards then
        -- Special case for virtualedit at the end of a line.
        local replace_string
        if not virtualedit_end then
          replace_string = 'test_stringx"%1'
        else
          replace_string = 'test_stringx"'
        end
        expect_base = expect_base:gsub('(.)test_stringx"', replace_string)
      end
    end
    if conversion_table.count > 1 then
      local rep_string = 'test_string"'
      local extra_puts = rep_string:rep(conversion_table.count - 1)
      expect_base = expect_base:gsub('test_stringx"', extra_puts .. 'test_stringx"')
    end
    if conversion_table.cursor_after then
      expect_base = expect_base:gsub('test_stringx"', 'test_string"x')
    end
    if conversion_table.dot_register then
      expect_base = expect_base:gsub('(test_stringx?)"', '%1.')
    end
    return expect_base
  end -- convert_charwise()

  local function make_back(string)
    local prev_line
    local rettab = {}
    local string_found = false
    for _, line in pairs(fn.split(string, '\n', 1)) do
      if line:find('test_string') then
        string_found = true
        table.insert(rettab, line)
      else
        if string_found then
          if prev_line then
            table.insert(rettab, prev_line)
            prev_line = nil
          end
          table.insert(rettab, line)
        else
          table.insert(rettab, prev_line)
          prev_line = line
        end
      end
    end
    -- In case there are no lines after the text that was put.
    if prev_line and string_found then
      table.insert(rettab, prev_line)
    end
    return table.concat(rettab, '\n')
  end -- make_back()

  local function convert_linewise(expect_base, conversion_table, _, use_a, indent)
    expect_base = dedent(expect_base)
    if conversion_table.put_backwards then
      expect_base = make_back(expect_base)
    end
    local p_str = 'test_string"'
    if use_a then
      p_str = 'test_stringa'
    end

    if conversion_table.dot_register then
      expect_base = expect_base:gsub('x' .. p_str, 'xtest_string.')
      p_str = 'test_string.'
    end

    if conversion_table.cursor_after then
      expect_base = expect_base:gsub('x' .. p_str .. '\n', p_str .. '\nx')
    end

    -- The 'indent' argument is only used here because a single put with an
    -- indent doesn't require special handling. It doesn't require special
    -- handling because the cursor is never put before the indent, hence
    -- the modification of 'test_stringx"' gives the same overall answer as
    -- modifying '    test_stringx"'.

    -- Only happens when using normal mode command actions.
    if conversion_table.count and conversion_table.count > 1 then
      if not indent then
        indent = ''
      end
      local rep_string = indent .. p_str .. '\n'
      local extra_puts = rep_string:rep(conversion_table.count - 1)
      local orig_string, new_string
      if conversion_table.cursor_after then
        orig_string = indent .. p_str .. '\nx'
        new_string = extra_puts .. orig_string
      else
        orig_string = indent .. 'x' .. p_str .. '\n'
        new_string = orig_string .. extra_puts
      end
      expect_base = expect_base:gsub(orig_string, new_string)
    end
    return expect_base
  end

  local function put_x_last(orig_line, p_str)
    local prev_end, cur_end, cur_start = 0, 0, 0
    while cur_start do
      prev_end = cur_end
      cur_start, cur_end = orig_line:find(p_str, prev_end)
    end
    -- Assume (because that is the only way I call it) that p_str matches
    -- the pattern 'test_string.'
    return orig_line:sub(1, prev_end - 1) .. 'x' .. orig_line:sub(prev_end)
  end

  local function convert_blockwise(
    expect_base,
    conversion_table,
    visual,
    use_b,
    trailing_whitespace
  )
    expect_base = dedent(expect_base)
    local p_str = 'test_string"'
    if use_b then
      p_str = 'test_stringb'
    end

    if conversion_table.dot_register then
      expect_base = expect_base:gsub('(x?)' .. p_str, '%1test_string.')
      -- Looks strange, but the dot is a special character in the pattern
      -- and a literal character in the replacement.
      expect_base = expect_base:gsub('test_stringx.', 'test_stringx.')
      p_str = 'test_string.'
    end

    -- No difference between 'p' and 'P' in visual mode.
    if not visual then
      if conversion_table.put_backwards then
        -- One for the line where the cursor is left, one for all other
        -- lines.
        expect_base = expect_base:gsub('([^x])' .. p_str, p_str .. '%1')
        expect_base = expect_base:gsub('([^x])x' .. p_str, 'x' .. p_str .. '%1')
        if not trailing_whitespace then
          expect_base = expect_base:gsub(' \n', '\n')
          expect_base = expect_base:gsub(' $', '')
        end
      end
    end

    if conversion_table.count and conversion_table.count > 1 then
      local p_pattern = p_str:gsub('%.', '%%.')
      expect_base = expect_base:gsub(p_pattern, p_str:rep(conversion_table.count))
      expect_base =
        expect_base:gsub('test_stringx([b".])', p_str:rep(conversion_table.count - 1) .. '%0')
    end

    if conversion_table.cursor_after then
      if not visual then
        local prev_line
        local rettab = {}
        local prev_in_block = false
        for _, line in pairs(fn.split(expect_base, '\n', 1)) do
          if line:find('test_string') then
            if prev_line then
              prev_line = prev_line:gsub('x', '')
              table.insert(rettab, prev_line)
            end
            prev_line = line
            prev_in_block = true
          else
            if prev_in_block then
              prev_line = put_x_last(prev_line, p_str)
              table.insert(rettab, prev_line)
              prev_in_block = false
            end
            table.insert(rettab, line)
          end
        end
        if prev_line and prev_in_block then
          table.insert(rettab, put_x_last(prev_line, p_str))
        end

        expect_base = table.concat(rettab, '\n')
      else
        expect_base = expect_base:gsub('x(.)', '%1x')
      end
    end

    return expect_base
  end
  -- }}}

  -- Convenience functions {{{
  local function run_normal_mode_tests(
    test_string,
    base_map,
    extra_setup,
    virtualedit_end,
    selection_string
  )
    local function convert_closure(e, c)
      return convert_charwise(e, c, virtualedit_end, selection_string)
    end
    local function expect_normal_creator(expect_base, conversion_table)
      local test_expect = expect_creator(convert_closure, expect_base, conversion_table)
      return function(exception_table, after_redo)
        test_expect(exception_table, after_redo)
        if selection_string then
          if not conversion_table.put_backwards then
            eq(selection_string, fn.getreg('"'))
          end
        else
          eq('test_string"', fn.getreg('"'))
        end
      end
    end
    run_test_variations(
      create_test_defs(
        normal_command_defs,
        base_map,
        create_p_action,
        test_string,
        expect_normal_creator
      ),
      extra_setup
    )
  end -- run_normal_mode_tests()

  local function convert_linewiseer(expect_base, conversion_table)
    return expect_creator(convert_linewise, expect_base, conversion_table)
  end

  local function run_linewise_tests(expect_base, base_command, extra_setup)
    local linewise_test_defs = create_test_defs(
      ex_command_defs,
      base_command,
      create_put_action,
      expect_base,
      convert_linewiseer
    )
    run_test_variations(linewise_test_defs, extra_setup)
  end -- run_linewise_tests()
  -- }}}

  -- Actual tests
  describe('default pasting', function()
    local expect_string = [[
    Ltest_stringx"ine of words 1
    Line of words 2]]
    run_normal_mode_tests(expect_string, 'p')

    run_linewise_tests(
      [[
      Line of words 1
      xtest_string"
      Line of words 2]],
      'put'
    )
  end)

  describe('linewise register', function()
    -- put with 'p'
    local local_ex_command_defs = non_dotdefs(normal_command_defs)
    local base_expect_string = [[
    Line of words 1
    xtest_stringa
    Line of words 2]]
    local function local_convert_linewise(expect_base, conversion_table)
      return convert_linewise(expect_base, conversion_table, nil, true)
    end
    local function expect_lineput(expect_base, conversion_table)
      return expect_creator(local_convert_linewise, expect_base, conversion_table)
    end
    run_test_variations(
      create_test_defs(
        local_ex_command_defs,
        '"ap',
        create_p_action,
        base_expect_string,
        expect_lineput
      )
    )

    -- put with :put
    local linewise_put_defs = non_dotdefs(ex_command_defs)
    base_expect_string = [[
    Line of words 1
    xtest_stringa
    Line of words 2]]
    run_test_variations(
      create_test_defs(
        linewise_put_defs,
        'put a',
        create_put_action,
        base_expect_string,
        convert_linewiseer
      )
    )
  end)

  describe('blockwise register', function()
    local blockwise_put_defs = non_dotdefs(normal_command_defs)
    local test_base = [[
    Lxtest_stringbine of words 1
    Ltest_stringbine of words 2
     test_stringb]]

    local function expect_block_creator(expect_base, conversion_table)
      return expect_creator(function(e, c)
        return convert_blockwise(e, c, nil, true)
      end, expect_base, conversion_table)
    end

    run_test_variations(
      create_test_defs(blockwise_put_defs, '"bp', create_p_action, test_base, expect_block_creator)
    )
  end)

  it('adds correct indentation when put with [p and ]p', function()
    feed('G>>"a]pix<esc>')
    -- luacheck: ignore
    expect([[
    Line of words 1
    	Line of words 2
    	xtest_stringa]])
    feed('uu"a[pix<esc>')
    -- luacheck: ignore
    expect([[
    Line of words 1
    	xtest_stringa
    	Line of words 2]])
  end)

  describe('linewise paste with autoindent', function()
    -- luacheck: ignore
    run_linewise_tests(
      [[
        Line of words 1
        	Line of words 2
        xtest_string"]],
      'put',
      function()
        fn.setline('$', '	Line of words 2')
        -- Set curswant to '8' to be at the end of the tab character
        -- This is where the cursor is put back after the 'u' command.
        fn.setpos('.', { 0, 2, 1, 0, 8 })
        command('set autoindent')
      end
    )
  end)

  describe('put inside tabs with virtualedit', function()
    local test_string = [[
    Line of words 1
       test_stringx"     Line of words 2]]
    run_normal_mode_tests(test_string, 'p', function()
      fn.setline('$', '	Line of words 2')
      command('setlocal virtualedit=all')
      fn.setpos('.', { 0, 2, 1, 2, 3 })
    end)
  end)

  describe('put after the line with virtualedit', function()
    -- luacheck: ignore 621
    local test_string = [[
    Line of words 1  test_stringx"
    	Line of words 2]]
    run_normal_mode_tests(test_string, 'p', function()
      fn.setline('$', '	Line of words 2')
      command('setlocal virtualedit=all')
      fn.setpos('.', { 0, 1, 16, 1, 17 })
    end, true)
  end)

  describe('Visual put', function()
    describe('basic put', function()
      local test_string = [[
      test_stringx" words 1
      Line of words 2]]
      run_normal_mode_tests(test_string, 'v2ep', nil, nil, 'Line of')
    end)
    describe('over trailing newline', function()
      local test_string = 'Line of test_stringx"Line of words 2'
      run_normal_mode_tests(test_string, 'v$p', function()
        fn.setpos('.', { 0, 1, 9, 0, 9 })
      end, nil, 'words 1\n')
    end)
    describe('linewise mode', function()
      local test_string = [[
      xtest_string"
      Line of words 2]]
      local function expect_vis_linewise(expect_base, conversion_table)
        return expect_creator(function(e, c)
          return convert_linewise(e, c, nil, nil)
        end, expect_base, conversion_table)
      end
      run_test_variations(
        create_test_defs(
          normal_command_defs,
          'Vp',
          create_p_action,
          test_string,
          expect_vis_linewise
        ),
        function()
          fn.setpos('.', { 0, 1, 1, 0, 1 })
        end
      )

      describe('with whitespace at bol', function()
        local function expect_vis_lineindented(expect_base, conversion_table)
          local test_expect = expect_creator(function(e, c)
            return convert_linewise(e, c, nil, nil, '    ')
          end, expect_base, conversion_table)
          return function(exception_table, after_redo)
            test_expect(exception_table, after_redo)
            if not conversion_table.put_backwards then
              eq('Line of words 1\n', fn.getreg('"'))
            end
          end
        end
        local base_expect_string = [[
            xtest_string"
        Line of words 2]]
        run_test_variations(
          create_test_defs(
            normal_command_defs,
            'Vp',
            create_p_action,
            base_expect_string,
            expect_vis_lineindented
          ),
          function()
            feed('i    test_string.<esc>u')
            fn.setreg('"', '    test_string"', 'v')
          end
        )
      end)
    end)

    describe('blockwise visual mode', function()
      local test_base = [[
        test_stringx"e of words 1
        test_string"e of words 2]]

      local function expect_block_creator(expect_base, conversion_table)
        local test_expect = expect_creator(function(e, c)
          return convert_blockwise(e, c, true)
        end, expect_base, conversion_table)
        return function(e, c)
          test_expect(e, c)
          if not conversion_table.put_backwards then
            eq('Lin\nLin', fn.getreg('"'))
          end
        end
      end

      local select_down_test_defs = create_test_defs(
        normal_command_defs,
        '<C-v>jllp',
        create_p_action,
        test_base,
        expect_block_creator
      )
      run_test_variations(select_down_test_defs)

      -- Undo and redo of a visual block put leave the cursor in the top
      -- left of the visual block area no matter where the cursor was
      -- when it started.
      local undo_redo_no = map(function(table)
        local rettab = copy_def(table)
        if not rettab[4] then
          rettab[4] = {}
        end
        rettab[4].undo_position = true
        rettab[4].redo_position = true
        return rettab
      end, normal_command_defs)

      -- Selection direction doesn't matter
      run_test_variations(
        create_test_defs(
          undo_redo_no,
          '<C-v>kllp',
          create_p_action,
          test_base,
          expect_block_creator
        ),
        function()
          fn.setpos('.', { 0, 2, 1, 0, 1 })
        end
      )

      describe('blockwise cursor after undo', function()
        -- A bit of a hack of the reset above.
        -- In the tests that selection direction doesn't matter, we
        -- don't check the undo/redo position because it doesn't fit
        -- the same pattern as everything else.
        -- Here we fix this by directly checking the undo/redo position
        -- in the test_assertions of our test definitions.
        local function assertion_creator(_, _)
          return function(_, _)
            feed('u')
            -- Have to use feed('u') here to set curswant, because
            -- ex_undo() doesn't do that.
            eq({ 0, 1, 1, 0, 1 }, fn.getcurpos())
            feed('<C-r>')
            eq({ 0, 1, 1, 0, 1 }, fn.getcurpos())
          end
        end

        run_test_variations(
          create_test_defs(undo_redo_no, '<C-v>kllp', create_p_action, test_base, assertion_creator),
          function()
            fn.setpos('.', { 0, 2, 1, 0, 1 })
          end
        )
      end)
    end)

    describe("with 'virtualedit'", function()
      describe('splitting a tab character', function()
        local base_expect_string = [[
        Line of words 1
          test_stringx"     Line of words 2]]
        run_normal_mode_tests(base_expect_string, 'vp', function()
          fn.setline('$', '	Line of words 2')
          command('setlocal virtualedit=all')
          fn.setpos('.', { 0, 2, 1, 2, 3 })
        end, nil, ' ')
      end)
      describe('after end of line', function()
        local base_expect_string = [[
        Line of words 1  test_stringx"
        Line of words 2]]
        run_normal_mode_tests(base_expect_string, 'vp', function()
          command('setlocal virtualedit=all')
          fn.setpos('.', { 0, 1, 16, 2, 18 })
        end, true, ' ')
      end)
    end)
  end)

  describe('. register special tests', function()
    -- luacheck: ignore 621
    before_each(reset)
    it('applies control character actions', function()
      feed('i<C-t><esc>u')
      expect([[
      Line of words 1
      Line of words 2]])
      feed('".p')
      expect([[
      	Line of words 1
      Line of words 2]])
      feed('u1go<C-v>j".p')
      eq(
        [[
	ine of words 1
	ine of words 2]],
        curbuf_contents()
      )
    end)

    local screen
    setup(function()
      screen = Screen.new()
    end)

    local function bell_test(actions, should_ring)
      if should_ring then
        -- check bell is not set by nvim before the action
        screen:sleep(50)
      end
      t.ok(not screen.bell and not screen.visual_bell)
      actions()
      screen:expect {
        condition = function()
          if should_ring then
            if not screen.bell and not screen.visual_bell then
              error('Bell was not rung after action')
            end
          else
            if screen.bell or screen.visual_bell then
              error('Bell was rung after action')
            end
          end
        end,
        unchanged = not should_ring,
      }
      screen.bell = false
      screen.visual_bell = false
    end

    it('should not ring the bell with gp at end of line', function()
      bell_test(function()
        feed('$".gp')
      end)

      -- Even if the last character is a multibyte character.
      reset()
      fn.setline(1, 'helloม')
      bell_test(function()
        feed('$".gp')
      end)
    end)

    it('should not ring the bell with gp and end of file', function()
      fn.setpos('.', { 0, 2, 1, 0 })
      bell_test(function()
        feed('$vl".gp')
      end)
    end)

    it('should ring the bell when deleting if not appropriate', function()
      t.skip(t.is_os('bsd'), 'crashes on freebsd')

      command('goto 2')
      feed('i<bs><esc>')
      expect([[
      ine of words 1
      Line of words 2]])
      bell_test(function()
        feed('".P')
      end, true)
    end)

    it('should restore cursor position after undo of ".p', function()
      local origpos = fn.getcurpos()
      feed('".pu')
      eq(origpos, fn.getcurpos())
    end)

    it("should be unaffected by 'autoindent' with V\".2p", function()
      command('set autoindent')
      feed('i test_string.<esc>u')
      feed('V".2p')
      expect([[
       test_string.
       test_string.
      Line of words 2]])
    end)
  end)
end)