mirror of
https://github.com/neovim/neovim.git
synced 2024-12-25 13:45:15 -07:00
af23d17388
The new oldtest directory is in test/old/testdir. The reason for this is that many tests have hardcoded the parent directory name to be 'testdir'.
5429 lines
68 KiB
VimL
5429 lines
68 KiB
VimL
" Test for cinoptions and cindent
|
||
"
|
||
|
||
func Test_cino_hash()
|
||
" Test that curbuf->b_ind_hash_comment is correctly reset
|
||
new
|
||
setlocal cindent cinoptions=#1
|
||
setlocal cinoptions=
|
||
call setline(1, ["#include <iostream>"])
|
||
call cursor(1, 1)
|
||
norm! o#include
|
||
"call feedkeys("o#include\<esc>", 't')
|
||
call assert_equal(["#include <iostream>", "#include"], getline(1,2))
|
||
bwipe!
|
||
endfunc
|
||
|
||
func Test_cino_extern_c()
|
||
" Test for cino-E
|
||
|
||
let without_ind =<< trim [CODE]
|
||
#ifdef __cplusplus
|
||
extern "C" {
|
||
#endif
|
||
int func_a(void);
|
||
#ifdef __cplusplus
|
||
}
|
||
#endif
|
||
[CODE]
|
||
|
||
let with_ind =<< trim [CODE]
|
||
#ifdef __cplusplus
|
||
extern "C" {
|
||
#endif
|
||
int func_a(void);
|
||
#ifdef __cplusplus
|
||
}
|
||
#endif
|
||
[CODE]
|
||
new
|
||
setlocal cindent cinoptions=E0
|
||
call setline(1, without_ind)
|
||
call feedkeys("gg=G", 'tx')
|
||
call assert_equal(with_ind, getline(1, '$'))
|
||
|
||
setlocal cinoptions=E-s
|
||
call setline(1, with_ind)
|
||
call feedkeys("gg=G", 'tx')
|
||
call assert_equal(without_ind, getline(1, '$'))
|
||
|
||
setlocal cinoptions=Es
|
||
let tests = [
|
||
\ ['recognized', ['extern "C" {'], "\t\t;"],
|
||
\ ['recognized', ['extern "C++" {'], "\t\t;"],
|
||
\ ['recognized', ['extern /* com */ "C"{'], "\t\t;"],
|
||
\ ['recognized', ['extern"C"{'], "\t\t;"],
|
||
\ ['recognized', ['extern "C"', '{'], "\t\t;"],
|
||
\ ['not recognized', ['extern {'], "\t;"],
|
||
\ ['not recognized', ['extern /*"C"*/{'], "\t;"],
|
||
\ ['not recognized', ['extern "C" //{'], ";"],
|
||
\ ['not recognized', ['extern "C" /*{*/'], ";"],
|
||
\ ]
|
||
|
||
for pair in tests
|
||
let lines = pair[1]
|
||
call setline(1, lines)
|
||
call feedkeys(len(lines) . "Go;", 'tx')
|
||
call assert_equal(pair[2], getline(len(lines) + 1), 'Failed for "' . string(lines) . '"')
|
||
endfor
|
||
|
||
bwipe!
|
||
endfunc
|
||
|
||
func Test_cindent_rawstring()
|
||
new
|
||
setl cindent
|
||
call feedkeys("i" .
|
||
\ "int main() {\<CR>" .
|
||
\ "R\"(\<CR>" .
|
||
\ ")\";\<CR>" .
|
||
\ "statement;\<Esc>", "x")
|
||
call assert_equal("\tstatement;", getline(line('.')))
|
||
bw!
|
||
endfunc
|
||
|
||
func Test_cindent_expr()
|
||
new
|
||
func! MyIndentFunction()
|
||
return v:lnum == 1 ? shiftwidth() : 0
|
||
endfunc
|
||
setl expandtab sw=8 indentkeys+=; indentexpr=MyIndentFunction()
|
||
let testinput =<< trim [CODE]
|
||
var_a = something()
|
||
b = something()
|
||
[CODE]
|
||
call setline(1, testinput)
|
||
call cursor(1, 1)
|
||
call feedkeys("^\<c-v>j$A;\<esc>", 'tnix')
|
||
let expected =<< [CODE]
|
||
var_a = something();
|
||
b = something();
|
||
[CODE]
|
||
call assert_equal(expected, getline(1, '$'))
|
||
|
||
%d
|
||
let testinput =<< [CODE]
|
||
var_a = something()
|
||
b = something()
|
||
[CODE]
|
||
call setline(1, testinput)
|
||
call cursor(1, 1)
|
||
call feedkeys("^\<c-v>j$A;\<esc>", 'tnix')
|
||
let expected =<< [CODE]
|
||
var_a = something();
|
||
b = something()
|
||
[CODE]
|
||
call assert_equal(expected, getline(1, '$'))
|
||
bw!
|
||
endfunc
|
||
|
||
func Test_cindent_func()
|
||
new
|
||
setlocal cindent
|
||
call setline(1, ['int main(void)', '{', 'return 0;', '}'])
|
||
call assert_equal(-1, cindent(0))
|
||
call assert_equal(&sw, 3->cindent())
|
||
call assert_equal(-1, cindent(line('$')+1))
|
||
bwipe!
|
||
endfunc
|
||
|
||
func Test_cindent_1()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino& sts&
|
||
|
||
let code =<< trim [CODE]
|
||
/* start of AUTO matically checked vim: set ts=4 : */
|
||
{
|
||
if (test)
|
||
cmd1;
|
||
cmd2;
|
||
}
|
||
|
||
{
|
||
if (test)
|
||
cmd1;
|
||
else
|
||
cmd2;
|
||
}
|
||
|
||
{
|
||
if (test)
|
||
{
|
||
cmd1;
|
||
cmd2;
|
||
}
|
||
}
|
||
|
||
{
|
||
if (test)
|
||
{
|
||
cmd1;
|
||
else
|
||
}
|
||
}
|
||
|
||
{
|
||
while (this)
|
||
if (test)
|
||
cmd1;
|
||
cmd2;
|
||
}
|
||
|
||
{
|
||
while (this)
|
||
if (test)
|
||
cmd1;
|
||
else
|
||
cmd2;
|
||
}
|
||
|
||
{
|
||
if (test)
|
||
{
|
||
cmd;
|
||
}
|
||
|
||
if (test)
|
||
cmd;
|
||
}
|
||
|
||
{
|
||
if (test) {
|
||
cmd;
|
||
}
|
||
|
||
if (test) cmd;
|
||
}
|
||
|
||
{
|
||
cmd1;
|
||
for (blah)
|
||
while (this)
|
||
if (test)
|
||
cmd2;
|
||
cmd3;
|
||
}
|
||
|
||
{
|
||
cmd1;
|
||
for (blah)
|
||
while (this)
|
||
if (test)
|
||
cmd2;
|
||
cmd3;
|
||
|
||
if (test)
|
||
{
|
||
cmd1;
|
||
cmd2;
|
||
cmd3;
|
||
}
|
||
}
|
||
|
||
|
||
/* Test for 'cindent' do/while mixed with if/else: */
|
||
|
||
{
|
||
do
|
||
if (asdf)
|
||
asdfasd;
|
||
while (cond);
|
||
|
||
do
|
||
if (asdf)
|
||
while (asdf)
|
||
asdf;
|
||
while (asdf);
|
||
}
|
||
|
||
/* Test for 'cindent' with two ) on a continuation line */
|
||
{
|
||
if (asdfasdf;asldkfj asdlkfj as;ldkfj sal;d
|
||
aal;sdkjf ( ;asldfkja;sldfk
|
||
al;sdjfka ;slkdf ) sa;ldkjfsa dlk;)
|
||
line up here;
|
||
}
|
||
|
||
|
||
/* C++ tests: */
|
||
|
||
// foo() these three lines should remain in column 0
|
||
// {
|
||
// }
|
||
|
||
/* Test for continuation and unterminated lines: */
|
||
{
|
||
i = 99 + 14325 +
|
||
21345 +
|
||
21345 +
|
||
21345 + ( 21345 +
|
||
21345) +
|
||
2345 +
|
||
1234;
|
||
c = 1;
|
||
}
|
||
|
||
/*
|
||
testje for indent with empty line
|
||
|
||
here */
|
||
|
||
{
|
||
if (testing &&
|
||
not a joke ||
|
||
line up here)
|
||
hay;
|
||
if (testing &&
|
||
(not a joke || testing
|
||
)line up here)
|
||
hay;
|
||
if (testing &&
|
||
(not a joke || testing
|
||
line up here))
|
||
hay;
|
||
}
|
||
|
||
|
||
{
|
||
switch (c)
|
||
{
|
||
case xx:
|
||
do
|
||
if (asdf)
|
||
do
|
||
asdfasdf;
|
||
while (asdf);
|
||
else
|
||
asdfasdf;
|
||
while (cond);
|
||
case yy:
|
||
case xx:
|
||
case zz:
|
||
testing;
|
||
}
|
||
}
|
||
|
||
{
|
||
if (cond) {
|
||
foo;
|
||
}
|
||
else
|
||
{
|
||
bar;
|
||
}
|
||
}
|
||
|
||
{
|
||
if (alskdfj ;alsdkfjal;skdjf (;sadlkfsa ;dlkf j;alksdfj ;alskdjf
|
||
alsdkfj (asldk;fj
|
||
awith cino=(0 ;lf this one goes to below the paren with ==
|
||
;laksjfd ;lsakdjf ;alskdf asd)
|
||
asdfasdf;)))
|
||
asdfasdf;
|
||
}
|
||
|
||
int
|
||
func(a, b)
|
||
int a;
|
||
int c;
|
||
{
|
||
if (c1 && (c2 ||
|
||
c3))
|
||
foo;
|
||
if (c1 &&
|
||
(c2 || c3)
|
||
)
|
||
}
|
||
|
||
{
|
||
while (asd)
|
||
{
|
||
if (asdf)
|
||
if (test)
|
||
if (that)
|
||
{
|
||
if (asdf)
|
||
do
|
||
cdasd;
|
||
while (as
|
||
df);
|
||
}
|
||
else
|
||
if (asdf)
|
||
asdf;
|
||
else
|
||
asdf;
|
||
asdf;
|
||
}
|
||
}
|
||
|
||
{
|
||
s = "/*"; b = ';'
|
||
s = "/*"; b = ';';
|
||
a = b;
|
||
}
|
||
|
||
{
|
||
switch (a)
|
||
{
|
||
case a:
|
||
switch (t)
|
||
{
|
||
case 1:
|
||
cmd;
|
||
break;
|
||
case 2:
|
||
cmd;
|
||
break;
|
||
}
|
||
cmd;
|
||
break;
|
||
case b:
|
||
{
|
||
int i;
|
||
cmd;
|
||
}
|
||
break;
|
||
case c: {
|
||
int i;
|
||
cmd;
|
||
}
|
||
case d: if (cond &&
|
||
test) { /* this line doesn't work right */
|
||
int i;
|
||
cmd;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
{
|
||
if (!(vim_strchr(p_cpo, CPO_BUFOPTGLOB) != NULL && entering) &&
|
||
(bp_to->b_p_initialized ||
|
||
(!entering && vim_strchr(p_cpo, CPO_BUFOPT) != NULL)))
|
||
return;
|
||
label :
|
||
asdf = asdf ?
|
||
asdf : asdf;
|
||
asdf = asdf ?
|
||
asdf: asdf;
|
||
}
|
||
|
||
/* Special Comments : This function has the added complexity (compared */
|
||
/* : to addtolist) of having to check for a detail */
|
||
/* : texture and add that to the list first. */
|
||
|
||
char *(array[100]) = {
|
||
"testje",
|
||
"foo",
|
||
"bar",
|
||
}
|
||
|
||
enum soppie
|
||
{
|
||
yes = 0,
|
||
no,
|
||
maybe
|
||
};
|
||
|
||
typedef enum soppie
|
||
{
|
||
yes = 0,
|
||
no,
|
||
maybe
|
||
};
|
||
|
||
static enum
|
||
{
|
||
yes = 0,
|
||
no,
|
||
maybe
|
||
} soppie;
|
||
|
||
public static enum
|
||
{
|
||
yes = 0,
|
||
no,
|
||
maybe
|
||
} soppie;
|
||
|
||
static private enum
|
||
{
|
||
yes = 0,
|
||
no,
|
||
maybe
|
||
} soppie;
|
||
|
||
{
|
||
int a,
|
||
b;
|
||
}
|
||
|
||
{
|
||
struct Type
|
||
{
|
||
int i;
|
||
char *str;
|
||
} var[] =
|
||
{
|
||
0, "zero",
|
||
1, "one",
|
||
2, "two",
|
||
3, "three"
|
||
};
|
||
|
||
float matrix[3][3] =
|
||
{
|
||
{
|
||
0,
|
||
1,
|
||
2
|
||
},
|
||
{
|
||
3,
|
||
4,
|
||
5
|
||
},
|
||
{
|
||
6,
|
||
7,
|
||
8
|
||
}
|
||
};
|
||
}
|
||
|
||
{
|
||
/* blah ( blah */
|
||
/* where does this go? */
|
||
|
||
/* blah ( blah */
|
||
cmd;
|
||
|
||
func(arg1,
|
||
/* comment */
|
||
arg2);
|
||
a;
|
||
{
|
||
b;
|
||
{
|
||
c; /* Hey, NOW it indents?! */
|
||
}
|
||
}
|
||
|
||
{
|
||
func(arg1,
|
||
arg2,
|
||
arg3);
|
||
/* Hey, what am I doing here? Is this coz of the ","? */
|
||
}
|
||
}
|
||
|
||
main ()
|
||
{
|
||
if (cond)
|
||
{
|
||
a = b;
|
||
}
|
||
if (cond) {
|
||
a = c;
|
||
}
|
||
if (cond)
|
||
a = d;
|
||
return;
|
||
}
|
||
|
||
{
|
||
case 2: if (asdf &&
|
||
asdfasdf)
|
||
aasdf;
|
||
a = 9;
|
||
case 3: if (asdf)
|
||
aasdf;
|
||
a = 9;
|
||
case 4: x = 1;
|
||
y = 2;
|
||
|
||
label: if (asdf)
|
||
here;
|
||
|
||
label: if (asdf &&
|
||
asdfasdf)
|
||
{
|
||
}
|
||
|
||
label: if (asdf &&
|
||
asdfasdf) {
|
||
there;
|
||
}
|
||
|
||
label: if (asdf &&
|
||
asdfasdf)
|
||
there;
|
||
}
|
||
|
||
{
|
||
/*
|
||
hello with ":set comments= cino=c5"
|
||
*/
|
||
|
||
/*
|
||
hello with ":set comments= cino="
|
||
*/
|
||
}
|
||
|
||
|
||
{
|
||
if (a < b) {
|
||
a = a + 1;
|
||
} else
|
||
a = a + 2;
|
||
|
||
if (a)
|
||
do {
|
||
testing;
|
||
} while (asdfasdf);
|
||
a = b + 1;
|
||
asdfasdf
|
||
}
|
||
|
||
{
|
||
for ( int i = 0;
|
||
i < 10; i++ )
|
||
{
|
||
}
|
||
i = 0;
|
||
}
|
||
|
||
class bob
|
||
{
|
||
int foo() {return 1;}
|
||
int bar;
|
||
}
|
||
|
||
main()
|
||
{
|
||
while(1)
|
||
if (foo)
|
||
{
|
||
bar;
|
||
}
|
||
else {
|
||
asdf;
|
||
}
|
||
misplacedline;
|
||
}
|
||
|
||
{
|
||
if (clipboard.state == SELECT_DONE
|
||
&& ((row == clipboard.start.lnum
|
||
&& col >= clipboard.start.col)
|
||
|| row > clipboard.start.lnum))
|
||
}
|
||
|
||
{
|
||
if (1) {i += 4;}
|
||
where_am_i;
|
||
return 0;
|
||
}
|
||
|
||
{
|
||
{
|
||
} // sdf(asdf
|
||
if (asdf)
|
||
asd;
|
||
}
|
||
|
||
{
|
||
label1:
|
||
label2:
|
||
}
|
||
|
||
{
|
||
int fooRet = foo(pBar1, false /*fKB*/,
|
||
true /*fPTB*/, 3 /*nT*/, false /*fDF*/);
|
||
f() {
|
||
for ( i = 0;
|
||
i < m;
|
||
/* c */ i++ ) {
|
||
a = b;
|
||
}
|
||
}
|
||
}
|
||
|
||
{
|
||
f1(/*comment*/);
|
||
f2();
|
||
}
|
||
|
||
{
|
||
do {
|
||
if (foo) {
|
||
} else
|
||
;
|
||
} while (foo);
|
||
foo(); // was wrong
|
||
}
|
||
|
||
int x; // no extra indent because of the ;
|
||
void func()
|
||
{
|
||
}
|
||
|
||
char *tab[] = {"aaa",
|
||
"};", /* }; */ NULL}
|
||
int indented;
|
||
{}
|
||
|
||
char *a[] = {"aaa", "bbb",
|
||
"ccc", NULL};
|
||
// here
|
||
|
||
char *tab[] = {"aaa",
|
||
"xx", /* xx */}; /* asdf */
|
||
int not_indented;
|
||
|
||
{
|
||
do {
|
||
switch (bla)
|
||
{
|
||
case 1: if (foo)
|
||
bar;
|
||
}
|
||
} while (boo);
|
||
wrong;
|
||
}
|
||
|
||
int foo,
|
||
bar;
|
||
int foo;
|
||
|
||
#if defined(foo) \
|
||
&& defined(bar)
|
||
char * xx = "asdf\
|
||
foo\
|
||
bor";
|
||
int x;
|
||
|
||
char *foo = "asdf\
|
||
asdf\
|
||
asdf",
|
||
*bar;
|
||
|
||
void f()
|
||
{
|
||
#if defined(foo) \
|
||
&& defined(bar)
|
||
char *foo = "asdf\
|
||
asdf\
|
||
asdf",
|
||
*bar;
|
||
{
|
||
int i;
|
||
char *foo = "asdf\
|
||
asdf\
|
||
asdf",
|
||
*bar;
|
||
}
|
||
#endif
|
||
}
|
||
#endif
|
||
|
||
int y; // comment
|
||
// comment
|
||
|
||
// comment
|
||
|
||
{
|
||
Constructor(int a,
|
||
int b ) : BaseClass(a)
|
||
{
|
||
}
|
||
}
|
||
|
||
void foo()
|
||
{
|
||
char one,
|
||
two;
|
||
struct bla piet,
|
||
jan;
|
||
enum foo kees,
|
||
jannie;
|
||
static unsigned sdf,
|
||
krap;
|
||
unsigned int piet,
|
||
jan;
|
||
int
|
||
kees,
|
||
jan;
|
||
}
|
||
|
||
{
|
||
t(int f,
|
||
int d); // )
|
||
d();
|
||
}
|
||
|
||
Constructor::Constructor(int a,
|
||
int b
|
||
) :
|
||
BaseClass(a,
|
||
b,
|
||
c),
|
||
mMember(b),
|
||
{
|
||
}
|
||
|
||
Constructor::Constructor(int a,
|
||
int b ) :
|
||
BaseClass(a)
|
||
{
|
||
}
|
||
|
||
Constructor::Constructor(int a,
|
||
int b ) /*x*/ : /*x*/ BaseClass(a),
|
||
member(b)
|
||
{
|
||
}
|
||
|
||
A::A(int a, int b)
|
||
: aa(a),
|
||
bb(b),
|
||
cc(c)
|
||
{
|
||
}
|
||
|
||
class CAbc :
|
||
public BaseClass1,
|
||
protected BaseClass2
|
||
{
|
||
int Test() { return FALSE; }
|
||
int Test1() { return TRUE; }
|
||
|
||
CAbc(int a, int b ) :
|
||
BaseClass(a)
|
||
{
|
||
switch(xxx)
|
||
{
|
||
case abc:
|
||
asdf();
|
||
break;
|
||
|
||
case 999:
|
||
baer();
|
||
break;
|
||
}
|
||
}
|
||
|
||
public: // <-- this was incorrectly indented before!!
|
||
void testfall();
|
||
protected:
|
||
void testfall();
|
||
};
|
||
|
||
class CAbc : public BaseClass1,
|
||
protected BaseClass2
|
||
{
|
||
};
|
||
|
||
static struct
|
||
{
|
||
int a;
|
||
int b;
|
||
} variable[COUNT] =
|
||
{
|
||
{
|
||
123,
|
||
456
|
||
},
|
||
{
|
||
123,
|
||
456
|
||
}
|
||
};
|
||
|
||
static struct
|
||
{
|
||
int a;
|
||
int b;
|
||
} variable[COUNT] =
|
||
{
|
||
{ 123, 456 },
|
||
{ 123, 456 }
|
||
};
|
||
|
||
void asdf() /* ind_maxparen may cause trouble here */
|
||
{
|
||
if ((0
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1)) break;
|
||
}
|
||
|
||
foo()
|
||
{
|
||
a = cond ? foo() : asdf
|
||
+ asdf;
|
||
|
||
a = cond ?
|
||
foo() : asdf
|
||
+ asdf;
|
||
}
|
||
|
||
int main(void)
|
||
{
|
||
if (a)
|
||
if (b)
|
||
2;
|
||
else 3;
|
||
next_line_of_code();
|
||
}
|
||
|
||
barry()
|
||
{
|
||
Foo::Foo (int one,
|
||
int two)
|
||
: something(4)
|
||
{}
|
||
}
|
||
|
||
barry()
|
||
{
|
||
Foo::Foo (int one, int two)
|
||
: something(4)
|
||
{}
|
||
}
|
||
|
||
Constructor::Constructor(int a,
|
||
int b
|
||
) :
|
||
BaseClass(a,
|
||
b,
|
||
c),
|
||
mMember(b)
|
||
{
|
||
}
|
||
int main ()
|
||
{
|
||
if (lala)
|
||
do
|
||
++(*lolo);
|
||
while (lili
|
||
&& lele);
|
||
lulu;
|
||
}
|
||
|
||
int main ()
|
||
{
|
||
switch (c)
|
||
{
|
||
case 'c': if (cond)
|
||
{
|
||
}
|
||
}
|
||
}
|
||
|
||
main()
|
||
{
|
||
(void) MyFancyFuasdfadsfnction(
|
||
argument);
|
||
}
|
||
|
||
main()
|
||
{
|
||
char foo[] = "/*";
|
||
/* as
|
||
df */
|
||
hello
|
||
}
|
||
|
||
/* valid namespaces with normal indent */
|
||
namespace
|
||
{
|
||
{
|
||
111111111111;
|
||
}
|
||
}
|
||
namespace /* test */
|
||
{
|
||
11111111111111111;
|
||
}
|
||
namespace // test
|
||
{
|
||
111111111111111111;
|
||
}
|
||
namespace
|
||
{
|
||
111111111111111111;
|
||
}
|
||
namespace test
|
||
{
|
||
111111111111111111;
|
||
}
|
||
namespace{
|
||
111111111111111111;
|
||
}
|
||
namespace test{
|
||
111111111111111111;
|
||
}
|
||
namespace {
|
||
111111111111111111;
|
||
}
|
||
namespace test {
|
||
111111111111111111;
|
||
namespace test2 {
|
||
22222222222222222;
|
||
}
|
||
}
|
||
inline namespace {
|
||
111111111111111111;
|
||
}
|
||
inline /* test */ namespace {
|
||
111111111111111111;
|
||
}
|
||
inline/* test */namespace {
|
||
111111111111111111;
|
||
}
|
||
|
||
/* invalid namespaces use block indent */
|
||
namespace test test2 {
|
||
111111111111111111111;
|
||
}
|
||
namespace11111111111 {
|
||
111111111111;
|
||
}
|
||
namespace() {
|
||
1111111111111;
|
||
}
|
||
namespace()
|
||
{
|
||
111111111111111111;
|
||
}
|
||
namespace test test2
|
||
{
|
||
1111111111111111111;
|
||
}
|
||
namespace111111111
|
||
{
|
||
111111111111111111;
|
||
}
|
||
inlinenamespace {
|
||
111111111111111111;
|
||
}
|
||
|
||
void getstring() {
|
||
/* Raw strings */
|
||
const char* s = R"(
|
||
test {
|
||
# comment
|
||
field: 123
|
||
}
|
||
)";
|
||
}
|
||
|
||
void getstring() {
|
||
const char* s = R"foo(
|
||
test {
|
||
# comment
|
||
field: 123
|
||
}
|
||
)foo";
|
||
}
|
||
|
||
{
|
||
int a[4] = {
|
||
[0] = 0,
|
||
[1] = 1,
|
||
[2] = 2,
|
||
[3] = 3,
|
||
};
|
||
}
|
||
|
||
{
|
||
a = b[2]
|
||
+ 3;
|
||
}
|
||
|
||
{
|
||
if (1)
|
||
/* aaaaa
|
||
* bbbbb
|
||
*/
|
||
a = 1;
|
||
}
|
||
|
||
void func()
|
||
{
|
||
switch (foo)
|
||
{
|
||
case (bar):
|
||
if (baz())
|
||
quux();
|
||
break;
|
||
case (shmoo):
|
||
if (!bar)
|
||
{
|
||
}
|
||
case (foo1):
|
||
switch (bar)
|
||
{
|
||
case baz:
|
||
baz_f();
|
||
break;
|
||
}
|
||
break;
|
||
default:
|
||
baz();
|
||
baz();
|
||
break;
|
||
}
|
||
}
|
||
|
||
/* end of AUTO */
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
call search('start of AUTO')
|
||
exe "normal =/end of AUTO\<CR>"
|
||
|
||
let expected =<< trim [CODE]
|
||
/* start of AUTO matically checked vim: set ts=4 : */
|
||
{
|
||
if (test)
|
||
cmd1;
|
||
cmd2;
|
||
}
|
||
|
||
{
|
||
if (test)
|
||
cmd1;
|
||
else
|
||
cmd2;
|
||
}
|
||
|
||
{
|
||
if (test)
|
||
{
|
||
cmd1;
|
||
cmd2;
|
||
}
|
||
}
|
||
|
||
{
|
||
if (test)
|
||
{
|
||
cmd1;
|
||
else
|
||
}
|
||
}
|
||
|
||
{
|
||
while (this)
|
||
if (test)
|
||
cmd1;
|
||
cmd2;
|
||
}
|
||
|
||
{
|
||
while (this)
|
||
if (test)
|
||
cmd1;
|
||
else
|
||
cmd2;
|
||
}
|
||
|
||
{
|
||
if (test)
|
||
{
|
||
cmd;
|
||
}
|
||
|
||
if (test)
|
||
cmd;
|
||
}
|
||
|
||
{
|
||
if (test) {
|
||
cmd;
|
||
}
|
||
|
||
if (test) cmd;
|
||
}
|
||
|
||
{
|
||
cmd1;
|
||
for (blah)
|
||
while (this)
|
||
if (test)
|
||
cmd2;
|
||
cmd3;
|
||
}
|
||
|
||
{
|
||
cmd1;
|
||
for (blah)
|
||
while (this)
|
||
if (test)
|
||
cmd2;
|
||
cmd3;
|
||
|
||
if (test)
|
||
{
|
||
cmd1;
|
||
cmd2;
|
||
cmd3;
|
||
}
|
||
}
|
||
|
||
|
||
/* Test for 'cindent' do/while mixed with if/else: */
|
||
|
||
{
|
||
do
|
||
if (asdf)
|
||
asdfasd;
|
||
while (cond);
|
||
|
||
do
|
||
if (asdf)
|
||
while (asdf)
|
||
asdf;
|
||
while (asdf);
|
||
}
|
||
|
||
/* Test for 'cindent' with two ) on a continuation line */
|
||
{
|
||
if (asdfasdf;asldkfj asdlkfj as;ldkfj sal;d
|
||
aal;sdkjf ( ;asldfkja;sldfk
|
||
al;sdjfka ;slkdf ) sa;ldkjfsa dlk;)
|
||
line up here;
|
||
}
|
||
|
||
|
||
/* C++ tests: */
|
||
|
||
// foo() these three lines should remain in column 0
|
||
// {
|
||
// }
|
||
|
||
/* Test for continuation and unterminated lines: */
|
||
{
|
||
i = 99 + 14325 +
|
||
21345 +
|
||
21345 +
|
||
21345 + ( 21345 +
|
||
21345) +
|
||
2345 +
|
||
1234;
|
||
c = 1;
|
||
}
|
||
|
||
/*
|
||
testje for indent with empty line
|
||
|
||
here */
|
||
|
||
{
|
||
if (testing &&
|
||
not a joke ||
|
||
line up here)
|
||
hay;
|
||
if (testing &&
|
||
(not a joke || testing
|
||
)line up here)
|
||
hay;
|
||
if (testing &&
|
||
(not a joke || testing
|
||
line up here))
|
||
hay;
|
||
}
|
||
|
||
|
||
{
|
||
switch (c)
|
||
{
|
||
case xx:
|
||
do
|
||
if (asdf)
|
||
do
|
||
asdfasdf;
|
||
while (asdf);
|
||
else
|
||
asdfasdf;
|
||
while (cond);
|
||
case yy:
|
||
case xx:
|
||
case zz:
|
||
testing;
|
||
}
|
||
}
|
||
|
||
{
|
||
if (cond) {
|
||
foo;
|
||
}
|
||
else
|
||
{
|
||
bar;
|
||
}
|
||
}
|
||
|
||
{
|
||
if (alskdfj ;alsdkfjal;skdjf (;sadlkfsa ;dlkf j;alksdfj ;alskdjf
|
||
alsdkfj (asldk;fj
|
||
awith cino=(0 ;lf this one goes to below the paren with ==
|
||
;laksjfd ;lsakdjf ;alskdf asd)
|
||
asdfasdf;)))
|
||
asdfasdf;
|
||
}
|
||
|
||
int
|
||
func(a, b)
|
||
int a;
|
||
int c;
|
||
{
|
||
if (c1 && (c2 ||
|
||
c3))
|
||
foo;
|
||
if (c1 &&
|
||
(c2 || c3)
|
||
)
|
||
}
|
||
|
||
{
|
||
while (asd)
|
||
{
|
||
if (asdf)
|
||
if (test)
|
||
if (that)
|
||
{
|
||
if (asdf)
|
||
do
|
||
cdasd;
|
||
while (as
|
||
df);
|
||
}
|
||
else
|
||
if (asdf)
|
||
asdf;
|
||
else
|
||
asdf;
|
||
asdf;
|
||
}
|
||
}
|
||
|
||
{
|
||
s = "/*"; b = ';'
|
||
s = "/*"; b = ';';
|
||
a = b;
|
||
}
|
||
|
||
{
|
||
switch (a)
|
||
{
|
||
case a:
|
||
switch (t)
|
||
{
|
||
case 1:
|
||
cmd;
|
||
break;
|
||
case 2:
|
||
cmd;
|
||
break;
|
||
}
|
||
cmd;
|
||
break;
|
||
case b:
|
||
{
|
||
int i;
|
||
cmd;
|
||
}
|
||
break;
|
||
case c: {
|
||
int i;
|
||
cmd;
|
||
}
|
||
case d: if (cond &&
|
||
test) { /* this line doesn't work right */
|
||
int i;
|
||
cmd;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
{
|
||
if (!(vim_strchr(p_cpo, CPO_BUFOPTGLOB) != NULL && entering) &&
|
||
(bp_to->b_p_initialized ||
|
||
(!entering && vim_strchr(p_cpo, CPO_BUFOPT) != NULL)))
|
||
return;
|
||
label :
|
||
asdf = asdf ?
|
||
asdf : asdf;
|
||
asdf = asdf ?
|
||
asdf: asdf;
|
||
}
|
||
|
||
/* Special Comments : This function has the added complexity (compared */
|
||
/* : to addtolist) of having to check for a detail */
|
||
/* : texture and add that to the list first. */
|
||
|
||
char *(array[100]) = {
|
||
"testje",
|
||
"foo",
|
||
"bar",
|
||
}
|
||
|
||
enum soppie
|
||
{
|
||
yes = 0,
|
||
no,
|
||
maybe
|
||
};
|
||
|
||
typedef enum soppie
|
||
{
|
||
yes = 0,
|
||
no,
|
||
maybe
|
||
};
|
||
|
||
static enum
|
||
{
|
||
yes = 0,
|
||
no,
|
||
maybe
|
||
} soppie;
|
||
|
||
public static enum
|
||
{
|
||
yes = 0,
|
||
no,
|
||
maybe
|
||
} soppie;
|
||
|
||
static private enum
|
||
{
|
||
yes = 0,
|
||
no,
|
||
maybe
|
||
} soppie;
|
||
|
||
{
|
||
int a,
|
||
b;
|
||
}
|
||
|
||
{
|
||
struct Type
|
||
{
|
||
int i;
|
||
char *str;
|
||
} var[] =
|
||
{
|
||
0, "zero",
|
||
1, "one",
|
||
2, "two",
|
||
3, "three"
|
||
};
|
||
|
||
float matrix[3][3] =
|
||
{
|
||
{
|
||
0,
|
||
1,
|
||
2
|
||
},
|
||
{
|
||
3,
|
||
4,
|
||
5
|
||
},
|
||
{
|
||
6,
|
||
7,
|
||
8
|
||
}
|
||
};
|
||
}
|
||
|
||
{
|
||
/* blah ( blah */
|
||
/* where does this go? */
|
||
|
||
/* blah ( blah */
|
||
cmd;
|
||
|
||
func(arg1,
|
||
/* comment */
|
||
arg2);
|
||
a;
|
||
{
|
||
b;
|
||
{
|
||
c; /* Hey, NOW it indents?! */
|
||
}
|
||
}
|
||
|
||
{
|
||
func(arg1,
|
||
arg2,
|
||
arg3);
|
||
/* Hey, what am I doing here? Is this coz of the ","? */
|
||
}
|
||
}
|
||
|
||
main ()
|
||
{
|
||
if (cond)
|
||
{
|
||
a = b;
|
||
}
|
||
if (cond) {
|
||
a = c;
|
||
}
|
||
if (cond)
|
||
a = d;
|
||
return;
|
||
}
|
||
|
||
{
|
||
case 2: if (asdf &&
|
||
asdfasdf)
|
||
aasdf;
|
||
a = 9;
|
||
case 3: if (asdf)
|
||
aasdf;
|
||
a = 9;
|
||
case 4: x = 1;
|
||
y = 2;
|
||
|
||
label: if (asdf)
|
||
here;
|
||
|
||
label: if (asdf &&
|
||
asdfasdf)
|
||
{
|
||
}
|
||
|
||
label: if (asdf &&
|
||
asdfasdf) {
|
||
there;
|
||
}
|
||
|
||
label: if (asdf &&
|
||
asdfasdf)
|
||
there;
|
||
}
|
||
|
||
{
|
||
/*
|
||
hello with ":set comments= cino=c5"
|
||
*/
|
||
|
||
/*
|
||
hello with ":set comments= cino="
|
||
*/
|
||
}
|
||
|
||
|
||
{
|
||
if (a < b) {
|
||
a = a + 1;
|
||
} else
|
||
a = a + 2;
|
||
|
||
if (a)
|
||
do {
|
||
testing;
|
||
} while (asdfasdf);
|
||
a = b + 1;
|
||
asdfasdf
|
||
}
|
||
|
||
{
|
||
for ( int i = 0;
|
||
i < 10; i++ )
|
||
{
|
||
}
|
||
i = 0;
|
||
}
|
||
|
||
class bob
|
||
{
|
||
int foo() {return 1;}
|
||
int bar;
|
||
}
|
||
|
||
main()
|
||
{
|
||
while(1)
|
||
if (foo)
|
||
{
|
||
bar;
|
||
}
|
||
else {
|
||
asdf;
|
||
}
|
||
misplacedline;
|
||
}
|
||
|
||
{
|
||
if (clipboard.state == SELECT_DONE
|
||
&& ((row == clipboard.start.lnum
|
||
&& col >= clipboard.start.col)
|
||
|| row > clipboard.start.lnum))
|
||
}
|
||
|
||
{
|
||
if (1) {i += 4;}
|
||
where_am_i;
|
||
return 0;
|
||
}
|
||
|
||
{
|
||
{
|
||
} // sdf(asdf
|
||
if (asdf)
|
||
asd;
|
||
}
|
||
|
||
{
|
||
label1:
|
||
label2:
|
||
}
|
||
|
||
{
|
||
int fooRet = foo(pBar1, false /*fKB*/,
|
||
true /*fPTB*/, 3 /*nT*/, false /*fDF*/);
|
||
f() {
|
||
for ( i = 0;
|
||
i < m;
|
||
/* c */ i++ ) {
|
||
a = b;
|
||
}
|
||
}
|
||
}
|
||
|
||
{
|
||
f1(/*comment*/);
|
||
f2();
|
||
}
|
||
|
||
{
|
||
do {
|
||
if (foo) {
|
||
} else
|
||
;
|
||
} while (foo);
|
||
foo(); // was wrong
|
||
}
|
||
|
||
int x; // no extra indent because of the ;
|
||
void func()
|
||
{
|
||
}
|
||
|
||
char *tab[] = {"aaa",
|
||
"};", /* }; */ NULL}
|
||
int indented;
|
||
{}
|
||
|
||
char *a[] = {"aaa", "bbb",
|
||
"ccc", NULL};
|
||
// here
|
||
|
||
char *tab[] = {"aaa",
|
||
"xx", /* xx */}; /* asdf */
|
||
int not_indented;
|
||
|
||
{
|
||
do {
|
||
switch (bla)
|
||
{
|
||
case 1: if (foo)
|
||
bar;
|
||
}
|
||
} while (boo);
|
||
wrong;
|
||
}
|
||
|
||
int foo,
|
||
bar;
|
||
int foo;
|
||
|
||
#if defined(foo) \
|
||
&& defined(bar)
|
||
char * xx = "asdf\
|
||
foo\
|
||
bor";
|
||
int x;
|
||
|
||
char *foo = "asdf\
|
||
asdf\
|
||
asdf",
|
||
*bar;
|
||
|
||
void f()
|
||
{
|
||
#if defined(foo) \
|
||
&& defined(bar)
|
||
char *foo = "asdf\
|
||
asdf\
|
||
asdf",
|
||
*bar;
|
||
{
|
||
int i;
|
||
char *foo = "asdf\
|
||
asdf\
|
||
asdf",
|
||
*bar;
|
||
}
|
||
#endif
|
||
}
|
||
#endif
|
||
|
||
int y; // comment
|
||
// comment
|
||
|
||
// comment
|
||
|
||
{
|
||
Constructor(int a,
|
||
int b ) : BaseClass(a)
|
||
{
|
||
}
|
||
}
|
||
|
||
void foo()
|
||
{
|
||
char one,
|
||
two;
|
||
struct bla piet,
|
||
jan;
|
||
enum foo kees,
|
||
jannie;
|
||
static unsigned sdf,
|
||
krap;
|
||
unsigned int piet,
|
||
jan;
|
||
int
|
||
kees,
|
||
jan;
|
||
}
|
||
|
||
{
|
||
t(int f,
|
||
int d); // )
|
||
d();
|
||
}
|
||
|
||
Constructor::Constructor(int a,
|
||
int b
|
||
) :
|
||
BaseClass(a,
|
||
b,
|
||
c),
|
||
mMember(b),
|
||
{
|
||
}
|
||
|
||
Constructor::Constructor(int a,
|
||
int b ) :
|
||
BaseClass(a)
|
||
{
|
||
}
|
||
|
||
Constructor::Constructor(int a,
|
||
int b ) /*x*/ : /*x*/ BaseClass(a),
|
||
member(b)
|
||
{
|
||
}
|
||
|
||
A::A(int a, int b)
|
||
: aa(a),
|
||
bb(b),
|
||
cc(c)
|
||
{
|
||
}
|
||
|
||
class CAbc :
|
||
public BaseClass1,
|
||
protected BaseClass2
|
||
{
|
||
int Test() { return FALSE; }
|
||
int Test1() { return TRUE; }
|
||
|
||
CAbc(int a, int b ) :
|
||
BaseClass(a)
|
||
{
|
||
switch(xxx)
|
||
{
|
||
case abc:
|
||
asdf();
|
||
break;
|
||
|
||
case 999:
|
||
baer();
|
||
break;
|
||
}
|
||
}
|
||
|
||
public: // <-- this was incorrectly indented before!!
|
||
void testfall();
|
||
protected:
|
||
void testfall();
|
||
};
|
||
|
||
class CAbc : public BaseClass1,
|
||
protected BaseClass2
|
||
{
|
||
};
|
||
|
||
static struct
|
||
{
|
||
int a;
|
||
int b;
|
||
} variable[COUNT] =
|
||
{
|
||
{
|
||
123,
|
||
456
|
||
},
|
||
{
|
||
123,
|
||
456
|
||
}
|
||
};
|
||
|
||
static struct
|
||
{
|
||
int a;
|
||
int b;
|
||
} variable[COUNT] =
|
||
{
|
||
{ 123, 456 },
|
||
{ 123, 456 }
|
||
};
|
||
|
||
void asdf() /* ind_maxparen may cause trouble here */
|
||
{
|
||
if ((0
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1
|
||
&& 1)) break;
|
||
}
|
||
|
||
foo()
|
||
{
|
||
a = cond ? foo() : asdf
|
||
+ asdf;
|
||
|
||
a = cond ?
|
||
foo() : asdf
|
||
+ asdf;
|
||
}
|
||
|
||
int main(void)
|
||
{
|
||
if (a)
|
||
if (b)
|
||
2;
|
||
else 3;
|
||
next_line_of_code();
|
||
}
|
||
|
||
barry()
|
||
{
|
||
Foo::Foo (int one,
|
||
int two)
|
||
: something(4)
|
||
{}
|
||
}
|
||
|
||
barry()
|
||
{
|
||
Foo::Foo (int one, int two)
|
||
: something(4)
|
||
{}
|
||
}
|
||
|
||
Constructor::Constructor(int a,
|
||
int b
|
||
) :
|
||
BaseClass(a,
|
||
b,
|
||
c),
|
||
mMember(b)
|
||
{
|
||
}
|
||
int main ()
|
||
{
|
||
if (lala)
|
||
do
|
||
++(*lolo);
|
||
while (lili
|
||
&& lele);
|
||
lulu;
|
||
}
|
||
|
||
int main ()
|
||
{
|
||
switch (c)
|
||
{
|
||
case 'c': if (cond)
|
||
{
|
||
}
|
||
}
|
||
}
|
||
|
||
main()
|
||
{
|
||
(void) MyFancyFuasdfadsfnction(
|
||
argument);
|
||
}
|
||
|
||
main()
|
||
{
|
||
char foo[] = "/*";
|
||
/* as
|
||
df */
|
||
hello
|
||
}
|
||
|
||
/* valid namespaces with normal indent */
|
||
namespace
|
||
{
|
||
{
|
||
111111111111;
|
||
}
|
||
}
|
||
namespace /* test */
|
||
{
|
||
11111111111111111;
|
||
}
|
||
namespace // test
|
||
{
|
||
111111111111111111;
|
||
}
|
||
namespace
|
||
{
|
||
111111111111111111;
|
||
}
|
||
namespace test
|
||
{
|
||
111111111111111111;
|
||
}
|
||
namespace{
|
||
111111111111111111;
|
||
}
|
||
namespace test{
|
||
111111111111111111;
|
||
}
|
||
namespace {
|
||
111111111111111111;
|
||
}
|
||
namespace test {
|
||
111111111111111111;
|
||
namespace test2 {
|
||
22222222222222222;
|
||
}
|
||
}
|
||
inline namespace {
|
||
111111111111111111;
|
||
}
|
||
inline /* test */ namespace {
|
||
111111111111111111;
|
||
}
|
||
inline/* test */namespace {
|
||
111111111111111111;
|
||
}
|
||
|
||
/* invalid namespaces use block indent */
|
||
namespace test test2 {
|
||
111111111111111111111;
|
||
}
|
||
namespace11111111111 {
|
||
111111111111;
|
||
}
|
||
namespace() {
|
||
1111111111111;
|
||
}
|
||
namespace()
|
||
{
|
||
111111111111111111;
|
||
}
|
||
namespace test test2
|
||
{
|
||
1111111111111111111;
|
||
}
|
||
namespace111111111
|
||
{
|
||
111111111111111111;
|
||
}
|
||
inlinenamespace {
|
||
111111111111111111;
|
||
}
|
||
|
||
void getstring() {
|
||
/* Raw strings */
|
||
const char* s = R"(
|
||
test {
|
||
# comment
|
||
field: 123
|
||
}
|
||
)";
|
||
}
|
||
|
||
void getstring() {
|
||
const char* s = R"foo(
|
||
test {
|
||
# comment
|
||
field: 123
|
||
}
|
||
)foo";
|
||
}
|
||
|
||
{
|
||
int a[4] = {
|
||
[0] = 0,
|
||
[1] = 1,
|
||
[2] = 2,
|
||
[3] = 3,
|
||
};
|
||
}
|
||
|
||
{
|
||
a = b[2]
|
||
+ 3;
|
||
}
|
||
|
||
{
|
||
if (1)
|
||
/* aaaaa
|
||
* bbbbb
|
||
*/
|
||
a = 1;
|
||
}
|
||
|
||
void func()
|
||
{
|
||
switch (foo)
|
||
{
|
||
case (bar):
|
||
if (baz())
|
||
quux();
|
||
break;
|
||
case (shmoo):
|
||
if (!bar)
|
||
{
|
||
}
|
||
case (foo1):
|
||
switch (bar)
|
||
{
|
||
case baz:
|
||
baz_f();
|
||
break;
|
||
}
|
||
break;
|
||
default:
|
||
baz();
|
||
baz();
|
||
break;
|
||
}
|
||
}
|
||
|
||
/* end of AUTO */
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_2()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl tw=0 noai fo=croq
|
||
let &wm = &columns - 20
|
||
|
||
let code =<< trim [CODE]
|
||
{
|
||
|
||
/* this is
|
||
* a real serious important big
|
||
* comment
|
||
*/
|
||
/* insert " about life, the universe, and the rest" after "serious" */
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
call search('serious', 'e')
|
||
normal a about life, the universe, and the rest
|
||
|
||
let expected =<< trim [CODE]
|
||
{
|
||
|
||
/* this is
|
||
* a real serious
|
||
* about life, the
|
||
* universe, and the
|
||
* rest important big
|
||
* comment
|
||
*/
|
||
/* insert " about life, the universe, and the rest" after "serious" */
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
set wm&
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_3()
|
||
new
|
||
setl nocindent ts=4 sw=4
|
||
|
||
let code =<< trim [CODE]
|
||
{
|
||
/*
|
||
* Testing for comments, without 'cin' set
|
||
*/
|
||
|
||
/*
|
||
* what happens here?
|
||
*/
|
||
|
||
/*
|
||
the end of the comment, try inserting a line below */
|
||
|
||
/* how about
|
||
this one */
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
call search('comments')
|
||
normal joabout life
|
||
call search('happens')
|
||
normal jothere
|
||
call search('below')
|
||
normal oline
|
||
call search('this')
|
||
normal Ohello
|
||
|
||
let expected =<< trim [CODE]
|
||
{
|
||
/*
|
||
* Testing for comments, without 'cin' set
|
||
*/
|
||
about life
|
||
|
||
/*
|
||
* what happens here?
|
||
*/
|
||
there
|
||
|
||
/*
|
||
the end of the comment, try inserting a line below */
|
||
line
|
||
|
||
/* how about
|
||
hello
|
||
this one */
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_4()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
|
||
let code =<< trim [CODE]
|
||
{
|
||
var = this + that + vec[0] * vec[0]
|
||
+ vec[1] * vec[1]
|
||
+ vec2[2] * vec[2];
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
call search('vec2')
|
||
normal ==
|
||
|
||
let expected =<< trim [CODE]
|
||
{
|
||
var = this + that + vec[0] * vec[0]
|
||
+ vec[1] * vec[1]
|
||
+ vec2[2] * vec[2];
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_5()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=}4
|
||
|
||
let code =<< trim [CODE]
|
||
{
|
||
asdf asdflkajds f;
|
||
if (tes & ting) {
|
||
asdf asdf asdf ;
|
||
asdfa sdf asdf;
|
||
}
|
||
testing1;
|
||
if (tes & ting)
|
||
{
|
||
asdf asdf asdf ;
|
||
asdfa sdf asdf;
|
||
}
|
||
testing2;
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
call search('testing1')
|
||
exe "normal k2==/testing2\<CR>"
|
||
normal k2==
|
||
|
||
let expected =<< trim [CODE]
|
||
{
|
||
asdf asdflkajds f;
|
||
if (tes & ting) {
|
||
asdf asdf asdf ;
|
||
asdfa sdf asdf;
|
||
}
|
||
testing1;
|
||
if (tes & ting)
|
||
{
|
||
asdf asdf asdf ;
|
||
asdfa sdf asdf;
|
||
}
|
||
testing2;
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_6()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=(0,)20
|
||
|
||
let code =<< trim [CODE]
|
||
main ( int first_par, /*
|
||
* Comment for
|
||
* first par
|
||
*/
|
||
int second_par /*
|
||
* Comment for
|
||
* second par
|
||
*/
|
||
)
|
||
{
|
||
func( first_par, /*
|
||
* Comment for
|
||
* first par
|
||
*/
|
||
second_par /*
|
||
* Comment for
|
||
* second par
|
||
*/
|
||
);
|
||
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
call search('main')
|
||
normal =][
|
||
|
||
let expected =<< trim [CODE]
|
||
main ( int first_par, /*
|
||
* Comment for
|
||
* first par
|
||
*/
|
||
int second_par /*
|
||
* Comment for
|
||
* second par
|
||
*/
|
||
)
|
||
{
|
||
func( first_par, /*
|
||
* Comment for
|
||
* first par
|
||
*/
|
||
second_par /*
|
||
* Comment for
|
||
* second par
|
||
*/
|
||
);
|
||
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_7()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=es,n0s
|
||
|
||
let code =<< trim [CODE]
|
||
main(void)
|
||
{
|
||
/* Make sure that cino=X0s is not parsed like cino=Xs. */
|
||
if (cond)
|
||
foo();
|
||
else
|
||
{
|
||
bar();
|
||
}
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
call search('main')
|
||
normal =][
|
||
|
||
let expected =<< trim [CODE]
|
||
main(void)
|
||
{
|
||
/* Make sure that cino=X0s is not parsed like cino=Xs. */
|
||
if (cond)
|
||
foo();
|
||
else
|
||
{
|
||
bar();
|
||
}
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_8()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=
|
||
|
||
let code =<< trim [CODE]
|
||
|
||
{
|
||
do
|
||
{
|
||
if ()
|
||
{
|
||
if ()
|
||
asdf;
|
||
else
|
||
asdf;
|
||
}
|
||
} while ();
|
||
cmd; /* this should go under the } */
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
normal ]]=][
|
||
|
||
let expected =<< trim [CODE]
|
||
|
||
{
|
||
do
|
||
{
|
||
if ()
|
||
{
|
||
if ()
|
||
asdf;
|
||
else
|
||
asdf;
|
||
}
|
||
} while ();
|
||
cmd; /* this should go under the } */
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_9()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
|
||
let code =<< trim [CODE]
|
||
|
||
void f()
|
||
{
|
||
if ( k() ) {
|
||
l();
|
||
|
||
} else { /* Start (two words) end */
|
||
m();
|
||
}
|
||
|
||
n();
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
normal ]]=][
|
||
|
||
let expected =<< trim [CODE]
|
||
|
||
void f()
|
||
{
|
||
if ( k() ) {
|
||
l();
|
||
|
||
} else { /* Start (two words) end */
|
||
m();
|
||
}
|
||
|
||
n();
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_10()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino={s,e-s
|
||
|
||
let code =<< trim [CODE]
|
||
|
||
void f()
|
||
{
|
||
if ( k() )
|
||
{
|
||
l();
|
||
} else { /* Start (two words) end */
|
||
m();
|
||
}
|
||
n(); /* should be under the if () */
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
normal ]]=][
|
||
|
||
let expected =<< trim [CODE]
|
||
|
||
void f()
|
||
{
|
||
if ( k() )
|
||
{
|
||
l();
|
||
} else { /* Start (two words) end */
|
||
m();
|
||
}
|
||
n(); /* should be under the if () */
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_11()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino={s,fs
|
||
|
||
let code =<< trim [CODE]
|
||
void bar(void)
|
||
{
|
||
static array[2][2] =
|
||
{
|
||
{ 1, 2 },
|
||
{ 3, 4 },
|
||
}
|
||
|
||
while (a)
|
||
{
|
||
foo(&a);
|
||
}
|
||
|
||
{
|
||
int a;
|
||
{
|
||
a = a + 1;
|
||
}
|
||
}
|
||
b = a;
|
||
}
|
||
|
||
void func(void)
|
||
{
|
||
a = 1;
|
||
{
|
||
b = 2;
|
||
}
|
||
c = 3;
|
||
d = 4;
|
||
}
|
||
/* foo */
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
exe "normal ]]=/ foo\<CR>"
|
||
|
||
let expected =<< trim [CODE]
|
||
void bar(void)
|
||
{
|
||
static array[2][2] =
|
||
{
|
||
{ 1, 2 },
|
||
{ 3, 4 },
|
||
}
|
||
|
||
while (a)
|
||
{
|
||
foo(&a);
|
||
}
|
||
|
||
{
|
||
int a;
|
||
{
|
||
a = a + 1;
|
||
}
|
||
}
|
||
b = a;
|
||
}
|
||
|
||
void func(void)
|
||
{
|
||
a = 1;
|
||
{
|
||
b = 2;
|
||
}
|
||
c = 3;
|
||
d = 4;
|
||
}
|
||
/* foo */
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_12()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=
|
||
|
||
let code =<< trim [CODE]
|
||
a()
|
||
{
|
||
do {
|
||
a = a +
|
||
a;
|
||
} while ( a ); /* add text under this line */
|
||
if ( a )
|
||
a;
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
call search('while')
|
||
normal ohere
|
||
|
||
let expected =<< trim [CODE]
|
||
a()
|
||
{
|
||
do {
|
||
a = a +
|
||
a;
|
||
} while ( a ); /* add text under this line */
|
||
here
|
||
if ( a )
|
||
a;
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_13()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino= com=
|
||
|
||
let code =<< trim [CODE]
|
||
a()
|
||
{
|
||
label1:
|
||
/* hmm */
|
||
// comment
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
call search('comment')
|
||
exe "normal olabel2: b();\rlabel3 /* post */:\r/* pre */ label4:\r" .
|
||
\ "f(/*com*/);\rif (/*com*/)\rcmd();"
|
||
|
||
let expected =<< trim [CODE]
|
||
a()
|
||
{
|
||
label1:
|
||
/* hmm */
|
||
// comment
|
||
label2: b();
|
||
label3 /* post */:
|
||
/* pre */ label4:
|
||
f(/*com*/);
|
||
if (/*com*/)
|
||
cmd();
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_14()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl comments& comments^=s:/*,m:**,ex:*/
|
||
|
||
let code =<< trim [CODE]
|
||
/*
|
||
* A simple comment
|
||
*/
|
||
|
||
/*
|
||
** A different comment
|
||
*/
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
call search('simple')
|
||
normal =5j
|
||
|
||
let expected =<< trim [CODE]
|
||
/*
|
||
* A simple comment
|
||
*/
|
||
|
||
/*
|
||
** A different comment
|
||
*/
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_15()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=c0
|
||
setl comments& comments-=s1:/* comments^=s0:/*
|
||
|
||
let code =<< trim [CODE]
|
||
void f()
|
||
{
|
||
|
||
/*********
|
||
A comment.
|
||
*********/
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
normal ]]=][
|
||
|
||
let expected =<< trim [CODE]
|
||
void f()
|
||
{
|
||
|
||
/*********
|
||
A comment.
|
||
*********/
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_16()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=c0,C1
|
||
setl comments& comments-=s1:/* comments^=s0:/*
|
||
|
||
let code =<< trim [CODE]
|
||
void f()
|
||
{
|
||
|
||
/*********
|
||
A comment.
|
||
*********/
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
normal ]]=][
|
||
|
||
let expected =<< trim [CODE]
|
||
void f()
|
||
{
|
||
|
||
/*********
|
||
A comment.
|
||
*********/
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_17()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=
|
||
|
||
let code =<< trim [CODE]
|
||
void f()
|
||
{
|
||
c = c1 &&
|
||
(
|
||
c2 ||
|
||
c3
|
||
) && c4;
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
normal ]]=][
|
||
|
||
let expected =<< trim [CODE]
|
||
void f()
|
||
{
|
||
c = c1 &&
|
||
(
|
||
c2 ||
|
||
c3
|
||
) && c4;
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_18()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=(s
|
||
|
||
let code =<< trim [CODE]
|
||
void f()
|
||
{
|
||
c = c1 &&
|
||
(
|
||
c2 ||
|
||
c3
|
||
) && c4;
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
normal ]]=][
|
||
|
||
let expected =<< trim [CODE]
|
||
void f()
|
||
{
|
||
c = c1 &&
|
||
(
|
||
c2 ||
|
||
c3
|
||
) && c4;
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_19()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
set cino=(s,U1
|
||
|
||
let code =<< trim [CODE]
|
||
void f()
|
||
{
|
||
c = c1 &&
|
||
(
|
||
c2 ||
|
||
c3
|
||
) && c4;
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
normal ]]=][
|
||
|
||
let expected =<< trim [CODE]
|
||
void f()
|
||
{
|
||
c = c1 &&
|
||
(
|
||
c2 ||
|
||
c3
|
||
) && c4;
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_20()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=(0
|
||
|
||
let code =<< trim [CODE]
|
||
void f()
|
||
{
|
||
if ( c1
|
||
&& ( c2
|
||
|| c3))
|
||
foo;
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
normal ]]=][
|
||
|
||
let expected =<< trim [CODE]
|
||
void f()
|
||
{
|
||
if ( c1
|
||
&& ( c2
|
||
|| c3))
|
||
foo;
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_21()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=(0,w1
|
||
|
||
let code =<< trim [CODE]
|
||
void f()
|
||
{
|
||
if ( c1
|
||
&& ( c2
|
||
|| c3))
|
||
foo;
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
normal ]]=][
|
||
|
||
let expected =<< trim [CODE]
|
||
void f()
|
||
{
|
||
if ( c1
|
||
&& ( c2
|
||
|| c3))
|
||
foo;
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_22()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=(s
|
||
|
||
let code =<< trim [CODE]
|
||
void f()
|
||
{
|
||
c = c1 && (
|
||
c2 ||
|
||
c3
|
||
) && c4;
|
||
if (
|
||
c1 && c2
|
||
)
|
||
foo;
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
normal ]]=][
|
||
|
||
let expected =<< trim [CODE]
|
||
void f()
|
||
{
|
||
c = c1 && (
|
||
c2 ||
|
||
c3
|
||
) && c4;
|
||
if (
|
||
c1 && c2
|
||
)
|
||
foo;
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_23()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=(s,m1
|
||
|
||
let code =<< trim [CODE]
|
||
void f()
|
||
{
|
||
c = c1 && (
|
||
c2 ||
|
||
c3
|
||
) && c4;
|
||
if (
|
||
c1 && c2
|
||
)
|
||
foo;
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
normal ]]=][
|
||
|
||
let expected =<< trim [CODE]
|
||
void f()
|
||
{
|
||
c = c1 && (
|
||
c2 ||
|
||
c3
|
||
) && c4;
|
||
if (
|
||
c1 && c2
|
||
)
|
||
foo;
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_24()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=b1
|
||
|
||
let code =<< trim [CODE]
|
||
void f()
|
||
{
|
||
switch (x)
|
||
{
|
||
case 1:
|
||
a = b;
|
||
break;
|
||
default:
|
||
a = 0;
|
||
break;
|
||
}
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
normal ]]=][
|
||
|
||
let expected =<< trim [CODE]
|
||
void f()
|
||
{
|
||
switch (x)
|
||
{
|
||
case 1:
|
||
a = b;
|
||
break;
|
||
default:
|
||
a = 0;
|
||
break;
|
||
}
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_25()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=(0,W5
|
||
|
||
let code =<< trim [CODE]
|
||
void f()
|
||
{
|
||
invokeme(
|
||
argu,
|
||
ment);
|
||
invokeme(
|
||
argu,
|
||
ment
|
||
);
|
||
invokeme(argu,
|
||
ment
|
||
);
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
normal ]]=][
|
||
|
||
let expected =<< trim [CODE]
|
||
void f()
|
||
{
|
||
invokeme(
|
||
argu,
|
||
ment);
|
||
invokeme(
|
||
argu,
|
||
ment
|
||
);
|
||
invokeme(argu,
|
||
ment
|
||
);
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_26()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=/6
|
||
|
||
let code =<< trim [CODE]
|
||
void f()
|
||
{
|
||
statement;
|
||
// comment 1
|
||
// comment 2
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
normal ]]=][
|
||
|
||
let expected =<< trim [CODE]
|
||
void f()
|
||
{
|
||
statement;
|
||
// comment 1
|
||
// comment 2
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_27()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=
|
||
|
||
let code =<< trim [CODE]
|
||
void f()
|
||
{
|
||
statement;
|
||
// comment 1
|
||
// comment 2
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
exe "normal ]]/comment 1/+1\<CR>=="
|
||
|
||
let expected =<< trim [CODE]
|
||
void f()
|
||
{
|
||
statement;
|
||
// comment 1
|
||
// comment 2
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_28()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=g0
|
||
|
||
let code =<< trim [CODE]
|
||
class CAbc
|
||
{
|
||
int Test() { return FALSE; }
|
||
|
||
public: // comment
|
||
void testfall();
|
||
protected:
|
||
void testfall();
|
||
};
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
normal ]]=][
|
||
|
||
let expected =<< trim [CODE]
|
||
class CAbc
|
||
{
|
||
int Test() { return FALSE; }
|
||
|
||
public: // comment
|
||
void testfall();
|
||
protected:
|
||
void testfall();
|
||
};
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_29()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=(0,gs,hs
|
||
|
||
let code =<< trim [CODE]
|
||
class Foo : public Bar
|
||
{
|
||
public:
|
||
virtual void method1(void) = 0;
|
||
virtual void method2(int arg1,
|
||
int arg2,
|
||
int arg3) = 0;
|
||
};
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
normal ]]=][
|
||
|
||
let expected =<< trim [CODE]
|
||
class Foo : public Bar
|
||
{
|
||
public:
|
||
virtual void method1(void) = 0;
|
||
virtual void method2(int arg1,
|
||
int arg2,
|
||
int arg3) = 0;
|
||
};
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_30()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=+20
|
||
|
||
let code =<< [CODE]
|
||
void
|
||
foo()
|
||
{
|
||
if (a)
|
||
{
|
||
} else
|
||
asdf;
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
normal ]]=][
|
||
|
||
let expected =<< [CODE]
|
||
void
|
||
foo()
|
||
{
|
||
if (a)
|
||
{
|
||
} else
|
||
asdf;
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_31()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=(0,W2s
|
||
|
||
let code =<< trim [CODE]
|
||
|
||
{
|
||
averylongfunctionnamelongfunctionnameaverylongfunctionname()->asd(
|
||
asdasdf,
|
||
func(asdf,
|
||
asdfadsf),
|
||
asdfasdf
|
||
);
|
||
|
||
/* those are ugly, but consequent */
|
||
|
||
func()->asd(asdasdf,
|
||
averylongfunctionname(
|
||
abc,
|
||
dec)->averylongfunctionname(
|
||
asdfadsf,
|
||
asdfasdf,
|
||
asdfasdf,
|
||
),
|
||
func(asdfadf,
|
||
asdfasdf
|
||
),
|
||
asdasdf
|
||
);
|
||
|
||
averylongfunctionnameaverylongfunctionnameavery()->asd(fasdf(
|
||
abc,
|
||
dec)->asdfasdfasdf(
|
||
asdfadsf,
|
||
asdfasdf,
|
||
asdfasdf,
|
||
),
|
||
func(asdfadf,
|
||
asdfasdf),
|
||
asdasdf
|
||
);
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
normal ]]=][
|
||
|
||
let expected =<< trim [CODE]
|
||
|
||
{
|
||
averylongfunctionnamelongfunctionnameaverylongfunctionname()->asd(
|
||
asdasdf,
|
||
func(asdf,
|
||
asdfadsf),
|
||
asdfasdf
|
||
);
|
||
|
||
/* those are ugly, but consequent */
|
||
|
||
func()->asd(asdasdf,
|
||
averylongfunctionname(
|
||
abc,
|
||
dec)->averylongfunctionname(
|
||
asdfadsf,
|
||
asdfasdf,
|
||
asdfasdf,
|
||
),
|
||
func(asdfadf,
|
||
asdfasdf
|
||
),
|
||
asdasdf
|
||
);
|
||
|
||
averylongfunctionnameaverylongfunctionnameavery()->asd(fasdf(
|
||
abc,
|
||
dec)->asdfasdfasdf(
|
||
asdfadsf,
|
||
asdfasdf,
|
||
asdfasdf,
|
||
),
|
||
func(asdfadf,
|
||
asdfasdf),
|
||
asdasdf
|
||
);
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_32()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=M1
|
||
|
||
let code =<< trim [CODE]
|
||
int main ()
|
||
{
|
||
if (cond1 &&
|
||
cond2
|
||
)
|
||
foo;
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
normal ]]=][
|
||
|
||
let expected =<< trim [CODE]
|
||
int main ()
|
||
{
|
||
if (cond1 &&
|
||
cond2
|
||
)
|
||
foo;
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_33()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=(0,ts
|
||
|
||
let code =<< trim [CODE]
|
||
void func(int a
|
||
#if defined(FOO)
|
||
, int b
|
||
, int c
|
||
#endif
|
||
)
|
||
{
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
normal 2j=][
|
||
|
||
let expected =<< trim [CODE]
|
||
void func(int a
|
||
#if defined(FOO)
|
||
, int b
|
||
, int c
|
||
#endif
|
||
)
|
||
{
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_34()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=(0
|
||
|
||
let code =<< trim [CODE]
|
||
|
||
void
|
||
func(int a
|
||
#if defined(FOO)
|
||
, int b
|
||
, int c
|
||
#endif
|
||
)
|
||
{
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
normal =][
|
||
|
||
let expected =<< trim [CODE]
|
||
|
||
void
|
||
func(int a
|
||
#if defined(FOO)
|
||
, int b
|
||
, int c
|
||
#endif
|
||
)
|
||
{
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_35()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino&
|
||
|
||
let code =<< trim [CODE]
|
||
void func(void)
|
||
{
|
||
if(x==y)
|
||
if(y==z)
|
||
foo=1;
|
||
else { bar=1;
|
||
baz=2;
|
||
}
|
||
printf("Foo!\n");
|
||
}
|
||
|
||
void func1(void)
|
||
{
|
||
char* tab[] = {"foo", "bar",
|
||
"baz", "quux",
|
||
"this line used", "to be indented incorrectly"};
|
||
foo();
|
||
}
|
||
|
||
void func2(void)
|
||
{
|
||
int tab[] =
|
||
{1, 2,
|
||
3, 4,
|
||
5, 6};
|
||
|
||
printf("This line used to be indented incorrectly.\n");
|
||
}
|
||
|
||
int foo[]
|
||
#ifdef BAR
|
||
|
||
= { 1, 2, 3,
|
||
4, 5, 6 }
|
||
|
||
#endif
|
||
;
|
||
int baz;
|
||
|
||
void func3(void)
|
||
{
|
||
int tab[] = {
|
||
1, 2,
|
||
3, 4,
|
||
5, 6};
|
||
|
||
printf("Don't you dare indent this line incorrectly!\n");
|
||
}
|
||
|
||
void
|
||
func4(a, b,
|
||
c)
|
||
int a;
|
||
int b;
|
||
int c;
|
||
{
|
||
}
|
||
|
||
void
|
||
func5(
|
||
int a,
|
||
int b)
|
||
{
|
||
}
|
||
|
||
void
|
||
func6(
|
||
int a)
|
||
{
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
normal ]]=7][
|
||
|
||
let expected =<< trim [CODE]
|
||
void func(void)
|
||
{
|
||
if(x==y)
|
||
if(y==z)
|
||
foo=1;
|
||
else { bar=1;
|
||
baz=2;
|
||
}
|
||
printf("Foo!\n");
|
||
}
|
||
|
||
void func1(void)
|
||
{
|
||
char* tab[] = {"foo", "bar",
|
||
"baz", "quux",
|
||
"this line used", "to be indented incorrectly"};
|
||
foo();
|
||
}
|
||
|
||
void func2(void)
|
||
{
|
||
int tab[] =
|
||
{1, 2,
|
||
3, 4,
|
||
5, 6};
|
||
|
||
printf("This line used to be indented incorrectly.\n");
|
||
}
|
||
|
||
int foo[]
|
||
#ifdef BAR
|
||
|
||
= { 1, 2, 3,
|
||
4, 5, 6 }
|
||
|
||
#endif
|
||
;
|
||
int baz;
|
||
|
||
void func3(void)
|
||
{
|
||
int tab[] = {
|
||
1, 2,
|
||
3, 4,
|
||
5, 6};
|
||
|
||
printf("Don't you dare indent this line incorrectly!\n");
|
||
}
|
||
|
||
void
|
||
func4(a, b,
|
||
c)
|
||
int a;
|
||
int b;
|
||
int c;
|
||
{
|
||
}
|
||
|
||
void
|
||
func5(
|
||
int a,
|
||
int b)
|
||
{
|
||
}
|
||
|
||
void
|
||
func6(
|
||
int a)
|
||
{
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_36()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino&
|
||
setl cino+=l1
|
||
|
||
let code =<< trim [CODE]
|
||
void func(void)
|
||
{
|
||
int tab[] =
|
||
{
|
||
1, 2, 3,
|
||
4, 5, 6};
|
||
|
||
printf("Indent this line correctly!\n");
|
||
|
||
switch (foo)
|
||
{
|
||
case bar:
|
||
printf("bar");
|
||
break;
|
||
case baz: {
|
||
printf("baz");
|
||
break;
|
||
}
|
||
case quux:
|
||
printf("But don't break the indentation of this instruction\n");
|
||
break;
|
||
}
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
normal ]]=][
|
||
|
||
let expected =<< trim [CODE]
|
||
void func(void)
|
||
{
|
||
int tab[] =
|
||
{
|
||
1, 2, 3,
|
||
4, 5, 6};
|
||
|
||
printf("Indent this line correctly!\n");
|
||
|
||
switch (foo)
|
||
{
|
||
case bar:
|
||
printf("bar");
|
||
break;
|
||
case baz: {
|
||
printf("baz");
|
||
break;
|
||
}
|
||
case quux:
|
||
printf("But don't break the indentation of this instruction\n");
|
||
break;
|
||
}
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_37()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino&
|
||
|
||
let code =<< trim [CODE]
|
||
void func(void)
|
||
{
|
||
cout << "a"
|
||
<< "b"
|
||
<< ") :"
|
||
<< "c";
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
normal ]]=][
|
||
|
||
let expected =<< trim [CODE]
|
||
void func(void)
|
||
{
|
||
cout << "a"
|
||
<< "b"
|
||
<< ") :"
|
||
<< "c";
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_38()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl com=s1:/*,m:*,ex:*/
|
||
|
||
let code =<< trim [CODE]
|
||
void func(void)
|
||
{
|
||
/*
|
||
* This is a comment.
|
||
*/
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
normal ]]3jofoo();
|
||
|
||
let expected =<< trim [CODE]
|
||
void func(void)
|
||
{
|
||
/*
|
||
* This is a comment.
|
||
*/
|
||
foo();
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_39()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino&
|
||
|
||
let code =<< trim [CODE]
|
||
void func(void)
|
||
{
|
||
for (int i = 0; i < 10; ++i)
|
||
if (i & 1) {
|
||
foo(1);
|
||
} else
|
||
foo(0);
|
||
baz();
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
normal ]]=][
|
||
|
||
let expected =<< trim [CODE]
|
||
void func(void)
|
||
{
|
||
for (int i = 0; i < 10; ++i)
|
||
if (i & 1) {
|
||
foo(1);
|
||
} else
|
||
foo(0);
|
||
baz();
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_40()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=k2s,(0
|
||
|
||
let code =<< trim [CODE]
|
||
void func(void)
|
||
{
|
||
if (condition1
|
||
&& condition2)
|
||
action();
|
||
function(argument1
|
||
&& argument2);
|
||
|
||
if (c1 && (c2 ||
|
||
c3))
|
||
foo;
|
||
if (c1 &&
|
||
(c2 || c3))
|
||
{
|
||
}
|
||
|
||
if ( c1
|
||
&& ( c2
|
||
|| c3))
|
||
foo;
|
||
func( c1
|
||
&& ( c2
|
||
|| c3))
|
||
foo;
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
normal ]]=][
|
||
|
||
let expected =<< trim [CODE]
|
||
void func(void)
|
||
{
|
||
if (condition1
|
||
&& condition2)
|
||
action();
|
||
function(argument1
|
||
&& argument2);
|
||
|
||
if (c1 && (c2 ||
|
||
c3))
|
||
foo;
|
||
if (c1 &&
|
||
(c2 || c3))
|
||
{
|
||
}
|
||
|
||
if ( c1
|
||
&& ( c2
|
||
|| c3))
|
||
foo;
|
||
func( c1
|
||
&& ( c2
|
||
|| c3))
|
||
foo;
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_41()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=k2s,(s
|
||
|
||
let code =<< trim [CODE]
|
||
void func(void)
|
||
{
|
||
if (condition1
|
||
&& condition2)
|
||
action();
|
||
function(argument1
|
||
&& argument2);
|
||
|
||
if (c1 && (c2 ||
|
||
c3))
|
||
foo;
|
||
if (c1 &&
|
||
(c2 || c3))
|
||
{
|
||
}
|
||
|
||
if ( c1
|
||
&& ( c2
|
||
|| c3))
|
||
foo;
|
||
func( c1
|
||
&& ( c2
|
||
|| c3))
|
||
foo;
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
normal ]]=][
|
||
|
||
let expected =<< trim [CODE]
|
||
void func(void)
|
||
{
|
||
if (condition1
|
||
&& condition2)
|
||
action();
|
||
function(argument1
|
||
&& argument2);
|
||
|
||
if (c1 && (c2 ||
|
||
c3))
|
||
foo;
|
||
if (c1 &&
|
||
(c2 || c3))
|
||
{
|
||
}
|
||
|
||
if ( c1
|
||
&& ( c2
|
||
|| c3))
|
||
foo;
|
||
func( c1
|
||
&& ( c2
|
||
|| c3))
|
||
foo;
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_42()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=k2s,(s,U1
|
||
|
||
let code =<< trim [CODE]
|
||
void func(void)
|
||
{
|
||
if (condition1
|
||
&& condition2)
|
||
action();
|
||
function(argument1
|
||
&& argument2);
|
||
|
||
if (c1 && (c2 ||
|
||
c3))
|
||
foo;
|
||
if (c1 &&
|
||
(c2 || c3))
|
||
{
|
||
}
|
||
if (c123456789
|
||
&& (c22345
|
||
|| c3))
|
||
printf("foo\n");
|
||
|
||
c = c1 &&
|
||
(
|
||
c2 ||
|
||
c3
|
||
) && c4;
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
normal ]]=][
|
||
|
||
let expected =<< trim [CODE]
|
||
void func(void)
|
||
{
|
||
if (condition1
|
||
&& condition2)
|
||
action();
|
||
function(argument1
|
||
&& argument2);
|
||
|
||
if (c1 && (c2 ||
|
||
c3))
|
||
foo;
|
||
if (c1 &&
|
||
(c2 || c3))
|
||
{
|
||
}
|
||
if (c123456789
|
||
&& (c22345
|
||
|| c3))
|
||
printf("foo\n");
|
||
|
||
c = c1 &&
|
||
(
|
||
c2 ||
|
||
c3
|
||
) && c4;
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_43()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=k2s,(0,W4
|
||
|
||
let code =<< trim [CODE]
|
||
void func(void)
|
||
{
|
||
if (condition1
|
||
&& condition2)
|
||
action();
|
||
function(argument1
|
||
&& argument2);
|
||
|
||
if (c1 && (c2 ||
|
||
c3))
|
||
foo;
|
||
if (c1 &&
|
||
(c2 || c3))
|
||
{
|
||
}
|
||
if (c123456789
|
||
&& (c22345
|
||
|| c3))
|
||
printf("foo\n");
|
||
|
||
if ( c1
|
||
&& ( c2
|
||
|| c3))
|
||
foo;
|
||
|
||
a_long_line(
|
||
argument,
|
||
argument);
|
||
a_short_line(argument,
|
||
argument);
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
normal ]]=][
|
||
|
||
let expected =<< trim [CODE]
|
||
void func(void)
|
||
{
|
||
if (condition1
|
||
&& condition2)
|
||
action();
|
||
function(argument1
|
||
&& argument2);
|
||
|
||
if (c1 && (c2 ||
|
||
c3))
|
||
foo;
|
||
if (c1 &&
|
||
(c2 || c3))
|
||
{
|
||
}
|
||
if (c123456789
|
||
&& (c22345
|
||
|| c3))
|
||
printf("foo\n");
|
||
|
||
if ( c1
|
||
&& ( c2
|
||
|| c3))
|
||
foo;
|
||
|
||
a_long_line(
|
||
argument,
|
||
argument);
|
||
a_short_line(argument,
|
||
argument);
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_44()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=k2s,u2
|
||
|
||
let code =<< trim [CODE]
|
||
void func(void)
|
||
{
|
||
if (condition1
|
||
&& condition2)
|
||
action();
|
||
function(argument1
|
||
&& argument2);
|
||
|
||
if (c1 && (c2 ||
|
||
c3))
|
||
foo;
|
||
if (c1 &&
|
||
(c2 || c3))
|
||
{
|
||
}
|
||
if (c123456789
|
||
&& (c22345
|
||
|| c3))
|
||
printf("foo\n");
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
normal ]]=][
|
||
|
||
let expected =<< trim [CODE]
|
||
void func(void)
|
||
{
|
||
if (condition1
|
||
&& condition2)
|
||
action();
|
||
function(argument1
|
||
&& argument2);
|
||
|
||
if (c1 && (c2 ||
|
||
c3))
|
||
foo;
|
||
if (c1 &&
|
||
(c2 || c3))
|
||
{
|
||
}
|
||
if (c123456789
|
||
&& (c22345
|
||
|| c3))
|
||
printf("foo\n");
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_45()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=k2s,(0,w1
|
||
|
||
let code =<< trim [CODE]
|
||
void func(void)
|
||
{
|
||
if (condition1
|
||
&& condition2)
|
||
action();
|
||
function(argument1
|
||
&& argument2);
|
||
|
||
if (c1 && (c2 ||
|
||
c3))
|
||
foo;
|
||
if (c1 &&
|
||
(c2 || c3))
|
||
{
|
||
}
|
||
if (c123456789
|
||
&& (c22345
|
||
|| c3))
|
||
printf("foo\n");
|
||
|
||
if ( c1
|
||
&& ( c2
|
||
|| c3))
|
||
foo;
|
||
func( c1
|
||
&& ( c2
|
||
|| c3))
|
||
foo;
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
normal ]]=][
|
||
|
||
let expected =<< trim [CODE]
|
||
void func(void)
|
||
{
|
||
if (condition1
|
||
&& condition2)
|
||
action();
|
||
function(argument1
|
||
&& argument2);
|
||
|
||
if (c1 && (c2 ||
|
||
c3))
|
||
foo;
|
||
if (c1 &&
|
||
(c2 || c3))
|
||
{
|
||
}
|
||
if (c123456789
|
||
&& (c22345
|
||
|| c3))
|
||
printf("foo\n");
|
||
|
||
if ( c1
|
||
&& ( c2
|
||
|| c3))
|
||
foo;
|
||
func( c1
|
||
&& ( c2
|
||
|| c3))
|
||
foo;
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_46()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=k2,(s
|
||
|
||
let code =<< trim [CODE]
|
||
void func(void)
|
||
{
|
||
if (condition1
|
||
&& condition2)
|
||
action();
|
||
function(argument1
|
||
&& argument2);
|
||
|
||
if (c1 && (c2 ||
|
||
c3))
|
||
foo;
|
||
if (c1 &&
|
||
(c2 || c3))
|
||
{
|
||
}
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
normal ]]=][
|
||
|
||
let expected =<< trim [CODE]
|
||
void func(void)
|
||
{
|
||
if (condition1
|
||
&& condition2)
|
||
action();
|
||
function(argument1
|
||
&& argument2);
|
||
|
||
if (c1 && (c2 ||
|
||
c3))
|
||
foo;
|
||
if (c1 &&
|
||
(c2 || c3))
|
||
{
|
||
}
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_47()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=N-s
|
||
|
||
let code =<< trim [CODE]
|
||
NAMESPACESTART
|
||
/* valid namespaces with normal indent */
|
||
namespace
|
||
{
|
||
{
|
||
111111111111;
|
||
}
|
||
}
|
||
namespace /* test */
|
||
{
|
||
11111111111111111;
|
||
}
|
||
namespace // test
|
||
{
|
||
111111111111111111;
|
||
}
|
||
namespace
|
||
{
|
||
111111111111111111;
|
||
}
|
||
namespace test
|
||
{
|
||
111111111111111111;
|
||
}
|
||
namespace test::cpp17
|
||
{
|
||
111111111111111111;
|
||
}
|
||
namespace ::incorrectcpp17
|
||
{
|
||
111111111111111111;
|
||
}
|
||
namespace test::incorrectcpp17::
|
||
{
|
||
111111111111111111;
|
||
}
|
||
namespace test:incorrectcpp17
|
||
{
|
||
111111111111111111;
|
||
}
|
||
namespace test:::incorrectcpp17
|
||
{
|
||
111111111111111111;
|
||
}
|
||
namespace{
|
||
111111111111111111;
|
||
}
|
||
namespace test{
|
||
111111111111111111;
|
||
}
|
||
namespace {
|
||
111111111111111111;
|
||
}
|
||
namespace test {
|
||
111111111111111111;
|
||
namespace test2 {
|
||
22222222222222222;
|
||
}
|
||
}
|
||
inline namespace {
|
||
111111111111111111;
|
||
}
|
||
inline /* test */ namespace {
|
||
111111111111111111;
|
||
}
|
||
inline/* test */namespace {
|
||
111111111111111111;
|
||
}
|
||
|
||
/* invalid namespaces use block indent */
|
||
namespace test test2 {
|
||
111111111111111111111;
|
||
}
|
||
namespace11111111111 {
|
||
111111111111;
|
||
}
|
||
namespace() {
|
||
1111111111111;
|
||
}
|
||
namespace()
|
||
{
|
||
111111111111111111;
|
||
}
|
||
namespace test test2
|
||
{
|
||
1111111111111111111;
|
||
}
|
||
namespace111111111
|
||
{
|
||
111111111111111111;
|
||
}
|
||
inlinenamespace {
|
||
111111111111111111;
|
||
}
|
||
NAMESPACEEND
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
call search('^NAMESPACESTART')
|
||
exe "normal =/^NAMESPACEEND\n"
|
||
|
||
let expected =<< trim [CODE]
|
||
NAMESPACESTART
|
||
/* valid namespaces with normal indent */
|
||
namespace
|
||
{
|
||
{
|
||
111111111111;
|
||
}
|
||
}
|
||
namespace /* test */
|
||
{
|
||
11111111111111111;
|
||
}
|
||
namespace // test
|
||
{
|
||
111111111111111111;
|
||
}
|
||
namespace
|
||
{
|
||
111111111111111111;
|
||
}
|
||
namespace test
|
||
{
|
||
111111111111111111;
|
||
}
|
||
namespace test::cpp17
|
||
{
|
||
111111111111111111;
|
||
}
|
||
namespace ::incorrectcpp17
|
||
{
|
||
111111111111111111;
|
||
}
|
||
namespace test::incorrectcpp17::
|
||
{
|
||
111111111111111111;
|
||
}
|
||
namespace test:incorrectcpp17
|
||
{
|
||
111111111111111111;
|
||
}
|
||
namespace test:::incorrectcpp17
|
||
{
|
||
111111111111111111;
|
||
}
|
||
namespace{
|
||
111111111111111111;
|
||
}
|
||
namespace test{
|
||
111111111111111111;
|
||
}
|
||
namespace {
|
||
111111111111111111;
|
||
}
|
||
namespace test {
|
||
111111111111111111;
|
||
namespace test2 {
|
||
22222222222222222;
|
||
}
|
||
}
|
||
inline namespace {
|
||
111111111111111111;
|
||
}
|
||
inline /* test */ namespace {
|
||
111111111111111111;
|
||
}
|
||
inline/* test */namespace {
|
||
111111111111111111;
|
||
}
|
||
|
||
/* invalid namespaces use block indent */
|
||
namespace test test2 {
|
||
111111111111111111111;
|
||
}
|
||
namespace11111111111 {
|
||
111111111111;
|
||
}
|
||
namespace() {
|
||
1111111111111;
|
||
}
|
||
namespace()
|
||
{
|
||
111111111111111111;
|
||
}
|
||
namespace test test2
|
||
{
|
||
1111111111111111111;
|
||
}
|
||
namespace111111111
|
||
{
|
||
111111111111111111;
|
||
}
|
||
inlinenamespace {
|
||
111111111111111111;
|
||
}
|
||
NAMESPACEEND
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_48()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=j1,J1
|
||
|
||
let code =<< trim [CODE]
|
||
JSSTART
|
||
var bar = {
|
||
foo: {
|
||
that: this,
|
||
some: ok,
|
||
},
|
||
"bar":{
|
||
a : 2,
|
||
b: "123abc",
|
||
x: 4,
|
||
"y": 5
|
||
}
|
||
}
|
||
JSEND
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
call search('^JSSTART')
|
||
exe "normal =/^JSEND\n"
|
||
|
||
let expected =<< trim [CODE]
|
||
JSSTART
|
||
var bar = {
|
||
foo: {
|
||
that: this,
|
||
some: ok,
|
||
},
|
||
"bar":{
|
||
a : 2,
|
||
b: "123abc",
|
||
x: 4,
|
||
"y": 5
|
||
}
|
||
}
|
||
JSEND
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_49()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=j1,J1
|
||
|
||
let code =<< trim [CODE]
|
||
JSSTART
|
||
var foo = [
|
||
1,
|
||
2,
|
||
3
|
||
];
|
||
JSEND
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
call search('^JSSTART')
|
||
exe "normal =/^JSEND\n"
|
||
|
||
let expected =<< trim [CODE]
|
||
JSSTART
|
||
var foo = [
|
||
1,
|
||
2,
|
||
3
|
||
];
|
||
JSEND
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_50()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=j1,J1
|
||
|
||
let code =<< trim [CODE]
|
||
JSSTART
|
||
function bar() {
|
||
var foo = [
|
||
1,
|
||
2,
|
||
3
|
||
];
|
||
}
|
||
JSEND
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
call search('^JSSTART')
|
||
exe "normal =/^JSEND\n"
|
||
|
||
let expected =<< trim [CODE]
|
||
JSSTART
|
||
function bar() {
|
||
var foo = [
|
||
1,
|
||
2,
|
||
3
|
||
];
|
||
}
|
||
JSEND
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_51()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=j1,J1
|
||
|
||
let code =<< trim [CODE]
|
||
JSSTART
|
||
(function($){
|
||
|
||
if (cond &&
|
||
cond) {
|
||
stmt;
|
||
}
|
||
window.something.left =
|
||
(width - 50 + offset) + "px";
|
||
var class_name='myclass';
|
||
|
||
function private_method() {
|
||
}
|
||
|
||
var public_method={
|
||
method: function(options,args){
|
||
private_method();
|
||
}
|
||
}
|
||
|
||
function init(options) {
|
||
|
||
$(this).data(class_name+'_public',$.extend({},{
|
||
foo: 'bar',
|
||
bar: 2,
|
||
foobar: [
|
||
1,
|
||
2,
|
||
3
|
||
],
|
||
callback: function(){
|
||
return true;
|
||
}
|
||
}, options||{}));
|
||
}
|
||
|
||
$.fn[class_name]=function() {
|
||
|
||
var _arguments=arguments;
|
||
return this.each(function(){
|
||
|
||
var options=$(this).data(class_name+'_public');
|
||
if (!options) {
|
||
init.apply(this,_arguments);
|
||
|
||
} else {
|
||
var method=public_method[_arguments[0]];
|
||
|
||
if (typeof(method)!='function') {
|
||
console.log(class_name+' has no method "'+_arguments[0]+'"');
|
||
return false;
|
||
}
|
||
_arguments[0]=options;
|
||
method.apply(this,_arguments);
|
||
}
|
||
});
|
||
}
|
||
|
||
})(jQuery);
|
||
JSEND
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
call search('^JSSTART')
|
||
exe "normal =/^JSEND\n"
|
||
|
||
let expected =<< trim [CODE]
|
||
JSSTART
|
||
(function($){
|
||
|
||
if (cond &&
|
||
cond) {
|
||
stmt;
|
||
}
|
||
window.something.left =
|
||
(width - 50 + offset) + "px";
|
||
var class_name='myclass';
|
||
|
||
function private_method() {
|
||
}
|
||
|
||
var public_method={
|
||
method: function(options,args){
|
||
private_method();
|
||
}
|
||
}
|
||
|
||
function init(options) {
|
||
|
||
$(this).data(class_name+'_public',$.extend({},{
|
||
foo: 'bar',
|
||
bar: 2,
|
||
foobar: [
|
||
1,
|
||
2,
|
||
3
|
||
],
|
||
callback: function(){
|
||
return true;
|
||
}
|
||
}, options||{}));
|
||
}
|
||
|
||
$.fn[class_name]=function() {
|
||
|
||
var _arguments=arguments;
|
||
return this.each(function(){
|
||
|
||
var options=$(this).data(class_name+'_public');
|
||
if (!options) {
|
||
init.apply(this,_arguments);
|
||
|
||
} else {
|
||
var method=public_method[_arguments[0]];
|
||
|
||
if (typeof(method)!='function') {
|
||
console.log(class_name+' has no method "'+_arguments[0]+'"');
|
||
return false;
|
||
}
|
||
_arguments[0]=options;
|
||
method.apply(this,_arguments);
|
||
}
|
||
});
|
||
}
|
||
|
||
})(jQuery);
|
||
JSEND
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_52()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=j1,J1
|
||
|
||
let code =<< trim [CODE]
|
||
JSSTART
|
||
function init(options) {
|
||
$(this).data(class_name+'_public',$.extend({},{
|
||
foo: 'bar',
|
||
bar: 2,
|
||
foobar: [
|
||
1,
|
||
2,
|
||
3
|
||
],
|
||
callback: function(){
|
||
return true;
|
||
}
|
||
}, options||{}));
|
||
}
|
||
JSEND
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
call search('^JSSTART')
|
||
exe "normal =/^JSEND\n"
|
||
|
||
let expected =<< trim [CODE]
|
||
JSSTART
|
||
function init(options) {
|
||
$(this).data(class_name+'_public',$.extend({},{
|
||
foo: 'bar',
|
||
bar: 2,
|
||
foobar: [
|
||
1,
|
||
2,
|
||
3
|
||
],
|
||
callback: function(){
|
||
return true;
|
||
}
|
||
}, options||{}));
|
||
}
|
||
JSEND
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_53()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=j1,J1
|
||
|
||
let code =<< trim [CODE]
|
||
JSSTART
|
||
(function($){
|
||
function init(options) {
|
||
$(this).data(class_name+'_public',$.extend({},{
|
||
foo: 'bar',
|
||
bar: 2,
|
||
foobar: [
|
||
1,
|
||
2,
|
||
3
|
||
],
|
||
callback: function(){
|
||
return true;
|
||
}
|
||
}, options||{}));
|
||
}
|
||
})(jQuery);
|
||
JSEND
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
call search('^JSSTART')
|
||
exe "normal =/^JSEND\n"
|
||
|
||
let expected =<< trim [CODE]
|
||
JSSTART
|
||
(function($){
|
||
function init(options) {
|
||
$(this).data(class_name+'_public',$.extend({},{
|
||
foo: 'bar',
|
||
bar: 2,
|
||
foobar: [
|
||
1,
|
||
2,
|
||
3
|
||
],
|
||
callback: function(){
|
||
return true;
|
||
}
|
||
}, options||{}));
|
||
}
|
||
})(jQuery);
|
||
JSEND
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_54()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=j1,J1,+2
|
||
|
||
let code =<< trim [CODE]
|
||
JSSTART
|
||
// Results of JavaScript indent
|
||
// 1
|
||
(function(){
|
||
var a = [
|
||
'a',
|
||
'b',
|
||
'c',
|
||
'd',
|
||
'e',
|
||
'f',
|
||
'g',
|
||
'h',
|
||
'i'
|
||
];
|
||
}())
|
||
|
||
// 2
|
||
(function(){
|
||
var a = [
|
||
0 +
|
||
5 *
|
||
9 *
|
||
'a',
|
||
'b',
|
||
0 +
|
||
5 *
|
||
9 *
|
||
'c',
|
||
'd',
|
||
'e',
|
||
'f',
|
||
'g',
|
||
'h',
|
||
'i'
|
||
];
|
||
}())
|
||
|
||
// 3
|
||
(function(){
|
||
var a = [
|
||
0 +
|
||
// comment 1
|
||
5 *
|
||
/* comment 2 */
|
||
9 *
|
||
'a',
|
||
'b',
|
||
0 +
|
||
5 *
|
||
9 *
|
||
'c',
|
||
'd',
|
||
'e',
|
||
'f',
|
||
'g',
|
||
'h',
|
||
'i'
|
||
];
|
||
}())
|
||
|
||
// 4
|
||
{
|
||
var a = [
|
||
0,
|
||
1
|
||
];
|
||
var b;
|
||
var c;
|
||
}
|
||
|
||
// 5
|
||
{
|
||
var a = [
|
||
[
|
||
0
|
||
],
|
||
2,
|
||
3
|
||
];
|
||
}
|
||
|
||
// 6
|
||
{
|
||
var a = [
|
||
[
|
||
0,
|
||
1
|
||
],
|
||
2,
|
||
3
|
||
];
|
||
}
|
||
|
||
// 7
|
||
{
|
||
var a = [
|
||
// [
|
||
0,
|
||
// 1
|
||
// ],
|
||
2,
|
||
3
|
||
];
|
||
}
|
||
|
||
// 8
|
||
var x = [
|
||
(function(){
|
||
var a,
|
||
b,
|
||
c,
|
||
d,
|
||
e,
|
||
f,
|
||
g,
|
||
h,
|
||
i;
|
||
})
|
||
];
|
||
|
||
// 9
|
||
var a = [
|
||
0 +
|
||
5 *
|
||
9 *
|
||
'a',
|
||
'b',
|
||
0 +
|
||
5 *
|
||
9 *
|
||
'c',
|
||
'd',
|
||
'e',
|
||
'f',
|
||
'g',
|
||
'h',
|
||
'i'
|
||
];
|
||
|
||
// 10
|
||
var a,
|
||
b,
|
||
c,
|
||
d,
|
||
e,
|
||
f,
|
||
g,
|
||
h,
|
||
i;
|
||
JSEND
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
call search('^JSSTART')
|
||
exe "normal =/^JSEND\n"
|
||
|
||
let expected =<< trim [CODE]
|
||
JSSTART
|
||
// Results of JavaScript indent
|
||
// 1
|
||
(function(){
|
||
var a = [
|
||
'a',
|
||
'b',
|
||
'c',
|
||
'd',
|
||
'e',
|
||
'f',
|
||
'g',
|
||
'h',
|
||
'i'
|
||
];
|
||
}())
|
||
|
||
// 2
|
||
(function(){
|
||
var a = [
|
||
0 +
|
||
5 *
|
||
9 *
|
||
'a',
|
||
'b',
|
||
0 +
|
||
5 *
|
||
9 *
|
||
'c',
|
||
'd',
|
||
'e',
|
||
'f',
|
||
'g',
|
||
'h',
|
||
'i'
|
||
];
|
||
}())
|
||
|
||
// 3
|
||
(function(){
|
||
var a = [
|
||
0 +
|
||
// comment 1
|
||
5 *
|
||
/* comment 2 */
|
||
9 *
|
||
'a',
|
||
'b',
|
||
0 +
|
||
5 *
|
||
9 *
|
||
'c',
|
||
'd',
|
||
'e',
|
||
'f',
|
||
'g',
|
||
'h',
|
||
'i'
|
||
];
|
||
}())
|
||
|
||
// 4
|
||
{
|
||
var a = [
|
||
0,
|
||
1
|
||
];
|
||
var b;
|
||
var c;
|
||
}
|
||
|
||
// 5
|
||
{
|
||
var a = [
|
||
[
|
||
0
|
||
],
|
||
2,
|
||
3
|
||
];
|
||
}
|
||
|
||
// 6
|
||
{
|
||
var a = [
|
||
[
|
||
0,
|
||
1
|
||
],
|
||
2,
|
||
3
|
||
];
|
||
}
|
||
|
||
// 7
|
||
{
|
||
var a = [
|
||
// [
|
||
0,
|
||
// 1
|
||
// ],
|
||
2,
|
||
3
|
||
];
|
||
}
|
||
|
||
// 8
|
||
var x = [
|
||
(function(){
|
||
var a,
|
||
b,
|
||
c,
|
||
d,
|
||
e,
|
||
f,
|
||
g,
|
||
h,
|
||
i;
|
||
})
|
||
];
|
||
|
||
// 9
|
||
var a = [
|
||
0 +
|
||
5 *
|
||
9 *
|
||
'a',
|
||
'b',
|
||
0 +
|
||
5 *
|
||
9 *
|
||
'c',
|
||
'd',
|
||
'e',
|
||
'f',
|
||
'g',
|
||
'h',
|
||
'i'
|
||
];
|
||
|
||
// 10
|
||
var a,
|
||
b,
|
||
c,
|
||
d,
|
||
e,
|
||
f,
|
||
g,
|
||
h,
|
||
i;
|
||
JSEND
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_55()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino&
|
||
|
||
let code =<< trim [CODE]
|
||
/* start of define */
|
||
{
|
||
}
|
||
#define AAA \
|
||
BBB\
|
||
CCC
|
||
|
||
#define CNT \
|
||
1 + \
|
||
2 + \
|
||
4
|
||
/* end of define */
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
call search('start of define')
|
||
exe "normal =/end of define\n"
|
||
|
||
let expected =<< trim [CODE]
|
||
/* start of define */
|
||
{
|
||
}
|
||
#define AAA \
|
||
BBB\
|
||
CCC
|
||
|
||
#define CNT \
|
||
1 + \
|
||
2 + \
|
||
4
|
||
/* end of define */
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_56()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino&
|
||
|
||
let code =<< trim [CODE]
|
||
{
|
||
a = second/*bug*/*line;
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
call search('a = second')
|
||
normal ox
|
||
|
||
let expected =<< trim [CODE]
|
||
{
|
||
a = second/*bug*/*line;
|
||
x
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
" this was going beyond the end of the line.
|
||
func Test_cindent_case()
|
||
new
|
||
call setline(1, 'case x: // x')
|
||
set cindent
|
||
norm! f:a:
|
||
call assert_equal('case x:: // x', getline(1))
|
||
set cindent&
|
||
bwipe!
|
||
endfunc
|
||
|
||
" Test for changing multiple lines (using c) with cindent
|
||
func Test_cindent_change_multline()
|
||
new
|
||
setlocal cindent
|
||
call setline(1, ['if (a)', '{', ' i = 1;', '}'])
|
||
normal! jc3jm = 2;
|
||
call assert_equal("\tm = 2;", getline(2))
|
||
close!
|
||
endfunc
|
||
|
||
" This was reading past the end of the line
|
||
func Test_cindent_check_funcdecl()
|
||
new
|
||
sil norm o0('\0=L
|
||
bwipe!
|
||
endfunc
|
||
|
||
func Test_cindent_scopedecls()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=g0
|
||
setl cinsd+=public\ slots,signals
|
||
|
||
let code =<< trim [CODE]
|
||
class Foo
|
||
{
|
||
public:
|
||
virtual void foo() = 0;
|
||
public slots:
|
||
void onBar();
|
||
signals:
|
||
void baz();
|
||
private:
|
||
int x;
|
||
};
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
normal ]]=][
|
||
|
||
let expected =<< trim [CODE]
|
||
class Foo
|
||
{
|
||
public:
|
||
virtual void foo() = 0;
|
||
public slots:
|
||
void onBar();
|
||
signals:
|
||
void baz();
|
||
private:
|
||
int x;
|
||
};
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_cindent_pragma()
|
||
new
|
||
setl cindent ts=4 sw=4
|
||
setl cino=Ps
|
||
|
||
let code =<< trim [CODE]
|
||
{
|
||
#pragma omp parallel
|
||
{
|
||
#pragma omp task
|
||
foo();
|
||
# pragma omp taskwait
|
||
}
|
||
}
|
||
[CODE]
|
||
|
||
call append(0, code)
|
||
normal gg
|
||
normal =G
|
||
|
||
let expected =<< trim [CODE]
|
||
{
|
||
#pragma omp parallel
|
||
{
|
||
#pragma omp task
|
||
foo();
|
||
# pragma omp taskwait
|
||
}
|
||
}
|
||
|
||
[CODE]
|
||
|
||
call assert_equal(expected, getline(1, '$'))
|
||
enew! | close
|
||
endfunc
|
||
|
||
func Test_backslash_at_end_of_line()
|
||
new
|
||
exe "norm v>O'\\\<C-m>-"
|
||
exe "norm \<C-q>="
|
||
bwipe!
|
||
endfunc
|
||
|
||
func Test_find_brace_backwards()
|
||
" this was looking beyond the end of the line
|
||
new
|
||
norm R/*
|
||
norm o0{
|
||
norm o//
|
||
norm V{=
|
||
call assert_equal(['/*', ' 0{', '//'], getline(1, 3))
|
||
bwipe!
|
||
endfunc
|
||
|
||
|
||
" vim: shiftwidth=2 sts=2 expandtab
|