" Test for commands that operate on the spellfile.

CheckFeature spell
CheckFeature syntax

func Test_spell_normal()
  new
  call append(0, ['1 good', '2 goood', '3 goood'])
  set spell spellfile=./Xspellfile.add spelllang=en
  let oldlang=v:lang
  lang C

  " Test for zg
  1
  norm! ]s
  call assert_equal('2 goood', getline('.'))
  norm! zg
  1
  let a=execute('unsilent :norm! ]s')
  call assert_equal('1 good', getline('.'))
  call assert_equal('search hit BOTTOM, continuing at TOP', a[1:])
  let cnt=readfile('./Xspellfile.add')
  call assert_equal('goood', cnt[0])

  " zg should fail in operator-pending mode
  call assert_beeps('norm! czg')

  " zg fails in visual mode when not able to get the visual text
  call assert_beeps('norm! ggVjzg')
  norm! V

  " zg fails for a non-identifier word
  call append(line('$'), '###')
  call assert_fails('norm! Gzg', 'E349:')
  $d

  " Test for zw
  2
  norm! $zw
  1
  norm! ]s
  call assert_equal('2 goood', getline('.'))
  let cnt=readfile('./Xspellfile.add')
  call assert_equal('#oood', cnt[0])
  call assert_equal('goood/!', cnt[1])

  " Test for :spellrare
  spellrare rare
  let cnt=readfile('./Xspellfile.add')
  call assert_equal(['#oood', 'goood/!', 'rare/?'], cnt)

  " Make sure :spellundo works for rare words.
  spellundo rare
  let cnt=readfile('./Xspellfile.add')
  call assert_equal(['#oood', 'goood/!', '#are/?'], cnt)

  " Test for zg in visual mode
  let a=execute('unsilent :norm! V$zg')
  call assert_equal("Word '2 goood' added to ./Xspellfile.add", a[1:])
  1
  norm! ]s
  call assert_equal('3 goood', getline('.'))
  let cnt=readfile('./Xspellfile.add')
  call assert_equal('2 goood', cnt[3])
  " Remove "2 good" from spellfile
  2
  let a=execute('unsilent norm! V$zw')
  call assert_equal("Word '2 goood' added to ./Xspellfile.add", a[1:])
  let cnt=readfile('./Xspellfile.add')
  call assert_equal('2 goood/!', cnt[4])

  " Test for zG
  let a=execute('unsilent norm! V$zG')
  call assert_match("Word '2 goood' added to .*", a)
  let fname=matchstr(a, 'to\s\+\zs\f\+$')
  let cnt=readfile(fname)
  call assert_equal('2 goood', cnt[0])

  " Test for zW
  let a=execute('unsilent norm! V$zW')
  call assert_match("Word '2 goood' added to .*", a)
  let cnt=readfile(fname)
  call assert_equal('# goood', cnt[0])
  call assert_equal('2 goood/!', cnt[1])

  " Test for zuW
  let a=execute('unsilent norm! V$zuW')
  call assert_match("Word '2 goood' removed from .*", a)
  let cnt=readfile(fname)
  call assert_equal('# goood', cnt[0])
  call assert_equal('# goood/!', cnt[1])

  " Test for zuG
  let a=execute('unsilent norm! $zG')
  call assert_match("Word 'goood' added to .*", a)
  let cnt=readfile(fname)
  call assert_equal('# goood', cnt[0])
  call assert_equal('# goood/!', cnt[1])
  call assert_equal('goood', cnt[2])
  let a=execute('unsilent norm! $zuG')
  let cnt=readfile(fname)
  call assert_match("Word 'goood' removed from .*", a)
  call assert_equal('# goood', cnt[0])
  call assert_equal('# goood/!', cnt[1])
  call assert_equal('#oood', cnt[2])
  " word not found in wordlist
  let a=execute('unsilent norm! V$zuG')
  let cnt=readfile(fname)
  call assert_match("", a)
  call assert_equal('# goood', cnt[0])
  call assert_equal('# goood/!', cnt[1])
  call assert_equal('#oood', cnt[2])

  " Test for zug
  call delete('./Xspellfile.add')
  2
  let a=execute('unsilent norm! $zg')
  let cnt=readfile('./Xspellfile.add')
  call assert_equal('goood', cnt[0])
  let a=execute('unsilent norm! $zug')
  call assert_match("Word 'goood' removed from \./Xspellfile.add", a)
  let cnt=readfile('./Xspellfile.add')
  call assert_equal('#oood', cnt[0])
  " word not in wordlist
  let a=execute('unsilent norm! V$zug')
  call assert_match('', a)
  let cnt=readfile('./Xspellfile.add')
  call assert_equal('#oood', cnt[0])

  " Test for zuw
  call delete('./Xspellfile.add')
  2
  let a=execute('unsilent norm! Vzw')
  let cnt=readfile('./Xspellfile.add')
  call assert_equal('2 goood/!', cnt[0])
  let a=execute('unsilent norm! Vzuw')
  call assert_match("Word '2 goood' removed from \./Xspellfile.add", a)
  let cnt=readfile('./Xspellfile.add')
  call assert_equal('# goood/!', cnt[0])
  " word not in wordlist
  let a=execute('unsilent norm! $zug')
  call assert_match('', a)
  let cnt=readfile('./Xspellfile.add')
  call assert_equal('# goood/!', cnt[0])

  " add second entry to spellfile setting
  set spellfile=./Xspellfile.add,./Xspellfile2.add
  call delete('./Xspellfile.add')
  2
  let a=execute('unsilent norm! $2zg')
  let cnt=readfile('./Xspellfile2.add')
  call assert_match("Word 'goood' added to ./Xspellfile2.add", a)
  call assert_equal('goood', cnt[0])

  " Test for :spellgood!
  let temp = execute(':spe!0/0')
  call assert_match('Invalid region', temp)
  let spellfile = matchstr(temp, 'Invalid region nr in \zs.*\ze line \d: 0')
  call assert_equal(['# goood', '# goood/!', '#oood', '0/0'], readfile(spellfile))

  " Test for :spellrare!
  :spellrare! raare
  call assert_equal(['# goood', '# goood/!', '#oood', '0/0', 'raare/?'], readfile(spellfile))
  call delete(spellfile)

  " clean up
  exe "lang" oldlang
  call delete("./Xspellfile.add")
  call delete("./Xspellfile2.add")
  call delete("./Xspellfile.add.spl")
  call delete("./Xspellfile2.add.spl")

  " zux -> no-op
  2
  norm! $zux
  call assert_equal([], glob('Xspellfile.add',0,1))
  call assert_equal([], glob('Xspellfile2.add',0,1))

  set spellfile= spell& spelllang&
  bw!
endfunc

" Spell file content test. Write 'content' to the spell file prefixed by the
" spell file header and then enable spell checking. If 'emsg' is not empty,
" then check for error.
func Spellfile_Test(content, emsg)
  let splfile = './Xtest/spell/Xtest.utf-8.spl'
  " Add the spell file header and version (VIMspell2)
  let v = 0z56494D7370656C6C32 + a:content
  call writefile(v, splfile, 'b')

  " 'encoding' is set before each test to clear the previously loaded suggest
  " file from memory.
  set encoding=utf-8

  set runtimepath=./Xtest
  set spelllang=Xtest
  if a:emsg != ''
    call assert_fails('set spell', a:emsg)
  else
    " FIXME: With some invalid spellfile contents, there are no error
    " messages. So don't know how to check for the test result.
    set spell
  endif
  set nospell spelllang& rtp&
endfunc

" Test for spell file format errors.
" The spell file format is described in spellfile.c
func Test_spellfile_format_error()
  let save_rtp = &rtp
  call mkdir('Xtest/spell', 'pR')
  let splfile = './Xtest/spell/Xtest.utf-8.spl'

  " empty spell file
  call writefile([], splfile)
  set runtimepath=./Xtest
  set spelllang=Xtest
  call assert_fails('set spell', 'E757:')
  set nospell spelllang&

  " invalid file ID
  call writefile(0z56494D, splfile, 'b')
  set runtimepath=./Xtest
  set spelllang=Xtest
  call assert_fails('set spell', 'E757:')
  set nospell spelllang&

  " missing version number
  call writefile(0z56494D7370656C6C, splfile, 'b')
  set runtimepath=./Xtest
  set spelllang=Xtest
  call assert_fails('set spell', 'E771:')
  set nospell spelllang&

  " invalid version number
  call writefile(0z56494D7370656C6C7A, splfile, 'b')
  set runtimepath=./Xtest
  set spelllang=Xtest
  call assert_fails('set spell', 'E772:')
  set nospell spelllang&

  " no sections
  call Spellfile_Test(0z, 'E758:')

  " missing section length
  call Spellfile_Test(0z00, 'E758:')

  " unsupported required section
  call Spellfile_Test(0z7A0100000004, 'E770:')

  " unsupported not-required section
  call Spellfile_Test(0z7A0000000004, 'E758:')

  " SN_REGION: invalid number of region names
  call Spellfile_Test(0z0000000000FF, 'E759:')

  " SN_CHARFLAGS: missing <charflagslen> length
  call Spellfile_Test(0z010000000004, 'E758:')

  " SN_CHARFLAGS: invalid <charflagslen> length
  call Spellfile_Test(0z0100000000010201, '')

  " SN_CHARFLAGS: charflagslen == 0 and folcharslen != 0
  call Spellfile_Test(0z01000000000400000101, 'E759:')

  " SN_CHARFLAGS: missing <folcharslen> length
  call Spellfile_Test(0z01000000000100, 'E758:')

  " SN_PREFCOND: invalid prefcondcnt
  call Spellfile_Test(0z03000000000100, 'E759:')

  " SN_PREFCOND: invalid condlen
  call Spellfile_Test(0z0300000000020001, 'E759:')

  " SN_REP: invalid repcount
  call Spellfile_Test(0z04000000000100, 'E758:')

  " SN_REP: missing rep
  call Spellfile_Test(0z0400000000020004, 'E758:')

  " SN_REP: zero repfromlen
  call Spellfile_Test(0z040000000003000100, 'E759:')

  " SN_REP: invalid reptolen
  call Spellfile_Test(0z0400000000050001014101, '')

  " SN_REP: zero reptolen
  call Spellfile_Test(0z0400000000050001014100, 'E759:')

  " SN_SAL: missing salcount
  call Spellfile_Test(0z05000000000102, 'E758:')

  " SN_SAL: missing salfromlen
  call Spellfile_Test(0z050000000003080001, 'E758:')

  " SN_SAL: missing saltolen
  call Spellfile_Test(0z0500000000050400010161, 'E758:')

  " SN_WORDS: non-NUL terminated word
  call Spellfile_Test(0z0D000000000376696D, 'E758:')

  " SN_WORDS: very long word
  let v = eval('0z0D000000012C' .. repeat('41', 300))
  call Spellfile_Test(v, 'E759:')

  " SN_SOFO: missing sofofromlen
  call Spellfile_Test(0z06000000000100, 'E758:')

  " SN_SOFO: missing sofotolen
  call Spellfile_Test(0z06000000000400016100, 'E758:')

  " SN_SOFO: missing sofoto
  call Spellfile_Test(0z0600000000050001610000, 'E759:')

  " SN_SOFO: empty sofofrom and sofoto
  call Spellfile_Test(0z06000000000400000000FF000000000000000000000000, '')

  " SN_SOFO: multi-byte characters in sofofrom and sofoto
  call Spellfile_Test(0z0600000000080002CF810002CF82FF000000000000000000000000, '')

  " SN_COMPOUND: compmax is less than 2
  call Spellfile_Test(0z08000000000101, 'E759:')

  " SN_COMPOUND: missing compsylmax and other options
  call Spellfile_Test(0z0800000000020401, 'E759:')

  " SN_COMPOUND: missing compoptions
  call Spellfile_Test(0z080000000005040101, 'E758:')

  " SN_COMPOUND: missing comppattern
  call Spellfile_Test(0z08000000000704010100000001, 'E758:')

  " SN_COMPOUND: incorrect comppatlen
  call Spellfile_Test(0z080000000007040101000000020165, 'E758:')

  " SN_COMPOUND: oversized sectionlen
  let v = eval('0z08004000000803010161' .. repeat('61', 50) .. 'FF')
  call Spellfile_Test(v, 'E759:')

  " SN_INFO: missing info
  call Spellfile_Test(0z0F0000000005040101, '')

  " SN_MIDWORD: missing midword
  call Spellfile_Test(0z0200000000040102, '')

  " SN_MAP: missing midword
  call Spellfile_Test(0z0700000000040102, '')

  " SN_MAP: empty map string
  call Spellfile_Test(0z070000000000FF000000000000000000000000, '')

  " SN_MAP: duplicate multibyte character
  call Spellfile_Test(0z070000000004DC81DC81, 'E783:')

  " SN_SYLLABLE: missing SYLLABLE item
  call Spellfile_Test(0z0900000000040102, '')

  " SN_SYLLABLE: More than SY_MAXLEN size
  let v = eval('0z090000000022612F' .. repeat('62', 32))
  call Spellfile_Test(v, '')

  " LWORDTREE: missing
  call Spellfile_Test(0zFF, 'E758:')

  " LWORDTREE: missing tree node
  call Spellfile_Test(0zFF00000004, 'E758:')

  " LWORDTREE: missing tree node value
  call Spellfile_Test(0zFF0000000402, 'E758:')

  " LWORDTREE: incorrect sibling node count
  call Spellfile_Test(0zFF00000001040000000000000000, 'E759:')

  " LWORDTREE: declared nodecount larger than the tree actually fills.
  " Root has two siblings: 'x' (recurses into an end-of-word at idx 3..4)
  " and BY_INDEX targeting position 9.  Tree fills positions 0..4, leaving
  " 5..9 unwritten — byts[9] would be uninitialized without the fix.
  call Spellfile_Test(0zFF0000000A02780100000979010000000000000000000000, 'E759:')

  " LWORDTREE: recursion depth past MAXWLEN.  A linear chain of 254
  " (siblingcount=1, byte='a') frames drives read_tree_node to depth
  " MAXWLEN where the new guard rejects.  The trailing (01 00) gives the
  " chain a clean end-of-word so an *unguarded* parser would accept the
  " file silently — that's what makes this a meaningful regression test
  " for the depth check specifically (a deeper chain would also crash
  " unguarded builds via stack overflow, which we don't want in CI).
  let v = eval('0zFF00000200' .. repeat('0161', 255)
               \ .. '0100' ..  repeat('00', 8))

  call Spellfile_Test(v, 'E759:')

  " KWORDTREE: missing tree node
  call Spellfile_Test(0zFF0000000000000004, 'E758:')

  " PREFIXTREE: missing tree node
  call Spellfile_Test(0zFF000000000000000000000004, 'E758:')

  " PREFIXTREE: incorrect prefcondnr
  call Spellfile_Test(0zFF000000000000000000000002010200000020, 'E759:')

  " PREFIXTREE: invalid nodeidx
  call Spellfile_Test(0zFF00000000000000000000000201010000, 'E759:')

  let &rtp = save_rtp
endfunc

" Test for format errors in suggest file
func Test_sugfile_format_error()
  let save_rtp = &rtp
  call mkdir('Xtest/spell', 'pR')
  let splfile = './Xtest/spell/Xtest.utf-8.spl'
  let sugfile = './Xtest/spell/Xtest.utf-8.sug'

  " create an empty spell file with a suggest timestamp
  call writefile(0z56494D7370656C6C320B00000000080000000000000044FF000000000000000000000000, splfile, 'b')

  " 'encoding' is set before each test to clear the previously loaded suggest
  " file from memory.

  " empty suggest file
  set encoding=utf-8
  call writefile([], sugfile)
  set runtimepath=./Xtest
  set spelllang=Xtest
  set spell
  call assert_fails("let s = spellsuggest('abc')", 'E778:')
  set nospell spelllang&

  " zero suggest version
  set encoding=utf-8
  call writefile(0z56494D73756700, sugfile)
  set runtimepath=./Xtest
  set spelllang=Xtest
  set spell
  call assert_fails("let s = spellsuggest('abc')", 'E779:')
  set nospell spelllang&

  " unsupported suggest version
  set encoding=utf-8
  call writefile(0z56494D7375671F, sugfile)
  set runtimepath=./Xtest
  set spelllang=Xtest
  set spell
  call assert_fails("let s = spellsuggest('abc')", 'E780:')
  set nospell spelllang&

  " missing suggest timestamp
  set encoding=utf-8
  call writefile(0z56494D73756701, sugfile)
  set runtimepath=./Xtest
  set spelllang=Xtest
  set spell
  call assert_fails("let s = spellsuggest('abc')", 'E781:')
  set nospell spelllang&

  " incorrect suggest timestamp
  set encoding=utf-8
  call writefile(0z56494D7375670100000000000000FF, sugfile)
  set runtimepath=./Xtest
  set spelllang=Xtest
  set spell
  call assert_fails("let s = spellsuggest('abc')", 'E781:')
  set nospell spelllang&

  " missing suggest wordtree
  set encoding=utf-8
  call writefile(0z56494D737567010000000000000044, sugfile)
  set runtimepath=./Xtest
  set spelllang=Xtest
  set spell
  call assert_fails("let s = spellsuggest('abc')", 'E782:')
  set nospell spelllang&

  " invalid suggest word count in SUGTABLE
  set encoding=utf-8
  call writefile(0z56494D7375670100000000000000440000000022, sugfile)
  set runtimepath=./Xtest
  set spelllang=Xtest
  set spell
  call assert_fails("let s = spellsuggest('abc')", 'E782:')
  set nospell spelllang&

  " missing sugline in SUGTABLE
  set encoding=utf-8
  call writefile(0z56494D7375670100000000000000440000000000000005, sugfile)
  set runtimepath=./Xtest
  set spelllang=Xtest
  set spell
  call assert_fails("let s = spellsuggest('abc')", 'E782:')
  set nospell spelllang&

  let &rtp = save_rtp
endfunc

" Test for using :mkspell to create a spell file from a list of words
func Test_wordlist_dic()
  " duplicate encoding
  let lines =<< trim [END]
    # This is an example word list

    /encoding=latin1
    /encoding=latin1
    example
  [END]
  call writefile(lines, 'Xwordlist.dic', 'D')
  let output = execute('mkspell Xwordlist.spl Xwordlist.dic')
  call assert_match('Duplicate /encoding= line ignored in Xwordlist.dic line 4: /encoding=latin1', output)

  " multiple encoding for a word
  let lines =<< trim [END]
    example
    /encoding=latin1
    example
  [END]
  call writefile(lines, 'Xwordlist.dic')
  let output = execute('mkspell! Xwordlist.spl Xwordlist.dic')
  call assert_match('/encoding= line after word ignored in Xwordlist.dic line 2: /encoding=latin1', output)

  " unsupported encoding for a word
  let lines =<< trim [END]
    /encoding=Xtest
    example
  [END]
  call writefile(lines, 'Xwordlist.dic')
  let output = execute('mkspell! Xwordlist.spl Xwordlist.dic')
  call assert_match('Conversion in Xwordlist.dic not supported: from Xtest to utf-8', output)

  " duplicate region
  let lines =<< trim [END]
    /regions=usca
    /regions=usca
    example
  [END]
  call writefile(lines, 'Xwordlist.dic')
  let output = execute('mkspell! Xwordlist.spl Xwordlist.dic')
  call assert_match('Duplicate /regions= line ignored in Xwordlist.dic line 2: regions=usca', output)

  " maximum regions
  let lines =<< trim [END]
    /regions=uscauscauscauscausca
    example
  [END]
  call writefile(lines, 'Xwordlist.dic')
  let output = execute('mkspell! Xwordlist.spl Xwordlist.dic')
  call assert_match('Too many regions in Xwordlist.dic line 1: uscauscauscauscausca', output)

  " unsupported '/' value
  let lines =<< trim [END]
    /test=abc
    example
  [END]
  call writefile(lines, 'Xwordlist.dic')
  let output = execute('mkspell! Xwordlist.spl Xwordlist.dic')
  call assert_match('/ line ignored in Xwordlist.dic line 1: /test=abc', output)

  " unsupported flag
  let lines =<< trim [END]
    example/+
  [END]
  call writefile(lines, 'Xwordlist.dic')
  let output = execute('mkspell! Xwordlist.spl Xwordlist.dic')
  call assert_match('Unrecognized flags in Xwordlist.dic line 1: +', output)

  " non-ascii word
  call writefile(["ʀʀ"], 'Xwordlist.dic')
  let output = execute('mkspell! -ascii Xwordlist.spl Xwordlist.dic')
  call assert_match('Ignored 1 words with non-ASCII characters', output)

  " keep case of a word
  let lines =<< trim [END]
    example/=
  [END]
  call writefile(lines, 'Xwordlist.dic')
  let output = execute('mkspell! Xwordlist.spl Xwordlist.dic')
  call assert_match('Compressed keep-case:', output)

  call delete('Xwordlist.spl')
endfunc

" Test for the :mkspell command
func Test_mkspell()
  call assert_fails('mkspell Xtest_us.spl', 'E751:')
  call assert_fails('mkspell Xtest.spl abc', 'E484:')
  call assert_fails('mkspell a b c d e f g h i j k', 'E754:')

  " create a .aff file but not the .dic file
  call writefile([], 'Xtest.aff')
  call assert_fails('mkspell Xtest.spl Xtest', 'E484:')
  call delete('Xtest.aff')

  call writefile([], 'Xtest.spl')
  call writefile([], 'Xtest.dic')
  call assert_fails('mkspell Xtest.spl Xtest.dic', 'E13:')
  call delete('Xtest.spl')
  call delete('Xtest.dic')

  call mkdir('Xtest.spl')
  call assert_fails('mkspell! Xtest.spl Xtest.dic', 'E17:')
  call delete('Xtest.spl', 'rf')

  " can't write the .spl file as its directory does not exist
  call writefile([], 'Xtest.aff')
  call writefile([], 'Xtest.dic')
  call assert_fails('mkspell DOES_NOT_EXIT/Xtest.spl Xtest.dic', 'E484:')
  call delete('Xtest.aff')
  call delete('Xtest.dic')

  call assert_fails('mkspell en en_US abc_xyz', 'E755:')
endfunc

" Tests for :mkspell with a .dic and .aff file
func Test_aff_file_format_error()
  " FIXME: For some reason, the :mkspell command below doesn't fail on the
  " MS-Windows CI build. Disable this test on MS-Windows for now.
  CheckNotMSWindows

  " No word count in .dic file
  call writefile([], 'Xtest.dic', 'D')
  call writefile([], 'Xtest.aff', 'D')
  call assert_fails('mkspell! Xtest.spl Xtest', 'E760:')

  " create a .dic file for the tests below
  call writefile(['1', 'work'], 'Xtest.dic')

  " Invalid encoding in .aff file
  call writefile(['# comment', 'SET Xinvalidencoding'], 'Xtest.aff')
  let output = execute('mkspell! Xtest.spl Xtest')
  call assert_match('Conversion in Xtest.aff not supported: from xinvalidencoding', output)

  " Invalid flag in .aff file
  call writefile(['FLAG xxx'], 'Xtest.aff')
  let output = execute('mkspell! Xtest.spl Xtest')
  call assert_match('Invalid value for FLAG in Xtest.aff line 1: xxx', output)

  " set FLAGS after using flag for an affix
  call writefile(['SFX L Y 1', 'SFX L 0 re [^x]', 'FLAG long'], 'Xtest.aff')
  let output = execute('mkspell! Xtest.spl Xtest')
  call assert_match('FLAG after using flags in Xtest.aff line 3: long', output)

  " INFO in affix file
  let save_encoding = &encoding
  call mkdir('Xrtp/spell', 'p')
  call writefile(['1', 'work'], 'Xrtp/spell/Xtest.dic')
  call writefile(['NAME klingon', 'VERSION 1.4', 'AUTHOR Spock'],
        \ 'Xrtp/spell/Xtest.aff')
  silent mkspell! Xrtp/spell/Xtest.utf-8.spl Xrtp/spell/Xtest
  let save_rtp = &rtp
  set runtimepath=./Xrtp
  set spelllang=Xtest
  set spell
  let output = split(execute('spellinfo'), "\n")
  call assert_equal("NAME klingon", output[1])
  call assert_equal("VERSION 1.4", output[2])
  call assert_equal("AUTHOR Spock", output[3])
  let &rtp = save_rtp
  call delete('Xrtp', 'rf')
  set spell& spelllang& spellfile&
  %bw!
  " 'encoding' must be set again to clear the spell file in memory
  let &encoding = save_encoding

  " COMPOUNDFORBIDFLAG flag after PFX in an affix file
  call writefile(['PFX L Y 1', 'PFX L 0 re x', 'COMPOUNDFLAG c', 'COMPOUNDFORBIDFLAG x'],
        \ 'Xtest.aff')
  let output = execute('mkspell! Xtest.spl Xtest')
  call assert_match('Defining COMPOUNDFORBIDFLAG after PFX item may give wrong results in Xtest.aff line 4', output)

  " COMPOUNDPERMITFLAG flag after PFX in an affix file
  call writefile(['PFX L Y 1', 'PFX L 0 re x', 'COMPOUNDPERMITFLAG c'],
        \ 'Xtest.aff')
  let output = execute('mkspell! Xtest.spl Xtest')
  call assert_match('Defining COMPOUNDPERMITFLAG after PFX item may give wrong results in Xtest.aff line 3', output)

  " Wrong COMPOUNDRULES flag value in an affix file
  call writefile(['COMPOUNDRULES a'], 'Xtest.aff')
  let output = execute('mkspell! Xtest.spl Xtest')
  call assert_match('Wrong COMPOUNDRULES value in Xtest.aff line 1: a', output)

  " Wrong COMPOUNDWORDMAX flag value in an affix file
  call writefile(['COMPOUNDWORDMAX 0'], 'Xtest.aff')
  let output = execute('mkspell! Xtest.spl Xtest')
  call assert_match('Wrong COMPOUNDWORDMAX value in Xtest.aff line 1: 0', output)

  " Wrong COMPOUNDMIN flag value in an affix file
  call writefile(['COMPOUNDMIN 0'], 'Xtest.aff')
  let output = execute('mkspell! Xtest.spl Xtest')
  call assert_match('Wrong COMPOUNDMIN value in Xtest.aff line 1: 0', output)

  " Wrong COMPOUNDSYLMAX flag value in an affix file
  call writefile(['COMPOUNDSYLMAX 0'], 'Xtest.aff')
  let output = execute('mkspell! Xtest.spl Xtest')
  call assert_match('Wrong COMPOUNDSYLMAX value in Xtest.aff line 1: 0', output)

  " Wrong CHECKCOMPOUNDPATTERN flag value in an affix file
  call writefile(['CHECKCOMPOUNDPATTERN 0'], 'Xtest.aff')
  let output = execute('mkspell! Xtest.spl Xtest')
  call assert_match('Wrong CHECKCOMPOUNDPATTERN value in Xtest.aff line 1: 0', output)

  " Both compounding and NOBREAK specified
  call writefile(['COMPOUNDFLAG c', 'NOBREAK'], 'Xtest.aff')
  let output = execute('mkspell! Xtest.spl Xtest')
  call assert_match('Warning: both compounding and NOBREAK specified', output)

  " Duplicate affix entry in an affix file
  call writefile(['PFX L Y 1', 'PFX L 0 re x', 'PFX L Y 1', 'PFX L 0 re x'],
        \ 'Xtest.aff')
  let output = execute('mkspell! Xtest.spl Xtest')
  call assert_match('Duplicate affix in Xtest.aff line 3: L', output)

  " Duplicate affix entry in an affix file
  call writefile(['PFX L Y 1', 'PFX L Y 1'], 'Xtest.aff')
  let output = execute('mkspell! Xtest.spl Xtest')
  call assert_match('Unrecognized or duplicate item in Xtest.aff line 2: PFX', output)

  " Different combining flags in an affix file
  call writefile(['PFX L Y 1', 'PFX L 0 re x', 'PFX L N 1'], 'Xtest.aff')
  let output = execute('mkspell! Xtest.spl Xtest')
  call assert_match('Different combining flag in continued affix block in Xtest.aff line 3', output)

  " Try to reuse an affix used for BAD flag
  call writefile(['BAD x', 'PFX x Y 1', 'PFX x 0 re x'], 'Xtest.aff')
  let output = execute('mkspell! Xtest.spl Xtest')
  call assert_match('Affix also used for BAD/RARE/KEEPCASE/NEEDAFFIX/NEEDCOMPOUND/NOSUGGEST in Xtest.aff line 2: x', output)

  " Trailing characters in an affix entry
  call writefile(['PFX L Y 1 Test', 'PFX L 0 re x'], 'Xtest.aff')
  let output = execute('mkspell! Xtest.spl Xtest')
  call assert_match('Trailing text in Xtest.aff line 1: Test', output)

  " Trailing characters in an affix entry
  call writefile(['PFX L Y 1', 'PFX L 0 re x Test'], 'Xtest.aff')
  let output = execute('mkspell! Xtest.spl Xtest')
  call assert_match('Trailing text in Xtest.aff line 2: Test', output)

  " Incorrect combine flag in an affix entry
  call writefile(['PFX L X 1', 'PFX L 0 re x'], 'Xtest.aff')
  let output = execute('mkspell! Xtest.spl Xtest')
  call assert_match('Expected Y or N in Xtest.aff line 1: X', output)

  " Invalid count for REP item
  call writefile(['REP a'], 'Xtest.aff')
  let output = execute('mkspell! Xtest.spl Xtest')
  call assert_match('Expected REP(SAL) count in Xtest.aff line 1', output)

  " Trailing characters in REP item
  call writefile(['REP 1', 'REP f ph test'], 'Xtest.aff')
  let output = execute('mkspell! Xtest.spl Xtest')
  call assert_match('Trailing text in Xtest.aff line 2: test', output)

  " Invalid count for MAP item
  call writefile(['MAP a'], 'Xtest.aff')
  let output = execute('mkspell! Xtest.spl Xtest')
  call assert_match('Expected MAP count in Xtest.aff line 1', output)

  " Duplicate character in a MAP item
  call writefile(['MAP 2', 'MAP xx', 'MAP yy'], 'Xtest.aff')
  let output = execute('mkspell! Xtest.spl Xtest')
  call assert_match('Duplicate character in MAP in Xtest.aff line 2', output)

  " Use COMPOUNDSYLMAX without SYLLABLE
  call writefile(['COMPOUNDSYLMAX 2'], 'Xtest.aff')
  let output = execute('mkspell! Xtest.spl Xtest')
  call assert_match('COMPOUNDSYLMAX used without SYLLABLE', output)

  " Missing SOFOTO
  call writefile(['SOFOFROM abcdef'], 'Xtest.aff')
  let output = execute('mkspell! Xtest.spl Xtest')
  call assert_match('Missing SOFOTO line in Xtest.aff', output)

  " Length of SOFOFROM and SOFOTO differ
  call writefile(['SOFOFROM abcde', 'SOFOTO ABCD'], 'Xtest.aff')
  call assert_fails('mkspell! Xtest.spl Xtest', 'E759:')

  " Both SAL and SOFOFROM/SOFOTO items
  call writefile(['SOFOFROM abcd', 'SOFOTO ABCD', 'SAL CIA X'], 'Xtest.aff')
  let output = execute('mkspell! Xtest.spl Xtest')
  call assert_match('Both SAL and SOFO lines in Xtest.aff', output)

  " use an alphabet flag when FLAG is num
  call writefile(['FLAG num', 'SFX L Y 1', 'SFX L 0 re [^x]'], 'Xtest.aff')
  let output = execute('mkspell! Xtest.spl Xtest')
  call assert_match('Flag is not a number in Xtest.aff line 2: L', output)

  " use number and alphabet flag when FLAG is num
  call writefile(['FLAG num', 'SFX 4f Y 1', 'SFX 4f 0 re [^x]'], 'Xtest.aff')
  let output = execute('mkspell! Xtest.spl Xtest')
  call assert_match('Affix name too long in Xtest.aff line 2: 4f', output)

  " use a single character flag when FLAG is long
  call writefile(['FLAG long', 'SFX L Y 1', 'SFX L 0 re [^x]'], 'Xtest.aff')
  let output = execute('mkspell! Xtest.spl Xtest')
  call assert_match('Illegal flag in Xtest.aff line 2: L', output)

  " missing character in UPP entry. The character table is used only in a
  " non-utf8 encoding
  call writefile(['FOL abc', 'LOW abc', 'UPP A'], 'Xtest.aff')
  let save_encoding = &encoding
  set encoding=cp949
  call assert_fails('mkspell! Xtest.spl Xtest', 'E761:')
  let &encoding = save_encoding

  " character range doesn't match between FOL and LOW entries
  call writefile(["FOL \u0102bc", 'LOW abc', 'UPP ABC'], 'Xtest.aff')
  let save_encoding = &encoding
  set encoding=cp949
  call assert_fails('mkspell! Xtest.spl Xtest', 'E762:')
  let &encoding = save_encoding

  " character range doesn't match between FOL and UPP entries
  call writefile(["FOL \u0102bc", "LOW \u0102bc", 'UPP ABC'], 'Xtest.aff')
  let save_encoding = &encoding
  set encoding=cp949
  call assert_fails('mkspell! Xtest.spl Xtest', 'E762:')
  let &encoding = save_encoding

  " additional characters in LOW and UPP entries
  call writefile(["FOL ab", "LOW abc", 'UPP ABC'], 'Xtest.aff')
  let save_encoding = &encoding
  set encoding=cp949
  call assert_fails('mkspell! Xtest.spl Xtest', 'E761:')
  let &encoding = save_encoding

  " missing UPP entry
  call writefile(["FOL abc", "LOW abc"], 'Xtest.aff')
  let save_encoding = &encoding
  set encoding=cp949
  let output = execute('mkspell! Xtest.spl Xtest')
  call assert_match('Missing FOL/LOW/UPP line in Xtest.aff', output)
  let &encoding = save_encoding

  " duplicate word in the .dic file
  call writefile(['2', 'good', 'good', 'good'], 'Xtest.dic')
  call writefile(['NAME vim'], 'Xtest.aff')
  let output = execute('mkspell! Xtest.spl Xtest')
  call assert_match('First duplicate word in Xtest.dic line 3: good', output)
  call assert_match('2 duplicate word(s) in Xtest.dic', output)

  " use multiple .aff files with different values for COMPOUNDWORDMAX and
  " MIDWORD (number and string)
  call writefile(['1', 'world'], 'Xtest_US.dic', 'D')
  call writefile(['1', 'world'], 'Xtest_CA.dic', 'D')
  call writefile(["COMPOUNDWORDMAX 3", "MIDWORD '-"], 'Xtest_US.aff', 'D')
  call writefile(["COMPOUNDWORDMAX 4", "MIDWORD '="], 'Xtest_CA.aff', 'D')
  let output = execute('mkspell! Xtest.spl Xtest_US Xtest_CA')
  call assert_match('COMPOUNDWORDMAX value differs from what is used in another .aff file', output)
  call assert_match('MIDWORD value differs from what is used in another .aff file', output)

  call delete('Xtest.spl')
  call delete('Xtest.sug')
endfunc

func Test_spell_add_word()
  set spellfile=
  call assert_fails('spellgood abc', 'E764:')

  set spellfile=Xtest.utf-8.add
  call assert_fails('2spellgood abc', 'E765:')

  edit Xtest.utf-8.add
  call setline(1, 'sample')
  call assert_fails('spellgood abc', 'E139:')
  set spellfile&
  %bw!
endfunc

func Test_spell_add_long_word()
  set spell spellfile=./Xspellfile.add spelllang=en

  let word = repeat('a', 9000)
  let v:errmsg = ''
  " Spell checking doesn't really work for such a long word,
  " but this should not cause an E1510 error.
  exe 'spellgood ' .. word
  call assert_equal('', v:errmsg)
  call assert_equal([word], readfile('./Xspellfile.add'))

  set spell& spellfile= spelllang& encoding=utf-8
  call delete('./Xspellfile.add')
  call delete('./Xspellfile.add.spl')
endfunc

func Test_spellfile_verbose()
  call writefile(['1', 'one'], 'XtestVerbose.dic', 'D')
  call writefile([], 'XtestVerbose.aff', 'D')
  mkspell! XtestVerbose-utf8.spl XtestVerbose
  set spell

  " First time: the spl file should be read.
  let a = execute('3verbose set spelllang=XtestVerbose-utf8.spl')
  call assert_match('Reading spell file "XtestVerbose-utf8.spl"', a)

  " Second time time: the spl file should not be read (already read).
  let a = execute('3verbose set spelllang=XtestVerbose-utf8.spl')
  call assert_notmatch('Reading spell file "XtestVerbose-utf8.spl"', a)

  set spell& spelllang&
  call delete('XtestVerbose-utf8.spl')
endfunc

" Test NOBREAK (see :help spell-NOBREAK)
func Test_NOBREAK()
  call writefile(['3', 'one', 'two', 'three' ], 'XtestNOBREAK.dic', 'D')
  call writefile(['NOBREAK' ], 'XtestNOBREAK.aff', 'D')

  mkspell! XtestNOBREAK-utf8.spl XtestNOBREAK
  set spell spelllang=XtestNOBREAK-utf8.spl

  call assert_equal(['', ''], spellbadword('One two three onetwo onetwothree threetwoone'))

  call assert_equal(['x', 'bad'], spellbadword('x'))
  call assert_equal(['y', 'bad'], spellbadword('yone'))
  call assert_equal(['z', 'bad'], spellbadword('onez'))
  call assert_equal(['zero', 'bad'], spellbadword('Onetwozerothree'))

  new
  call setline(1, 'Onetwwothree')
  norm! fw1z=
  call assert_equal('Onetwothree', getline(1))
  call setline(1, 'Onetwothre')
  norm! fh1z=
  call assert_equal('Onetwothree', getline(1))

  bw!
  set spell& spelllang&
  call delete('XtestNOBREAK-utf8.spl')
endfunc

" Test CHECKCOMPOUNDPATTERN (see :help spell-CHECKCOMPOUNDPATTERN)
func Test_spellfile_CHECKCOMPOUNDPATTERN()
  call writefile(['4',
        \         'one/c',
        \         'two/c',
        \         'three/c',
        \         'four'], 'XtestCHECKCOMPOUNDPATTERN.dic', 'D')
  " Forbid compound words where first word ends with 'wo' and second starts with 'on'.
  call writefile(['CHECKCOMPOUNDPATTERN 1',
        \         'CHECKCOMPOUNDPATTERN wo on',
        \         'COMPOUNDFLAG c'], 'XtestCHECKCOMPOUNDPATTERN.aff', 'D')

  mkspell! XtestCHECKCOMPOUNDPATTERN-utf8.spl XtestCHECKCOMPOUNDPATTERN
  set spell spelllang=XtestCHECKCOMPOUNDPATTERN-utf8.spl

  " Check valid words with and without valid compounds.
  for goodword in ['one', 'two', 'three', 'four',
        \          'oneone', 'onetwo',  'onethree',
        \          'twotwo', 'twothree',
        \          'threeone', 'threetwo', 'threethree',
        \          'onetwothree', 'onethreetwo', 'twothreeone', 'oneoneone']
    call assert_equal(['', ''], spellbadword(goodword), goodword)
  endfor

  " Compounds 'twoone' or 'threetwoone' should be forbidden by CHECKCOMPOUNPATTERN.
  " 'four' does not have the 'c' flag in *.aff file so no compound.
  " 'five' is not in the *.dic file.
  for badword in ['five', 'onetwox',
        \         'twoone', 'threetwoone',
        \         'fourone', 'onefour']
    call assert_equal([badword, 'bad'], spellbadword(badword))
  endfor

  set spell& spelllang&
  call delete('XtestCHECKCOMPOUNDPATTERN-utf8.spl')
endfunc

" Test NOCOMPOUNDSUGS (see :help spell-NOCOMPOUNDSUGS)
func Test_spellfile_NOCOMPOUNDSUGS()
  call writefile(['3',
        \         'one/c',
        \         'two/c',
        \         'three/c'], 'XtestNOCOMPOUNDSUGS.dic', 'D')

  " pass 0 tests without NOCOMPOUNDSUGS, pass 1 tests with NOCOMPOUNDSUGS
  for pass in [0, 1]
    if pass == 0
      call writefile(['COMPOUNDFLAG c'], 'XtestNOCOMPOUNDSUGS.aff', 'D')
    else
      call writefile(['NOCOMPOUNDSUGS',
          \           'COMPOUNDFLAG c'], 'XtestNOCOMPOUNDSUGS.aff', 'D')
    endif

    mkspell! XtestNOCOMPOUNDSUGS-utf8.spl XtestNOCOMPOUNDSUGS
    set spell spelllang=XtestNOCOMPOUNDSUGS-utf8.spl

    for goodword in ['one', 'two', 'three',
          \          'oneone', 'onetwo',  'onethree',
          \          'twoone', 'twotwo', 'twothree',
          \          'threeone', 'threetwo', 'threethree',
          \          'onetwothree', 'onethreetwo', 'twothreeone', 'oneoneone']
      call assert_equal(['', ''], spellbadword(goodword), goodword)
    endfor

    for badword in ['four', 'onetwox', 'onexone']
      call assert_equal([badword, 'bad'], spellbadword(badword))
    endfor

    if pass == 0
      call assert_equal(['one', 'oneone'], spellsuggest('onne', 2))
      call assert_equal(['onethree', 'one three'], spellsuggest('onethre', 2))
    else
      call assert_equal(['one', 'one one'], spellsuggest('onne', 2))
      call assert_equal(['one three'], spellsuggest('onethre', 2))
    endif
  endfor

  set spell& spelllang&
  call delete('XtestNOCOMPOUNDSUGS-utf8.spl')
endfunc

" Test COMMON (better suggestions with common words, see :help spell-COMMON)
func Test_spellfile_COMMON()
  call writefile(['7',
        \         'and',
        \         'ant',
        \         'end',
        \         'any',
        \         'tee',
        \         'the',
        \         'ted'], 'XtestCOMMON.dic', 'D')
  call writefile(['COMMON the and'], 'XtestCOMMON.aff', 'D')

  mkspell! XtestCOMMON-utf8.spl XtestCOMMON
  set spell spelllang=XtestCOMMON-utf8.spl

  " COMMON words 'and' and 'the' should be the top suggestions.
  call assert_equal(['and', 'ant'], spellsuggest('anr', 2))
  call assert_equal(['and', 'end'], spellsuggest('ond', 2))
  call assert_equal(['the', 'ted'], spellsuggest('tha', 2))
  call assert_equal(['the', 'tee'], spellsuggest('dhe', 2))

  set spell& spelllang&
  call delete('XtestCOMMON-utf8.spl')
endfunc

" Test NOSUGGEST (see :help spell-COMMON)
func Test_spellfile_NOSUGGEST()
  call writefile(['2', 'foo/X', 'fog'], 'XtestNOSUGGEST.dic', 'D')
  call writefile(['NOSUGGEST X'], 'XtestNOSUGGEST.aff', 'D')

  mkspell! XtestNOSUGGEST-utf8.spl XtestNOSUGGEST
  set spell spelllang=XtestNOSUGGEST-utf8.spl

  for goodword in ['foo', 'Foo', 'FOO', 'fog', 'Fog', 'FOG']
    call assert_equal(['', ''], spellbadword(goodword), goodword)
  endfor
  for badword in ['foO', 'fOO', 'fooo', 'foog', 'foofog', 'fogfoo']
    call assert_equal([badword, 'bad'], spellbadword(badword))
  endfor

  call assert_equal(['fog'], spellsuggest('fooo', 1))
  call assert_equal(['fog'], spellsuggest('fOo', 1))
  call assert_equal(['fog'], spellsuggest('foG', 1))
  call assert_equal(['fog'], spellsuggest('fogg', 1))

  set spell& spelllang&
  call delete('XtestNOSUGGEST-utf8.spl')
endfunc


" Test CIRCUMFIX (see: :help spell-CIRCUMFIX)
func Test_spellfile_CIRCUMFIX()
  " Example taken verbatim from https://github.com/hunspell/hunspell/tree/master/tests
  call writefile(['1',
        \         'nagy/C	po:adj'], 'XtestCIRCUMFIX.dic', 'D')
  call writefile(['# circumfixes: ~ obligate prefix/suffix combinations',
        \         '# superlative in Hungarian: leg- (prefix) AND -bb (suffix)',
        \         '',
        \         'CIRCUMFIX X',
        \         '',
        \         'PFX A Y 1',
        \         'PFX A 0 leg/X .',
        \         '',
        \         'PFX B Y 1',
        \         'PFX B 0 legesleg/X .',
        \         '',
        \         'SFX C Y 3',
        \         'SFX C 0 obb . is:COMPARATIVE',
        \         'SFX C 0 obb/AX . is:SUPERLATIVE',
        \         'SFX C 0 obb/BX . is:SUPERSUPERLATIVE'], 'XtestCIRCUMFIX.aff', 'D')

  mkspell! XtestCIRCUMFIX-utf8.spl XtestCIRCUMFIX
  set spell spelllang=XtestCIRCUMFIX-utf8.spl

  " From https://catalog.ldc.upenn.edu/docs/LDC2008T01/acta04.pdf:
  " Hungarian       English
  " ---------       -------
  " nagy            great
  " nagyobb         greater
  " legnagyobb      greatest
  " legeslegnagyob  most greatest
  call assert_equal(['', ''], spellbadword('nagy nagyobb legnagyobb legeslegnagyobb'))

  for badword in ['legnagy', 'legeslegnagy', 'legobb', 'legeslegobb']
    call assert_equal([badword, 'bad'], spellbadword(badword))
  endfor

  set spell& spelllang&
  call delete('XtestCIRCUMFIX-utf8.spl')
endfunc

" Test SFX that strips/chops characters
func Test_spellfile_SFX_strip()
  " Simplified conjugation of Italian verbs ending in -are (first conjugation).
  call writefile(['SFX A Y 4',
        \         'SFX A are iamo [^icg]are',
        \         'SFX A are hiamo [cg]are',
        \         'SFX A re mo iare',
        \         'SFX A re vamo are'],
        \         'XtestSFX.aff', 'D')
  " Examples of Italian verbs:
  " - cantare = to sing
  " - cercare = to search
  " - odiare = to hate
  call writefile(['3', 'cantare/A', 'cercare/A', 'odiare/A'], 'XtestSFX.dic', 'D')

  mkspell! XtestSFX-utf8.spl XtestSFX
  set spell spelllang=XtestSFX-utf8.spl

  " To sing, we're singing, we were singing.
  call assert_equal(['', ''], spellbadword('cantare cantiamo cantavamo'))

  " To search, we're searching, we were searching.
  call assert_equal(['', ''], spellbadword('cercare cerchiamo cercavamo'))

  " To hate, we hate, we were hating.
  call assert_equal(['', ''], spellbadword('odiare odiamo odiavamo'))

  for badword in ['canthiamo', 'cerciamo', 'cantarevamo', 'odiiamo']
    call assert_equal([badword, 'bad'], spellbadword(badword))
  endfor

  call assert_equal(['cantiamo'],  spellsuggest('canthiamo', 1))
  call assert_equal(['cerchiamo'], spellsuggest('cerciamo', 1))
  call assert_equal(['cantavamo'], spellsuggest('cantarevamo', 1))
  call assert_equal(['odiamo'],    spellsuggest('odiiamo', 1))

  set spell& spelllang&
  call delete('XtestSFX-utf8.spl')
endfunc

" When 'spellfile' is not set, adding a new good word will automatically set
" the 'spellfile'
func Test_init_spellfile()
  let save_rtp = &rtp
  let save_encoding = &encoding
  call mkdir('Xrtp/spell', 'pR')
  call writefile(['vim'], 'Xrtp/spell/Xtest.dic')
  silent mkspell Xrtp/spell/Xtest.utf-8.spl Xrtp/spell/Xtest.dic
  set runtimepath=./Xrtp
  set spelllang=Xtest
  set spell
  silent spellgood abc
  call assert_equal('./Xrtp/spell/Xtest.utf-8.add', &spellfile)
  call assert_equal(['abc'], readfile('Xrtp/spell/Xtest.utf-8.add'))
  call assert_true(filereadable('Xrtp/spell/Xtest.utf-8.spl'))

  set spell& spelllang& spellfile&
  let &encoding = save_encoding
  let &rtp = save_rtp
  %bw!
endfunc

" Test for the 'mkspellmem' option
func Test_mkspellmem_opt()
  call assert_fails('set mkspellmem=1000', 'E474:')
  call assert_fails('set mkspellmem=1000,', 'E474:')
  call assert_fails('set mkspellmem=1000,50', 'E474:')
  call assert_fails('set mkspellmem=1000,50,', 'E474:')
  call assert_fails('set mkspellmem=1000,50,10,', 'E474:')
  call assert_fails('set mkspellmem=1000,50,0', 'E474:')
endfunc

" 'spellfile' accepts '@' on top of 'isfname'.
def Test_spellfile_allow_at_character()
  mkdir('Xtest/the foo@bar,dir', 'p')
  &spellfile = './Xtest/the foo@bar\,dir/Xspellfile.add'
  &spellfile = ''
  delete('Xtest', 'rf')
enddef

" this was using a NULL pointer
func Test_mkspell_empty_dic()
  call writefile(['1'], 'XtestEmpty.dic', 'D')
  call writefile(['SOFOFROM abcd', 'SOFOTO ABCD', 'SAL CIA X'], 'XtestEmpty.aff', 'D')
  mkspell! XtestEmpty.spl XtestEmpty

  call delete('XtestEmpty.spl')
endfunc

" This used to cause a buffer overflow
func Test_mkspell_no_buffer_overflow()
  CheckNotMSWindows

  let aff_lines = ['SET ISO8859-1', 'SFX A Y 1',
        \ 'SFX A 0 s ' .. repeat(nr2char(0xff), 491)]
  call writefile(aff_lines, 'Xbof.aff', 'D')
  call writefile(['1', 'word/A'], 'Xbof.dic', 'D')
  " Must not crash; ignore any conversion/regex errors.
  try
    mkspell! Xbof.spl Xbof
  catch
  endtry
  defer delete('Xbof.spl')

  let long = repeat(nr2char(0xff), 200)
  let aff2_lines = ['SET ISO8859-1', 'SFX A Y 1',
        \ 'SFX A 0 ' .. long .. ' .']
  call writefile(aff2_lines, 'Xbof2.aff', 'D')
  call writefile(['1', long .. '/A'], 'Xbof2.dic', 'D')
  try
    mkspell! Xbof2.spl Xbof2
  catch
  endtry
  defer delete('Xbof2.spl')
endfunc

func Test_mkspell_no_affixlist_overflow()
  let aff_lines = [
        \ 'SET ISO8859-1',
        \ 'PFXPOSTPONE',
        \ 'PFX A Y 1',
        \ 'PFX A 0 pre .',
        \ ]
  call writefile(aff_lines, 'Xaffbof.aff', 'D')
  call writefile(['1', 'word/' .. repeat('A', 300)], 'Xaffbof.dic', 'D')

  call assert_fails('mkspell! Xaffbof.spl Xaffbof',
        \ 'Too many postponed prefixes and/or compound flags')
  call assert_false(filereadable('Xaffbof.spl'))
endfunc

func Test_mkspell_no_compflag_overflow()
  " Overflow the compound-flag path in get_compflags(): a word whose
  " affix list repeats a compound flag many times accumulates one ID per
  " occurrence, overrunning store_afflist[MAXWLEN].
  let aff_lines = [
        \ 'SET ISO8859-1',
        \ 'COMPOUNDFLAG c',
        \ ]
  call writefile(aff_lines, 'Xcompbof.aff', 'D')

  " Repeat the compound flag 'c' far past MAXWLEN.
  call writefile(['1', 'word/' .. repeat('c', 300)], 'Xcompbof.dic', 'D')

  call assert_fails('mkspell! Xcompbof.spl Xcompbof',
        \ 'Too many postponed prefixes and/or compound flags')
  call assert_false(filereadable('Xcompbof.spl'))
endfunc

" vim: shiftwidth=2 sts=2 expandtab
