tests: Migrate legacy test 3 #2399

1 files changed, 4216 insertions, 0 deletions

diff --git a/test/functional/legacy/003_cindent_spec.lua b/test/functional/legacy/003_cindent_spec.lua
new file mode 100644
index 0000000000..1857721563
--- /dev/null
+++ b/test/functional/legacy/003_cindent_spec.lua
@@ -0,0 +1,4216 @@
+-- Test for 'cindent'.
+--
+-- There are 50+ test command blocks (the stuff between STARTTEST and ENDTEST)
+-- in the original test. These have been converted to "it" test cases here.
+
+local helpers = require('test.functional.helpers')
+local feed, insert, source = helpers.feed, helpers.insert, helpers.source
+local clear, execute, expect = helpers.clear, helpers.execute, helpers.expect
+
+-- Inserts text as usual, and additionally positions the cursor on line 1 and
+-- sets 'cindent' and tab settings. (In the original "test3.in" the modeline at
+-- the top of the file takes care of this.)
+local function insert_(content)
+  insert(content)
+  execute('1', 'set cin ts=4 sw=4')
+end
+
+describe('cindent', function()
+  before_each(clear)
+
+  it('1 is working', function()
+    insert_([=[
+      
+      /* 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)
+      {
+      }
+      
+      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 incoreectly 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;
+      }
+      }
+      
+      /* invalid namespaces use block indent */
+      namespace test test2 {
+        111111111111111111111;
+      }
+      namespace11111111111 {
+        111111111111;
+      }
+      namespace() {
+        1111111111111;
+      }
+      namespace()
+      {
+        111111111111111111;
+      }
+      namespace test test2
+      {
+        1111111111111111111;
+      }
+      namespace111111111
+      {
+        111111111111111111;
+      }
+      
+      /* end of AUTO */
+      ]=])
+
+    execute('/start of AUTO')
+    feed('=/end of AUTO<cr>')
+
+    expect([=[
+      
+      /* 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)
+      {
+      }
+      
+      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 incoreectly 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;
+      	}
+      }
+      
+      /* invalid namespaces use block indent */
+      namespace test test2 {
+      	111111111111111111111;
+      }
+      namespace11111111111 {
+      	111111111111;
+      }
+      namespace() {
+      	1111111111111;
+      }
+      namespace()
+      {
+      	111111111111111111;
+      }
+      namespace test test2
+      {
+      	1111111111111111111;
+      }
+      namespace111111111
+      {
+      	111111111111111111;
+      }
+      
+      /* end of AUTO */
+      ]=])
+  end)
+
+  it('2 is working', function()
+    insert_([=[
+      
+      {
+      
+      /* this is
+       * a real serious important big
+       * comment
+       */
+      	/* insert " about life, the universe, and the rest" after "serious" */
+      }
+      ]=])
+
+    execute('set tw=0 wm=60 columns=80 noai fo=croq')
+    execute('/serious/e')
+    feed('a about life, the universe, and the rest<esc>')
+
+    expect([=[
+      
+      {
+      
+      /* 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" */
+      }
+      ]=])
+  end)
+
+  it('3 is working', function()
+    insert_([=[
+      
+      {
+      	/*
+      	 * Testing for comments, without 'cin' set
+      	 */
+      
+      /*
+      * what happens here?
+      */
+      
+      	/*
+      	   the end of the comment, try inserting a line below */
+      
+      		/* how about
+      		                this one */
+      }
+      ]=])
+
+    execute('set nocin')
+    execute('/comments')
+    feed('joabout life<esc>/happens<cr>')
+    feed('jothere<esc>/below<cr>')
+    feed('oline<esc>/this<cr>')
+    feed('Ohello<esc>')
+
+    expect([=[
+      
+      {
+      	/*
+      	 * 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 */
+      }
+      ]=])
+  end)
+
+  it('4 is working', function()
+    insert_([=[
+      
+      {
+          var = this + that + vec[0] * vec[0]
+      				      + vec[1] * vec[1]
+      					  + vec2[2] * vec[2];
+      }
+      ]=])
+    execute('set cin')
+    execute('/vec2')
+    feed('==<cr>')
+
+    expect([=[
+      
+      {
+          var = this + that + vec[0] * vec[0]
+      				      + vec[1] * vec[1]
+      					  + vec2[2] * vec[2];
+      }
+      ]=])
+  end)
+
+  it('5 is working', function()
+    insert_([=[
+      
+      {
+      		asdf asdflkajds f;
+      	if (tes & ting) {
+      		asdf asdf asdf ;
+      		asdfa sdf asdf;
+      		}
+      	testing1;
+      	if (tes & ting)
+      	{
+      		asdf asdf asdf ;
+      		asdfa sdf asdf;
+      		}
+      	testing2;
+      }
+      ]=])
+
+    execute('set cin')
+    execute('set cino=}4')
+    execute('/testing1')
+    feed('k2==/testing2<cr>')
+    feed('k2==<cr>')
+
+    expect([=[
+      
+      {
+      		asdf asdflkajds f;
+      	if (tes & ting) {
+      		asdf asdf asdf ;
+      		asdfa sdf asdf;
+      		}
+      	testing1;
+      	if (tes & ting)
+      	{
+      		asdf asdf asdf ;
+      		asdfa sdf asdf;
+      		}
+      	testing2;
+      }
+      ]=])
+  end)
+
+  it('6 is working', function()
+    insert_([=[
+      
+      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
+                            */
+              );
+      
+      }
+      ]=])
+
+    execute('set cin')
+    execute('set cino=(0,)20')
+    execute('/main')
+    feed('=][<cr>')
+
+    expect([=[
+      
+      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
+      					  */
+      		);
+      
+      }
+      ]=])
+  end)
+
+  it('7 is working', function()
+    insert_([=[
+      
+      main(void)
+      {
+      	/* Make sure that cino=X0s is not parsed like cino=Xs. */
+      	if (cond)
+      		foo();
+      	else
+      	{
+      		bar();
+      	}
+      }
+      ]=])
+
+    execute('set cin')
+    execute('set cino=es,n0s')
+    execute('/main')
+    feed('=][<cr>')
+
+    expect([=[
+      
+      main(void)
+      {
+      	/* Make sure that cino=X0s is not parsed like cino=Xs. */
+      	if (cond)
+      		foo();
+      	else
+      	{
+      		bar();
+      	}
+      }
+      ]=])
+  end)
+
+  it('8 is working', function()
+    insert_([=[
+      
+      {
+      	do
+      	{
+      		if ()
+      		{
+      			if ()
+      				asdf;
+      			else
+      				asdf;
+      		}
+      	} while ();
+      			cmd;		/* this should go under the } */
+      }
+      ]=])
+
+    execute('set cin')
+    execute('set cino=')
+    feed(']]=][<cr>')
+
+    expect([=[
+      
+      {
+      	do
+      	{
+      		if ()
+      		{
+      			if ()
+      				asdf;
+      			else
+      				asdf;
+      		}
+      	} while ();
+      	cmd;		/* this should go under the } */
+      }
+      ]=])
+  end)
+
+  it('9 is working', function()
+    insert_([=[
+      
+      void f()
+      {
+          if ( k() ) {
+              l();
+      
+          } else { /* Start (two words) end */
+              m();
+          }
+      
+          n();
+      }
+      ]=])
+
+    feed(']]=][<cr>')
+
+    expect([=[
+      
+      void f()
+      {
+      	if ( k() ) {
+      		l();
+      
+      	} else { /* Start (two words) end */
+      		m();
+      	}
+      
+      	n();
+      }
+      ]=])
+  end)
+
+  it('10 is working', function()
+    -- This is nasty. This is the only test case where the buffer content
+    -- differs from the original. Why? Proper behaviour of this test depends on
+    -- the fact that the setup code contains an (unbalanced) opening curly
+    -- bracket in "set cino={s,e-s". This bracket actually affects the outcome
+    -- of the test: without it the curly bracket under "void f()" would not be
+    -- indented properly. And that's why we've had to add one explicitly.
+    insert_([=[
+      { <= THIS IS THE CURLY BRACKET EXPLAINED IN THE COMMENT.
+      
+      void f()
+      {
+          if ( k() )
+      	{
+              l();
+          } else { /* Start (two words) end */
+              m();
+          }
+      		n();	/* should be under the if () */
+      }
+      ]=])
+
+    execute('set cino={s,e-s')
+    feed(']]=][<cr>')
+
+    expect([=[
+      { <= THIS IS THE CURLY BRACKET EXPLAINED IN THE COMMENT.
+      
+      void f()
+      	{
+      	if ( k() )
+      		{
+      		l();
+      		} else { /* Start (two words) end */
+      		m();
+      		}
+      	n();	/* should be under the if () */
+      }
+      ]=])
+  end)
+
+  it('11 is working', function()
+    insert_([=[
+      
+      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 */
+      ]=])
+
+    execute('set cino={s,fs')
+    feed(']]=/ foo<cr>')
+
+    expect([=[
+      
+      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 */
+      ]=])
+  end)
+
+  it('12 is working', function()
+    insert_([=[
+      
+      a()
+      {
+        do {
+          a = a +
+            a;
+        } while ( a );		/* add text under this line */
+          if ( a )
+            a;
+      }
+      ]=])
+
+    execute('set cino=')
+    execute('/while')
+    feed('ohere<esc>')
+
+    expect([=[
+      
+      a()
+      {
+        do {
+          a = a +
+            a;
+        } while ( a );		/* add text under this line */
+        here
+          if ( a )
+            a;
+      }
+      ]=])
+  end)
+
+  it('13 is working', function()
+    insert_([=[
+      
+      a()
+      {
+      label1:
+                  /* hmm */
+                  // comment
+      }
+      ]=])
+
+    execute('set cino= com=')
+    execute('/comment')
+    feed('olabel2: b();<cr>label3 /* post */:<cr>/* pre */ label4:<cr>f(/*com*/);<cr>if (/*com*/)<cr>cmd();<esc>')
+
+    expect([=[
+      
+      a()
+      {
+      label1:
+                  /* hmm */
+                  // comment
+      label2: b();
+      label3 /* post */:
+      /* pre */ label4:
+      		f(/*com*/);
+      		if (/*com*/)
+      			cmd();
+      }
+      ]=])
+  end)
+
+  it('14 is working', function()
+    insert_([=[
+      
+      /*
+        * A simple comment
+         */
+      
+      /*
+        ** A different comment
+         */
+      ]=])
+
+    execute('set comments& comments^=s:/*,m:**,ex:*/')
+    execute('/simple')
+    feed('=5j<cr>')
+
+    expect([=[
+      
+      /*
+       * A simple comment
+       */
+      
+      /*
+      ** A different comment
+      */
+      ]=])
+  end)
+
+  it('15 is working', function()
+    insert_([=[
+      
+      
+      void f()
+      {
+      
+      	/*********
+        A comment.
+      *********/
+      }
+      ]=])
+
+    execute('set cino=c0')
+    execute('set comments& comments-=s1:/* comments^=s0:/*')
+    feed('2kdd]]=][<cr>')
+
+    expect([=[
+      
+      void f()
+      {
+      
+      	/*********
+      	  A comment.
+      	*********/
+      }
+      ]=])
+  end)
+
+  it('16 is working', function()
+    insert_([=[
+      
+      
+      void f()
+      {
+      
+      	/*********
+        A comment.
+      *********/
+      }
+      ]=])
+
+    execute('set cino=c0,C1')
+    execute('set comments& comments-=s1:/* comments^=s0:/*')
+    feed('2kdd]]=][<cr>')
+
+    expect([=[
+      
+      void f()
+      {
+      
+      	/*********
+      	A comment.
+      	*********/
+      }
+      ]=])
+  end)
+
+  it('17 is working', function()
+    insert_([=[
+      
+      void f()
+      {
+      	c = c1 &&
+      	(
+      	c2 ||
+      	c3
+      	) && c4;
+      }
+      ]=])
+
+    execute('set cino=')
+    feed(']]=][<cr>')
+
+    expect([=[
+      
+      void f()
+      {
+      	c = c1 &&
+      		(
+      		 c2 ||
+      		 c3
+      		) && c4;
+      }
+      ]=])
+  end)
+
+  it('18 is working', function()
+    insert_([=[
+      
+      
+      void f()
+      {
+      	c = c1 &&
+      	(
+      	c2 ||
+      	c3
+      	) && c4;
+      }
+      ]=])
+
+    execute('set cino=(s')
+    feed('2kdd]]=][<cr>')
+
+    expect([=[
+      
+      void f()
+      {
+      	c = c1 &&
+      		(
+      		 c2 ||
+      		 c3
+      		) && c4;
+      }
+      ]=])
+  end)
+
+  it('19 is working', function()
+    insert_([=[
+      
+      
+      void f()
+      {
+      	c = c1 &&
+      	(
+      	c2 ||
+      	c3
+      	) && c4;
+      }
+      ]=])
+
+    execute('set cino=(s,U1  ')
+    feed('2kdd]]=][<cr>')
+
+    expect([=[
+      
+      void f()
+      {
+      	c = c1 &&
+      		(
+      			c2 ||
+      			c3
+      		) && c4;
+      }
+      ]=])
+  end)
+
+  it('20 is working', function()
+    insert_([=[
+      
+      
+      void f()
+      {
+      	if (   c1
+      	&& (   c2
+      	|| c3))
+      	foo;
+      }
+      ]=])
+
+    execute('set cino=(0')
+    feed('2kdd]]=][<cr>')
+
+    expect([=[
+      
+      void f()
+      {
+      	if (   c1
+      		   && (   c2
+      				  || c3))
+      		foo;
+      }
+      ]=])
+  end)
+
+  it('21 is working', function()
+    insert_([=[
+      
+      
+      void f()
+      {
+      	if (   c1
+      	&& (   c2
+      	|| c3))
+      	foo;
+      }
+      ]=])
+
+    execute('set cino=(0,w1  ')
+    feed('2kdd]]=][<cr>')
+
+    expect([=[
+      
+      void f()
+      {
+      	if (   c1
+      		&& (   c2
+      			|| c3))
+      		foo;
+      }
+      ]=])
+  end)
+
+  it('22 is working', function()
+    insert_([=[
+      
+      
+      void f()
+      {
+      	c = c1 && (
+      	c2 ||
+      	c3
+      	) && c4;
+      	if (
+      	c1 && c2
+      	)
+      	foo;
+      }
+      ]=])
+
+    execute('set cino=(s')
+    feed('2kdd]]=][<cr>')
+
+    expect([=[
+      
+      void f()
+      {
+      	c = c1 && (
+      		c2 ||
+      		c3
+      		) && c4;
+      	if (
+      		c1 && c2
+      	   )
+      		foo;
+      }
+      ]=])
+  end)
+
+  it('23 is working', function()
+    insert_([=[
+      
+      
+      void f()
+      {
+      	c = c1 && (
+      	c2 ||
+      	c3
+      	) && c4;
+      	if (
+      	c1 && c2
+      	)
+      	foo;
+      }
+      ]=])
+
+    execute('set cino=(s,m1  ')
+    feed('2kdd]]=][<cr>')
+
+    expect([=[
+      
+      void f()
+      {
+      	c = c1 && (
+      		c2 ||
+      		c3
+      	) && c4;
+      	if (
+      		c1 && c2
+      	)
+      		foo;
+      }
+      ]=])
+  end)
+
+  it('24 is working', function()
+    insert_([=[
+      
+      
+      void f()
+      {
+      	switch (x)
+      	{
+      		case 1:
+      			a = b;
+      			break;
+      		default:
+      			a = 0;
+      			break;
+      	}
+      }
+      ]=])
+
+    execute('set cino=b1')
+    feed('2kdd]]=][<cr>')
+
+    expect([=[
+      
+      void f()
+      {
+      	switch (x)
+      	{
+      		case 1:
+      			a = b;
+      		break;
+      		default:
+      			a = 0;
+      		break;
+      	}
+      }
+      ]=])
+  end)
+
+  it('25 is working', function()
+    insert_([=[
+      
+      
+      void f()
+      {
+      	invokeme(
+      	argu,
+      	ment);
+      	invokeme(
+      	argu,
+      	ment
+      	);
+      	invokeme(argu,
+      	ment
+      	);
+      }
+      ]=])
+
+    execute('set cino=(0,W5')
+    feed('2kdd]]=][<cr>')
+
+    expect([=[
+      
+      void f()
+      {
+      	invokeme(
+      		 argu,
+      		 ment);
+      	invokeme(
+      		 argu,
+      		 ment
+      		 );
+      	invokeme(argu,
+      			 ment
+      			);
+      }
+      ]=])
+  end)
+
+  it('26 is working', function()
+    insert_([=[
+      
+      
+      void f()
+      {
+      	statement;
+      		// comment 1
+      	// comment 2
+      }
+      ]=])
+
+    execute('set cino=/6')
+    feed('2kdd]]=][<cr>')
+
+    expect([=[
+      
+      void f()
+      {
+      	statement;
+      		  // comment 1
+      		  // comment 2
+      }
+      ]=])
+  end)
+
+  it('27 is working', function()
+    insert_([=[
+      
+      
+      void f()
+      {
+      	statement;
+      	   // comment 1
+      	// comment 2
+      }
+      ]=])
+
+    execute('set cino=')
+    feed('2kdd]]/comment 1/+1<cr>')
+    feed('==<cr>')
+
+    expect([=[
+      
+      void f()
+      {
+      	statement;
+      	   // comment 1
+      	   // comment 2
+      }
+      ]=])
+  end)
+
+  it('28 is working', function()
+    insert_([=[
+      
+      
+      class CAbc
+      {
+         int Test() { return FALSE; }
+      
+      public: // comment
+         void testfall();
+      protected:
+         void testfall();
+      };
+      ]=])
+
+    execute('set cino=g0')
+    feed('2kdd]]=][<cr>')
+
+    expect([=[
+      
+      class CAbc
+      {
+      	int Test() { return FALSE; }
+      
+      public: // comment
+      	void testfall();
+      protected:
+      	void testfall();
+      };
+      ]=])
+  end)
+
+  it('29 is working', function()
+    insert_([=[
+      
+      
+      class Foo : public Bar
+      {
+      public:
+      virtual void method1(void) = 0;
+      virtual void method2(int arg1,
+      int arg2,
+      int arg3) = 0;
+      };
+      ]=])
+
+    execute('set cino=(0,gs,hs')
+    feed('2kdd]]=][<cr>')
+
+    expect([=[
+      
+      class Foo : public Bar
+      {
+      	public:
+      		virtual void method1(void) = 0;
+      		virtual void method2(int arg1,
+      							 int arg2,
+      							 int arg3) = 0;
+      };
+      ]=])
+  end)
+
+  it('30 is working', function()
+    insert_([=[
+      
+      
+      	void
+      foo()
+      {
+      	if (a)
+      	{
+      	} else
+      		asdf;
+      }
+      ]=])
+
+    execute('set cino=+20')
+    feed('2kdd]]=][<cr>')
+
+    expect([=[
+      
+      	void
+      foo()
+      {
+      	if (a)
+      	{
+      	} else
+      		asdf;
+      }
+      ]=])
+  end)
+
+  it('31 is working', function()
+    insert_([=[
+      
+      
+      {
+         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
+               );
+      }
+      ]=])
+
+    execute('set cino=(0,W2s')
+    feed('2kdd]]=][<cr>')
+
+    expect([=[
+      
+      {
+      	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
+      			);
+      }
+      ]=])
+  end)
+
+  it('32 is working', function()
+    insert_([=[
+      
+      
+      int main ()
+      {
+      	if (cond1 &&
+      			cond2
+      			)
+      		foo;
+      }
+      ]=])
+
+    execute('set cino=M1')
+    feed('2kdd]]=][<cr>')
+
+    expect([=[
+      
+      int main ()
+      {
+      	if (cond1 &&
+      			cond2
+      			)
+      		foo;
+      }
+      ]=])
+  end)
+
+  it('33 is working', function()
+    insert_([=[
+      
+      
+      void func(int a
+      #if defined(FOO)
+      		  , int b
+      		  , int c
+      #endif
+      		 )
+      {
+      }
+      ]=])
+
+    execute('set cino=(0,ts')
+    feed('2kdd2j=][<cr>')
+
+    expect([=[
+      
+      void func(int a
+      #if defined(FOO)
+      		  , int b
+      		  , int c
+      #endif
+      		 )
+      {
+      }
+      ]=])
+  end)
+
+  it('34 is working', function()
+    insert_([=[
+      
+      
+      
+      void
+      func(int a
+      #if defined(FOO)
+      		  , int b
+      		  , int c
+      #endif
+      		 )
+      {
+      }
+      ]=])
+
+    execute('set cino=(0')
+    feed('2kdd2j=][<cr>')
+
+    expect([=[
+      
+      
+      	void
+      func(int a
+      #if defined(FOO)
+      	 , int b
+      	 , int c
+      #endif
+      	)
+      {
+      }
+      ]=])
+  end)
+
+  it('35 is working', function()
+    insert_([=[
+      
+      
+      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)
+      {
+      }
+      ]=])
+
+    execute('set cino&')
+    feed('2kdd2j=7][<cr>')
+
+    expect([=[
+      
+      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)
+      {
+      }
+      ]=])
+  end)
+
+  it('36 is working', function()
+    insert_([=[
+      
+      
+      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;
+      	}
+      }
+      ]=])
+
+    execute('set cino&')
+    execute('set cino+=l1')
+    feed('2kdd2j=][<cr>')
+
+    expect([=[
+      
+      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;
+      	}
+      }
+      ]=])
+  end)
+
+  it('37 is working', function()
+    insert_([=[
+      
+      
+      void func(void)
+      {
+      	cout << "a"
+      	<< "b"
+      	<< ") :"
+      	<< "c";
+      }
+      ]=])
+
+    execute('set cino&')
+    feed('2kdd2j=][<cr>')
+
+    expect([=[
+      
+      void func(void)
+      {
+      	cout << "a"
+      		<< "b"
+      		<< ") :"
+      		<< "c";
+      }
+      ]=])
+  end)
+
+  it('38 is working', function()
+    insert_([=[
+      
+      void func(void)
+      {
+      	/*
+      	 * This is a comment.
+      	 */
+      }
+      ]=])
+
+    execute('set com=s1:/*,m:*,ex:*/')
+    feed(']]3jofoo();<esc>')
+
+    expect([=[
+      
+      void func(void)
+      {
+      	/*
+      	 * This is a comment.
+      	 */
+      	foo();
+      }
+      ]=])
+  end)
+
+  it('39 is working', function()
+    insert_([=[
+      
+      
+      void func(void)
+      {
+      	for (int i = 0; i < 10; ++i)
+      		if (i & 1) {
+      			foo(1);
+      		} else
+      			foo(0);
+      baz();
+      }
+      ]=])
+
+    execute('set cino&')
+    feed('2kdd2j=][<cr>')
+
+    expect([=[
+      
+      void func(void)
+      {
+      	for (int i = 0; i < 10; ++i)
+      		if (i & 1) {
+      			foo(1);
+      		} else
+      			foo(0);
+      	baz();
+      }
+      ]=])
+  end)
+
+  it('40 is working', function()
+    insert_([=[
+      
+      
+      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;
+      }
+      ]=])
+
+    execute('set cino=k2s,(0')
+    feed('2kdd3j=][<cr>')
+
+    expect([=[
+      
+      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;
+      }
+      ]=])
+  end)
+
+  it('41 is working', function()
+    insert_([=[
+      
+      
+      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;
+      }
+      ]=])
+
+    execute('set cino=k2s,(s')
+    feed('2kdd3j=][<cr>')
+
+    expect([=[
+      
+      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;
+      }
+      ]=])
+  end)
+
+  it('42 is working', function()
+    insert_([=[
+      
+      
+      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;
+      }
+      ]=])
+
+    execute('set cino=k2s,(s,U1')
+    feed('2kdd3j=][<cr>')
+
+    expect([=[
+      
+      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;
+      }
+      ]=])
+  end)
+
+  it('43 is working', function()
+    insert_([=[
+      
+      
+      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);
+      }
+      ]=])
+
+    execute('set cino=k2s,(0,W4')
+    feed('2kdd3j=][<cr>')
+
+    expect([=[
+      
+      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);
+      }
+      ]=])
+  end)
+
+  it('44 is working', function()
+    insert_([=[
+      
+      
+      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");
+      }
+      ]=])
+
+    execute('set cino=k2s,u2')
+    feed('2kdd3j=][<cr>')
+
+    expect([=[
+      
+      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");
+      }
+      ]=])
+  end)
+
+  it('45 is working', function()
+    insert_([=[
+      
+      
+      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;
+      }
+      ]=])
+
+    execute('set cino=k2s,(0,w1')
+    feed('2kdd3j=][<cr>')
+
+    expect([=[
+      
+      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;
+      }
+      ]=])
+  end)
+
+  it('46 is working', function()
+    insert_([=[
+      
+      
+      void func(void)
+      {
+      	if (condition1
+      	  && condition2)
+      		action();
+      	function(argument1
+      		&& argument2);
+      
+      	if (c1 && (c2 ||
+      		  c3))
+      		foo;
+      	if (c1 &&
+      	  (c2 || c3))
+      	{
+      	}
+      }
+      ]=])
+
+    execute('set cino=k2,(s')
+    feed('2kdd3j=][<cr>')
+
+    expect([=[
+      
+      void func(void)
+      {
+      	if (condition1
+      	  && condition2)
+      		action();
+      	function(argument1
+      		&& argument2);
+      
+      	if (c1 && (c2 ||
+      		  c3))
+      		foo;
+      	if (c1 &&
+      	  (c2 || c3))
+      	{
+      	}
+      }
+      ]=])
+  end)
+
+  it('47 is working', function()
+    insert_([=[
+      
+      NAMESPACESTART
+      /* 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;
+      }
+      }
+      
+      /* invalid namespaces use block indent */
+      namespace test test2 {
+        111111111111111111111;
+      }
+      namespace11111111111 {
+        111111111111;
+      }
+      namespace() {
+        1111111111111;
+      }
+      namespace()
+      {
+        111111111111111111;
+      }
+      namespace test test2
+      {
+        1111111111111111111;
+      }
+      namespace111111111
+      {
+        111111111111111111;
+      }
+      NAMESPACEEND
+      ]=])
+
+    execute('set cino=N-s')
+    execute('/^NAMESPACESTART')
+    feed('=/^NAMESPACEEND<cr>')
+
+    expect([=[
+      
+      NAMESPACESTART
+      /* 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;
+      }
+      }
+      
+      /* invalid namespaces use block indent */
+      namespace test test2 {
+      	111111111111111111111;
+      }
+      namespace11111111111 {
+      	111111111111;
+      }
+      namespace() {
+      	1111111111111;
+      }
+      namespace()
+      {
+      	111111111111111111;
+      }
+      namespace test test2
+      {
+      	1111111111111111111;
+      }
+      namespace111111111
+      {
+      	111111111111111111;
+      }
+      NAMESPACEEND
+      ]=])
+  end)
+
+  it('48 is working', function()
+    insert_([=[
+      
+      JSSTART
+      var bar = {
+      foo: {
+      that: this,
+      some: ok,
+      },
+      "bar":{
+      a : 2,
+      b: "123abc",
+      x: 4,
+      "y": 5
+      }
+      }
+      JSEND
+      ]=])
+
+    execute('set cino=j1,J1')
+    execute('/^JSSTART')
+    feed('=/^JSEND<cr>')
+
+    expect([=[
+      
+      JSSTART
+      var bar = {
+      	foo: {
+      		that: this,
+      		some: ok,
+      	},
+      	"bar":{
+      		a : 2,
+      		b: "123abc",
+      		x: 4,
+      		"y": 5
+      	}
+      }
+      JSEND
+      ]=])
+  end)
+
+  it('49 is working', function()
+    insert_([=[
+      
+      JSSTART
+      var foo = [
+      1,
+      2,
+      3
+      ];
+      JSEND
+      ]=])
+
+    execute('set cino=j1,J1')
+    execute('/^JSSTART')
+    feed('=/^JSEND<cr>')
+
+    expect([=[
+      
+      JSSTART
+      var foo = [
+      	1,
+      	2,
+      	3
+      ];
+      JSEND
+      ]=])
+  end)
+
+  it('50 is working', function()
+    insert_([=[
+      
+      JSSTART
+      function bar() {
+      var foo = [
+      1,
+      2,
+      3
+      ];
+      }
+      JSEND
+      ]=])
+
+    execute('set cino=j1,J1')
+    execute('/^JSSTART')
+    feed('=/^JSEND<cr>')
+
+    expect([=[
+      
+      JSSTART
+      function bar() {
+      	var foo = [
+      		1,
+      		2,
+      		3
+      	];
+      }
+      JSEND
+      ]=])
+  end)
+
+  it('51 is working', function()
+    insert_([=[
+      
+      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
+      ]=])
+
+    execute('set cino=j1,J1')
+    execute('/^JSSTART')
+    feed('=/^JSEND<cr>')
+
+    expect([=[
+      
+      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
+      ]=])
+  end)
+
+  it('52 is working', function()
+    insert_([=[
+      
+      JSSTART
+      function init(options) {
+      $(this).data(class_name+'_public',$.extend({},{
+      foo: 'bar',
+      bar: 2,
+      foobar: [
+      1,
+      2,
+      3
+      ],
+      callback: function(){
+      return true;
+      }
+      }, options||{}));
+      }
+      JSEND
+      ]=])
+
+    execute('set cino=j1,J1')
+    execute('/^JSSTART')
+    feed('=/^JSEND<cr>')
+
+    expect([=[
+      
+      JSSTART
+      function init(options) {
+      	$(this).data(class_name+'_public',$.extend({},{
+      		foo: 'bar',
+      		bar: 2,
+      		foobar: [
+      			1,
+      			2,
+      			3
+      		],
+      		callback: function(){
+      			return true;
+      		}
+      	}, options||{}));
+      }
+      JSEND
+      ]=])
+  end)
+
+  it('53 is working', function()
+    insert_([=[
+      
+      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
+      ]=])
+
+    execute('set cino=j1,J1')
+    execute('/^JSSTART')
+    feed('=/^JSEND<cr>')
+
+    expect([=[
+      
+      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
+      ]=])
+  end)
+end)