Migrate testing to tcltest + expect

Fix repeat and undo

.gitignore

@@ -1,5 +1,12 @@
 *.sw?
+*.un?
 *.vba
+*.vmb
 *.zip
 *.gz
 vimball.txt
+*.orig
+tags
+test/build
+test/*.tap
+test/*.msgout

LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Israel Chauca
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Makefile

@@ -1,29 +1,15 @@
-PLUGIN=delimitMate
+.DEFAULT: test
 
-install:
-	install -m 755 -d ~/.vim
-	install -m 755 -d ~/.vim/plugin/
-	install -m 755 -d ~/.vim/autoload/
-	install -m 755 -d ~/.vim/doc/
-	cp -f doc/${PLUGIN}.txt      ~/.vim/doc/${PLUGIN}.txt
-	cp -f plugin/${PLUGIN}.vim   ~/.vim/plugin/${PLUGIN}.vim
-	cp -f autoload/${PLUGIN}.vim ~/.vim/autoload/${PLUGIN}.vim
-	cp -f autoload/${PLUGIN}Tests.vim ~/.vim/autoload/${PLUGIN}Tests.vim
+test_files := $(wildcard test/*.test)
+short_targets := $(patsubst test/%,%,$(test_files))
 
-doc_update: install
-	/usr/bin/vim -u NONE -c ':helptags ~/.vim/doc' -c ':q'
+.PHONY: monitor test $(test_files) $(short_targets)
 
-zip:
-	zip -r ${PLUGIN}.zip doc plugin autoload
-	zip ${PLUGIN}.zip -d \*.sw\?
-	zip ${PLUGIN}.zip -d autoload/${PLUGIN}Tests.vim
+test:
+	$(MAKE) -C test
 
-vimball: install
-	echo doc/${PLUGIN}.txt > vimball.txt
-	echo plugin/${PLUGIN}.vim >> vimball.txt
-	echo autoload/${PLUGIN}.vim >> vimball.txt
-	/usr/bin/vim  -c 'e vimball.txt' -c '%MkVimball! ${PLUGIN}' -c 'q'
-
-gzip: vimball
-	gzip -f ${PLUGIN}.vba
+monitor:
+	$(MAKE) -C test monitor
 
+$(test_files) $(short_targets):
+	$(MAKE) -C test $(patsubst test/%,%,$@)

README.md

@@ -0,0 +1,6 @@
+This plug-in provides automatic closing of quotes, parenthesis, brackets, etc., besides some other related features that
+should make your time in insert mode a little bit easier, like syntax awareness (will not insert the closing delimiter
+in comments and other configurable regions), <CR> and <Space> expansions (off by default), and some more.
+
+Most of the features can be modified or disabled permanently, using global variables, or on a FileType basis, using
+:autocmd.

autoload/delimitMateTests.vim

@@ -1,225 +0,0 @@
-function! delimitMateTests#Main() " {{{
-	if !exists("g:delimitMate_testing")
-		echoerr "delimitMateTests#Main(): If you really want to use me, you must set delimitMate_testing to any value."
-		return
-	endif
-	nmap <F1> :qall!<CR>
-	let b:test_results = {}
-
-	function! SetOptions(list) " {{{
-		let b:delimitMate_autoclose = 1
-		let b:delimitMate_matchpairs = &matchpairs
-		let b:delimitMate_quotes = "\" ' `"
-		let b:delimitMate_excluded_regions = "Comment"
-		silent! unlet b:delimitMate_visual_leader
-		let b:delimitMate_expand_space = 0
-		let b:delimitMate_expand_cr = 0
-		let b:delimitMate_smart_quotes = 1
-		let b:delimitMate_apostrophes = ""
-		let b:delimitMate_tab2exit = 1
-		" Set current test options:
-		for str in a:list
-			let pair = split(str, ':')
-			exec "let b:delimitMate_" . pair[0] . " = " . pair[1]
-		endfor
-		DelimitMateReload
-	endfunction " }}}
-
-	function! Type(name, input, output, options) " {{{
-		" Set default options:
-		call SetOptions(a:options)
-		normal ggVG"_d
-		exec "normal i" . a:input . "|\<Esc>"
-		call setpos('.', [0, 1, 1, 0])
-		let result = len(a:output) != line('$')
-		for line in a:output
-			if getline('.') != line || result == 1
-				let result = 1
-				break
-			endif
-			call setpos('.', [0, line('.') + 1, 1, 0])
-		endfor
-		let text = getline('.')
-		let i = 2
-		while i <= line('$')
-			let text = text . "<cr>" . getline(i)
-			let i += 1
-		endwhile
-		if result == 0
-			exec "let b:test_results['" . substitute(a:name, "[^a-zA-Z0-9_]", "_", "g") . "'] = 'Passed: ' . text . ' == ' . join(a:output, '<cr>')"
-		else
-			exec "let b:test_results['" . substitute(a:name, "[^a-zA-Z0-9_]", "_", "g") . "'] = 'Failed: ' . text . ' != ' . join(a:output, '<cr>')"
-		endif
-	endfunction " }}}
-
-	function! RepeatLast(name, output) " {{{
-		normal gg.
-		call setpos('.', [0, 1, 1, 0])
-		let result = len(a:output) != line('$')
-		for line in a:output
-			if getline('.') != line || result == 1
-				let result = 1
-				break
-			endif
-			call setpos('.', [0, line('.') + 1, 1, 0])
-		endfor
-		let text = getline('1')
-		let i = 2
-		while i <= line('$')
-			let text = text . "<cr>" . getline(i)
-			let i += 1
-		endwhile
-		if result == 0
-			exec "let b:test_results['" . substitute(a:name, "[^a-zA-Z0-9_]", "_", "g") . "_R'] = 'Passed: ' . text . ' == ' . join(a:output, '<cr>')"
-		else
-			exec "let b:test_results['" . substitute(a:name, "[^a-zA-Z0-9_]", "_", "g") . "_R'] = 'Failed: ' . text . ' != ' . join(a:output, '<cr>')"
-		endif
-	endfunction " }}}
-
-	" Test's test {{{
-	call Type("Test 1", "123", ["123|"], [])
-	call RepeatLast("Test 1", ["123|123|"])
-
-	" Auto-closing parens
-	call Type("Autoclose parens", "(", ["(|)"], [])
-	call RepeatLast("Autoclose_parens", ["(|)(|)"])
-
-	" Auto-closing quotes
-	call Type("Autoclose quotes", '"', ['"|"'], [])
-	call RepeatLast("Autoclose_quotes", ['"|""|"'])
-
-	" Deleting parens
-	call Type("Delete empty parens", "(\<BS>", ["|"], [])
-	call RepeatLast("Delete empty parens", ["||"])
-
-	" Deleting quotes
-	call Type("Delete emtpy quotes", "\"\<BS>", ['|'], [])
-	call RepeatLast("Delete empty quotes", ["||"])
-
-	" Manual closing parens
-	call Type("Manual closing parens", "()", ["(|)"], ["autoclose:0"])
-	call RepeatLast("Manual closing parens", ["(|)(|)"])
-
-	" Manual closing quotes
-	call Type("Manual closing quotes", "\"\"", ['"|"'], ["autoclose:0"])
-	call RepeatLast("Manual closing quotes", ['"|""|"'])
-
-	" Jump over paren
-	call Type("Jump over paren", "()", ['()|'], [])
-	call RepeatLast("Jump over paren", ['()|()|'])
-
-	" Jump over quote
-	call Type("Jump over quote", "\"\"", ['""|'], [])
-	call RepeatLast("Jump over quote", ['""|""|'])
-
-	" Apostrophe
-	call Type("Apostrophe", "test'", ["test'|"], [])
-	call RepeatLast("Apostrophe", ["test'|test'|"])
-
-	" Close quote
-	call Type("Close quote", "'\<Del>\<Esc>a'", ["'|'"], [])
-
-	" Closing paren
-	call Type("Closing paren", "abcd)", ["abcd)|"], [])
-
-	" <S-Tab>
-	call Type("S Tab", "(\<S-Tab>", ["()|"], [])
-	call RepeatLast("S Tab", ["()|()|"])
-
-	" Space expansion
-	call Type("Space expansion", "(\<Space>\<BS>", ['(|)'], ['expand_space:1'])
-	call RepeatLast("BS with space expansion", ['(|)(|)'])
-
-	" BS with space expansion
-	call Type("BS with space expansion", "(\<Space>", ['( | )'], ['expand_space:1'])
-	call RepeatLast("Space expansion", ['( | )( | )'])
-
-	" Car return expansion
-	call Type("CR expansion", "(\<CR>", ['(', '|', ')'], ['expand_cr:1'])
-	call RepeatLast("CR expansion", ['(', '|', ')(', '|', ')'])
-
-	" BS with car return expansion
-	call Type("BS with CR expansion", "(\<CR>\<BS>", ['(|)'], ['expand_cr:1'])
-	call RepeatLast("BS with CR expansion", ['(|)(|)'])
-
-	" Visual wrapping
-	call Type("Visual wrapping left paren", "1234\<Esc>v,(", ['123(4)'], ['visual_leader:","'])
-	cal RepeatLast("Visual wrapping left paren", ['(1)23(4)'])
-
-	" Visual line wrapping
-	call Type("Visual line wrapping left paren", "1234\<Esc>V,(", ['(1234)'], ['visual_leader:","'])
-	cal RepeatLast("Visual line wrapping left paren", ['((1234))'])
-
-	" Visual wrapping
-	call Type("Visual wrapping right paren", "1234\<Esc>v,)", ['123(4)'], ['visual_leader:","'])
-	cal RepeatLast("Visual wrapping right paren", ['(1)23(4)'])
-
-	" Visual line wrapping
-	call Type("Visual line wrapping right paren", "1234\<Esc>V,)", ['(1234)'], ['visual_leader:","'])
-	cal RepeatLast("Visual line wrapping right paren", ['((1234))'])
-
-	" Visual wrapping
-	call Type("Visual wrapping quote", "1234\<Esc>v,\"", ['123"4"'], ['visual_leader:","'])
-	cal RepeatLast("Visual wrapping quote", ['"1"23"4"'])
-
-	" Visual line wrapping
-	call Type("Visual line wrapping quote", "1234\<Esc>V,\"", ['"1234"'], ['visual_leader:","'])
-	cal RepeatLast("Visual line wrapping quote", ['""1234""'])
-
-	" Visual line wrapping empty line
-	call Type("Visual line wrapping paren empty line", "\<Esc>V,(", ['()'], ['visual_leader:","'])
-
-	" Visual line wrapping empty line
-	call Type("Visual line wrapping quote empty line", "\<Esc>V,\"", ['""'], ['visual_leader:","'])
-
-	" Smart quotes
-	call Type("Smart quote alphanumeric", "alpha\"numeric", ['alpha"numeric|'], [])
-	call RepeatLast("Smart quote alphanumeric", ['alpha"numeric|alpha"numeric|'])
-
-	" Smart quotes
-	call Type("Smart quote escaped", "esc\\\"", ['esc\"|'], [])
-	call RepeatLast("Smart quote escaped", ['esc\"|esc\"|'])
-
-	" Smart quotes
-	call Type("Smart quote apostrophe", "I'm", ["I'm|"], ['smart_quotes:0'])
-	call RepeatLast("Smart quote escaped", ["I'm|I'm|"])
-
-	" Backspace inside space expansion
-	call Type("Backspace inside space expansion", "(\<Space>\<BS>", ['(|)'], ['expand_space:1'])
-	call RepeatLast("Backspace inside space expansion", ['(|)(|)'])
-
-	" Backspace inside CR expansion
-	call Type("Backspace inside CR expansion", "(\<CR>\<BS>", ['(|)'], ['expand_cr:1'])
-	call RepeatLast("Backspace inside CR expansion", ['(|)(|)'])
-
-	" FileType event
-	let g:delimitMate_excluded_ft = "vim"
-	set ft=vim
-	call Type("FileType Autoclose parens", "(", ["(|"], [])
-	unlet g:delimitMate_excluded_ft
-	set ft=
-
-	"}}}
-
-	" Show results: {{{
-	normal ggVG"_d
-	call append(0, split(string(b:test_results)[1:-2], ', '))
-	normal "_ddgg
-	let @/ = ".\\+Failed:.*!="
-	set nohlsearch
-	"syntax match failedLine "^.*Failed.*$" contains=ALL
-	"syn match passedLine ".*Passed.*"
-	syn match labelPassed "'\@<=.\+\(': 'Passed\)\@="
-	syn match labelFailed "'\@<=.\+\(': 'Failed\)\@="
-	syn match resultPassed "\('Passed: \)\@<=.\+\('$\)\@="
-	syn match resultFailed "\('Failed: \)\@<=.\+\('$\)\@=" contains=resultInequal
-	syn match resultInequal "!="
-
-	hi def link labelPassed Comment
-	hi def link labelFailed Special
-	hi def link resultPassed Ignore
-	hi def link resultFailed Boolean
-	hi def link resultInequal Error
-	" }}}
-endfunction " }}}
-" vim:foldmethod=marker:foldcolumn=4

basic_vimrc

@@ -0,0 +1,4 @@
+so ./test/_setup.vim
+let delimitMate_expand_cr = 1
+filetype indent plugin on
+

plugin/delimitMate.vim

@@ -1,226 +1,22 @@
-" ============================================================================
-" File:        plugin/delimitMate.vim
-" Version:     2.1
-" Description: This plugin provides auto-completion for quotes, parens, etc.
-" Maintainer:  Israel Chauca F. <israelchauca@gmail.com>
-" Manual:      Read ":help delimitMate".
-
-" Initialization: {{{
-if exists("g:loaded_delimitMate") "{{{
-	" User doesn't want this plugin, let's get out!
-	finish
+if exists("g:loaded_delimitMate") || &cp || !exists('##InsertCharPre')
+  finish
 endif
 let g:loaded_delimitMate = 1
+let save_cpo = &cpo
+set cpo&vim
 
-if exists("s:loaded_delimitMate") && !exists("g:delimitMate_testing")
-	" Don't define the functions if they already exist: just do the work
-	" (unless we are testing):
-	call s:DelimitMateDo()
-	finish
-endif
+command! -bar -bang DelimitMateSwitch call delimitMate#ex_cmd(<bang>0, 'switch' )
+command! -bar -bang DelimitMateOn     call delimitMate#ex_cmd(<bang>0, 'enable' )
+command! -bar -bang DelimitMateOff    call delimitMate#ex_cmd(<bang>0, 'disable')
 
-if v:version < 700
-	echoerr "delimitMate: this plugin requires vim >= 7!"
-	finish
-endif
-
-let s:loaded_delimitMate = 1 " }}}
-let delimitMate_version = '2.1'
-
-"}}}
-
-" Tools: {{{
-function! s:Init() "{{{
-
-	let b:loaded_delimitMate = 1
-
-	" delimitMate_autoclose {{{
-	if !exists("b:delimitMate_autoclose") && !exists("g:delimitMate_autoclose")
-		let b:delimitMate_autoclose = 1
-	elseif !exists("b:delimitMate_autoclose") && exists("g:delimitMate_autoclose")
-		let b:delimitMate_autoclose = g:delimitMate_autoclose
-	else
-		" Nothing to do.
-	endif " }}}
-
-	" delimitMate_matchpairs {{{
-	if !exists("b:delimitMate_matchpairs") && !exists("g:delimitMate_matchpairs")
-		let s:matchpairs_temp = &matchpairs
-	elseif exists("b:delimitMate_matchpairs")
-		let s:matchpairs_temp = b:delimitMate_matchpairs
-	else
-		let s:matchpairs_temp = g:delimitMate_matchpairs
-	endif " }}}
-
-	" delimitMate_quotes {{{
-	if exists("b:delimitMate_quotes")
-		let s:quotes = split(b:delimitMate_quotes)
-	elseif exists("g:delimitMate_quotes")
-		let s:quotes = split(g:delimitMate_quotes)
-	else
-		let s:quotes = split("\" ' `")
-	endif
-	let b:delimitMate_quotes_list = s:quotes " }}}
-
-	" delimitMate_excluded_regions {{{
-	if exists("b:delimitMate_excluded_regions")
-		let s:excluded_regions = b:delimitMate_excluded_regions
-	elseif exists("g:delimitMate_excluded_regions")
-		let s:excluded_regions = g:delimitMate_excluded_regions
-	else
-		let s:excluded_regions = "Comment"
-	endif
-	let b:delimitMate_excluded_regions_list = split(s:excluded_regions, ',\s*')
-	let b:delimitMate_excluded_regions_enabled = len(b:delimitMate_excluded_regions_list) " }}}
-
-	" delimitMate_visual_leader {{{
-	if !exists("b:delimitMate_visual_leader") && !exists("g:delimitMate_visual_leader")
-		let b:delimitMate_visual_leader = exists('b:maplocalleader') ? b:maplocalleader :
-					\ exists('g:mapleader') ? g:mapleader : "\\"
-	elseif !exists("b:delimitMate_visual_leader") && exists("g:delimitMate_visual_leader")
-		let b:delimitMate_visual_leader = g:delimitMate_visual_leader
-	else
-		" Nothing to do.
-	endif " }}}
-
-	" delimitMate_expand_space {{{
-	if !exists("b:delimitMate_expand_space") && !exists("g:delimitMate_expand_space")
-		let b:delimitMate_expand_space = 0
-	elseif !exists("b:delimitMate_expand_space") && exists("g:delimitMate_expand_space")
-		let b:delimitMate_expand_space = g:delimitMate_expand_space
-	else
-		" Nothing to do.
-	endif " }}}
-
-	" delimitMate_expand_cr {{{
-	if !exists("b:delimitMate_expand_cr") && !exists("g:delimitMate_expand_cr")
-		let b:delimitMate_expand_cr = 0
-	elseif !exists("b:delimitMate_expand_cr") && exists("g:delimitMate_expand_cr")
-		let b:delimitMate_expand_cr = g:delimitMate_expand_cr
-	else
-		" Nothing to do.
-	endif " }}}
-
-	" delimitMate_smart_quotes {{{
-	if !exists("b:delimitMate_smart_quotes") && !exists("g:delimitMate_smart_quotes")
-		let b:delimitMate_smart_quotes = 1
-	elseif !exists("b:delimitMate_smart_quotes") && exists("g:delimitMate_smart_quotes")
-		let b:delimitMate_smart_quotes = split(g:delimitMate_smart_quotes)
-	else
-		" Nothing to do.
-	endif " }}}
-
-	" delimitMate_apostrophes {{{
-	if !exists("b:delimitMate_apostrophes") && !exists("g:delimitMate_apostrophes")
-		"let s:apostrophes = split("n't:'s:'re:'m:'d:'ll:'ve:s'",':')
-		let s:apostrophes = []
-	elseif !exists("b:delimitMate_apostrophes") && exists("g:delimitMate_apostrophes")
-		let s:apostrophes = split(g:delimitMate_apostrophes)
-	else
-		let s:apostrophes = split(b:delimitMate_apostrophes)
-	endif
-		let b:delimitMate_apostrophes_list = s:apostrophes " }}}
-
-	" delimitMate_tab2exit {{{
-	if !exists("b:delimitMate_tab2exit") && !exists("g:delimitMate_tab2exit")
-		let b:delimitMate_tab2exit = 1
-	elseif !exists("b:delimitMate_tab2exit") && exists("g:delimitMate_tab2exit")
-		let b:delimitMate_tab2exit = g:delimitMate_tab2exit
-	else
-		" Nothing to do.
-	endif " }}}
-
-	let b:delimitMate_matchpairs_list = split(s:matchpairs_temp, ',')
-	let b:delimitMate_left_delims = split(s:matchpairs_temp, ':.,\=')
-	let b:delimitMate_right_delims = split(s:matchpairs_temp, ',\=.:')
-
-	let b:delimitMate_buffer = []
-
-	call delimitMate#UnMap()
-	if b:delimitMate_autoclose
-		call delimitMate#AutoClose()
-	else
-		call delimitMate#NoAutoClose()
-	endif
-	call delimitMate#VisualMaps()
-	call delimitMate#ExtraMappings()
-
-endfunction "}}} Init()
-
-function! s:TestMappingsDo() "{{{
-	if !exists("g:delimitMate_testing")
-		silent call delimitMate#TestMappings()
-	else
-		let temp_varsDM = [b:delimitMate_expand_space, b:delimitMate_expand_cr, b:delimitMate_autoclose]
-		for i in [0,1]
-			let b:delimitMate_expand_space = i
-			let b:delimitMate_expand_cr = i
-			for a in [0,1]
-				let b:delimitMate_autoclose = a
-				call s:Init()
-				call delimitMate#TestMappings()
-				exec "normal i\<CR>"
-			endfor
-		endfor
-		let b:delimitMate_expand_space = temp_varsDM[0]
-		let b:delimitMate_expand_cr = temp_varsDM[1]
-		let b:delimitMate_autoclose = temp_varsDM[2]
-		unlet temp_varsDM
-	endif
-	normal gg
-endfunction "}}}
-
-function! s:DelimitMateDo() "{{{
-	if exists("g:delimitMate_excluded_ft")
-		" Check if this file type is excluded:
-		for ft in split(g:delimitMate_excluded_ft,',')
-			if ft ==? &filetype
-				"echomsg "excluded"
-				call delimitMate#UnMap()
-				return 1
-			endif
-		endfor
-	endif
-	try
-		"echomsg "included"
-		let save_cpo = &cpo
-		let save_keymap = &keymap
-		set keymap=
-		set cpo&vim
-		call s:Init()
-	finally
-		let &cpo = save_cpo
-		let &keymap = save_keymap
-	endtry
-endfunction "}}}
-"}}}
-
-" Commands: {{{
-call s:DelimitMateDo()
-
-" Let me refresh without re-loading the buffer:
-command! DelimitMateReload call s:DelimitMateDo()
-
-" Quick test:
-command! DelimitMateTest call s:TestMappingsDo()
-
-"command! DelimitMateRegions echo s:excluded_regions
-" Turn
-
-" Run on file type events.
-"autocmd VimEnter * autocmd FileType * call <SID>DelimitMateDo()
-autocmd FileType * call <SID>DelimitMateDo()
-
-" Run on new buffers.
-autocmd BufNewFile,BufRead,BufEnter * if !exists("b:loaded_delimitMate") | call <SID>DelimitMateDo() | endif
-
-" Flush the char buffer:
-autocmd InsertEnter * call delimitMate#FlushBuffer()
-autocmd BufEnter * if mode() == 'i' | call delimitMate#FlushBuffer() | endif
-
-"function! s:GetSynRegion () | echo synIDattr(synIDtrans(synID(line('.'), col('.'), 1)), 'name') | endfunction
-
-"}}}
+augroup delimitMate
+  au!
+  au InsertCharPre * call delimitMate#InsertCharPre(v:char)
+  au TextChangedI  * call delimitMate#TextChangedI()
+  au InsertEnter   * call delimitMate#InsertEnter()
+  au CursorMovedI  * call delimitMate#CursorMovedI()
+augroup END
 
+let &cpo = save_cpo
 " GetLatestVimScripts: 2754 1 :AutoInstall: delimitMate.vim
-" vim:foldmethod=marker:foldcolumn=4
+" vim: sw=2 et

test/Makefile

@@ -0,0 +1,14 @@
+test_files := $(wildcard *.test)
+
+.PHONY: all monitor $(test_files)
+
+all:
+	time tclsh all.tcl
+
+$(test_files):
+	time tclsh $@
+	printf "\a"
+
+monitor:
+	fswatch -o ../autoload/*.vim ../plugin/*.vim *.test \
+		| xargs -n1 -I\{\} time tclsh all.tcl || printf "\a"

test/README.md

@@ -0,0 +1,18 @@
+# Automatic test setup
+You can use `make` (or `make test` from the top level directory) to run the
+tests.
+
+# Manual test setup instructions
+The plugins [runVimTests](http://www.vim.org/scripts/script.php?script_id=2565)
+and [VimTAP](http://www.vim.org/scripts/script.php?script_id=2213) are needed
+to run these tests.
+
+Besides the `_setup.vim` configuration file present in this repo you need to
+create a global one and place it in the same dir where the runVimTests
+executable is located. Assuming the executable is at '~/bin/runVimTests' this
+global configuration file should be '~/bin/runVimTestsSetup.vim' and should
+have something like the following lines inside of it:
+
+    " Prepend tests repos to &rtp
+    let &runtimepath = '/path/to/runVimTests_dir,' . &rtp
+    let &runtimepath = '/path/to/vimTAP_dir,' . &rtp

test/_setup.vim

@@ -0,0 +1,11 @@
+set bs=2
+set hidden
+set noshowmode
+set whichwrap=[]
+set noswapfile
+let &hl = join(map(split(&hl, ','), 'substitute(v:val, '':.\+'', ''n'', ''g'')'), ',')
+let &rtp = expand('<sfile>:p:h:h') . ',' . &rtp . ',' . expand('<sfile>:p:h:h') . '/after'
+let g:delimitMate_pairs = ['()','{}','[]','<>','¿?','¡!',',:']
+let g:delimitMate_quotes = ['"', "'", '`', '«', '|']
+ru plugin/delimitMate.vim
+au VimEnter * echom 'Start test'

test/all.tcl

@@ -0,0 +1,18 @@
+package require tcltest 2
+namespace import -force ::tcltest::*
+configure {*}$argv -testdir [file dir [info script]]
+
+# Hook to determine if any of the tests failed. Then we can exit with
+# proper exit code: 0=all passed, 1=one or more failed
+proc tcltest::cleanupTestsHook {} {
+	variable numTests
+	upvar 2 testFileFailures crashed
+	set ::exitCode [expr {$numTests(Failed) > 0}]
+	if {[info exists crashed]} {
+		set ::exitCode [expr {$::exitCode || [llength $crashed]}]
+	}
+}
+
+runAllTests
+puts "\a"
+exit $exitCode

test/eol_marker.test

@@ -0,0 +1,49 @@
+# singleTest name desc setup input result vimCmds? skipScript?
+#
+# - desc can be empty and input would be used.
+# - vimCmds is a list of ex commands.
+# - skipScript will be evaluated in the scope of the function "single" and it
+#   should return a keywowd such as toDo, badTest or other as listed in the
+#   docs for tcltest. e.g.:
+#     {expr "[string first {i'} \"${input}\"] > -1 ? {emptyTest} : {}"}
+# see tcltest documentation for other values.
+
+# Get some help:
+source helper.tcl
+
+set vimCmds [list {let g:delimitMate_expand_cr = 1}]
+lappend vimCmds {let g:delimitMate_eol_marker = ';'}
+lappend vimCmds {let g:delimitMate_insert_eol_marker = 0}
+
+single ins_eol_marker_0-1 {} "" "i(" "()" ${vimCmds}
+
+single ins_eol_marker_0-2 {} "" "i(\rx" "(\nx\n)" ${vimCmds}
+
+set vimCmds [list {let g:delimitMate_expand_cr = 1}]
+lappend vimCmds {let g:delimitMate_eol_marker = ';'}
+lappend vimCmds {let g:delimitMate_insert_eol_marker = 1}
+single ins_eol_marker_1-1 {} "" "i(" "();" ${vimCmds}
+
+single ins_eol_marker_1-2 {} " a" "0i(" "() a" ${vimCmds}
+
+single ins_eol_marker_1-3 {} "" "i(\rx" "(\nx\n);" ${vimCmds}
+
+set vimCmds [list {let g:delimitMate_expand_cr = 1}]
+lappend vimCmds {let g:delimitMate_eol_marker = ';'}
+lappend vimCmds {let g:delimitMate_insert_eol_marker = 2}
+single ins_eol_marker_2-1 {} "" "i(" "()" ${vimCmds}
+
+single ins_eol_marker_2-2 {} "" "i(\rx" "(\nx\n);" ${vimCmds}
+
+# Issue #195
+single issue_195-1 {} "" "i{(\rx" "{(\nx\n)}" ${vimCmds}
+
+# Issue #195
+single issue_195-2 {} ";" "I{(\rx" "{(\nx\n)};" ${vimCmds}
+
+
+
+################################################################
+# This gives nice statistics and cleans up the mess left behind.
+cleanupTests
+# vim: set filetype=tcl et sw=2 sts=0 ts=8:

test/expand_cr.test

@@ -0,0 +1,92 @@
+# singleTest name desc setup input result vimCmds? skipScript?
+#
+# - desc can be empty and input would be used.
+# - vimCmds is a list of ex commands.
+# - skipScript will be evaluated in the scope of the function "single" and it
+#   should return a keywowd such as toDo, badTest or other as listed in the
+#   docs for tcltest. e.g.:
+#     {expr "[string first {i'} \"${input}\"] > -1 ? {emptyTest} : {}"}
+# see tcltest documentation for other values.
+
+# Get some help:
+source helper.tcl
+
+set vimCmds [list {let g:delimitMate_expand_cr = 1}]
+#"let g:delimitMate_eol_marker = ';'
+lappend vimCmds {filetype indent on}
+lappend vimCmds {set bs=2 et sts=4 sw=4 ft=javascript}
+single javascript-1 {} "\$(document).ready(function() {})" "f{a\rx" \
+    "\$(document).ready(function() {\n    x\n})" ${vimCmds}
+
+# Issue #95
+set vimCmds [list {let g:delimitMate_expand_cr = 1}]
+lappend vimCmds {let b:delimitMate_jump_expansion = 1}
+set skipScript {string cat toDo}
+single issue_95 {} "" "i(\rtest)x" "(\ntest\n)x" ${vimCmds} ${skipScript}
+
+# Remove CR expansion on BS
+set skipScript {string cat toDo}
+single bs {} "" "i(\r\bx" "(x)" ${vimCmds} ${skipScript}
+
+# Consider indentation with BS inside an empty CR expansion.
+single bs_indentation {} "" "i( \r\b\bx"  "(x)" ${vimCmds}
+
+# Conflict with indentation settings (cindent). Issue #95
+lappend vimCmds {se cindent}
+single issue_95 {} "sub foo {\n    while (1) {\n\n    }\n}" "3Gi\bx" \
+      "sub foo {\n    while (1) {x}\n}" ${vimCmds}
+
+single nested_expansion-1 {} "sub foo {\n    while (1) {\n        bar\n    }\n}" \
+      "3GA}x" "sub foo {\n    while (1) {\n        bar\n    }x\n}" ${vimCmds}
+
+single nested_expansion-2 {} "sub foo {\n    while (1) {\n        bar\n    }\n}" \
+      "3GA{x" "sub foo {\n    while (1) {\n        bar{x}\n    }\n}" ${vimCmds}
+
+single bracketed {} "\"{bracketed}" "\033A\"x" "\"{bracketed}\"x" ${vimCmds}
+
+# Syntax folding enabled by autocmd breaks expansion.
+set vimCmds [list {let g:delimitMate_expand_cr = 1}]
+lappend vimCmds {se cindent}
+lappend vimCmds {set bs=2 et sts=4 sw=4}
+lappend vimCmds {autocmd InsertEnter <buffer> let w:fdm=&foldmethod \
+    | setl foldmethod=manual}
+lappend vimCmds {autocmd InsertLeave <buffer> let &foldmethod = w:fdm}
+lappend vimCmds {set foldmethod=marker}
+lappend vimCmds {set foldmarker={,}}
+lappend vimCmds {set foldlevel=0}
+lappend vimCmds {set backspace=2}
+single folding {} "" "iabc {\rx" "abc {\n    x\n}" ${vimCmds}
+
+# expand_cr != 2}
+set vimCmds [list {let g:delimitMate_expand_cr = 1}]
+lappend vimCmds {se cindent}
+lappend vimCmds {set bs=2 et sts=4 sw=4 ft=javascript}
+lappend vimCmds {let b:delimitMate_jump_expansion = 1}
+single axpand_cr_no_2 {} "abc(def)" "\$i\rx" "abc(def\n        x)" ${vimCmds}
+
+# expand_cr == 2
+set vimCmds [list {let g:delimitMate_expand_cr = 2}]
+lappend vimCmds {se cindent}
+lappend vimCmds {set bs=2 et sts=4 sw=4 ft=javascript}
+lappend vimCmds {let b:delimitMate_jump_expansion = 1}
+single expand_cr_2 {} "abc(def)" "\$i\rx" "abc(def\n        x\n   )" ${vimCmds}
+
+# Play nice with smartindent
+set vimCmds [list {let g:delimitMate_expand_cr = 2}]
+lappend vimCmds {let b:delimitMate_jump_expansion = 1}
+lappend vimCmds {set smartindent}
+single smartindent-1 {} "" "i{\rx" "{\n	x\n}" ${vimCmds}
+
+single quotes-1 {} "" "i\" x" {" x"} ${vimCmds}
+
+single quotes-2 {} "" "i\"\rx" "\"\nx\"" ${vimCmds}
+
+lappend vimCmds {let g:delimitMate_expand_inside_quotes = 1}
+single quotes-3 {} "" "i\"\nx" "\"\nx\n\"" ${vimCmds}
+
+
+
+################################################################
+# This gives nice statistics and cleans up the mess left behind.
+cleanupTests
+# vim: set filetype=tcl et sw=2 sts=0 ts=8:

test/expand_space.test

@@ -0,0 +1,48 @@
+# singleTest name desc setup input result vimCmds? skipScript?
+#
+# - desc can be empty and input would be used.
+# - vimCmds is a list of ex commands.
+# - skipScript will be evaluated in the scope of the function "single" and it
+#   should return a keywowd such as toDo, badTest or other as listed in the
+#   docs for tcltest. e.g.:
+#     {expr "[string first {i'} \"${input}\"] > -1 ? {emptyTest} : {}"}
+# see tcltest documentation for other values.
+
+# Get some help:
+source helper.tcl
+
+set vimCmds [list {let g:delimitMate_expand_space = 1}]
+lappend vimCmds {let g:delimitMate_autoclose = 1}
+
+pairs pairs-1 {} "" "i( x" "( x )" ${vimCmds}
+
+pairs pairs-2 {} "(  )" "la\bx" "(x)" ${vimCmds}
+
+pairs pairs-3 {} "" "iabc x" "abc x" ${vimCmds}
+
+quotes quotes-1 {} "" "i' x" "' x'" ${vimCmds}
+
+lappend vimCmds {let g:delimitMate_expand_inside_quotes = 1}
+quotes quotes-2 {} "" "i' x" "' x '" ${vimCmds}
+
+quotes quotes-3 {} "" "i' \bx" "'x'" ${vimCmds}
+
+set skipScript {string cat quoteBug}
+lappend vimCmds {let g:delimitMate_autoclose = 0}
+quotes quotes-4 {} "abc\\" "A'' x" "abc\\'' x '" ${vimCmds} ${skipScript}
+
+# Issue #95
+lappend vimCmds {let b:delimitMate_jump_expansion = 1}
+set skipScript {string cat toDo}
+pairs issue_95 {} "" "i( test)x" "( test )x" ${vimCmds} ${skipScript}
+
+pairs pairs-4 {} "" "i() \bx" "(x)" ${vimCmds}
+
+quotes quotes-5 {} "" "i'' \bx" "'x'" ${vimCmds}
+
+
+
+################################################################
+# This gives nice statistics and cleans up the mess left behind.
+cleanupTests
+# vim: set filetype=tcl et sw=2 sts=0 ts=8:

test/helper.tcl

@@ -0,0 +1,125 @@
+if {[lsearch [namespace children] ::tcltest] == -1} {
+  package require tcltest 2
+  namespace import -force ::tcltest::*
+}
+
+configure -verbose {body error skip}
+#configure -verbose {start msec pass body error skip}
+
+set charMap [list    \
+    "\""      "\\\"" \
+    "\$"      "\\$"  \
+    "\["      "\\\[" \
+    "\]"      "\\\]" \
+    "\\"      "\\\\" \
+    "{"       "\\{"  \
+    "}"       "\\}"  \
+  ]
+
+# In order to skip a test pass a script that, when evaluated, returns emptyTest
+# for tests that can not pass, or knownBug for ToDo features. e.g.:
+#   {expr "[string first {i'} \"${input}\"] > -1 ? {emptyTest} : {}"}
+# see tcltest documentation for other values.
+
+proc single {name desc setup input result \
+  {vimCmds {}}                            \
+  {constr {}}                             \
+  } {
+  set fnamePrefix "test_${name}"
+  global charMap
+  makeFile ${setup} "${fnamePrefix}.in"
+  makeFile {} "${fnamePrefix}.out"
+  makeFile [join ${vimCmds} "\n"] "${fnamePrefix}.vim"
+  set input [string map ${charMap} ${input}]
+  #puts [lindex ${vimCmds} 0]
+  set optCharMap [list {[} {\[} {]} {\]}]
+  set vimArgs [lmap option ${vimCmds} \
+      {string cat " -c \"[string map $charMap ${option}]\""}]
+  set body [string cat "
+  exec -- ./test.exp \"${fnamePrefix}\" \"${input}\"
+  return \[viewFile \"${fnamePrefix}.out\"\]
+  " ]
+  #puts ${body}
+  if {[string length ${desc}] eq 0} {
+    set desc ${input}
+  }
+  if {[string length ${constr}] ne 0} {
+    #puts ${constr}
+    set constr [eval ${constr}]
+    #puts ${constr}
+  }
+  set name "${name}:  \"${setup}\", \"${desc}\" ->"
+  #puts $desc
+  #puts $name
+  test ${name}               \
+      ${desc}                \
+      -body ${body}          \
+      -constraints ${constr} \
+      -result ${result}
+}
+
+proc multi {items evalScript name desc setup input result \
+  {vimCmds {}}                                            \
+  {constr {}}                                             \
+  } {
+  global charMap
+  set minor 0
+  foreach item $items {
+    incr minor
+    eval ${evalScript}
+    foreach var {desc setup input result} {
+      set "the_${var}"   [string map ${aCharMap} [expr "$${var}"]]
+    }
+    set the_name "${name}.${minor}"
+    single       \
+        ${the_name}   \
+        ${the_desc}   \
+        ${the_setup}  \
+        ${the_input}  \
+        ${the_result} \
+        ${vimCmds}    \
+        ${constr}     \
+  }
+}
+
+proc quotes {name desc setup input result \
+  {vimCmds {}}                            \
+  {constr {}}                             \
+  } {
+  set quotes [list {'} \" {`} {«} {|}]
+  set mapScript {set aCharMap [list "'" ${item}]}
+  multi       \
+      ${quotes}    \
+      ${mapScript} \
+      ${name}      \
+      ${desc}      \
+      ${setup}     \
+      ${input}     \
+      ${result}    \
+      ${vimCmds}   \
+      ${constr}    \
+}
+
+proc pairs {name desc setup input result \
+  {vimCmds {}}                           \
+  {constr {}}                            \
+  } {
+  set pairs [list () \{\} \[\] <> ¿? ¡!  ,:]
+  set mapScript {
+    set left [string index ${item} 0]
+    set right [string index ${item} 1]
+    set aCharMap [list ( ${left} ) ${right}]
+  }
+  multi       \
+      ${pairs}     \
+      ${mapScript} \
+      ${name}      \
+      ${desc}      \
+      ${setup}     \
+      ${input}     \
+      ${result}    \
+      ${vimCmds}   \
+      ${constr}    \
+}
+
+# vim: set filetype=tcl et sw=2 sts=0 ts=8:

test/pairs.test

@@ -0,0 +1,153 @@
+# singleTest name desc setup input result vimCmds? skipScript?
+#
+# - desc can be empty and input would be used.
+# - vimCmds is a list of ex commands.
+# - skipScript will be evaluated in the scope of the function "single" and it
+#   should return a keywowd such as toDo, badTest or other as listed in the
+#   docs for tcltest. e.g.:
+#     {expr "[string first {i'} \"${input}\"] > -1 ? {emptyTest} : {}"}
+# see tcltest documentation for other values.
+
+# Get some help:
+source helper.tcl
+
+set vimCmds [list ]
+pairs autoclose-1 {} {} "i(" "()"
+
+pairs autoclose-2 {} {()} "a\b" ""
+
+pairs autoclose-3 {} "()" "a)x" "()x"
+
+set skipScript {string cat {toDo}}
+single jump_all {} "" "((<magic>x" "(())x" {} ${skipScript}
+
+pairs undo {} "" "i(x\033u" ""
+
+pairs autoclose-4 {} "" "i@(x" "@(x)"
+
+pairs autoclose-5 {} "@#" "a(x" "@(x)#"
+
+pairs autoclose-6 {} "\\" "a(x" "\\(x"
+
+pairs autoclose-7 {} "(\\)" "la)x" "(\\)x)"
+
+pairs autoclose-8 {} {"abc"} "ifoo(" "foo(\"abc\""
+
+set vimCmds [list {let g:delimitMate_autoclose = 0}]
+pairs noautoclose-1 {} "" "i(x" "(x" ${vimCmds}
+
+pairs noautoclose-2 {} "" "i()x" "(x)" ${vimCmds}
+
+pairs noautoclose-3 {} "" "i())x" "()x" ${vimCmds}
+
+pairs noautoclose-4 {} "" "i()\bx" "x" ${vimCmds}
+
+pairs noautoclose-5 {} "" "i@()x" "@(x)" ${vimCmds}
+
+pairs noautoclose-6 {} "@#" "a()x" "@(x)#" ${vimCmds}
+
+#" Handle backspace gracefully.
+set vimCmds [list {set backspace=}]
+pairs bad_bs {} "" "i(\033a\bx" "(x)" ${vimCmds}
+
+set vimCmds [list ]
+
+# closing parens removes characters. #133
+pairs autoclose-9 {} "(a)" "a)" "()a)" ${vimCmds}
+
+# Expand iabbreviations
+set vimCmds [list {iabb def ghi}]
+# Not sure how to make it work on the test
+pairs iabbr {} "" "idef(" "ghi()" ${vimCmds}
+
+set vimCmds [list ]
+
+pairs autoclose-10 {} {abc а} {$i(} {abc (а} ${vimCmds}
+
+pairs autoclose-11 {} "abc ñ" "\$i(" "abc (ñ" ${vimCmds}
+
+pairs autoclose-12 {} "abc \$" "\$i(" "abc (\$" ${vimCmds}
+
+pairs autoclose-13 {} "abc £" "\$i(" "abc (£" ${vimCmds}
+
+pairs autoclose-14 {} "abc d" "\$i(" "abc (d" ${vimCmds}
+
+pairs autoclose-15 {} "abc ." "\$i(" "abc ()." ${vimCmds}
+
+pairs autoclose-16 {} "abc  " "\$i(" "abc () " ${vimCmds}
+
+pairs autoclose-17 {} "abc (" "\$i(" "abc ((" ${vimCmds}
+
+# Play nice with undo.
+pairs undo {} "" "ia\007u(c)b\033u" "a" ${vimCmds}
+
+# TODO: way to jump over one or several closing chars
+set skipScript {string cat {toDo}}
+single jump_to {} "()" "a\<magic>x" "()x" ${vimCmds} ${skipScript}
+
+single jump_to {} "{()}" "la\\<magic>x" "{()}x" ${vimCmds} ${skipScript}
+
+set vimCmds [list {let g:delimitMate_balance_pairs = 0}]
+pairs no_balance_pairs-1 {} "ab cd)" "la(x" "ab(x) cd)" ${vimCmds}
+
+# Issue #229
+pairs issue_229-1 {} "((ab cd)" "\$i)x" "((ab cd)x" ${vimCmds}
+
+set vimCmds [list ]
+
+set vimCmds [list {let g:delimitMate_balance_pairs = 1}]
+pairs issue_229-2 {} "ab cd)" "la(x" "ab(x cd)" ${vimCmds}
+
+# Issue #229
+pairs issue_229-3 {} "((ab cd)" "\$i)x" "((ab cd)x)" ${vimCmds}
+
+# Issue #220
+set vimCmds [list {let g:delimitMate_jump_next = 0}]
+pairs issue_220-1 {} "()" "a)" "())" ${vimCmds}
+
+# Issues #207 and #223
+set vimCmds [list {let g:delimitMate_jump_long = 1}]
+pairs jump_long-1 {} "{\[(foobar)\]}" "fbi)x" "{\[(foobar)x\]}" ${vimCmds}
+
+# Issues #207 and #223
+set skipScript {expr "[string first {[[foobar]]} \"${setup}\"] > -1 \
+    ? {badTest} : {}"}
+single jump_long-2 {} "{\[(foobar)\]}" "fbi\]x" "{\[(foobar)\]x}" ${vimCmds} ${skipScript}
+
+# Issues #207 and #223
+set skipScript {string cat {toDo}}
+set vimCmds [list {let g:delimitMate_jump_all = 1}]
+single issues_207_223 {} "{\[(foobar)\]}" "fbi<magic>x" "{\[(foobar)\]}x" \
+    ${vimCmds} ${skipScript}
+
+set vimCmds [list {let g:delimitMate_jump_back = 1}]
+pairs jump_back {} "" "i()x" "()x" ${vimCmds}
+
+# Disable on syntax groups
+set vimCmds [list {syntax on}]
+lappend vimCmds {set ft=vim}
+lappend vimCmds {let g:delimitMate_excluded_regions = ['String']}
+pairs ignore_syntax {} {echo "  "} "f\"la(" {echo " ( "} ${vimCmds}
+
+#" Issue #160
+set vimCmds [list {filetype indent plugin on}]
+lappend vimCmds {set ft=php}
+set skipScript {string cat {toDo}}
+single issue_160 {} "<?php incl" "A\x18\x0F\x19" "<?php include()" \
+    ${vimCmds} ${skipScript}
+
+set vimCmds [list ]
+
+# Play nice with redo
+pairs redo {} "abc " "Afoo(x\033." "abc foo(x)foo(x)" ${vimCmds}
+
+pairs smart {} {""} "0a(x" {"(x"}
+
+pairs smart {} {""} "0a()x" {"(x)"}
+
+
+
+################################################################
+# This gives nice statistics and cleans up the mess left behind.
+cleanupTests
+# vim: set filetype=tcl et sw=2 sts=0 ts=8:

test/quotes.test

@@ -0,0 +1,107 @@
+# singleTest name desc setup input result vimCmds? skipScript?
+#
+# - desc can be empty and input would be used.
+# - vimCmds is a list of ex commands.
+# - skipScript will be evaluated in the scope of the function "single" and it
+#   should return a keywowd such as toDo, badTest or other as listed in the
+#   docs for tcltest. e.g.:
+#     {expr "[string first {i'} \"${input}\"] > -1 ? {emptyTest} : {}"}
+# see tcltest documentation for other values.
+
+# Get some help:
+source helper.tcl
+
+quotes autoclose-1 {} {} "i'x" "'x'"
+
+quotes autoclose-2 {} {} "i'x\033u" {}
+
+quotes autoclose-3 {} {} {i''x} {''x}
+
+quotes autoclose-4 {} {''} "a\bx" {x}
+
+set skipScript {expr "[string first {i\"} \"${input}\"] > -1 ? {badTest} : {}"}
+quotes autoclose-5 {} "" "i'x\"" "'x\"'" {} ${skipScript}
+
+quotes autoclose-6 {} {} "i@'x" "@'x'"
+
+quotes autoclose-7 {} {@#} "a'x" "@'x'#"
+
+#quotes autoclose-8 {} {} "'\<S-Tab>x" "''x"
+
+single autoclose-8 {} {abc'} "A'" "abc'" {} {string cat toDo}
+
+quotes autoclose-9 {} "abc\\" "A'x" {abc\'x}
+
+quotes autoclose-10 {} {} "au'Привет'" "u'Привет'"
+
+quotes autoclose-11 {} {} "au'string'" "u'string'"
+
+set vimCmds [list {let g:delimitMate_autoclose = 0}]
+quotes noautoclose-1 {} {} "a'x" "'x" ${vimCmds}
+
+quotes noautoclose-2 {} {} "a''x" "'x'" ${vimCmds}
+
+quotes noautoclose-3 {} {} "a'''x" "''x" ${vimCmds}
+
+quotes noautoclose-4 {} {} "a''\bx" "x" ${vimCmds}
+
+quotes noautoclose-5 {} {} "a@''x" "@'x'" ${vimCmds}
+
+quotes noautoclose-6 {} "@#" "a''x" "@'x'#" ${vimCmds}
+
+set vimCmds [list {let g:delimitMate_autoclose = 1}]
+# Handle backspace gracefully.
+lappend vimCmds {set backspace=}
+quotes badBS-1 {} {} "a'\033a\bx" "'x'" ${vimCmds}
+
+set vimCmds [list {set cpo=ces$}]
+quotes cpo {} {} "a'x" "'x'" ${vimCmds}
+
+# Make sure smart quote works beyond first column.
+quotes beyond_first_column {} { } "a'x" " 'x'"
+
+# smart quote, check fo char on the right.
+quotes smart_quote-1 {} "a b" "la'" "a 'b"
+
+# Make sure we jump over a quote on the right. #89.
+quotes autoclose-12 {} {} "a('test'x" "('test'x)"
+
+# Duplicate whole line when inserting quote at bol #105
+quotes autoclose-13 {} "}" "i'" "''}"
+
+quotes autoclose-14 {} "'abc  " "A'" "'abc  '"
+
+quotes autoclose-15 {} "''abc " "A'" "''abc ''"
+
+# Nesting quotes:
+set vimCmds [list {let g:delimitMate_nesting_quotes = delimitMate#option('quotes')}]
+quotes nesting-1 {} "''" "A'x" "'''x'''" ${vimCmds}
+
+quotes nesting-2 {} "'''" "A'x" "''''x''''" ${vimCmds}
+
+quotes nesting-3 {} {} "i''x" "''x" ${vimCmds}
+
+quotes nesting-4 {} {} "i'x" "'x'" ${vimCmds}
+
+set vimCmds [list]
+
+# expand iabbreviations
+set vimCmds [list {iabb def ghi}]
+single iabbr {} {} {idef"} {ghi"} ${vimCmds}
+
+set vimCmds [list]
+
+quotes autoclose-16 {} {} "i'\n\b" "''"
+
+# Double quote starts a comment in viml
+set vimCmds [list {set ft=vim}]
+single vim_comment {} {} {i"} {"} ${vimCmds}
+
+#" Allow quote to exit from string when disabled by syntax group.
+set vimCmds [list {syntax on}]
+quotes disabled_syntax {} "'abc'" "\$i'x" "'abc'x" ${vimCmds}
+
+# --------
+# This gives nice statistics and cleans up the mess left behind.
+cleanupTests
+# vim: set filetype=tcl et sw=2 sts=0 ts=8:

test/test.exp

@@ -0,0 +1,20 @@
+#!/usr/bin/env expect -f
+
+set testName [lindex $argv 0]
+set filein "${testName}.in"
+set fileout "${testName}.out"
+set input [lindex $argv 1]
+
+set timeout 2
+spawn env TERM=dumb vim -N -i NONE -u _setup.vim -S "${testName}.vim" -- ${filein}
+match_max 100000
+expect -exact "Start test"
+foreach char [split ${input} {}] {
+	send -- "${char}"
+	sleep .01
+}
+send -- " "
+sleep .01
+send -- ":w! ${fileout}\r"
+send -- ":qa!\r"
+expect eof