" Test for commands that operate on the spellfile.

source shared.vim
source check.vim

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])

  " 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', 'p')
  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_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:')

  " 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
  call delete('Xtest', 'rf')
endfunc

" Test for format errors in suggest file
func Test_sugfile_format_error()
  let save_rtp = &rtp
  call mkdir('Xtest/spell', 'p')
  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
  call delete('Xtest', 'rf')
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')
  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')
  call delete('Xwordlist.dic')
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')

  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')
  call writefile([], 'Xtest.aff')
  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)

  " 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 a 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')
  call writefile(['1', 'world'], 'Xtest_CA.dic')
  call writefile(["COMPOUNDWORDMAX 3", "MIDWORD '-"], 'Xtest_US.aff')
  call writefile(["COMPOUNDWORDMAX 4", "MIDWORD '="], 'Xtest_CA.aff')
  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_US.dic')
  call delete('Xtest_CA.dic')
  call delete('Xtest_US.aff')
  call delete('Xtest_CA.aff')

  call delete('Xtest.dic')
  call delete('Xtest.aff')
  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

" 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', 'p')
  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&
  call delete('Xrtp', 'rf')
  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

" vim: shiftwidth=2 sts=2 expandtab