local t = require('test.unit.testutil')

local itp = t.gen_itp(it)

local bit = require('bit')

--- @class vterm

--- @field ENC_UTF8 integer

--- @field VTERM_ATTR_BLINK integer

--- @field VTERM_ATTR_BOLD integer

--- @field VTERM_ATTR_FONT integer

--- @field VTERM_ATTR_ITALIC integer

--- @field VTERM_ATTR_REVERSE integer

--- @field VTERM_ATTR_UNDERLINE integer

--- @field VTERM_BASELINE_RAISE integer

--- @field VTERM_KEY_ENTER integer

--- @field VTERM_KEY_FUNCTION_0 integer

--- @field VTERM_KEY_KP_0 integer

--- @field VTERM_KEY_NONE integer

--- @field VTERM_KEY_TAB integer

--- @field VTERM_KEY_UP integer

--- @field VTERM_KEY_BACKSPACE integer

--- @field VTERM_KEY_ESCAPE integer

--- @field VTERM_KEY_DEL integer

--- @field VTERM_MOD_ALT integer

--- @field VTERM_MOD_CTRL integer

--- @field VTERM_MOD_SHIFT integer

--- @field parser_apc function

--- @field parser_csi function

--- @field parser_dcs function

--- @field parser_osc function

--- @field parser_pm function

--- @field parser_sos function

--- @field parser_text function

--- @field print_color function

--- @field schar_get fun(any, any):integer

--- @field screen_sb_clear function

--- @field screen_sb_popline function

--- @field screen_sb_pushline function

--- @field selection_query function

--- @field selection_set function

--- @field state_erase function

--- @field state_movecursor function

--- @field state_moverect function

--- @field state_pos function

--- @field state_putglyph function

--- @field state_sb_clear function

--- @field state_scrollrect function

--- @field state_setpenattr function

--- @field state_settermprop function

--- @field term_output function

--- @field utf_ptr2char fun(any):integer

--- @field utf_ptr2len fun(any):integer

--- @field vterm_input_write function

--- @field vterm_keyboard_end_paste function

--- @field vterm_keyboard_key function

--- @field vterm_keyboard_start_paste function

--- @field vterm_keyboard_unichar function

--- @field vterm_lookup_encoding fun(any, any):any

--- @field vterm_mouse_button function

--- @field vterm_mouse_move function

--- @field vterm_new fun(any, any):any

--- @field vterm_obtain_screen fun(any):any

--- @field vterm_obtain_state fun(any): any

--- @field vterm_output_set_callback function

--- @field vterm_parser_set_callbacks fun(any, any, any):any

--- @field vterm_screen_convert_color_to_rgb function

--- @field vterm_screen_enable_altscreen function

--- @field vterm_screen_enable_reflow function

--- @field vterm_screen_get_attrs_extent function

--- @field vterm_screen_get_cell function

--- @field vterm_screen_get_text fun(any, any, any, any):any

--- @field vterm_screen_is_eol fun(any, any):any

--- @field vterm_screen_reset function

--- @field vterm_screen_set_callbacks function

--- @field vterm_set_size function

--- @field vterm_set_utf8 fun(any, any, any):any

--- @field vterm_state_focus_in function

--- @field vterm_state_focus_out function

--- @field vterm_state_get_cursorpos fun(any, any)

--- @field vterm_state_get_lineinfo fun(any, any):any

--- @field vterm_state_get_penattr function

--- @field vterm_state_reset function

--- @field vterm_state_set_bold_highbright function

--- @field vterm_state_set_callbacks function

--- @field vterm_state_set_selection_callbacks function

--- @field vterm_state_set_unrecognised_fallbacks function

local vterm = t.cimport(

'./src/nvim/grid.h',

'./src/nvim/mbyte.h',

'./src/nvim/vterm/encoding.h',

'./src/nvim/vterm/keyboard.h',

'./src/nvim/vterm/mouse.h',

'./src/nvim/vterm/parser.h',

'./src/nvim/vterm/pen.h',

'./src/nvim/vterm/screen.h',

'./src/nvim/vterm/state.h',

'./src/nvim/vterm/vterm.h',

'./src/nvim/vterm/vterm_internal.h',

'./test/unit/fixtures/vterm_test.h'

)

--- @return string

local function read_rm()

end

local function append(str)

end

local function parser_control(control)

return append(string.format('control %02x\n', control))

end

local function parser_escape(bytes)

return append(string.format('escape %s\n', t.ffi.string(bytes)))

end

local function wantparser(vt)

end

--- @return any

local function init()

end

local function state_setlineinfo()

return 1

end

--- @return any

local function wantstate(vt, opts)

end

--- @return any

local function wantscreen(vt, opts)

end

local function reset(state, screen)

end

local function push(input, vt)

vterm.vterm_input_write(vt, input, string.len(input))

end

local function expect(expected)

local actual = read_rm()

t.eq(expected .. '\n', actual)

end

local function expect_output(expected_preformat)

end

local function cursor(row, col, state)

end

local function lineinfo(row, expected, state)

end

local function pen(attribute, expected, state)

end

local function resize(rows, cols, vt)

vterm.vterm_set_size(vt, rows, cols)

end

local function screen_chars(start_row, start_col, end_row, end_col, expected, screen)

end

local function screen_text(start_row, start_col, end_row, end_col, expected, screen)

end

--- @param row integer

local function screen_row(row, expected, screen, end_col)

end

local function screen_cell(row, col, expected, screen)

end

local function screen_eol(row, col, expected, screen)

end

local function screen_attrs_extent(row, col, expected, screen)

end

local function wantencoding()

end

local function encin(input, encoding)

end

local function strpe_modifiers(input_mod)

end

local function strp_key(input_key)

end

local function mousemove(row, col, vt, input_mod)

end

local function mousebtn(press, button, vt, input_mod)

end

local function inchar(c, vt, input_mod)

end

local function inkey(input_key, vt, input_mod)

end

before_each(function()

vim.fs.rm(t.paths.vterm_test_file, { force = true })

end)

describe('vterm', function()

itp('02parser', function()

local vt = init()

vterm.vterm_set_utf8(vt, false)

wantparser(vt)

-- Basic text

push('hello', vt)

expect('text 68,65,6c,6c,6f')

-- C0

push('\x03', vt)

expect('control 03')

push('\x1f', vt)

expect('control 1f')

-- C1 8bit

push('\x83', vt)

expect('control 83')

push('\x99', vt)

expect('control 99')

-- C1 7bit

push('\x1b\x43', vt)

expect('control 83')

push('\x1b\x59', vt)

expect('control 99')

-- High bytes

push('\xa0\xcc\xfe', vt)

expect('text a0,cc,fe')

-- Mixed

push('1\n2', vt)

expect('text 31\ncontrol 0a\ntext 32')

-- Escape

push('\x1b=', vt)

expect('escape =')

-- Escape 2-byte

push('\x1b(X', vt)

expect('escape (X')

-- Split write Escape

push('\x1b(', vt)

push('Y', vt)

expect('escape (Y')

-- Escape cancels Escape, starts another

push('\x1b(\x1b)Z', vt)

expect('escape )Z')

-- CAN cancels Escape, returns to normal mode

push('\x1b(\x18AB', vt)

expect('text 41,42')

-- C0 in Escape interrupts and continues

push('\x1b(\nX', vt)

expect('control 0a\nescape (X')

-- CSI 0 args

push('\x1b[a', vt)

expect('csi 61 *')

-- CSI 1 arg

push('\x1b[9b', vt)

expect('csi 62 9')

-- CSI 2 args

push('\x1b[3;4c', vt)

expect('csi 63 3,4')

-- CSI 1 arg 1 sub

push('\x1b[1:2c', vt)

expect('csi 63 1+,2')

-- CSI many digits

push('\x1b[678d', vt)

expect('csi 64 678')

-- CSI leading zero

push('\x1b[007e', vt)

expect('csi 65 7')

-- CSI qmark

push('\x1b[?2;7f', vt)

expect('csi 66 L=3f 2,7')

-- CSI greater

push('\x1b[>c', vt)

expect('csi 63 L=3e *')

-- CSI SP

push('\x1b[12 q', vt)

expect('csi 71 12 I=20')

-- Mixed CSI

push('A\x1b[8mB', vt)

expect('text 41\ncsi 6d 8\ntext 42')

-- Split write

push('\x1b', vt)

push('[a', vt)

expect('csi 61 *')

push('foo\x1b[', vt)

expect('text 66,6f,6f')

push('4b', vt)

expect('csi 62 4')

push('\x1b[12;', vt)

push('3c', vt)

expect('csi 63 12,3')

-- Escape cancels CSI, starts Escape

push('\x1b[123\x1b9', vt)

expect('escape 9')

-- CAN cancels CSI, returns to normal mode

push('\x1b[12\x18AB', vt)

expect('text 41,42')

-- C0 in Escape interrupts and continues

push('\x1b(\nX', vt)

expect('control 0a\nescape (X')

-- OSC BEL

push('\x1b]1;Hello\x07', vt)

expect('osc [1;Hello]')

-- OSC ST (7bit)

push('\x1b]1;Hello\x1b\\', vt)

expect('osc [1;Hello]')

-- OSC ST (8bit)

push('\x9d1;Hello\x9c', vt)

expect('osc [1;Hello]')

-- OSC in parts

push('\x1b]52;abc', vt)

expect('osc [52;abc')

push('def', vt)

expect('osc def')

push('ghi\x1b\\', vt)

expect('osc ghi]')

-- OSC BEL without semicolon

push('\x1b]1234\x07', vt)

expect('osc [1234;]')

-- OSC ST without semicolon

push('\x1b]1234\x1b\\', vt)

expect('osc [1234;]')

-- Escape cancels OSC, starts Escape

push('\x1b]Something\x1b9', vt)

expect('escape 9')

-- CAN cancels OSC, returns to normal mode

push('\x1b]12\x18AB', vt)

expect('text 41,42')

-- C0 in OSC interrupts and continues

push('\x1b]2;\nBye\x07', vt)

expect('osc [2;\ncontrol 0a\nosc Bye]')

-- DCS BEL

push('\x1bPHello\x07', vt)

expect('dcs [Hello]')

-- DCS ST (7bit)

push('\x1bPHello\x1b\\', vt)

expect('dcs [Hello]')

-- DCS ST (8bit)

push('\x90Hello\x9c', vt)

expect('dcs [Hello]')

-- Split write of 7bit ST

push('\x1bPABC\x1b', vt)

expect('dcs [ABC')

push('\\', vt)

expect('dcs ]')

-- Escape cancels DCS, starts Escape

push('\x1bPSomething\x1b9', vt)

expect('escape 9')

-- CAN cancels DCS, returns to normal mode

push('\x1bP12\x18AB', vt)

expect('text 41,42')

-- C0 in OSC interrupts and continues

push('\x1bPBy\ne\x07', vt)

expect('dcs [By\ncontrol 0a\ndcs e]')

-- APC BEL

push('\x1b_Hello\x07', vt)

expect('apc [Hello]')

-- APC ST (7bit)

push('\x1b_Hello\x1b\\', vt)

expect('apc [Hello]')

-- APC ST (8bit)

push('\x9fHello\x9c', vt)

expect('apc [Hello]')

-- PM BEL

push('\x1b^Hello\x07', vt)

expect('pm [Hello]')

-- PM ST (7bit)

push('\x1b^Hello\x1b\\', vt)

expect('pm [Hello]')

-- PM ST (8bit)

push('\x9eHello\x9c', vt)

expect('pm [Hello]')

-- SOS BEL

push('\x1bXHello\x07', vt)

expect('sos [Hello]')

-- SOS ST (7bit)

push('\x1bXHello\x1b\\', vt)

expect('sos [Hello]')

-- SOS ST (8bit)

push('\x98Hello\x9c', vt)

expect('sos [Hello]')

push('\x1bXABC\x01DEF\x1b\\', vt)

expect('sos [ABC\x01DEF]')

push('\x1bXABC\x99DEF\x1b\\', vt)

expect('sos [ABC\x99DEF]')

-- NUL ignored

push('\x00', vt)

-- NUL ignored within CSI

push('\x1b[12\x003m', vt)

expect('csi 6d 123')

-- DEL ignored

push('\x7f', vt)

-- DEL ignored within CSI

push('\x1b[12\x7f3m', vt)

expect('csi 6d 123')

-- DEL inside text"

push('AB\x7fC', vt)

expect('text 41,42\ntext 43')

end)

itp('03encoding_utf8', function()

local encoding = wantencoding()

-- Low

encin('123', encoding)

expect('encout 31,32,33')

-- We want to prove the UTF-8 parser correctly handles all the sequences.

-- Easy way to do this is to check it does low/high boundary cases, as that

-- leaves only two for each sequence length

--

-- These ranges are therefore:

--

-- Two bytes:

-- U+0080 = 000 10000000 => 00010 000000

-- => 11000010 10000000 = C2 80

-- U+07FF = 111 11111111 => 11111 111111

-- => 11011111 10111111 = DF BF

--

-- Three bytes:

-- U+0800 = 00001000 00000000 => 0000 100000 000000

-- => 11100000 10100000 10000000 = E0 A0 80

-- U+FFFD = 11111111 11111101 => 1111 111111 111101

-- => 11101111 10111111 10111101 = EF BF BD

-- (We avoid U+FFFE and U+FFFF as they're invalid codepoints)

--

-- Four bytes:

-- U+10000 = 00001 00000000 00000000 => 000 010000 000000 000000

-- => 11110000 10010000 10000000 10000000 = F0 90 80 80

-- U+1FFFFF = 11111 11111111 11111111 => 111 111111 111111 111111

-- => 11110111 10111111 10111111 10111111 = F7 BF BF BF

-- 2 byte

encin('\xC2\x80\xDF\xBF', encoding)

expect('encout 80,7ff')

-- 3 byte

encin('\xE0\xA0\x80\xEF\xBF\xBD', encoding)

expect('encout 800,fffd')

-- 4 byte

encin('\xF0\x90\x80\x80\xF7\xBF\xBF\xBF', encoding)

expect('encout 10000,1fffff')

-- Next up, we check some invalid sequences

-- + Early termination (back to low bytes too soon)

-- + Early restart (another sequence introduction before the previous one was finished)

-- Early termination

encin('\xC2!', encoding)

expect('encout fffd,21')

encin('\xE0!\xE0\xA0!', encoding)

expect('encout fffd,21,fffd,21')

encin('\xF0!\xF0\x90!\xF0\x90\x80!', encoding)

expect('encout fffd,21,fffd,21,fffd,21')

-- Early restart

encin('\xC2\xC2\x90', encoding)

expect('encout fffd,90')

encin('\xE0\xC2\x90\xE0\xA0\xC2\x90', encoding)

expect('encout fffd,90,fffd,90')

encin('\xF0\xC2\x90\xF0\x90\xC2\x90\xF0\x90\x80\xC2\x90', encoding)

expect('encout fffd,90,fffd,90,fffd,90')

-- Test the overlong sequences by giving an overlong encoding of U+0000 and

-- an encoding of the highest codepoint still too short

--

-- Two bytes:

-- U+0000 = C0 80

-- U+007F = 000 01111111 => 00001 111111 =>

-- => 11000001 10111111 => C1 BF

--

-- Three bytes:

-- U+0000 = E0 80 80

-- U+07FF = 00000111 11111111 => 0000 011111 111111

-- => 11100000 10011111 10111111 = E0 9F BF

--

-- Four bytes:

-- U+0000 = F0 80 80 80

-- U+FFFF = 11111111 11111111 => 000 001111 111111 111111

-- => 11110000 10001111 10111111 10111111 = F0 8F BF BF

-- Overlong

encin('\xC0\x80\xC1\xBF', encoding)

expect('encout fffd,fffd')

encin('\xE0\x80\x80\xE0\x9F\xBF', encoding)

expect('encout fffd,fffd')

encin('\xF0\x80\x80\x80\xF0\x8F\xBF\xBF', encoding)

expect('encout fffd,fffd')

-- UTF-16 surrogates U+D800 and U+DFFF

-- UTF-16 Surrogates

encin('\xED\xA0\x80\xED\xBF\xBF', encoding)

expect('encout fffd,fffd')

-- Split write

encin('\xC2', encoding)

encin('\xA0', encoding)

expect('encout a0')

encin('\xE0', encoding)

encin('\xA0\x80', encoding)

expect('encout 800')

encin('\xE0\xA0', encoding)

encin('\x80', encoding)

expect('encout 800')

encin('\xF0', encoding)

encin('\x90\x80\x80', encoding)

expect('encout 10000')

encin('\xF0\x90', encoding)

encin('\x80\x80', encoding)

expect('encout 10000')

encin('\xF0\x90\x80', encoding)

encin('\x80', encoding)

expect('encout 10000')

end)

itp('10state_putglyph', function()

local vt = init()

local state = wantstate(vt, { g = true })

-- Low

reset(state, nil)

push('ABC', vt)

expect('putglyph 41 1 0,0\nputglyph 42 1 0,1\nputglyph 43 1 0,2')

-- UTF-8 1 char

-- U+00C1 = 0xC3 0x81 name: LATIN CAPITAL LETTER A WITH ACUTE

-- U+00E9 = 0xC3 0xA9 name: LATIN SMALL LETTER E WITH ACUTE

reset(state, nil)

push('\xC3\x81\xC3\xA9', vt)

expect('putglyph c1 1 0,0\nputglyph e9 1 0,1')

-- UTF-8 split writes

reset(state, nil)

push('\xC3', vt)

push('\x81', vt)

expect('putglyph c1 1 0,0')

-- UTF-8 wide char

-- U+FF10 = EF BC 90 name: FULLWIDTH DIGIT ZERO

reset(state, nil)

push('\xEF\xBC\x90 ', vt)

expect('putglyph ff10 2 0,0\nputglyph 20 1 0,2')

-- UTF-8 emoji wide char

-- U+1F600 = F0 9F 98 80 name: GRINNING FACE

reset(state, nil)

push('\xF0\x9F\x98\x80 ', vt)

expect('putglyph 1f600 2 0,0\nputglyph 20 1 0,2')

-- UTF-8 combining chars

-- U+0301 = CC 81 name: COMBINING ACUTE

reset(state, nil)

push('e\xCC\x81Z', vt)

expect('putglyph 65,301 1 0,0\nputglyph 5a 1 0,1')

-- Combining across buffers

reset(state, nil)

push('e', vt)

expect('putglyph 65 1 0,0')

push('\xCC\x81Z', vt)

expect('putglyph 65,301 1 0,0\nputglyph 5a 1 0,1')

-- Spare combining chars get truncated

reset(state, nil)

push('e' .. string.rep('\xCC\x81', 20), vt)

expect('putglyph 65,301,301,301,301,301,301,301,301,301,301,301,301,301,301 1 0,0') -- and nothing more

reset(state, nil)

push('e', vt)

expect('putglyph 65 1 0,0')

push('\xCC\x81', vt)

expect('putglyph 65,301 1 0,0')

push('\xCC\x82', vt)