aboutsummaryrefslogtreecommitdiff
path: root/test/functional/editor/ctrl_c_spec.lua
blob: 60131bf2a4142f8dcba9fa76b357d56ea703a809 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
local helpers = require('test.functional.helpers')(after_each)
local Screen = require('test.functional.ui.screen')
local clear, feed, source = helpers.clear, helpers.feed, helpers.source
local command = helpers.command
local sleep = helpers.sleep

describe("CTRL-C (mapped)", function()
  local screen

  before_each(function()
    clear()
    screen = Screen.new(52, 6)
    screen:attach()
  end)

  it("interrupts :global", function()
    -- Crashes luajit.
    if helpers.skip_fragile(pending) then
      return
    end

    source([[
      set nomore nohlsearch undolevels=-1
      nnoremap <C-C> <NOP>
    ]])

    command("silent edit! test/functional/fixtures/bigfile.txt")

    screen:expect([[
      ^0000;<control>;Cc;0;BN;;;;;N;NULL;;;;               |
      0001;<control>;Cc;0;BN;;;;;N;START OF HEADING;;;;   |
      0002;<control>;Cc;0;BN;;;;;N;START OF TEXT;;;;      |
      0003;<control>;Cc;0;BN;;;;;N;END OF TEXT;;;;        |
      0004;<control>;Cc;0;BN;;;;;N;END OF TRANSMISSION;;;;|
                                                          |
    ]])

    local function test_ctrl_c(ms)
      feed(":global/^/p<CR>")
      screen:sleep(ms)
      feed("<C-C>")
      screen:expect{any="Interrupt"}
    end

    -- The test is time-sensitive. Try different sleep values.
    local ms_values = {100, 1000, 10000}
    for i, ms in ipairs(ms_values) do
      if i < #ms_values then
        local status, _ = pcall(test_ctrl_c, ms)
        if status then break end
      else  -- Call the last attempt directly.
        test_ctrl_c(ms)
      end
    end
  end)

  it('interrupts :sleep', function()
    command('nnoremap <C-C> <Nop>')
    feed(':sleep 100<CR>')
    -- wait for :sleep to start
    sleep(10)
    feed('foo<C-C>')
    -- wait for input buffer to be flushed
    sleep(10)
    feed('i')
    screen:expect([[
      ^                                                    |
      ~                                                   |
      ~                                                   |
      ~                                                   |
      ~                                                   |
      -- INSERT --                                        |
    ]])
  end)

  it('interrupts recursive mapping', function()
    command('nnoremap <C-C> <Nop>')
    command('nmap <F2> <Ignore><F2>')
    feed('<F2>')
    sleep(10)
    feed('foo<C-C>')
    -- wait for input buffer to be flushed
    sleep(10)
    feed('i')
    screen:expect([[
      ^                                                    |
      ~                                                   |
      ~                                                   |
      ~                                                   |
      ~                                                   |
      -- INSERT --                                        |
    ]])
  end)
end)