local helpers = require('test.unit.helpers')(after_each)
local itp = helpers.gen_itp(it)
local viml_helpers = require('test.unit.viml.helpers')

local child_call_once = helpers.child_call_once
local conv_enum = helpers.conv_enum
local cimport = helpers.cimport
local ffi = helpers.ffi
local eq = helpers.eq
local shallowcopy = helpers.shallowcopy
local intchar2lua = helpers.intchar2lua

local conv_ccs = viml_helpers.conv_ccs
local new_pstate = viml_helpers.new_pstate
local conv_cmp_type = viml_helpers.conv_cmp_type
local pstate_set_str = viml_helpers.pstate_set_str
local conv_expr_asgn_type = viml_helpers.conv_expr_asgn_type

local lib = cimport('./src/nvim/viml/parser/expressions.h')

local eltkn_type_tab, eltkn_mul_type_tab, eltkn_opt_scope_tab
child_call_once(function()
  eltkn_type_tab = {
    [tonumber(lib.kExprLexInvalid)] = 'Invalid',
    [tonumber(lib.kExprLexMissing)] = 'Missing',
    [tonumber(lib.kExprLexSpacing)] = 'Spacing',
    [tonumber(lib.kExprLexEOC)] = 'EOC',

    [tonumber(lib.kExprLexQuestion)] = 'Question',
    [tonumber(lib.kExprLexColon)] = 'Colon',
    [tonumber(lib.kExprLexOr)] = 'Or',
    [tonumber(lib.kExprLexAnd)] = 'And',
    [tonumber(lib.kExprLexComparison)] = 'Comparison',
    [tonumber(lib.kExprLexPlus)] = 'Plus',
    [tonumber(lib.kExprLexMinus)] = 'Minus',
    [tonumber(lib.kExprLexDot)] = 'Dot',
    [tonumber(lib.kExprLexMultiplication)] = 'Multiplication',

    [tonumber(lib.kExprLexNot)] = 'Not',

    [tonumber(lib.kExprLexNumber)] = 'Number',
    [tonumber(lib.kExprLexSingleQuotedString)] = 'SingleQuotedString',
    [tonumber(lib.kExprLexDoubleQuotedString)] = 'DoubleQuotedString',
    [tonumber(lib.kExprLexOption)] = 'Option',
    [tonumber(lib.kExprLexRegister)] = 'Register',
    [tonumber(lib.kExprLexEnv)] = 'Env',
    [tonumber(lib.kExprLexPlainIdentifier)] = 'PlainIdentifier',

    [tonumber(lib.kExprLexBracket)] = 'Bracket',
    [tonumber(lib.kExprLexFigureBrace)] = 'FigureBrace',
    [tonumber(lib.kExprLexParenthesis)] = 'Parenthesis',
    [tonumber(lib.kExprLexComma)] = 'Comma',
    [tonumber(lib.kExprLexArrow)] = 'Arrow',

    [tonumber(lib.kExprLexAssignment)] = 'Assignment',
  }

  eltkn_mul_type_tab = {
    [tonumber(lib.kExprLexMulMul)] = 'Mul',
    [tonumber(lib.kExprLexMulDiv)] = 'Div',
    [tonumber(lib.kExprLexMulMod)] = 'Mod',
  }

  eltkn_opt_scope_tab = {
    [tonumber(lib.kExprOptScopeUnspecified)] = 'Unspecified',
    [tonumber(lib.kExprOptScopeGlobal)] = 'Global',
    [tonumber(lib.kExprOptScopeLocal)] = 'Local',
  }
end)

local function conv_eltkn_type(typ)
  return conv_enum(eltkn_type_tab, typ)
end

local bracket_types = {
  Bracket = true,
  FigureBrace = true,
  Parenthesis = true,
}

local function eltkn2lua(pstate, tkn)
  local ret = {
    type = conv_eltkn_type(tkn.type),
  }
  pstate_set_str(pstate, tkn.start, tkn.len, ret)
  if not ret.error and (#ret.str ~= ret.len) then
    ret.error = '#str /= len'
  end
  if ret.type == 'Comparison' then
    ret.data = {
      type = conv_cmp_type(tkn.data.cmp.type),
      ccs = conv_ccs(tkn.data.cmp.ccs),
      inv = not not tkn.data.cmp.inv,
    }
  elseif ret.type == 'Multiplication' then
    ret.data = { type = conv_enum(eltkn_mul_type_tab, tkn.data.mul.type) }
  elseif bracket_types[ret.type] then
    ret.data = { closing = not not tkn.data.brc.closing }
  elseif ret.type == 'Register' then
    ret.data = { name = intchar2lua(tkn.data.reg.name) }
  elseif ret.type == 'SingleQuotedString' or ret.type == 'DoubleQuotedString' then
    ret.data = { closed = not not tkn.data.str.closed }
  elseif ret.type == 'Option' then
    ret.data = {
      scope = conv_enum(eltkn_opt_scope_tab, tkn.data.opt.scope),
      name = ffi.string(tkn.data.opt.name, tkn.data.opt.len),
    }
  elseif ret.type == 'PlainIdentifier' then
    ret.data = {
      scope = intchar2lua(tkn.data.var.scope),
      autoload = not not tkn.data.var.autoload,
    }
  elseif ret.type == 'Number' then
    ret.data = {
      is_float = not not tkn.data.num.is_float,
      base = tonumber(tkn.data.num.base),
    }
    ret.data.val =
      tonumber(tkn.data.num.is_float and tkn.data.num.val.floating or tkn.data.num.val.integer)
  elseif ret.type == 'Assignment' then
    ret.data = { type = conv_expr_asgn_type(tkn.data.ass.type) }
  elseif ret.type == 'Invalid' then
    ret.data = { error = ffi.string(tkn.data.err.msg) }
  end
  return ret, tkn
end

local function next_eltkn(pstate, flags)
  return eltkn2lua(pstate, lib.viml_pexpr_next_token(pstate, flags))
end

describe('Expressions lexer', function()
  local flags = 0
  local should_advance = true
  local function check_advance(pstate, bytes_to_advance, initial_col)
    local tgt = initial_col + bytes_to_advance
    if should_advance then
      if pstate.reader.lines.items[0].size == tgt then
        eq(1, pstate.pos.line)
        eq(0, pstate.pos.col)
      else
        eq(0, pstate.pos.line)
        eq(tgt, pstate.pos.col)
      end
    else
      eq(0, pstate.pos.line)
      eq(initial_col, pstate.pos.col)
    end
  end
  local function singl_eltkn_test(typ, str, data)
    local pstate = new_pstate({ str })
    eq(
      { data = data, len = #str, start = { col = 0, line = 0 }, str = str, type = typ },
      next_eltkn(pstate, flags)
    )
    check_advance(pstate, #str, 0)
    if
      not (
        typ == 'Spacing'
        or (typ == 'Register' and str == '@')
        or ((typ == 'SingleQuotedString' or typ == 'DoubleQuotedString') and not data.closed)
      )
    then
      pstate = new_pstate({ str .. ' ' })
      eq(
        { data = data, len = #str, start = { col = 0, line = 0 }, str = str, type = typ },
        next_eltkn(pstate, flags)
      )
      check_advance(pstate, #str, 0)
    end
    pstate = new_pstate({ 'x' .. str })
    pstate.pos.col = 1
    eq(
      { data = data, len = #str, start = { col = 1, line = 0 }, str = str, type = typ },
      next_eltkn(pstate, flags)
    )
    check_advance(pstate, #str, 1)
  end
  local function scope_test(scope)
    singl_eltkn_test('PlainIdentifier', scope .. ':test#var', { autoload = true, scope = scope })
    singl_eltkn_test('PlainIdentifier', scope .. ':', { autoload = false, scope = scope })
  end
  local function comparison_test(op, inv_op, cmp_type)
    singl_eltkn_test('Comparison', op, { type = cmp_type, inv = false, ccs = 'UseOption' })
    singl_eltkn_test('Comparison', inv_op, { type = cmp_type, inv = true, ccs = 'UseOption' })
    singl_eltkn_test('Comparison', op .. '#', { type = cmp_type, inv = false, ccs = 'MatchCase' })
    singl_eltkn_test(
      'Comparison',
      inv_op .. '#',
      { type = cmp_type, inv = true, ccs = 'MatchCase' }
    )
    singl_eltkn_test('Comparison', op .. '?', { type = cmp_type, inv = false, ccs = 'IgnoreCase' })
    singl_eltkn_test(
      'Comparison',
      inv_op .. '?',
      { type = cmp_type, inv = true, ccs = 'IgnoreCase' }
    )
  end
  local function simple_test(pstate_arg, exp_type, exp_len, exp)
    local pstate = new_pstate(pstate_arg)
    exp = shallowcopy(exp)
    exp.type = exp_type
    exp.len = exp_len or #pstate_arg[0]
    exp.start = { col = 0, line = 0 }
    eq(exp, next_eltkn(pstate, flags))
  end
  local function stable_tests()
    singl_eltkn_test('Parenthesis', '(', { closing = false })
    singl_eltkn_test('Parenthesis', ')', { closing = true })
    singl_eltkn_test('Bracket', '[', { closing = false })
    singl_eltkn_test('Bracket', ']', { closing = true })
    singl_eltkn_test('FigureBrace', '{', { closing = false })
    singl_eltkn_test('FigureBrace', '}', { closing = true })
    singl_eltkn_test('Question', '?')
    singl_eltkn_test('Colon', ':')
    singl_eltkn_test('Dot', '.')
    singl_eltkn_test('Assignment', '.=', { type = 'Concat' })
    singl_eltkn_test('Plus', '+')
    singl_eltkn_test('Assignment', '+=', { type = 'Add' })
    singl_eltkn_test('Comma', ',')
    singl_eltkn_test('Multiplication', '*', { type = 'Mul' })
    singl_eltkn_test('Multiplication', '/', { type = 'Div' })
    singl_eltkn_test('Multiplication', '%', { type = 'Mod' })
    singl_eltkn_test('Spacing', '  \t\t  \t\t')
    singl_eltkn_test('Spacing', ' ')
    singl_eltkn_test('Spacing', '\t')
    singl_eltkn_test(
      'Invalid',
      '\x01\x02\x03',
      { error = 'E15: Invalid control character present in input: %.*s' }
    )
    singl_eltkn_test('Number', '0123', { is_float = false, base = 8, val = 83 })
    singl_eltkn_test('Number', '01234567', { is_float = false, base = 8, val = 342391 })
    singl_eltkn_test('Number', '012345678', { is_float = false, base = 10, val = 12345678 })
    singl_eltkn_test('Number', '0x123', { is_float = false, base = 16, val = 291 })
    singl_eltkn_test('Number', '0x56FF', { is_float = false, base = 16, val = 22271 })
    singl_eltkn_test('Number', '0xabcdef', { is_float = false, base = 16, val = 11259375 })
    singl_eltkn_test('Number', '0xABCDEF', { is_float = false, base = 16, val = 11259375 })
    singl_eltkn_test('Number', '0x0', { is_float = false, base = 16, val = 0 })
    singl_eltkn_test('Number', '00', { is_float = false, base = 8, val = 0 })
    singl_eltkn_test('Number', '0b0', { is_float = false, base = 2, val = 0 })
    singl_eltkn_test('Number', '0b010111', { is_float = false, base = 2, val = 23 })
    singl_eltkn_test('Number', '0b100111', { is_float = false, base = 2, val = 39 })
    singl_eltkn_test('Number', '0', { is_float = false, base = 10, val = 0 })
    singl_eltkn_test('Number', '9', { is_float = false, base = 10, val = 9 })
    singl_eltkn_test('Env', '$abc')
    singl_eltkn_test('Env', '$')
    singl_eltkn_test('PlainIdentifier', 'test', { autoload = false, scope = 0 })
    singl_eltkn_test('PlainIdentifier', '_test', { autoload = false, scope = 0 })
    singl_eltkn_test('PlainIdentifier', '_test_foo', { autoload = false, scope = 0 })
    singl_eltkn_test('PlainIdentifier', 't', { autoload = false, scope = 0 })
    singl_eltkn_test('PlainIdentifier', 'test5', { autoload = false, scope = 0 })
    singl_eltkn_test('PlainIdentifier', 't0', { autoload = false, scope = 0 })
    singl_eltkn_test('PlainIdentifier', 'test#var', { autoload = true, scope = 0 })
    singl_eltkn_test('PlainIdentifier', 'test#var#val###', { autoload = true, scope = 0 })
    singl_eltkn_test('PlainIdentifier', 't#####', { autoload = true, scope = 0 })
    singl_eltkn_test('And', '&&')
    singl_eltkn_test('Or', '||')
    singl_eltkn_test('Invalid', '&', { error = 'E112: Option name missing: %.*s' })
    singl_eltkn_test('Option', '&opt', { scope = 'Unspecified', name = 'opt' })
    singl_eltkn_test('Option', '&t_xx', { scope = 'Unspecified', name = 't_xx' })
    singl_eltkn_test('Option', '&t_\r\r', { scope = 'Unspecified', name = 't_\r\r' })
    singl_eltkn_test('Option', '&t_\t\t', { scope = 'Unspecified', name = 't_\t\t' })
    singl_eltkn_test('Option', '&t_  ', { scope = 'Unspecified', name = 't_  ' })
    singl_eltkn_test('Option', '&g:opt', { scope = 'Global', name = 'opt' })
    singl_eltkn_test('Option', '&l:opt', { scope = 'Local', name = 'opt' })
    singl_eltkn_test('Invalid', '&l:', { error = 'E112: Option name missing: %.*s' })
    singl_eltkn_test('Invalid', '&g:', { error = 'E112: Option name missing: %.*s' })
    singl_eltkn_test('Register', '@', { name = -1 })
    singl_eltkn_test('Register', '@a', { name = 'a' })
    singl_eltkn_test('Register', '@\r', { name = 13 })
    singl_eltkn_test('Register', '@ ', { name = ' ' })
    singl_eltkn_test('Register', '@\t', { name = 9 })
    singl_eltkn_test('SingleQuotedString', "'test", { closed = false })
    singl_eltkn_test('SingleQuotedString', "'test'", { closed = true })
    singl_eltkn_test('SingleQuotedString', "''''", { closed = true })
    singl_eltkn_test('SingleQuotedString', "'x'''", { closed = true })
    singl_eltkn_test('SingleQuotedString', "'''x'", { closed = true })
    singl_eltkn_test('SingleQuotedString', "'''", { closed = false })
    singl_eltkn_test('SingleQuotedString', "'x''", { closed = false })
    singl_eltkn_test('SingleQuotedString', "'''x", { closed = false })
    singl_eltkn_test('DoubleQuotedString', '"test', { closed = false })
    singl_eltkn_test('DoubleQuotedString', '"test"', { closed = true })
    singl_eltkn_test('DoubleQuotedString', '"\\""', { closed = true })
    singl_eltkn_test('DoubleQuotedString', '"x\\""', { closed = true })
    singl_eltkn_test('DoubleQuotedString', '"\\"x"', { closed = true })
    singl_eltkn_test('DoubleQuotedString', '"\\"', { closed = false })
    singl_eltkn_test('DoubleQuotedString', '"x\\"', { closed = false })
    singl_eltkn_test('DoubleQuotedString', '"\\"x', { closed = false })
    singl_eltkn_test('Not', '!')
    singl_eltkn_test('Assignment', '=', { type = 'Plain' })
    comparison_test('==', '!=', 'Equal')
    comparison_test('=~', '!~', 'Matches')
    comparison_test('>', '<=', 'Greater')
    comparison_test('>=', '<', 'GreaterOrEqual')
    singl_eltkn_test('Minus', '-')
    singl_eltkn_test('Assignment', '-=', { type = 'Subtract' })
    singl_eltkn_test('Arrow', '->')
    singl_eltkn_test('Invalid', '~', { error = 'E15: Unidentified character: %.*s' })
    simple_test({ { data = nil, size = 0 } }, 'EOC', 0, { error = 'start.col >= #pstr' })
    simple_test({ '' }, 'EOC', 0, { error = 'start.col >= #pstr' })
    simple_test(
      { '2.' },
      'Number',
      1,
      { data = { is_float = false, base = 10, val = 2 }, str = '2' }
    )
    simple_test(
      { '2e5' },
      'Number',
      1,
      { data = { is_float = false, base = 10, val = 2 }, str = '2' }
    )
    simple_test(
      { '2.x' },
      'Number',
      1,
      { data = { is_float = false, base = 10, val = 2 }, str = '2' }
    )
    simple_test(
      { '2.2.' },
      'Number',
      1,
      { data = { is_float = false, base = 10, val = 2 }, str = '2' }
    )
    simple_test(
      { '2.0x' },
      'Number',
      1,
      { data = { is_float = false, base = 10, val = 2 }, str = '2' }
    )
    simple_test(
      { '2.0e' },
      'Number',
      1,
      { data = { is_float = false, base = 10, val = 2 }, str = '2' }
    )
    simple_test(
      { '2.0e+' },
      'Number',
      1,
      { data = { is_float = false, base = 10, val = 2 }, str = '2' }
    )
    simple_test(
      { '2.0e-' },
      'Number',
      1,
      { data = { is_float = false, base = 10, val = 2 }, str = '2' }
    )
    simple_test(
      { '2.0e+x' },
      'Number',
      1,
      { data = { is_float = false, base = 10, val = 2 }, str = '2' }
    )
    simple_test(
      { '2.0e-x' },
      'Number',
      1,
      { data = { is_float = false, base = 10, val = 2 }, str = '2' }
    )
    simple_test(
      { '2.0e+1a' },
      'Number',
      1,
      { data = { is_float = false, base = 10, val = 2 }, str = '2' }
    )
    simple_test(
      { '2.0e-1a' },
      'Number',
      1,
      { data = { is_float = false, base = 10, val = 2 }, str = '2' }
    )
    simple_test(
      { '0b102' },
      'Number',
      4,
      { data = { is_float = false, base = 2, val = 2 }, str = '0b10' }
    )
    simple_test(
      { '10F' },
      'Number',
      2,
      { data = { is_float = false, base = 10, val = 10 }, str = '10' }
    )
    simple_test({ '0x0123456789ABCDEFG' }, 'Number', 18, {
      data = { is_float = false, base = 16, val = 81985529216486895 },
      str = '0x0123456789ABCDEF',
    })
    simple_test(
      { { data = '00', size = 2 } },
      'Number',
      2,
      { data = { is_float = false, base = 8, val = 0 }, str = '00' }
    )
    simple_test(
      { { data = '009', size = 2 } },
      'Number',
      2,
      { data = { is_float = false, base = 8, val = 0 }, str = '00' }
    )
    simple_test(
      { { data = '01', size = 1 } },
      'Number',
      1,
      { data = { is_float = false, base = 10, val = 0 }, str = '0' }
    )
  end

  local function regular_scope_tests()
    scope_test('s')
    scope_test('g')
    scope_test('v')
    scope_test('b')
    scope_test('w')
    scope_test('t')
    scope_test('l')
    scope_test('a')

    simple_test(
      { 'g:' },
      'PlainIdentifier',
      2,
      { data = { scope = 'g', autoload = false }, str = 'g:' }
    )
    simple_test(
      { 'g:is#foo' },
      'PlainIdentifier',
      8,
      { data = { scope = 'g', autoload = true }, str = 'g:is#foo' }
    )
    simple_test(
      { 'g:isnot#foo' },
      'PlainIdentifier',
      11,
      { data = { scope = 'g', autoload = true }, str = 'g:isnot#foo' }
    )
  end

  local function regular_is_tests()
    comparison_test('is', 'isnot', 'Identical')

    simple_test(
      { 'is' },
      'Comparison',
      2,
      { data = { type = 'Identical', inv = false, ccs = 'UseOption' }, str = 'is' }
    )
    simple_test(
      { 'isnot' },
      'Comparison',
      5,
      { data = { type = 'Identical', inv = true, ccs = 'UseOption' }, str = 'isnot' }
    )
    simple_test(
      { 'is?' },
      'Comparison',
      3,
      { data = { type = 'Identical', inv = false, ccs = 'IgnoreCase' }, str = 'is?' }
    )
    simple_test(
      { 'isnot?' },
      'Comparison',
      6,
      { data = { type = 'Identical', inv = true, ccs = 'IgnoreCase' }, str = 'isnot?' }
    )
    simple_test(
      { 'is#' },
      'Comparison',
      3,
      { data = { type = 'Identical', inv = false, ccs = 'MatchCase' }, str = 'is#' }
    )
    simple_test(
      { 'isnot#' },
      'Comparison',
      6,
      { data = { type = 'Identical', inv = true, ccs = 'MatchCase' }, str = 'isnot#' }
    )
    simple_test(
      { 'is#foo' },
      'Comparison',
      3,
      { data = { type = 'Identical', inv = false, ccs = 'MatchCase' }, str = 'is#' }
    )
    simple_test(
      { 'isnot#foo' },
      'Comparison',
      6,
      { data = { type = 'Identical', inv = true, ccs = 'MatchCase' }, str = 'isnot#' }
    )
  end

  local function regular_number_tests()
    simple_test(
      { '2.0' },
      'Number',
      1,
      { data = { is_float = false, base = 10, val = 2 }, str = '2' }
    )
    simple_test(
      { '2.0e5' },
      'Number',
      1,
      { data = { is_float = false, base = 10, val = 2 }, str = '2' }
    )
    simple_test(
      { '2.0e+5' },
      'Number',
      1,
      { data = { is_float = false, base = 10, val = 2 }, str = '2' }
    )
    simple_test(
      { '2.0e-5' },
      'Number',
      1,
      { data = { is_float = false, base = 10, val = 2 }, str = '2' }
    )
  end

  local function regular_eoc_tests()
    singl_eltkn_test('EOC', '|')
    singl_eltkn_test('EOC', '\0')
    singl_eltkn_test('EOC', '\n')
  end

  itp('works (single tokens, zero flags)', function()
    stable_tests()

    regular_eoc_tests()
    regular_scope_tests()
    regular_is_tests()
    regular_number_tests()
  end)
  itp('peeks', function()
    flags = tonumber(lib.kELFlagPeek)
    should_advance = false
    stable_tests()

    regular_eoc_tests()
    regular_scope_tests()
    regular_is_tests()
    regular_number_tests()
  end)
  itp('forbids scope', function()
    flags = tonumber(lib.kELFlagForbidScope)
    stable_tests()

    regular_eoc_tests()
    regular_is_tests()
    regular_number_tests()

    simple_test(
      { 'g:' },
      'PlainIdentifier',
      1,
      { data = { scope = 0, autoload = false }, str = 'g' }
    )
  end)
  itp('allows floats', function()
    flags = tonumber(lib.kELFlagAllowFloat)
    stable_tests()

    regular_eoc_tests()
    regular_scope_tests()
    regular_is_tests()

    simple_test(
      { '2.2' },
      'Number',
      3,
      { data = { is_float = true, base = 10, val = 2.2 }, str = '2.2' }
    )
    simple_test(
      { '2.0e5' },
      'Number',
      5,
      { data = { is_float = true, base = 10, val = 2e5 }, str = '2.0e5' }
    )
    simple_test(
      { '2.0e+5' },
      'Number',
      6,
      { data = { is_float = true, base = 10, val = 2e5 }, str = '2.0e+5' }
    )
    simple_test(
      { '2.0e-5' },
      'Number',
      6,
      { data = { is_float = true, base = 10, val = 2e-5 }, str = '2.0e-5' }
    )
    simple_test(
      { '2.500000e-5' },
      'Number',
      11,
      { data = { is_float = true, base = 10, val = 2.5e-5 }, str = '2.500000e-5' }
    )
    simple_test(
      { '2.5555e2' },
      'Number',
      8,
      { data = { is_float = true, base = 10, val = 2.5555e2 }, str = '2.5555e2' }
    )
    simple_test(
      { '2.5555e+2' },
      'Number',
      9,
      { data = { is_float = true, base = 10, val = 2.5555e2 }, str = '2.5555e+2' }
    )
    simple_test(
      { '2.5555e-2' },
      'Number',
      9,
      { data = { is_float = true, base = 10, val = 2.5555e-2 }, str = '2.5555e-2' }
    )
    simple_test(
      { { data = '2.5e-5', size = 3 } },
      'Number',
      3,
      { data = { is_float = true, base = 10, val = 2.5 }, str = '2.5' }
    )
    simple_test(
      { { data = '2.5e5', size = 4 } },
      'Number',
      1,
      { data = { is_float = false, base = 10, val = 2 }, str = '2' }
    )
    simple_test(
      { { data = '2.5e-50', size = 6 } },
      'Number',
      6,
      { data = { is_float = true, base = 10, val = 2.5e-5 }, str = '2.5e-5' }
    )
  end)
  itp('treats `is` as an identifier', function()
    flags = tonumber(lib.kELFlagIsNotCmp)
    stable_tests()

    regular_eoc_tests()
    regular_scope_tests()
    regular_number_tests()

    simple_test(
      { 'is' },
      'PlainIdentifier',
      2,
      { data = { scope = 0, autoload = false }, str = 'is' }
    )
    simple_test(
      { 'isnot' },
      'PlainIdentifier',
      5,
      { data = { scope = 0, autoload = false }, str = 'isnot' }
    )
    simple_test(
      { 'is?' },
      'PlainIdentifier',
      2,
      { data = { scope = 0, autoload = false }, str = 'is' }
    )
    simple_test(
      { 'isnot?' },
      'PlainIdentifier',
      5,
      { data = { scope = 0, autoload = false }, str = 'isnot' }
    )
    simple_test(
      { 'is#' },
      'PlainIdentifier',
      3,
      { data = { scope = 0, autoload = true }, str = 'is#' }
    )
    simple_test(
      { 'isnot#' },
      'PlainIdentifier',
      6,
      { data = { scope = 0, autoload = true }, str = 'isnot#' }
    )
    simple_test(
      { 'is#foo' },
      'PlainIdentifier',
      6,
      { data = { scope = 0, autoload = true }, str = 'is#foo' }
    )
    simple_test(
      { 'isnot#foo' },
      'PlainIdentifier',
      9,
      { data = { scope = 0, autoload = true }, str = 'isnot#foo' }
    )
  end)
  itp('forbids EOC', function()
    flags = tonumber(lib.kELFlagForbidEOC)
    stable_tests()

    regular_scope_tests()
    regular_is_tests()
    regular_number_tests()

    singl_eltkn_test('Invalid', '|', { error = 'E15: Unexpected EOC character: %.*s' })
    singl_eltkn_test('Invalid', '\0', { error = 'E15: Unexpected EOC character: %.*s' })
    singl_eltkn_test('Invalid', '\n', { error = 'E15: Unexpected EOC character: %.*s' })
  end)
end)