mirrors/neovim
1
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2026-08-28 18:11:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge #2990 'tests: Migrate legacy test 69.'

Browse Source
This commit is contained in:
Justin M. Keyes
2017-02-03 22:55:05 +01:00
parent 54293b73d4 b4c172d612
commit 6239492d9c
4 changed files with 340 additions and 358 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/nvim/testdir/Makefile
View File

@@ -22,7 +22,6 @@ SCRIPTS := \
test52.out \
test53.out \
test64.out \
test69.out \
test73.out \
test79.out \
test_marks.out \

191
src/nvim/testdir/test69.in
View File

@@ -1,191 +0,0 @@
Test for multi-byte text formatting.
Also test, that 'mps' with multibyte chars works.
And test "ra" on multi-byte characters.
Also test byteidx() and byteidxcomp()
STARTTEST
:
ENDTEST
Results of test69:
STARTTEST
/^{/+1
:set tw=2 fo=t
gqgqjgqgqo
ＸＹＺ
abc ＸＹＺ
ENDTEST
{
ＸＹＺ
abc ＸＹＺ
}
STARTTEST
/^{/+1
:set tw=1 fo=tm
gqgqjgqgqjgqgqjgqgqjgqgqo
Ｘ
Ｘa
Ｘ a
ＸＹ
Ｘ Ｙ
ENDTEST
{
Ｘ
Ｘa
Ｘ a
ＸＹ
Ｘ Ｙ
}
STARTTEST
/^{/+1
:set tw=2 fo=tm
gqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqo
Ｘ
Ｘa
Ｘ a
ＸＹ
Ｘ Ｙ
aＸ
abＸ
abcＸ
abＸ c
abＸＹ
ENDTEST
{
Ｘ
Ｘa
Ｘ a
ＸＹ
Ｘ Ｙ
aＸ
abＸ
abcＸ
abＸ c
abＸＹ
}
STARTTEST
/^{/+1
:set ai tw=2 fo=tm
gqgqjgqgqo
Ｘ
Ｘa
ENDTEST
{
Ｘ
Ｘa
}
STARTTEST
/^{/+1
:set noai tw=2 fo=tm
gqgqjgqgqo
Ｘ
Ｘa
ENDTEST
{
Ｘ
Ｘa
}
STARTTEST
/^{/+1
:set tw=2 fo=cqm comments=n:Ｘ
gqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqo
Ｘ
Ｘa
ＸaＹ
ＸＹ
ＸＹＺ
Ｘ Ｙ
Ｘ ＹＺ
ＸＸ
ＸＸa
ＸＸＹ
ENDTEST
{
Ｘ
Ｘa
ＸaＹ
ＸＹ
ＸＹＺ
Ｘ Ｙ
Ｘ ＹＺ
ＸＸ
ＸＸa
ＸＸＹ
}
STARTTEST
/^{/+1
:set tw=2 fo=tm
RＸa
ENDTEST
{
}
STARTTEST
/^{/+1
:set mps+=u2018:u2019
d%
ENDTEST
{
‘ two three ’ four
}
STARTTEST
/^ra test
jVjra
ENDTEST
ra test
ａbbａ
ａａb
STARTTEST
:set whichwrap+=h
/^x
dh
:set whichwrap-=h
ENDTEST
á
x
STARTTEST
:let a = '.é.' " one char of two bytes
:let b = '.é.' " normal e with composing char
/^byteidx
:put =string([byteidx(a, 0), byteidx(a, 1), byteidx(a, 2), byteidx(a, 3), byteidx(a, 4)])
:put =string([byteidx(b, 0), byteidx(b, 1), byteidx(b, 2), byteidx(b, 3), byteidx(b, 4)])
/^byteidxcomp
:put =string([byteidxcomp(a, 0), byteidxcomp(a, 1), byteidxcomp(a, 2), byteidxcomp(a, 3), byteidxcomp(a, 4)])
:let b = '.é.'
:put =string([byteidxcomp(b, 0), byteidxcomp(b, 1), byteidxcomp(b, 2), byteidxcomp(b, 3), byteidxcomp(b, 4), byteidxcomp(b, 5)])
ENDTEST
byteidx
byteidxcomp
STARTTEST
/^substitute
:let y = substitute('１２３', '\zs', 'a', 'g') | put =y
ENDTEST
substitute
STARTTEST
:g/^STARTTEST/.,/^ENDTEST/d
:1;/^Results/,$wq! test.out
ENDTEST

166
src/nvim/testdir/test69.ok
View File

@@ -1,166 +0,0 @@
Results of test69:
{
ＸＹＺ
abc
ＸＹＺ
ＸＹＺ
abc
ＸＹＺ
}
{
Ｘ
Ｘ
a
Ｘ
a
Ｘ
Ｙ
Ｘ
Ｙ
Ｘ
Ｘ
a
Ｘ
a
Ｘ
Ｙ
Ｘ
Ｙ
}
{
Ｘ
Ｘ
a
Ｘ
a
Ｘ
Ｙ
Ｘ
Ｙ
a
Ｘ
ab
Ｘ
abc
Ｘ
ab
Ｘ
c
ab
Ｘ
Ｙ
Ｘ
Ｘ
a
Ｘ
a
Ｘ
Ｙ
Ｘ
Ｙ
a
Ｘ
ab
Ｘ
abc
Ｘ
ab
Ｘ
c
ab
Ｘ
Ｙ
}
{
Ｘ
Ｘ
a
Ｘ
Ｘ
a
}
{
Ｘ
Ｘ
a
Ｘ
Ｘ
a
}
{
Ｘ
Ｘa
Ｘa
ＸＹ
ＸＹ
ＸＹ
ＸＺ
Ｘ Ｙ
Ｘ Ｙ
Ｘ Ｚ
ＸＸ
ＸＸa
ＸＸＹ
Ｘ
Ｘa
Ｘa
ＸＹ
ＸＹ
ＸＹ
ＸＺ
Ｘ Ｙ
Ｘ Ｙ
Ｘ Ｚ
ＸＸ
ＸＸa
ＸＸＹ
}
{
Ｘ
a
}
{
four
}
ra test
aaaa
aaa
áx
byteidx
[0, 1, 3, 4, -1]
[0, 1, 4, 5, -1]
byteidxcomp
[0, 1, 3, 4, -1]
[0, 1, 2, 4, 5, -1]
substitute
a１a２a３a

340
test/functional/legacy/069_multibyte_formatting_spec.lua Normal file
View File

@@ -0,0 +1,340 @@
-- Test for multibyte text formatting.
-- Also test, that 'mps' with multibyte chars works.
-- And test "ra" on multibyte characters.
-- Also test byteidx() and byteidxcomp()
local helpers = require('test.functional.helpers')(after_each)
local feed, insert, eq, eval, clear, execute, expect = helpers.feed,
helpers.insert, helpers.eq, helpers.eval, helpers.clear, helpers.execute,
helpers.expect
describe('multibyte text', function()
before_each(clear)
it('formatting with "set fo=t"', function()
insert([[
{
ＸＹＺ
abc ＸＹＺ
}]])
execute('/^{/+1')
execute('set tw=2 fo=t')
feed('gqgqjgqgqo<cr>')
feed('ＸＹＺ<cr>')
feed('abc ＸＹＺ<esc><esc>')
expect([[
{
ＸＹＺ
abc
ＸＹＺ
ＸＹＺ
abc
ＸＹＺ
}]])
end)
it('formatting with "set fo=tm"', function()
insert([[
{
Ｘ
Ｘa
Ｘ a
ＸＹ
Ｘ Ｙ
}]])
execute('/^{/+1')
execute('set tw=1 fo=tm')
feed('gqgqjgqgqjgqgqjgqgqjgqgqo<cr>')
feed('Ｘ<cr>')
feed('Ｘa<cr>')
feed('Ｘ a<cr>')
feed('ＸＹ<cr>')
feed('Ｘ Ｙ<esc><esc>')
expect([[
{
Ｘ
Ｘ
a
Ｘ
a
Ｘ
Ｙ
Ｘ
Ｙ
Ｘ
Ｘ
a
Ｘ
a
Ｘ
Ｙ
Ｘ
Ｙ
}]])
end)
it('formatting with "set fo=tm" (part 2)', function()
insert([[
{
Ｘ
Ｘa
Ｘ a
ＸＹ
Ｘ Ｙ
aＸ
abＸ
abcＸ
abＸ c
abＸＹ
}]])
execute('/^{/+1')
execute('set tw=2 fo=tm')
feed('gqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqo<cr>')
feed('Ｘ<cr>')
feed('Ｘa<cr>')
feed('Ｘ a<cr>')
feed('ＸＹ<cr>')
feed('Ｘ Ｙ<cr>')
feed('aＸ<cr>')
feed('abＸ<cr>')
feed('abcＸ<cr>')
feed('abＸ c<cr>')
feed('abＸＹ<esc><esc>')
expect([[
{
Ｘ
Ｘ
a
Ｘ
a
Ｘ
Ｙ
Ｘ
Ｙ
a
Ｘ
ab
Ｘ
abc
Ｘ
ab
Ｘ
c
ab
Ｘ
Ｙ
Ｘ
Ｘ
a
Ｘ
a
Ｘ
Ｙ
Ｘ
Ｙ
a
Ｘ
ab
Ｘ
abc
Ｘ
ab
Ｘ
c
ab
Ｘ
Ｙ
}]])
end)
it('formatting with "set ai fo=tm"', function()
insert([[
{
Ｘ
Ｘa
}]])
execute('/^{/+1')
execute('set ai tw=2 fo=tm')
feed('gqgqjgqgqo<cr>')
feed('Ｘ<cr>')
feed('Ｘa<esc>')
expect([[
{
Ｘ
Ｘ
a
Ｘ
Ｘ
a
}]])
end)
it('formatting with "set ai fo=tm" (part 2)', function()
insert([[
{
Ｘ
Ｘa
}]])
execute('/^{/+1')
execute('set noai tw=2 fo=tm')
feed('gqgqjgqgqo<cr>')
-- Literal spaces will be trimmed from the by feed().
feed('<space><space>Ｘ<cr>')
feed('<space><space>Ｘa<esc>')
expect([[
{
Ｘ
Ｘ
a
Ｘ
Ｘ
a
}]])
end)
it('formatting with "set fo=cqm" and multibyte comments', function()
insert([[
{
Ｘ
Ｘa
ＸaＹ
ＸＹ
ＸＹＺ
Ｘ Ｙ
Ｘ ＹＺ
ＸＸ
ＸＸa
ＸＸＹ
}]])
execute('/^{/+1')
execute('set tw=2 fo=cqm comments=n:Ｘ')
feed('gqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqo<cr>')
feed('Ｘ<cr>')
feed('Ｘa<cr>')
feed('ＸaＹ<cr>')
feed('ＸＹ<cr>')
feed('ＸＹＺ<cr>')
feed('Ｘ Ｙ<cr>')
feed('Ｘ ＹＺ<cr>')
feed('ＸＸ<cr>')
feed('ＸＸa<cr>')
feed('ＸＸＹ<esc><esc>')
expect([[
{
Ｘ
Ｘa
Ｘa
ＸＹ
ＸＹ
ＸＹ
ＸＺ
Ｘ Ｙ
Ｘ Ｙ
Ｘ Ｚ
ＸＸ
ＸＸa
ＸＸＹ
Ｘ
Ｘa
Ｘa
ＸＹ
ＸＹ
ＸＹ
ＸＺ
Ｘ Ｙ
Ｘ Ｙ
Ｘ Ｚ
ＸＸ
ＸＸa
ＸＸＹ
}]])
end)
it('formatting in replace mode', function()
insert([[
{
}]])
execute('/^{/+1')
execute('set tw=2 fo=tm')
feed('RＸa<esc>')
expect([[
{
Ｘ
a
}]])
end)
it("as values of 'mps'", function()
insert([[
{
‘ two three ’ four
}]])
execute('/^{/+1')
execute('set mps+=‘:’')
feed('d%<cr>')
expect([[
{
four
}]])
end)
it('can be replaced with r', function()
insert([[
ａbbａ
ａａb]])
feed('gg0Vjra<cr>')
expect([[
aaaa
aaa]])
end)
it("doesn't interfere with 'whichwrap'", function()
insert([[
á
x]])
execute('set whichwrap+=h')
execute('/^x')
feed('dh')
expect([[
áx]])
end)
it('can be queried with byteidx() and byteidxcomp()', function()
-- One char of two bytes.
execute("let a = '.é.'")
-- Normal e with composing char.
execute("let b = '.é.'")
eq(0, eval('byteidx(a, 0)'))
eq(1, eval('byteidx(a, 1)'))
eq(3, eval('byteidx(a, 2)'))
eq(4, eval('byteidx(a, 3)'))
eq(-1, eval('byteidx(a, 4)'))
eq(0, eval('byteidx(b, 0)'))
eq(1, eval('byteidx(b, 1)'))
eq(4, eval('byteidx(b, 2)'))
eq(5, eval('byteidx(b, 3)'))
eq(-1, eval('byteidx(b, 4)'))
eq(0, eval('byteidxcomp(a, 0)'))
eq(1, eval('byteidxcomp(a, 1)'))
eq(3, eval('byteidxcomp(a, 2)'))
eq(4, eval('byteidxcomp(a, 3)'))
eq(-1, eval('byteidxcomp(a, 4)'))
eq(0, eval('byteidxcomp(b, 0)'))
eq(1, eval('byteidxcomp(b, 1)'))
eq(2, eval('byteidxcomp(b, 2)'))
eq(4, eval('byteidxcomp(b, 3)'))
eq(5, eval('byteidxcomp(b, 4)'))
eq(-1, eval('byteidxcomp(b, 5)'))
end)
it('correctly interact with the \zs pattern', function()
eq('a１a２a３a', eval([[substitute('１２３', '\zs', 'a', 'g')]]))
end)
end)