" Test for cinoptions and cindent

def Test_cino_hash()

# Test that curbuf->b_ind_hash_comment is correctly reset

new

setlocal cindent cinoptions=#1

setlocal cinoptions=

setline(1, ["#include <iostream>"])

cursor(1, 1)

norm! o#include

assert_equal(["#include <iostream>", "#include"], getline(1, 2))

bwipe!

enddef

def Test_cino_extern_c()

# Test for cino-E

var without_ind =<< trim [CODE]

#ifdef __cplusplus

extern "C" {

#endif

int func_a(void);

#ifdef __cplusplus

}

#endif

[CODE]

var with_ind =<< trim [CODE]

#ifdef __cplusplus

extern "C" {

#endif

int func_a(void);

#ifdef __cplusplus

}

#endif

[CODE]

new

setlocal cindent cinoptions=E0

setline(1, without_ind)

feedkeys("gg=G", 'tx')

assert_equal(with_ind, getline(1, '$'))

setlocal cinoptions=E-s

setline(1, with_ind)

feedkeys("gg=G", 'tx')

assert_equal(without_ind, getline(1, '$'))

setlocal cinoptions=Es

var 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

var lines = pair[1]

setline(1, lines)

feedkeys(len(lines) .. "Go;", 'tx')

assert_equal(pair[2], getline(len(lines) + 1),

'Failed for "' .. string(lines) .. '"')

endfor

bwipe!

enddef

def Test_cindent_rawstring()

new

setl cindent

feedkeys("i" ..

\ "int main() {\<CR>" ..

\ "R\"(\<CR>" ..

\ ")\";\<CR>" ..

\ "statement;\<Esc>", "x")

assert_equal("\tstatement;", getline(line('.')))

bwipe!

enddef

def Test_cindent_expr()

new

def g:MyIndentFunction(): number

return v:lnum == 1 ? shiftwidth() : 0

enddef

setl expandtab sw=8 indentkeys+=; indentexpr=g:MyIndentFunction()

var testinput =<< trim [CODE]

var_a = something()

b = something()

[CODE]

setline(1, testinput)

cursor(1, 1)

feedkeys("^\<c-v>j$A;\<esc>", 'tnix')

var expected =<< [CODE]

var_a = something();

b = something();

[CODE]

assert_equal(expected, getline(1, '$'))

:%d

testinput =<< [CODE]

var_a = something()

b = something()

[CODE]

setline(1, testinput)

cursor(1, 1)

feedkeys("^\<c-v>j$A;\<esc>", 'tnix')

expected =<< [CODE]

var_a = something();

b = something()

[CODE]

assert_equal(expected, getline(1, '$'))

delfunc g:MyIndentFunction

bwipe!

enddef

def Test_cindent_func()

new

setlocal cindent

setline(1, ['int main(void)', '{', 'return 0;', '}'])

assert_equal(-1, cindent(0))

assert_equal(&sw, 3->cindent())

assert_equal(-1, cindent(line('$') + 1))

bwipe!

enddef

def Test_cindent_01()

new

setl cindent ts=4 sw=4

setl cino& sts&

var 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;