diff --git a/ICSharpCode.NRefactory.Tests/FormattingTests/TestBraceStlye.cs b/ICSharpCode.NRefactory.Tests/FormattingTests/TestBraceStlye.cs
new file mode 100644
index 0000000000..23cc5e8dd5
--- /dev/null
+++ b/ICSharpCode.NRefactory.Tests/FormattingTests/TestBraceStlye.cs
@@ -0,0 +1,530 @@
+// 
+// TestBraceStyle.cs
+//  
+// Author:
+//       Mike Krüger <mkrueger@novell.com>
+// 
+// Copyright (c) 2010 Novell, Inc (http://www.novell.com)
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+/* 
+using System;
+using NUnit.Framework;
+using MonoDevelop.Ide.Gui;
+using MonoDevelop.Projects;
+using MonoDevelop.Core;
+using MonoDevelop.Ide.CodeCompletion;
+using MonoDevelop.Ide.Gui.Content;
+using MonoDevelop.Projects.Dom.Parser;
+using MonoDevelop.CSharp.Parser;
+using MonoDevelop.CSharp.Resolver;
+using MonoDevelop.CSharp.Completion;
+using Mono.TextEditor;
+using MonoDevelop.CSharp.Formatting;
+
+namespace MonoDevelop.CSharpBinding.FormattingTests
+{
+	[TestFixture()]
+	public class TestBraceStyle : UnitTests.TestBase
+	{
+		[Test()]
+		[Ignore("currently failing because namespaces are not inserted")]
+		public void TestNamespaceBraceStyle ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"namespace A
+{
+namespace B {
+	class Test {}
+}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.NamespaceBraceStyle = BraceStyle.EndOfLine;
+			policy.ClassBraceStyle = BraceStyle.DoNotChange;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"namespace A {
+	namespace B {
+		class Test {}
+	}
+}", data.Document.Text);
+			
+			policy.NamespaceBraceStyle = BraceStyle.NextLineShifted;
+			compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"namespace A 
+	{
+	namespace B
+		{
+		class Test {}
+		}
+	}", data.Document.Text);
+		}
+		
+		
+		[Test()]
+		public void TestClassBraceStlye ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.ClassBraceStyle =  BraceStyle.EndOfLine;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test {
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestStructBraceStyle ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"struct Test {}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.StructBraceStyle =  BraceStyle.NextLine;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"struct Test
+{
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestInterfaceBraceStyle ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"interface Test {}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.InterfaceBraceStyle =  BraceStyle.NextLine;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"interface Test
+{
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestEnumBraceStyle ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"enum Test {
+	A
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.EnumBraceStyle =  BraceStyle.NextLineShifted;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"enum Test
+	{
+	A
+	}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestMethodBraceStlye ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test MyMethod() {}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.MethodBraceStyle = BraceStyle.NextLine;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			
+			Console.WriteLine (data.Document.Text);
+			Assert.AreEqual (@"class Test
+{
+	Test MyMethod()
+	{
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestConstructorBraceStyle ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test() {}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.ConstructorBraceStyle = BraceStyle.NextLine;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			
+			Console.WriteLine (data.Document.Text);
+			Assert.AreEqual (@"class Test
+{
+	Test()
+	{
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestDestructorBraceStyle ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	~Test() {}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.DestructorBraceStyle = BraceStyle.NextLine;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			
+			Console.WriteLine (data.Document.Text);
+			Assert.AreEqual (@"class Test
+{
+	~Test()
+	{
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestPropertyBraceStyle ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test A {
+		get;
+		set;
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.PropertyBraceStyle = BraceStyle.NextLine;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			
+			Console.WriteLine (data.Document.Text);
+			Assert.AreEqual (@"class Test
+{
+	Test A
+	{
+		get;
+		set;
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestPropertyGetBraceStyle ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test A {
+		get {
+			return null;
+		}
+		set;
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.PropertyGetBraceStyle = BraceStyle.NextLine;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			
+			Console.WriteLine (data.Document.Text);
+			Assert.AreEqual (@"class Test
+{
+	Test A {
+		get
+		{
+			return null;
+		}
+		set;
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestAllowPropertyGetBlockInline ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test A {
+		get { return null; }
+		set { ; }
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.PropertyBraceStyle = BraceStyle.DoNotChange;
+			policy.AllowPropertyGetBlockInline = true;
+			policy.AllowPropertySetBlockInline = false;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			
+			Console.WriteLine (data.Document.Text);
+			Assert.AreEqual (@"class Test
+{
+	Test A {
+		get { return null; }
+		set {
+			;
+		}
+	}
+}", data.Document.Text);
+			
+			policy.AllowPropertyGetBlockInline = false;
+			compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			
+			Assert.AreEqual (@"class Test
+{
+	Test A {
+		get {
+			return null;
+		}
+		set {
+			;
+		}
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestAllowPropertySetBlockInline ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test A {
+		get { return null; }
+		set { ; }
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.PropertyBraceStyle = BraceStyle.DoNotChange;
+			policy.AllowPropertyGetBlockInline = false;
+			policy.AllowPropertySetBlockInline = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			
+			Console.WriteLine (data.Document.Text);
+			Assert.AreEqual (@"class Test
+{
+	Test A {
+		get {
+			return null;
+		}
+		set { ; }
+	}
+}", data.Document.Text);
+			
+			policy.AllowPropertySetBlockInline = false;
+			compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			
+			Assert.AreEqual (@"class Test
+{
+	Test A {
+		get {
+			return null;
+		}
+		set {
+			;
+		}
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestPropertySetBraceStyle ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test A {
+		get;
+		set {
+			;
+		}
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.PropertySetBraceStyle = BraceStyle.NextLine;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			
+			Console.WriteLine (data.Document.Text);
+			Assert.AreEqual (@"class Test
+{
+	Test A {
+		get;
+		set
+		{
+			;
+		}
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestEventBraceStyle ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	public event EventHandler Handler {
+		add {
+}
+		remove {
+}
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.EventBraceStyle = BraceStyle.NextLine;
+			policy.EventAddBraceStyle = BraceStyle.NextLine;
+			policy.EventRemoveBraceStyle = BraceStyle.NextLine;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			
+			Console.WriteLine (data.Document.Text);
+			Assert.AreEqual (@"class Test
+{
+	public event EventHandler Handler
+	{
+		add
+		{
+		}
+		remove
+		{
+		}
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestAllowEventAddBlockInline ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	public event EventHandler Handler {
+		add { ; }
+		remove { ; }
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.AllowEventAddBlockInline = true;
+			policy.AllowEventRemoveBlockInline = false;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			
+			Console.WriteLine (data.Document.Text);
+			Assert.AreEqual (@"class Test
+{
+	public event EventHandler Handler {
+		add { ; }
+		remove {
+			;
+		}
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestAllowEventRemoveBlockInline ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	public event EventHandler Handler {
+		add { ; }
+		remove { ; }
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.AllowEventAddBlockInline = false;
+			policy.AllowEventRemoveBlockInline = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			
+			Console.WriteLine (data.Document.Text);
+			Assert.AreEqual (@"class Test
+{
+	public event EventHandler Handler {
+		add {
+			;
+		}
+		remove { ; }
+	}
+}", data.Document.Text);
+		}
+		
+		
+		
+	}
+}*/
diff --git a/ICSharpCode.NRefactory.Tests/FormattingTests/TestFormattingBugs.cs b/ICSharpCode.NRefactory.Tests/FormattingTests/TestFormattingBugs.cs
new file mode 100644
index 0000000000..0a6a2d6f8f
--- /dev/null
+++ b/ICSharpCode.NRefactory.Tests/FormattingTests/TestFormattingBugs.cs
@@ -0,0 +1,162 @@
+// 
+// TestFormattingBugs.cs
+//  
+// Author:
+//       Mike Krüger <mkrueger@novell.com>
+// 
+// Copyright (c) 2010 Novell, Inc (http://www.novell.com)
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+/* 
+using System;
+using NUnit.Framework;
+using MonoDevelop.Ide.Gui;
+using MonoDevelop.Projects;
+using MonoDevelop.Core;
+using MonoDevelop.Ide.CodeCompletion;
+using MonoDevelop.Ide.Gui.Content;
+using MonoDevelop.Projects.Dom.Parser;
+using MonoDevelop.CSharp.Parser;
+using MonoDevelop.CSharp.Resolver;
+using MonoDevelop.CSharp.Completion;
+using Mono.TextEditor;
+using MonoDevelop.CSharp.Formatting;
+using System.Collections.Generic;
+using MonoDevelop.Refactoring;
+
+namespace MonoDevelop.CSharpBinding.FormattingTests
+{
+	[TestFixture()]
+	public class TestFormattingBugs : UnitTests.TestBase
+	{
+		/// <summary>
+		/// Bug 325187 - Bug in smart indent
+		/// </summary>
+		[Test()]
+		public void TestBug325187 ()
+		{
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.PlaceElseOnNewLine = true;
+			
+			TestStatementFormatting (policy,
+@"foreach (int i in myints)
+if (i == 6)
+Console.WriteLine (""Yeah"");
+else
+Console.WriteLine (""Bad indent"");",
+@"foreach (int i in myints)
+	if (i == 6)
+		Console.WriteLine (""Yeah"");
+	else
+		Console.WriteLine (""Bad indent"");");
+		}
+		
+		/// <summary>
+		/// Bug 415469 - return ternary in a switch is not tabbed properly
+		/// </summary>
+		[Test()]
+		[Ignore("currently failing because of 'string' has the wrong offset - mcs bug")]
+		public void TestBug415469 () 
+		{
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			TestStatementFormatting (policy,
+@"switch (condition) {
+case CONDITION1:
+return foo != null ? foo.Bar : null;
+case CONDITION2:
+string goo = foo != null ? foo.Bar : null;
+return ""Should be indented like this"";
+}", @"switch (condition) {
+case CONDITION1:
+	return foo != null ? foo.Bar : null;
+case CONDITION2:
+	string goo = foo != null ? foo.Bar : null;
+	return ""Should be indented like this"";
+}");
+		}
+		
+		/// <summary>
+		/// Bug 540043 - Format option for alignment of using-statements
+		/// </summary>
+		[Test()]
+		public void TestBug540043 ()
+		{
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			TestStatementFormatting (policy,
+@"using (IDisposable a = null)
+   using (IDisposable b = null) {
+			int c;
+   }
+", @"using (IDisposable a = null)
+using (IDisposable b = null) {
+	int c;
+}");
+		}
+		
+		
+
+
+		
+		static void TestStatementFormatting (CSharpFormattingPolicy policy, string input, string expectedOutput)
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text =
+@"class Test
+{
+	MyType TestMethod ()
+	{
+		" + input + @"
+	}
+}";
+			
+			Console.WriteLine (data.Document.Text);
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			DomSpacingVisitor domSpacingVisitor = new DomSpacingVisitor (policy, data);
+			domSpacingVisitor.AutoAcceptChanges = false;
+			compilationUnit.AcceptVisitor (domSpacingVisitor, null);
+			
+			DomIndentationVisitor domIndentationVisitor = new DomIndentationVisitor (policy, data);
+			domIndentationVisitor.AutoAcceptChanges = false;
+			compilationUnit.AcceptVisitor (domIndentationVisitor, null);
+			
+			List<Change> changes = new List<Change> ();
+			changes.AddRange (domSpacingVisitor.Changes);
+			changes.AddRange (domIndentationVisitor.Changes);
+			RefactoringService.AcceptChanges (null, null, changes);
+			
+			for (int i = 0; i < data.Document.LineCount; i++) {
+				LineSegment line = data.Document.GetLine (i);
+				if (line.EditableLength < 2)
+					continue;
+				data.Remove (line.Offset, 2);
+			}
+			string text = data.Document.GetTextBetween (data.Document.GetLine (4).Offset,
+			                                            data.Document.GetLine (data.Document.LineCount - 2).Offset).Trim ();
+			Console.WriteLine (text);
+			Assert.AreEqual (expectedOutput, text);
+		}
+
+		
+	}
+}
+*/
diff --git a/ICSharpCode.NRefactory.Tests/FormattingTests/TestSpacingVisitor.cs b/ICSharpCode.NRefactory.Tests/FormattingTests/TestSpacingVisitor.cs
new file mode 100644
index 0000000000..9a2cdc8212
--- /dev/null
+++ b/ICSharpCode.NRefactory.Tests/FormattingTests/TestSpacingVisitor.cs
@@ -0,0 +1,1167 @@
+// 
+// TestFormattingVisitor.cs
+//  
+// Author:
+//       Mike Krüger <mkrueger@novell.com>
+// 
+// Copyright (c) 2010 Novell, Inc (http://www.novell.com)
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+/* 
+using System;
+using NUnit.Framework;
+using MonoDevelop.Ide.Gui;
+using MonoDevelop.Projects;
+using MonoDevelop.Core;
+using MonoDevelop.Ide.CodeCompletion;
+using MonoDevelop.Ide.Gui.Content;
+using MonoDevelop.Projects.Dom.Parser;
+using MonoDevelop.CSharp.Parser;
+using MonoDevelop.CSharp.Resolver;
+using MonoDevelop.CSharp.Completion;
+using Mono.TextEditor;
+using MonoDevelop.CSharp.Formatting;
+
+namespace MonoDevelop.CSharpBinding.FormattingTests
+{
+	[TestFixture()]
+	public class TestSpacingVisitor : UnitTests.TestBase
+	{
+		[Test()]
+		public void TestFieldSpacesBeforeComma1 ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	int a           ,                   b,          c;
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.ClassBraceStyle =  BraceStyle.EndOfLine;
+			policy.SpacesAfterComma = false;
+			policy.SpacesBeforeComma = false;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test {
+	int a,b,c;
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestFieldSpacesBeforeComma2 ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	int a           ,                   b,          c;
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.ClassBraceStyle =  BraceStyle.EndOfLine;
+			policy.SpacesAfterComma = true;
+			policy.SpacesBeforeComma = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test {
+	int a , b , c;
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestFixedFieldSpacesBeforeComma ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	fixed int a[10]           ,                   b[10],          c[10];
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.ClassBraceStyle =  BraceStyle.EndOfLine;
+			policy.SpacesAfterComma = true;
+			policy.SpacesBeforeComma = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test {
+	fixed int a[10] , b[10] , c[10];
+}", data.Document.Text);
+		}
+
+		[Test()]
+		public void TestConstFieldSpacesBeforeComma ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	const int a = 1           ,                   b = 2,          c = 3;
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.ClassBraceStyle =  BraceStyle.EndOfLine;
+			policy.SpacesAfterComma = false;
+			policy.SpacesBeforeComma = false;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test {
+	const int a = 1,b = 2,c = 3;
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestBeforeDelegateDeclarationParentheses ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = "delegate void TestDelegate();";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.BeforeDelegateDeclarationParentheses = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			Assert.AreEqual (@"delegate void TestDelegate ();", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestBeforeDelegateDeclarationParenthesesComplex ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = "delegate void TestDelegate\n\t\t\t();";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.BeforeDelegateDeclarationParentheses = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			Assert.AreEqual (@"delegate void TestDelegate ();", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestBeforeMethodDeclarationParentheses ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"public abstract class Test
+{
+	public abstract Test TestMethod();
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.BeforeMethodDeclarationParentheses = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			Console.WriteLine (data.Document.Text);
+			Assert.AreEqual (@"public abstract class Test
+{
+	public abstract Test TestMethod ();
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestBeforeConstructorDeclarationParentheses ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test()
+	{
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.BeforeConstructorDeclarationParentheses = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+	Test ()
+	{
+	}
+}", data.Document.Text);
+		}
+		
+		
+		
+		[Test()]
+		public void TestBeforeConstructorDeclarationParenthesesDestructorCase ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	~Test()
+	{
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.BeforeConstructorDeclarationParentheses = true;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+	~Test ()
+	{
+	}
+}", data.Document.Text);
+		}
+		
+		
+		
+		static void TestBinaryOperator (CSharpFormattingPolicy policy, string op)
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = "class Test { void TestMe () { result = left" +op+"right; } }";
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			int i1 = data.Document.Text.IndexOf ("left");
+			int i2 = data.Document.Text.IndexOf ("right") + "right".Length;
+			if (i1 < 0 || i2 < 0)
+				Assert.Fail ("text invalid:" + data.Document.Text);
+			Assert.AreEqual ("left " + op + " right", data.Document.GetTextBetween (i1, i2));
+		}
+		
+		[Test()]
+		public void TestSpacesAroundMultiplicativeOperator ()
+		{
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.AroundMultiplicativeOperatorParentheses = true;
+			
+			TestBinaryOperator (policy, "*");
+			TestBinaryOperator (policy, "/");
+		}
+		
+		[Test()]
+		public void TestSpacesAroundShiftOperator ()
+		{
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.AroundShiftOperatorParentheses = true;
+			TestBinaryOperator (policy, "<<");
+			TestBinaryOperator (policy, ">>");
+		}
+		
+		[Test()]
+		public void TestSpacesAroundAdditiveOperator ()
+		{
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.AroundAdditiveOperatorParentheses = true;
+			
+			TestBinaryOperator (policy, "+");
+			TestBinaryOperator (policy, "-");
+		}
+		
+		[Test()]
+		public void TestSpacesAroundBitwiseOperator ()
+		{
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.AroundBitwiseOperatorParentheses = true;
+			
+			TestBinaryOperator (policy, "&");
+			TestBinaryOperator (policy, "|");
+			TestBinaryOperator (policy, "^");
+		}
+		
+		[Test()]
+		public void TestSpacesAroundRelationalOperator ()
+		{
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.AroundRelationalOperatorParentheses = true;
+			
+			TestBinaryOperator (policy, "<");
+			TestBinaryOperator (policy, "<=");
+			TestBinaryOperator (policy, ">");
+			TestBinaryOperator (policy, ">=");
+		}
+		
+		[Test()]
+		public void TestSpacesAroundEqualityOperator ()
+		{
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.AroundEqualityOperatorParentheses = true;
+			
+			TestBinaryOperator (policy, "==");
+			TestBinaryOperator (policy, "!=");
+		}
+		
+		[Test()]
+		public void TestSpacesAroundLogicalOperator ()
+		{
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.AroundLogicalOperatorParentheses = true;
+			
+			TestBinaryOperator (policy, "&&");
+			TestBinaryOperator (policy, "||");
+		}
+		
+		[Test()]
+		public void TestConditionalOperator ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	void TestMe ()
+	{
+		result = condition?trueexpr:falseexpr;
+	}
+}";
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.ConditionalOperatorAfterConditionSpace = true;
+			policy.ConditionalOperatorAfterSeparatorSpace = true;
+			policy.ConditionalOperatorBeforeConditionSpace = true;
+			policy.ConditionalOperatorBeforeSeparatorSpace = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			
+			int i1 = data.Document.Text.IndexOf ("condition");
+			int i2 = data.Document.Text.IndexOf ("falseexpr") + "falseexpr".Length;
+			Assert.AreEqual (@"condition ? trueexpr : falseexpr", data.Document.GetTextBetween (i1, i2));
+			
+			
+			data.Document.Text = @"class Test {
+	void TestMe ()
+	{
+		result = true ? trueexpr : falseexpr;
+	}
+}";
+			policy.ConditionalOperatorAfterConditionSpace = false;
+			policy.ConditionalOperatorAfterSeparatorSpace = false;
+			policy.ConditionalOperatorBeforeConditionSpace = false;
+			policy.ConditionalOperatorBeforeSeparatorSpace = false;
+			
+			compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			i1 = data.Document.Text.IndexOf ("true");
+			i2 = data.Document.Text.IndexOf ("falseexpr") + "falseexpr".Length;
+			Assert.AreEqual (@"true?trueexpr:falseexpr", data.Document.GetTextBetween (i1, i2));
+		}
+		
+		[Test()]
+		public void TestBeforeMethodCallParenthesesSpace ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	void TestMe ()
+	{
+		MethodCall();
+	}
+}";
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.BeforeMethodCallParentheses = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			int i1 = data.Document.Text.IndexOf ("MethodCall");
+			int i2 = data.Document.Text.IndexOf (";") + ";".Length;
+			Assert.AreEqual (@"MethodCall ();", data.Document.GetTextBetween (i1, i2));
+			
+			
+			data.Document.Text = @"class Test {
+	void TestMe ()
+	{
+		MethodCall                         				();
+	}
+}";
+			policy.BeforeMethodCallParentheses = false;
+			
+			compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			i1 = data.Document.Text.IndexOf ("MethodCall");
+			i2 = data.Document.Text.IndexOf (";") + ";".Length;
+			Assert.AreEqual (@"MethodCall();", data.Document.GetTextBetween (i1, i2));
+		}
+		
+		[Test()]
+		public void TestWithinMethodCallParenthesesSpace ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	void TestMe ()
+	{
+		MethodCall(true);
+	}
+}";
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.WithinMethodCallParentheses = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			int i1 = data.Document.Text.LastIndexOf ("(");
+			int i2 = data.Document.Text.LastIndexOf (")") + ")".Length;
+			Assert.AreEqual (@"( true )", data.Document.GetTextBetween (i1, i2));
+			
+			
+			data.Document.Text = @"class Test {
+	void TestMe ()
+	{
+		MethodCall( true );
+	}
+}";
+			policy.WithinMethodCallParentheses = false;
+			
+			compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			i1 = data.Document.Text.LastIndexOf ("(");
+			i2 = data.Document.Text.LastIndexOf (")") + ")".Length;
+			Assert.AreEqual (@"(true)", data.Document.GetTextBetween (i1, i2));
+		}
+		
+		[Test()]
+		public void TestBeforeIfParenthesesSpace ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	void TestMe ()
+	{
+		if(true);
+	}
+}";
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.IfParentheses = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			int i1 = data.Document.Text.IndexOf ("if");
+			int i2 = data.Document.Text.LastIndexOf (")") + ")".Length;
+			Assert.AreEqual (@"if (true)", data.Document.GetTextBetween (i1, i2));
+		}
+		
+		[Test()]
+		public void TestWithinIfParenthesesSpace ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	void TestMe ()
+	{
+		if (true);
+	}
+}";
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.WithinIfParentheses = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			int i1 = data.Document.Text.LastIndexOf ("(");
+			int i2 = data.Document.Text.LastIndexOf (")") + ")".Length;
+			Assert.AreEqual (@"( true )", data.Document.GetTextBetween (i1, i2));
+		}
+		
+		[Test()]
+		public void TestBeforeWhileParenthesesSpace ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	void TestMe ()
+	{
+		while(true);
+	}
+}";
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.WhileParentheses = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			int i1 = data.Document.Text.IndexOf ("while");
+			int i2 = data.Document.Text.LastIndexOf (")") + ")".Length;
+			Assert.AreEqual (@"while (true)", data.Document.GetTextBetween (i1, i2));
+		}
+		
+		[Test()]
+		public void TestWithinWhileParenthesesSpace ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	void TestMe ()
+	{
+		while (true);
+	}
+}";
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.WithinWhileParentheses = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			int i1 = data.Document.Text.LastIndexOf ("(");
+			int i2 = data.Document.Text.LastIndexOf (")") + ")".Length;
+			Assert.AreEqual (@"( true )", data.Document.GetTextBetween (i1, i2));
+		}
+		
+		[Test()]
+		public void TestBeforeForParenthesesSpace ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	void TestMe ()
+	{
+		for(;;);
+	}
+}";
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.ForParentheses = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			int i1 = data.Document.Text.IndexOf ("for");
+			int i2 = data.Document.Text.LastIndexOf ("(") + "(".Length;
+			Assert.AreEqual (@"for (", data.Document.GetTextBetween (i1, i2));
+		}
+		
+		[Test()]
+		public void TestWithinForParenthesesSpace ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	void TestMe ()
+	{
+		for(;;);
+	}
+}";
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.WithinForParentheses = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			int i1 = data.Document.Text.LastIndexOf ("(");
+			int i2 = data.Document.Text.LastIndexOf (")") + ")".Length;
+			Assert.AreEqual (@"( ;; )", data.Document.GetTextBetween (i1, i2));
+		}
+		
+		[Test()]
+		public void TestBeforeForeachParenthesesSpace ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	void TestMe ()
+	{
+		foreach(var o in list);
+	}
+}";
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.ForeachParentheses = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			int i1 = data.Document.Text.IndexOf ("foreach");
+			int i2 = data.Document.Text.LastIndexOf (")") + ")".Length;
+			Assert.AreEqual (@"foreach (var o in list)", data.Document.GetTextBetween (i1, i2));
+		}
+		
+		[Test()]
+		public void TestWithinForeachParenthesesSpace ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	void TestMe ()
+	{
+		foreach(var o in list);
+	}
+}";
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.WithinForEachParentheses = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			int i1 = data.Document.Text.LastIndexOf ("(");
+			int i2 = data.Document.Text.LastIndexOf (")") + ")".Length;
+			Assert.AreEqual (@"( var o in list )", data.Document.GetTextBetween (i1, i2));
+		}
+		
+		[Test()]
+		public void TestBeforeCatchParenthesesSpace ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	void TestMe ()
+	{
+  try {} catch(Exception) {}
+	}
+}";
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.CatchParentheses = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			int i1 = data.Document.Text.IndexOf ("catch");
+			int i2 = data.Document.Text.LastIndexOf (")") + ")".Length;
+			Assert.AreEqual (@"catch (Exception)", data.Document.GetTextBetween (i1, i2));
+		}
+		
+		[Test()]
+		public void TestWithinCatchParenthesesSpace ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	void TestMe ()
+	{
+		try {} catch(Exception) {}
+	}
+}";
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.WithinCatchParentheses = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			int i1 = data.Document.Text.LastIndexOf ("(");
+			int i2 = data.Document.Text.LastIndexOf (")") + ")".Length;
+			Assert.AreEqual (@"( Exception )", data.Document.GetTextBetween (i1, i2));
+		}
+		
+		[Test()]
+		public void TestBeforeLockParenthesesSpace ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	void TestMe ()
+	{
+		lock(this) {}
+	}
+}";
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.LockParentheses = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			int i1 = data.Document.Text.IndexOf ("lock");
+			int i2 = data.Document.Text.LastIndexOf (")") + ")".Length;
+			Assert.AreEqual (@"lock (this)", data.Document.GetTextBetween (i1, i2));
+		}
+		
+		[Test()]
+		public void TestWithinLockParenthesesSpace ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	void TestMe ()
+	{
+		lock(this) {}
+	}
+}";
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.WithinLockParentheses = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			int i1 = data.Document.Text.LastIndexOf ("(");
+			int i2 = data.Document.Text.LastIndexOf (")") + ")".Length;
+			Assert.AreEqual (@"( this )", data.Document.GetTextBetween (i1, i2));
+		}
+		
+		
+		[Test()]
+		public void TestSpacesAfterSemicolon ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	void TestMe ()
+	{
+		for (int i;true;i++) ;
+	}
+}";
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.SpacesAfterSemicolon = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			int i1 = data.Document.Text.LastIndexOf ("for");
+			int i2 = data.Document.Text.LastIndexOf (")") + ")".Length;
+			
+			Assert.AreEqual (@"for (int i; true; i++)", data.Document.GetTextBetween (i1, i2));
+		}
+		
+		[Test()]
+		public void TestSpacesAfterTypecast ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	Test TestMe ()
+	{
+return (Test)null;
+	}
+}";
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.SpacesAfterTypecast = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			int i1 = data.Document.Text.LastIndexOf ("return");
+			int i2 = data.Document.Text.LastIndexOf ("null") + "null".Length;
+			
+			Assert.AreEqual (@"return (Test) null", data.Document.GetTextBetween (i1, i2));
+		}
+		
+		[Test()]
+		public void TestBeforeUsingParenthesesSpace ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	void TestMe ()
+	{
+		using(a) {}
+	}
+}";
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.UsingParentheses = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			int i1 = data.Document.Text.IndexOf ("using");
+			int i2 = data.Document.Text.LastIndexOf ("(") + "(".Length;
+			Assert.AreEqual (@"using (", data.Document.GetTextBetween (i1, i2));
+		}
+		
+		[Test()]
+		public void TestWithinUsingParenthesesSpace ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	void TestMe ()
+	{
+		using(a) {}
+	}
+}";
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.WithinUsingParentheses = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			int i1 = data.Document.Text.LastIndexOf ("(");
+			int i2 = data.Document.Text.LastIndexOf (")") + ")".Length;
+			Assert.AreEqual (@"( a )", data.Document.GetTextBetween (i1, i2));
+		}
+		
+		static void TestAssignmentOperator (CSharpFormattingPolicy policy, string op)
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = "class Test { void TestMe () { left" +op+"right; } }";
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			int i1 = data.Document.Text.IndexOf ("left");
+			int i2 = data.Document.Text.IndexOf ("right") + "right".Length;
+			if (i1 < 0 || i2 < 0)
+				Assert.Fail ("text invalid:" + data.Document.Text);
+			Assert.AreEqual ("left " + op + " right", data.Document.GetTextBetween (i1, i2));
+		}
+		
+		[Test()]
+		public void TestAroundAssignmentSpace ()
+		{
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.AroundAssignmentParentheses = true;
+			
+			TestAssignmentOperator (policy, "=");
+			TestAssignmentOperator (policy, "*=");
+			TestAssignmentOperator (policy, "/=");
+			TestAssignmentOperator (policy, "+=");
+			TestAssignmentOperator (policy, "%=");
+			TestAssignmentOperator (policy, "-=");
+			TestAssignmentOperator (policy, "<<=");
+			TestAssignmentOperator (policy, ">>=");
+			TestAssignmentOperator (policy, "&=");
+			TestAssignmentOperator (policy, "|=");
+			TestAssignmentOperator (policy, "^=");
+		}
+		
+		[Test()]
+		public void TestAroundAssignmentSpaceInDeclarations ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	void TestMe ()
+	{
+		int left=right;
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.AroundAssignmentParentheses = true;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			int i1 = data.Document.Text.LastIndexOf ("left");
+			int i2 = data.Document.Text.LastIndexOf ("right") + "right".Length;
+			Assert.AreEqual (@"left = right", data.Document.GetTextBetween (i1, i2));
+		}
+		
+		[Test()]
+		public void TestBeforeSwitchParenthesesSpace ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	void TestMe ()
+	{
+		switch (test) { default: break; }
+	}
+}";
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.SwitchParentheses = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			int i1 = data.Document.Text.IndexOf ("switch");
+			int i2 = data.Document.Text.LastIndexOf ("(") + "(".Length;
+			Assert.AreEqual (@"switch (", data.Document.GetTextBetween (i1, i2));
+		}
+		
+		[Test()]
+		public void TestWithinSwitchParenthesesSpace ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	void TestMe ()
+	{
+		switch (test) { default: break; }
+	}
+}";
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.WithinSwitchParentheses = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			int i1 = data.Document.Text.LastIndexOf ("(");
+			int i2 = data.Document.Text.LastIndexOf (")") + ")".Length;
+			Assert.AreEqual (@"( test )", data.Document.GetTextBetween (i1, i2));
+		}
+		
+		[Test()]
+		public void TestWithinParenthesesSpace ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	void TestMe ()
+	{
+		c = (test);
+	}
+}";
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.WithinParentheses = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			int i1 = data.Document.Text.LastIndexOf ("(");
+			int i2 = data.Document.Text.LastIndexOf (")") + ")".Length;
+			Assert.AreEqual (@"( test )", data.Document.GetTextBetween (i1, i2));
+		}
+		
+		[Test()]
+		public void TestWithinMethodDeclarationParenthesesSpace ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	void TestMe (int a)
+	{
+	}
+}";
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.WithinMethodDeclarationParentheses = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			int i1 = data.Document.Text.LastIndexOf ("(");
+			int i2 = data.Document.Text.LastIndexOf (")") + ")".Length;
+			Assert.AreEqual (@"( int a )", data.Document.GetTextBetween (i1, i2));
+		}
+		
+		[Test()]
+		public void TestWithinCastParenthesesSpace ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	void TestMe ()
+	{
+		a = (int)b;
+	}
+}";
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.WithinCastParentheses = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			int i1 = data.Document.Text.LastIndexOf ("(");
+			int i2 = data.Document.Text.LastIndexOf (")") + ")".Length;
+			Assert.AreEqual (@"( int )", data.Document.GetTextBetween (i1, i2));
+		}
+		
+		[Test()]
+		public void TestWithinSizeOfParenthesesSpace ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	void TestMe ()
+	{
+		a = sizeof(int);
+	}
+}";
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.WithinSizeOfParentheses = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			int i1 = data.Document.Text.LastIndexOf ("(");
+			int i2 = data.Document.Text.LastIndexOf (")") + ")".Length;
+			Assert.AreEqual (@"( int )", data.Document.GetTextBetween (i1, i2));
+		}
+		
+		[Test()]
+		public void TestWithinTypeOfParenthesesSpace ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	void TestMe ()
+	{
+		a = typeof(int);
+	}
+}";
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.WithinTypeOfParentheses = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			int i1 = data.Document.Text.LastIndexOf ("(");
+			int i2 = data.Document.Text.LastIndexOf (")") + ")".Length;
+			Assert.AreEqual (@"( int )", data.Document.GetTextBetween (i1, i2));
+		}
+		
+		[Test()]
+		public void TestWithinCheckedExpressionParanthesesSpace ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	void TestMe ()
+	{
+		a = checked(a + b);
+	}
+}";
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.WithinCheckedExpressionParantheses = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			int i1 = data.Document.Text.LastIndexOf ("(");
+			int i2 = data.Document.Text.LastIndexOf (")") + ")".Length;
+			Assert.AreEqual (@"( a + b )", data.Document.GetTextBetween (i1, i2));
+			
+			data.Document.Text = @"class Test {
+	void TestMe ()
+	{
+		a = unchecked(a + b);
+	}
+}";
+			
+			compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			i1 = data.Document.Text.LastIndexOf ("(");
+			i2 = data.Document.Text.LastIndexOf (")") + ")".Length;
+			Assert.AreEqual (@"( a + b )", data.Document.GetTextBetween (i1, i2));
+		}
+		
+		[Test()]
+		public void TestSpacesWithinBrackets ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	Test this[int i] {
+		get {}
+		set {}
+	}
+	
+	void TestMe ()
+	{
+		this[0] = 5;
+	}
+}";
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.SpacesWithinBrackets = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			
+			Assert.AreEqual (@"class Test {
+	Test this[ int i ] {
+		get {}
+		set {}
+	}
+	
+	void TestMe ()
+	{
+		this[ 0 ] = 5;
+	}
+}", data.Document.Text);
+			
+			policy.SpacesWithinBrackets = false;
+			
+			compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			
+			Assert.AreEqual (@"class Test {
+	Test this[int i] {
+		get {}
+		set {}
+	}
+	
+	void TestMe ()
+	{
+		this[0] = 5;
+	}
+}", data.Document.Text);
+		}
+		
+		
+		[Test()]
+		public void TestSpaceBeforeNewParentheses ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	void TestMe ()
+	{
+		new Test();
+	}
+}";
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.NewParentheses = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			int i1 = data.Document.Text.LastIndexOf ("new");
+			int i2 = data.Document.Text.LastIndexOf (";") + ";".Length;
+			Assert.AreEqual (@"new Test ();", data.Document.GetTextBetween (i1, i2));
+		}
+		
+		[Test()]
+		public void TestSpacesBeforeComma ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	void TestMe ()
+	{
+		int[] i = new int[] { 1,3,3,7 };
+	}
+}";
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.SpacesBeforeComma = true;
+			policy.SpacesAfterComma = false;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			int i1 = data.Document.Text.LastIndexOf ("new");
+			int i2 = data.Document.Text.LastIndexOf (";") + ";".Length;
+			Assert.AreEqual (@"new int[] { 1 ,3 ,3 ,7 };", data.Document.GetTextBetween (i1, i2));
+			policy.SpacesBeforeComma = false;
+			
+			compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			i1 = data.Document.Text.LastIndexOf ("new");
+			i2 = data.Document.Text.LastIndexOf (";") + ";".Length;
+			Assert.AreEqual (@"new int[] { 1,3,3,7 };", data.Document.GetTextBetween (i1, i2));
+		}
+		
+		[Test()]
+		public void TestSpacesAfterComma ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	void TestMe ()
+	{
+		int[] i = new int[] { 1,3,3,7 };
+	}
+}";
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.SpacesBeforeComma = false;
+			policy.SpacesAfterComma = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			int i1 = data.Document.Text.LastIndexOf ("new");
+			int i2 = data.Document.Text.LastIndexOf (";") + ";".Length;
+			Assert.AreEqual (@"new int[] { 1, 3, 3, 7 };", data.Document.GetTextBetween (i1, i2));
+			policy.SpacesAfterComma = false;
+			
+			compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			i1 = data.Document.Text.LastIndexOf ("new");
+			i2 = data.Document.Text.LastIndexOf (";") + ";".Length;
+			Assert.AreEqual (@"new int[] { 1,3,3,7 };", data.Document.GetTextBetween (i1, i2));
+		}
+		
+		[Test()]
+		public void TestSpacesInLambdaExpression ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	void TestMe ()
+	{
+		var v = x=>x!=null;
+	}
+}";
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.WithinWhileParentheses = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomSpacingVisitor (policy, data), null);
+			int i1 = data.Document.Text.IndexOf ("x");
+			int i2 = data.Document.Text.LastIndexOf ("null") + "null".Length;
+			Assert.AreEqual (@"x => x != null", data.Document.GetTextBetween (i1, i2));
+		}
+		
+	}
+}
+ */
\ No newline at end of file
diff --git a/ICSharpCode.NRefactory.Tests/FormattingTests/TestStatementIndentation.cs b/ICSharpCode.NRefactory.Tests/FormattingTests/TestStatementIndentation.cs
new file mode 100644
index 0000000000..6d483a6c7d
--- /dev/null
+++ b/ICSharpCode.NRefactory.Tests/FormattingTests/TestStatementIndentation.cs
@@ -0,0 +1,1749 @@
+// 
+// TestStatementIndentation.cs
+//  
+// Author:
+//       Mike Krüger <mkrueger@novell.com>
+// 
+// Copyright (c) 2010 Novell, Inc (http://www.novell.com)
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+/* 
+using System;
+using NUnit.Framework;
+using MonoDevelop.Ide.Gui;
+using MonoDevelop.Projects;
+using MonoDevelop.Core;
+using MonoDevelop.Ide.CodeCompletion;
+using MonoDevelop.Ide.Gui.Content;
+using MonoDevelop.Projects.Dom.Parser;
+using MonoDevelop.CSharp.Parser;
+using MonoDevelop.CSharp.Resolver;
+using MonoDevelop.CSharp.Completion;
+using Mono.TextEditor;
+using MonoDevelop.CSharp.Formatting;
+
+namespace MonoDevelop.CSharpBinding.FormattingTests
+{
+	[TestFixture()]
+	public class TestStatementIndentation : UnitTests.TestBase
+	{
+		[Test()]
+		public void TestInvocationIndentation ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	Test TestMethod ()
+	{
+this.TestMethod ();
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.ClassBraceStyle = BraceStyle.EndOfLine;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test {
+	Test TestMethod ()
+	{
+		this.TestMethod ();
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestIndentBlocks ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	Test TestMethod ()
+	{
+{
+{}
+}
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.IndentBlocks = true;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		{
+			{}
+		}
+	}
+}", data.Document.Text);
+			policy.IndentBlocks = false;
+			compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		{
+		{}
+		}
+	}
+}", data.Document.Text);
+			policy.IndentBlocks = false;
+		}
+		
+		[Test()]
+		public void TestBreakIndentation ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	Test TestMethod ()
+	{
+                              break;
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.ClassBraceStyle = BraceStyle.EndOfLine;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test {
+	Test TestMethod ()
+	{
+		break;
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestCheckedIndentation ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	Test TestMethod ()
+	{
+checked {
+}
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.ClassBraceStyle = BraceStyle.EndOfLine;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test {
+	Test TestMethod ()
+	{
+		checked {
+		}
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestBaseIndentation ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	Test TestMethod ()
+	{
+                              base.FooBar();
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.ClassBraceStyle = BraceStyle.EndOfLine;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test {
+	Test TestMethod ()
+	{
+		base.FooBar();
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestUncheckedIndentation ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	Test TestMethod ()
+	{
+unchecked {
+}
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.ClassBraceStyle = BraceStyle.EndOfLine;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test {
+	Test TestMethod ()
+	{
+		unchecked {
+		}
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestContinueIndentation ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	Test TestMethod ()
+	{
+continue;
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.ClassBraceStyle = BraceStyle.EndOfLine;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test {
+	Test TestMethod ()
+	{
+		continue;
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestEmptyStatementIndentation ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	Test TestMethod ()
+	{
+;
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.ClassBraceStyle = BraceStyle.EndOfLine;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test {
+	Test TestMethod ()
+	{
+		;
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestFixedStatementIndentation ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	Test TestMethod ()
+	{
+fixed (object* obj = &obj)
+;
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.ClassBraceStyle = BraceStyle.EndOfLine;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test {
+	Test TestMethod ()
+	{
+		fixed (object* obj = &obj)
+			;
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestFixedForcementAdd ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test TestMethod ()
+	{
+		fixed (object* obj = &obj) {
+		}
+		fixed (object* obj = &obj) ;
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.StatementBraceStyle = BraceStyle.EndOfLine;
+			policy.FixedBraceForcement = BraceForcement.AddBraces;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		fixed (object* obj = &obj) {
+		}
+		fixed (object* obj = &obj) {
+			;
+		}
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestForeachIndentation ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test TestMethod ()
+	{
+foreach (var obj in col) {
+}
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.StatementBraceStyle = BraceStyle.EndOfLine;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		foreach (var obj in col) {
+		}
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestForIndentation ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	Test TestMethod ()
+	{
+for (;;) {
+}
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.ClassBraceStyle = BraceStyle.EndOfLine;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test {
+	Test TestMethod ()
+	{
+		for (;;) {
+		}
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestGotoIndentation ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	Test TestMethod ()
+	{
+goto label;
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.ClassBraceStyle = BraceStyle.EndOfLine;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test {
+	Test TestMethod ()
+	{
+		goto label;
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestReturnIndentation ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	Test TestMethod ()
+	{
+return;
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.ClassBraceStyle = BraceStyle.EndOfLine;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test {
+	Test TestMethod ()
+	{
+		return;
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestLockIndentation ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	Test TestMethod ()
+	{
+lock (this) {
+}
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.ClassBraceStyle = BraceStyle.EndOfLine;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test {
+	Test TestMethod ()
+	{
+		lock (this) {
+		}
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestThrowIndentation ()
+		{
+			
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	Test TestMethod ()
+	{
+throw new NotSupportedException ();
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.ClassBraceStyle = BraceStyle.EndOfLine;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test {
+	Test TestMethod ()
+	{
+		throw new NotSupportedException ();
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestUnsafeIndentation ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	Test TestMethod ()
+	{
+unsafe {
+}
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.ClassBraceStyle = BraceStyle.EndOfLine;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test {
+	Test TestMethod ()
+	{
+		unsafe {
+		}
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestUsingIndentation ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	Test TestMethod ()
+	{
+using (var o = new MyObj()) {
+}
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.ClassBraceStyle = BraceStyle.EndOfLine;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test {
+	Test TestMethod ()
+	{
+		using (var o = new MyObj()) {
+		}
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestUsingForcementAdd ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test TestMethod ()
+	{
+		using (var o = new MyObj()) {
+		}
+		using (var o = new MyObj()) ;
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.StatementBraceStyle = BraceStyle.EndOfLine;
+			policy.UsingBraceForcement = BraceForcement.AddBraces;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		using (var o = new MyObj()) {
+		}
+		using (var o = new MyObj()) {
+			;
+		}
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestUsingForcementDoNotChange ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test TestMethod ()
+	{
+		using (var o = new MyObj()) {
+		}
+		using (var o = new MyObj()) ;
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.StatementBraceStyle = BraceStyle.EndOfLine;
+			policy.UsingBraceForcement = BraceForcement.DoNotChange;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		using (var o = new MyObj()) {
+		}
+		using (var o = new MyObj())
+			;
+	}
+}", data.Document.Text);
+		}
+		
+		
+		[Test()]
+		public void TestVariableDeclarationIndentation ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	Test TestMethod ()
+	{
+Test a;
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			Console.WriteLine (data.Document.Text);
+			policy.ClassBraceStyle = BraceStyle.EndOfLine;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test {
+	Test TestMethod ()
+	{
+		Test a;
+	}
+}", data.Document.Text);
+		}
+		
+		
+		[Test()]
+		public void TestYieldIndentation ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	Test TestMethod ()
+	{
+yield return null;
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.ClassBraceStyle = BraceStyle.EndOfLine;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test {
+	Test TestMethod ()
+	{
+		yield return null;
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestWhileIndentation ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	Test TestMethod ()
+	{
+while (true)
+;
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.ClassBraceStyle = BraceStyle.EndOfLine;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test {
+	Test TestMethod ()
+	{
+		while (true)
+			;
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestDoWhileIndentation ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test {
+	Test TestMethod ()
+	{
+do {
+} while (true);
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.ClassBraceStyle = BraceStyle.EndOfLine;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test {
+	Test TestMethod ()
+	{
+		do {
+		} while (true);
+	}
+}", data.Document.Text);
+		}
+		
+		
+		[Test()]
+		public void TestForeachBracketPlacement ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test TestMethod ()
+	{
+		foreach (var obj in col) {}
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.StatementBraceStyle = BraceStyle.EndOfLine;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		foreach (var obj in col) {
+		}
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestForeachBracketPlacement2 ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test TestMethod ()
+	{
+		foreach (var obj in col) {;}
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.StatementBraceStyle = BraceStyle.NextLineShifted2;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		foreach (var obj in col)
+			{
+				;
+			}
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestForEachBraceForcementAdd ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test TestMethod ()
+	{
+		foreach (var obj in col)
+		{
+		}
+		foreach (var obj in col) ;
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.StatementBraceStyle = BraceStyle.NextLine;
+			policy.ForEachBraceForcement = BraceForcement.AddBraces;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			
+			Console.WriteLine (data.Document.Text);
+			
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		foreach (var obj in col)
+		{
+		}
+		foreach (var obj in col)
+		{
+			;
+		}
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestForBraceForcementAdd ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test TestMethod ()
+	{
+		for (;;)
+		{
+		}
+		for (;;) ;
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.StatementBraceStyle = BraceStyle.NextLine;
+			policy.ForBraceForcement = BraceForcement.AddBraces;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		for (;;)
+		{
+		}
+		for (;;)
+		{
+			;
+		}
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestForEachBraceForcementRemove ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test TestMethod ()
+	{
+		foreach (var obj in col)
+		{
+			;
+			;
+		}
+		foreach (var obj in col)
+		{
+			;
+		}
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.StatementBraceStyle = BraceStyle.NextLine;
+			policy.ForEachBraceForcement = BraceForcement.RemoveBraces;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			
+			Console.WriteLine (data.Document.Text);
+			
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		foreach (var obj in col)
+		{
+			;
+			;
+		}
+		foreach (var obj in col)
+			;
+	}
+}", data.Document.Text);
+		}
+		
+		
+		[Test()]
+		public void TestIfBracketPlacement ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test TestMethod ()
+	{
+		if (true) {}
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.StatementBraceStyle = BraceStyle.EndOfLine;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		if (true) {
+		}
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestAllowIfBlockInline ()
+		{
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.StatementBraceStyle = BraceStyle.EndOfLine;
+			policy.AllowIfBlockInline = true;
+			
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test TestMethod ()
+	{
+		if (true) {}
+	}
+}";
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		if (true) {}
+	}
+}", data.Document.Text);
+			
+			
+			data.Document.Text = @"class Test
+{
+	Test TestMethod ()
+	{
+		if (true) { Foo (); }
+	}
+}";
+			
+			compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		if (true) { Foo (); }
+	}
+}", data.Document.Text);
+			
+			
+			data.Document.Text = @"class Test
+{
+	Test TestMethod ()
+	{
+		if (true) Foo ();
+	}
+}";
+			
+			compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		if (true) Foo ();
+	}
+}", data.Document.Text);
+			
+			
+			data.Document.Text = @"class Test
+{
+	Test TestMethod ()
+	{
+		if (true)
+			Foo ();
+	}
+}";
+			
+			compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		if (true)
+			Foo ();
+	}
+}", data.Document.Text);
+			
+			
+		}
+		
+		[Test()]
+		public void TestIfElseBracketPlacement ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test TestMethod ()
+	{
+		if (true) {} else {}
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.StatementBraceStyle = BraceStyle.EndOfLine;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		if (true) {
+		} else {
+		}
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestIfForcementRemove ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test TestMethod ()
+	{
+		if (true)
+		{
+			;
+			;
+		}
+		if (true)
+		{
+			;
+		}
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.StatementBraceStyle = BraceStyle.NextLine;
+			policy.IfElseBraceForcement = BraceForcement.RemoveBraces;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			
+			Console.WriteLine (data.Document.Text);
+			
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		if (true)
+		{
+			;
+			;
+		}
+		if (true)
+			;
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestElseOnNewLine ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test TestMethod ()
+	{
+		if (true) {
+			;
+		} else if (false) {
+			;
+		}
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.PlaceElseOnNewLine = true;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			
+			Console.WriteLine (data.Document.Text);
+			
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		if (true) {
+			;
+		}
+		else if (false) {
+			;
+		}
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestElseIfOnNewLine ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test TestMethod ()
+	{
+		if (true) {
+			;
+		} else if (false) {
+			;
+		}
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.PlaceElseIfOnNewLine = true;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		if (true) {
+			;
+		} else
+		if (false) {
+			;
+		}
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestElseOnNewLineOff ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test TestMethod ()
+	{
+		if (true) {
+			;
+		}
+		else if (false) {
+			;
+		}
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.PlaceElseOnNewLine = false;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			
+			Console.WriteLine (data.Document.Text);
+			
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		if (true) {
+			;
+		} else if (false) {
+			;
+		}
+	}
+}", data.Document.Text);
+		}
+		
+		
+		[Test()]
+		public void TestWhileForcementRemove ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test TestMethod ()
+	{
+		while (true)
+		{
+			;
+			;
+		}
+		while (true)
+		{
+			;
+		}
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.StatementBraceStyle = BraceStyle.NextLine;
+			policy.WhileBraceForcement = BraceForcement.RemoveBraces;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			
+			Console.WriteLine (data.Document.Text);
+			
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		while (true)
+		{
+			;
+			;
+		}
+		while (true)
+			;
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestFixedBracketPlacement ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test TestMethod ()
+	{
+		fixed (object* obj = &obj)
+
+;
+	}
+}";
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.StatementBraceStyle = BraceStyle.NextLineShifted;
+			policy.FixedBraceForcement = BraceForcement.AddBraces;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Console.WriteLine (data.Document.Text);
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		fixed (object* obj = &obj)
+			{
+			;
+			}
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestForBracketPlacement ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test TestMethod ()
+	{
+		for (;;) {;}
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.StatementBraceStyle = BraceStyle.EndOfLineWithoutSpace;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		for (;;){
+			;
+		}
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestCheckedBracketPlacement ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test TestMethod ()
+	{
+		checked {;}
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.StatementBraceStyle = BraceStyle.EndOfLineWithoutSpace;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		checked{
+			;
+		}
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestUncheckedBracketPlacement ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test TestMethod ()
+	{
+		unchecked {;}
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.StatementBraceStyle = BraceStyle.EndOfLineWithoutSpace;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		unchecked{
+			;
+		}
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestLockBracketPlacement ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test TestMethod ()
+	{
+		lock (this)
+		{
+			;
+		}
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.StatementBraceStyle = BraceStyle.EndOfLine;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		lock (this) {
+			;
+		}
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestUnsafeBracketPlacement ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test TestMethod ()
+	{
+		unsafe
+		{
+			;
+		}
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.StatementBraceStyle = BraceStyle.EndOfLine;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		unsafe {
+			;
+		}
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestUsingBracketPlacement ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test TestMethod ()
+	{
+		using (var e = new E())
+		{
+			;
+		}
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.StatementBraceStyle = BraceStyle.EndOfLine;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		using (var e = new E()) {
+			;
+		}
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestWhileBracketPlacement ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test TestMethod ()
+	{
+		while (true)
+		{
+			;
+		}
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.StatementBraceStyle = BraceStyle.EndOfLine;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		while (true) {
+			;
+		}
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestDoWhileBracketPlacement ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test TestMethod ()
+	{
+		do
+		{
+			;
+		} while (true);
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.StatementBraceStyle = BraceStyle.EndOfLine;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		do {
+			;
+		} while (true);
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestSwitchFormatting1 ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test TestMethod ()
+	{
+		switch (a) { case 1: case 2: DoSomething(); break; default: Foo (); break;}
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.IndentSwitchBody = true;
+			policy.IndentCaseBody = true;
+			policy.IndentBreakStatements = true;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		switch (a) {
+			case 1:
+			case 2:
+				DoSomething();
+				break;
+			default:
+				Foo ();
+				break;
+		}
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestSwitchFormatting2 ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test TestMethod ()
+	{
+		switch (a) { case 1: case 2: DoSomething(); break; default: Foo (); break;}
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.IndentSwitchBody = false;
+			policy.IndentCaseBody = false;
+			policy.IndentBreakStatements = false;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		switch (a) {
+		case 1:
+		case 2:
+		DoSomething();
+		break;
+		default:
+		Foo ();
+		break;
+		}
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestTryCatchBracketPlacement ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test TestMethod ()
+	{
+		try { ; } catch (Exception e) { } finally { }
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.StatementBraceStyle = BraceStyle.EndOfLine;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			
+			Console.WriteLine (data.Document.Text);
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		try {
+			;
+		} catch (Exception e) {
+		} finally {
+		}
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestPlaceCatchOnNewLine ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test TestMethod ()
+	{
+		try {
+			;
+		} catch (Exception e) {
+		} finally {
+		}
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.PlaceCatchOnNewLine = true;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			
+			Console.WriteLine (data.Document.Text);
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		try {
+			;
+		}
+		catch (Exception e) {
+		} finally {
+		}
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestPlaceFinallyOnNewLine ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test TestMethod ()
+	{
+		try {
+			;
+		} catch (Exception e) {
+		} finally {
+		}
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.PlaceFinallyOnNewLine = true;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			
+			Console.WriteLine (data.Document.Text);
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		try {
+			;
+		} catch (Exception e) {
+		}
+		finally {
+		}
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestPlaceWhileOnNewLine ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = @"class Test
+{
+	Test TestMethod ()
+	{
+		do {
+			;
+		} while (true);
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			policy.PlaceWhileOnNewLine = true;
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			
+			Console.WriteLine (data.Document.Text);
+			Assert.AreEqual (@"class Test
+{
+	Test TestMethod ()
+	{
+		do {
+			;
+		}
+		while (true);
+	}
+}", data.Document.Text);
+		}
+		
+	}
+}*/
diff --git a/ICSharpCode.NRefactory.Tests/FormattingTests/TestTypeLevelIndentation.cs b/ICSharpCode.NRefactory.Tests/FormattingTests/TestTypeLevelIndentation.cs
new file mode 100644
index 0000000000..c41489eb52
--- /dev/null
+++ b/ICSharpCode.NRefactory.Tests/FormattingTests/TestTypeLevelIndentation.cs
@@ -0,0 +1,500 @@
+// 
+// TestTypeLevelIndentation.cs
+//   
+// Author:
+//       Mike Krüger <mkrueger@novell.com>
+// 
+// Copyright (c) 2010 Novell, Inc (http://www.novell.com)
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+/*
+using System;
+using NUnit.Framework;
+using MonoDevelop.Ide.Gui;
+using MonoDevelop.Projects;
+using MonoDevelop.Core;
+using MonoDevelop.Ide.CodeCompletion;
+using MonoDevelop.Ide.Gui.Content;
+using MonoDevelop.Projects.Dom.Parser;
+using MonoDevelop.CSharp.Parser;
+using MonoDevelop.CSharp.Resolver;
+using MonoDevelop.CSharp.Completion;
+using Mono.TextEditor;
+using MonoDevelop.CSharp.Formatting;
+
+namespace MonoDevelop.CSharpBinding.FormattingTests
+{
+	[TestFixture()]
+	public class TestTypeLevelIndentation : UnitTests.TestBase
+	{
+		[Test()]
+		public void TestClassIndentation ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = 
+@"			class Test {}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.ClassBraceStyle =  BraceStyle.DoNotChange;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test {}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestIndentClassBody ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = 
+@"class Test
+{
+				Test a;
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.IndentClassBody = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+	Test a;
+}", data.Document.Text);
+			policy.IndentClassBody = false;
+			compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+Test a;
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestIndentInterfaceBody ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = 
+@"interface Test
+{
+				Test Foo ();
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.IndentInterfaceBody = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"interface Test
+{
+	Test Foo ();
+}", data.Document.Text);
+			policy.IndentInterfaceBody = false;
+			compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"interface Test
+{
+Test Foo ();
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestIndentStructBody ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = 
+@"struct Test
+{
+				Test a;
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.IndentStructBody = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"struct Test
+{
+	Test a;
+}", data.Document.Text);
+			policy.IndentStructBody = false;
+			compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"struct Test
+{
+Test a;
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestIndentEnumBody ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = 
+@"enum Test
+{
+								A
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.IndentEnumBody = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"enum Test
+{
+	A
+}", data.Document.Text);
+			policy.IndentEnumBody = false;
+			compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"enum Test
+{
+A
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestIndentMethodBody ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = 
+@"class Test
+{
+	Test Foo ()
+	{
+;
+								;
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.IndentMethodBody = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+	Test Foo ()
+	{
+		;
+		;
+	}
+}", data.Document.Text);
+			policy.IndentMethodBody = false;
+			compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+	Test Foo ()
+	{
+	;
+	;
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestIndentMethodBodyOperatorCase ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = 
+@"class Test
+{
+	static Test operator+(Test left, Test right)
+	{
+;
+								;
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.IndentMethodBody = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+	static Test operator+(Test left, Test right)
+	{
+		;
+		;
+	}
+}", data.Document.Text);
+			policy.IndentMethodBody = false;
+			compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+	static Test operator+(Test left, Test right)
+	{
+	;
+	;
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestIndentPropertyBody ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = 
+@"class Test
+{
+	Test TestMe {
+			get;
+set;
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.IndentPropertyBody = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+	Test TestMe {
+		get;
+		set;
+	}
+}", data.Document.Text);
+			policy.IndentPropertyBody = false;
+			compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+	Test TestMe {
+	get;
+	set;
+	}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestIndentPropertyBodyIndexerCase ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = 
+@"class Test
+{
+	Test this[int a] {
+			get {
+	return null;
+}
+set {
+	;
+}
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.IndentPropertyBody = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+	Test this[int a] {
+		get {
+			return null;
+		}
+		set {
+			;
+		}
+	}
+}", data.Document.Text);
+			policy.IndentPropertyBody = false;
+			compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+	Test this[int a] {
+	get {
+		return null;
+	}
+	set {
+		;
+	}
+	}
+}", data.Document.Text);
+		}
+		
+		
+		[Test()]
+		[Ignore("currently failing because namespaces are not inserted")]
+		public void TestIndentNamespaceBody ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = 
+@"			namespace Test {
+class FooBar {}
+		}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.ClassBraceStyle =  BraceStyle.DoNotChange;
+			policy.IndentNamespaceBody = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"namespace Test {
+	class FooBar {}
+}", data.Document.Text);
+			
+			policy.IndentNamespaceBody = false;
+			compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"namespace Test {
+class FooBar {}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestMethodIndentation ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = 
+@"class Test
+{
+MyType TestMethod () {}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.MethodBraceStyle =  BraceStyle.DoNotChange;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+	MyType TestMethod () {}
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestPropertyIndentation ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = 
+@"class Test
+{
+				public int Prop { get; set; }
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.PropertyBraceStyle =  BraceStyle.DoNotChange;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+	public int Prop { get; set; }
+}", data.Document.Text);
+		}
+		
+		[Test()]
+		public void TestPropertyIndentationCase2 ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = 
+@"class Test
+{
+				public int Prop {
+ get;
+set;
+}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+	public int Prop {
+		get;
+		set;
+	}
+}", data.Document.Text);
+		}
+		
+		
+		[Test()]
+		public void TestIndentEventBody ()
+		{
+			TextEditorData data = new TextEditorData ();
+			data.Document.FileName = "a.cs";
+			data.Document.Text = 
+@"class Test
+{
+	public event EventHandler TestMe {
+								add {
+							;
+						}
+remove {
+	;
+}
+	}
+}";
+			
+			CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
+			policy.IndentEventBody = true;
+			
+			CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+	public event EventHandler TestMe {
+		add {
+			;
+		}
+		remove {
+			;
+		}
+	}
+}", data.Document.Text);
+			policy.IndentEventBody = false;
+			compilationUnit = new CSharpParser ().Parse (data);
+			compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
+			Assert.AreEqual (@"class Test
+{
+	public event EventHandler TestMe {
+	add {
+		;
+	}
+	remove {
+		;
+	}
+	}
+}", data.Document.Text);
+		}
+	}
+}*/