← Back to branch summary

~ubuntu-branches/ubuntu/quantal/monodevelop/quantal

« back to all changes in this revision

Viewing changes to tests/UnitTests/MonoDevelop.CSharpBinding/TestStatementIndentation.cs

  • Committer: Bazaar Package Importer
  • Author(s): Andrew Mitchell
  • Date: 2011-06-29 06:56:25 UTC
  • mfrom: (1.8.1 upstream) (1.3.11 experimental)
  • Revision ID: james.westby@ubuntu.com-20110629065625-7xx19c4vb95j65pl
Tags: 2.5.92+dfsg-1ubuntu1
* Merge from Debian experimental:
 - Dropped patches & changes to debian/control for Moonlight
   + debian/patches/remove_support_for_moonlight.patch,
   + debian/patches/dont_add_moonlight_to_core_addins.patch,
 - Remaining patches:
   + debian/patches/no_appmenu:

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/UnitTests/MonoDevelop.CSharpBinding/TestStatementIndentation.cs
23
23
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24
24
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25
25
// THE SOFTWARE.
26
 
/*
 
26
 
27
27
using System;
28
28
using NUnit.Framework;
29
29
using MonoDevelop.Ide.Gui;
58
58
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
59
59
                        
60
60
                        policy.ClassBraceStyle = BraceStyle.EndOfLine;
61
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
62
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
61
                        var compilationUnit = new CSharpParser ().Parse (data);
 
62
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
63
63
                        Assert.AreEqual (@"class Test {
64
64
        Test TestMethod ()
65
65
        {
85
85
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
86
86
                        
87
87
                        policy.IndentBlocks = true;
88
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
89
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
88
                        var compilationUnit = new CSharpParser ().Parse (data);
 
89
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
90
90
                        Assert.AreEqual (@"class Test
91
91
{
92
92
        Test TestMethod ()
98
98
}", data.Document.Text);
99
99
                        policy.IndentBlocks = false;
100
100
                        compilationUnit = new CSharpParser ().Parse (data);
101
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
101
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
102
102
                        
103
103
                        Assert.AreEqual (@"class Test
104
104
{
127
127
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
128
128
                        
129
129
                        policy.ClassBraceStyle = BraceStyle.EndOfLine;
130
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
131
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
130
                        var compilationUnit = new CSharpParser ().Parse (data);
 
131
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
132
132
                        Assert.AreEqual (@"class Test {
133
133
        Test TestMethod ()
134
134
        {
153
153
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
154
154
                        
155
155
                        policy.ClassBraceStyle = BraceStyle.EndOfLine;
156
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
157
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
156
                        var compilationUnit = new CSharpParser ().Parse (data);
 
157
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
158
158
                        Assert.AreEqual (@"class Test {
159
159
        Test TestMethod ()
160
160
        {
179
179
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
180
180
                        
181
181
                        policy.ClassBraceStyle = BraceStyle.EndOfLine;
182
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
183
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
182
                        var compilationUnit = new CSharpParser ().Parse (data);
 
183
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
 
184
 
184
185
                        Assert.AreEqual (@"class Test {
185
186
        Test TestMethod ()
186
187
        {
187
 
                base.FooBar();
 
188
                base.FooBar ();
188
189
        }
189
190
}", data.Document.Text);
190
191
                }
205
206
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
206
207
                        
207
208
                        policy.ClassBraceStyle = BraceStyle.EndOfLine;
208
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
209
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
209
                        var compilationUnit = new CSharpParser ().Parse (data);
 
210
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
210
211
                        Assert.AreEqual (@"class Test {
211
212
        Test TestMethod ()
212
213
        {
231
232
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
232
233
                        
233
234
                        policy.ClassBraceStyle = BraceStyle.EndOfLine;
234
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
235
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
235
                        var compilationUnit = new CSharpParser ().Parse (data);
 
236
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
236
237
                        Assert.AreEqual (@"class Test {
237
238
        Test TestMethod ()
238
239
        {
256
257
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
257
258
                        
258
259
                        policy.ClassBraceStyle = BraceStyle.EndOfLine;
259
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
260
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
260
                        var compilationUnit = new CSharpParser ().Parse (data);
 
261
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
261
262
                        Assert.AreEqual (@"class Test {
262
263
        Test TestMethod ()
263
264
        {
282
283
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
283
284
                        
284
285
                        policy.ClassBraceStyle = BraceStyle.EndOfLine;
285
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
286
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
286
                        var compilationUnit = new CSharpParser ().Parse (data);
 
287
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
287
288
                        Assert.AreEqual (@"class Test {
288
289
        Test TestMethod ()
289
290
        {
312
313
                        
313
314
                        policy.StatementBraceStyle = BraceStyle.EndOfLine;
314
315
                        policy.FixedBraceForcement = BraceForcement.AddBraces;
315
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
316
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
316
                        var compilationUnit = new CSharpParser ().Parse (data);
 
317
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
317
318
                        
318
319
                        Assert.AreEqual (@"class Test
319
320
{
345
346
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
346
347
                        
347
348
                        policy.StatementBraceStyle = BraceStyle.EndOfLine;
348
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
349
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
349
                        var compilationUnit = new CSharpParser ().Parse (data);
 
350
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
350
351
                        Assert.AreEqual (@"class Test
351
352
{
352
353
        Test TestMethod ()
373
374
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
374
375
                        
375
376
                        policy.ClassBraceStyle = BraceStyle.EndOfLine;
376
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
377
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
377
                        var compilationUnit = new CSharpParser ().Parse (data);
 
378
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
378
379
                        Assert.AreEqual (@"class Test {
379
380
        Test TestMethod ()
380
381
        {
399
400
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
400
401
                        
401
402
                        policy.ClassBraceStyle = BraceStyle.EndOfLine;
402
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
403
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
403
                        var compilationUnit = new CSharpParser ().Parse (data);
 
404
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
404
405
                        Assert.AreEqual (@"class Test {
405
406
        Test TestMethod ()
406
407
        {
424
425
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
425
426
                        
426
427
                        policy.ClassBraceStyle = BraceStyle.EndOfLine;
427
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
428
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
428
                        var compilationUnit = new CSharpParser ().Parse (data);
 
429
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
429
430
                        Assert.AreEqual (@"class Test {
430
431
        Test TestMethod ()
431
432
        {
450
451
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
451
452
                        
452
453
                        policy.ClassBraceStyle = BraceStyle.EndOfLine;
453
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
454
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
454
                        var compilationUnit = new CSharpParser ().Parse (data);
 
455
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
455
456
                        Assert.AreEqual (@"class Test {
456
457
        Test TestMethod ()
457
458
        {
477
478
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
478
479
                        
479
480
                        policy.ClassBraceStyle = BraceStyle.EndOfLine;
480
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
481
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
481
                        var compilationUnit = new CSharpParser ().Parse (data);
 
482
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
482
483
                        Assert.AreEqual (@"class Test {
483
484
        Test TestMethod ()
484
485
        {
503
504
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
504
505
                        
505
506
                        policy.ClassBraceStyle = BraceStyle.EndOfLine;
506
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
507
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
507
                        var compilationUnit = new CSharpParser ().Parse (data);
 
508
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
508
509
                        Assert.AreEqual (@"class Test {
509
510
        Test TestMethod ()
510
511
        {
530
531
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
531
532
                        
532
533
                        policy.ClassBraceStyle = BraceStyle.EndOfLine;
533
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
534
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
534
                        var compilationUnit = new CSharpParser ().Parse (data);
 
535
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
535
536
                        Assert.AreEqual (@"class Test {
536
537
        Test TestMethod ()
537
538
        {
560
561
                        
561
562
                        policy.StatementBraceStyle = BraceStyle.EndOfLine;
562
563
                        policy.UsingBraceForcement = BraceForcement.AddBraces;
563
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
564
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
564
                        var compilationUnit = new CSharpParser ().Parse (data);
 
565
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
565
566
                        
566
567
                        Assert.AreEqual (@"class Test
567
568
{
595
596
                        
596
597
                        policy.StatementBraceStyle = BraceStyle.EndOfLine;
597
598
                        policy.UsingBraceForcement = BraceForcement.DoNotChange;
598
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
599
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
599
                        var compilationUnit = new CSharpParser ().Parse (data);
 
600
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
600
601
                        
601
602
                        Assert.AreEqual (@"class Test
602
603
{
610
611
}", data.Document.Text);
611
612
                }
612
613
                
 
614
                [Test()]
 
615
                public void TestUsingAlignment ()
 
616
                {
 
617
                        TextEditorData data = new TextEditorData ();
 
618
                        data.Document.FileName = "a.cs";
 
619
                        data.Document.Text = @"class Test {
 
620
        Test TestMethod ()
 
621
        {
 
622
using (var p = new MyObj())
 
623
using (var o = new MyObj()) {
 
624
}
 
625
        }
 
626
}";
 
627
                        
 
628
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
 
629
                        policy.AlignEmbeddedUsingStatements = true;
 
630
                        policy.ClassBraceStyle = BraceStyle.EndOfLine;
 
631
                        var compilationUnit = new CSharpParser ().Parse (data);
 
632
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
 
633
                        Assert.AreEqual (@"class Test {
 
634
        Test TestMethod ()
 
635
        {
 
636
                using (var p = new MyObj())
 
637
                using (var o = new MyObj()) {
 
638
                }
 
639
        }
 
640
}", data.Document.Text);
 
641
                        policy.AlignEmbeddedUsingStatements = false;
 
642
                        compilationUnit = new CSharpParser ().Parse (data);
 
643
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
 
644
                        Assert.AreEqual (@"class Test {
 
645
        Test TestMethod ()
 
646
        {
 
647
                using (var p = new MyObj())
 
648
                        using (var o = new MyObj()) {
 
649
                        }
 
650
        }
 
651
}", data.Document.Text);
 
652
                }
613
653
                
614
654
                [Test()]
615
655
                public void TestVariableDeclarationIndentation ()
624
664
}";
625
665
                        
626
666
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
627
 
                        Console.WriteLine (data.Document.Text);
628
667
                        policy.ClassBraceStyle = BraceStyle.EndOfLine;
629
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
630
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
668
                        var compilationUnit = new CSharpParser ().Parse (data);
 
669
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
631
670
                        Assert.AreEqual (@"class Test {
632
671
        Test TestMethod ()
633
672
        {
636
675
}", data.Document.Text);
637
676
                }
638
677
                
 
678
                [Test()]
 
679
                public void TestConstantVariableDeclarationIndentation ()
 
680
                {
 
681
                        TextEditorData data = new TextEditorData ();
 
682
                        data.Document.FileName = "a.cs";
 
683
                        data.Document.Text = @"class Test {
 
684
        Test TestMethod ()
 
685
        {
 
686
const int a = 5;
 
687
        }
 
688
}";
 
689
                        
 
690
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
 
691
                        policy.ClassBraceStyle = BraceStyle.EndOfLine;
 
692
                        var compilationUnit = new CSharpParser ().Parse (data);
 
693
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
 
694
                        Assert.AreEqual (@"class Test {
 
695
        Test TestMethod ()
 
696
        {
 
697
                const int a = 5;
 
698
        }
 
699
}", data.Document.Text);
 
700
                }
639
701
                
640
702
                [Test()]
641
703
                public void TestYieldIndentation ()
652
714
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
653
715
                        
654
716
                        policy.ClassBraceStyle = BraceStyle.EndOfLine;
655
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
656
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
717
                        var compilationUnit = new CSharpParser ().Parse (data);
 
718
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
657
719
                        Assert.AreEqual (@"class Test {
658
720
        Test TestMethod ()
659
721
        {
678
740
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
679
741
                        
680
742
                        policy.ClassBraceStyle = BraceStyle.EndOfLine;
681
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
682
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
743
                        var compilationUnit = new CSharpParser ().Parse (data);
 
744
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
683
745
                        Assert.AreEqual (@"class Test {
684
746
        Test TestMethod ()
685
747
        {
705
767
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
706
768
                        
707
769
                        policy.ClassBraceStyle = BraceStyle.EndOfLine;
708
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
709
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
770
                        var compilationUnit = new CSharpParser ().Parse (data);
 
771
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
710
772
                        Assert.AreEqual (@"class Test {
711
773
        Test TestMethod ()
712
774
        {
733
795
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
734
796
                        
735
797
                        policy.StatementBraceStyle = BraceStyle.EndOfLine;
736
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
737
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
798
                        var compilationUnit = new CSharpParser ().Parse (data);
 
799
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
738
800
                        Assert.AreEqual (@"class Test
739
801
{
740
802
        Test TestMethod ()
761
823
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
762
824
                        
763
825
                        policy.StatementBraceStyle = BraceStyle.NextLineShifted2;
764
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
765
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
826
                        var compilationUnit = new CSharpParser ().Parse (data);
 
827
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
766
828
                        Assert.AreEqual (@"class Test
767
829
{
768
830
        Test TestMethod ()
795
857
                        
796
858
                        policy.StatementBraceStyle = BraceStyle.NextLine;
797
859
                        policy.ForEachBraceForcement = BraceForcement.AddBraces;
798
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
799
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
800
 
                        
801
 
                        Console.WriteLine (data.Document.Text);
 
860
                        var compilationUnit = new CSharpParser ().Parse (data);
 
861
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
802
862
                        
803
863
                        Assert.AreEqual (@"class Test
804
864
{
835
895
                        
836
896
                        policy.StatementBraceStyle = BraceStyle.NextLine;
837
897
                        policy.ForBraceForcement = BraceForcement.AddBraces;
838
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
839
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
898
                        var compilationUnit = new CSharpParser ().Parse (data);
 
899
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
840
900
                        
841
901
                        Assert.AreEqual (@"class Test
842
902
{
878
938
                        
879
939
                        policy.StatementBraceStyle = BraceStyle.NextLine;
880
940
                        policy.ForEachBraceForcement = BraceForcement.RemoveBraces;
881
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
882
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
883
 
                        
884
 
                        Console.WriteLine (data.Document.Text);
 
941
                        var compilationUnit = new CSharpParser ().Parse (data);
 
942
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
885
943
                        
886
944
                        Assert.AreEqual (@"class Test
887
945
{
915
973
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
916
974
                        
917
975
                        policy.StatementBraceStyle = BraceStyle.EndOfLine;
918
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
919
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
976
                        var compilationUnit = new CSharpParser ().Parse (data);
 
977
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
920
978
                        Assert.AreEqual (@"class Test
921
979
{
922
980
        Test TestMethod ()
944
1002
        }
945
1003
}";
946
1004
                        
947
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
948
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
1005
                        var compilationUnit = new CSharpParser ().Parse (data);
 
1006
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
949
1007
                        Assert.AreEqual (@"class Test
950
1008
{
951
1009
        Test TestMethod ()
964
1022
}";
965
1023
                        
966
1024
                        compilationUnit = new CSharpParser ().Parse (data);
967
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
1025
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
968
1026
                        Assert.AreEqual (@"class Test
969
1027
{
970
1028
        Test TestMethod ()
983
1041
}";
984
1042
                        
985
1043
                        compilationUnit = new CSharpParser ().Parse (data);
986
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
1044
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
987
1045
                        Assert.AreEqual (@"class Test
988
1046
{
989
1047
        Test TestMethod ()
1003
1061
}";
1004
1062
                        
1005
1063
                        compilationUnit = new CSharpParser ().Parse (data);
1006
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
1064
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
1007
1065
                        Assert.AreEqual (@"class Test
1008
1066
{
1009
1067
        Test TestMethod ()
1032
1090
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
1033
1091
                        
1034
1092
                        policy.StatementBraceStyle = BraceStyle.EndOfLine;
1035
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
1036
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
1093
                        var compilationUnit = new CSharpParser ().Parse (data);
 
1094
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
1037
1095
                        Assert.AreEqual (@"class Test
1038
1096
{
1039
1097
        Test TestMethod ()
1070
1128
                        
1071
1129
                        policy.StatementBraceStyle = BraceStyle.NextLine;
1072
1130
                        policy.IfElseBraceForcement = BraceForcement.RemoveBraces;
1073
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
1074
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
1075
 
                        
1076
 
                        Console.WriteLine (data.Document.Text);
1077
 
                        
1078
 
                        Assert.AreEqual (@"class Test
1079
 
{
1080
 
        Test TestMethod ()
1081
 
        {
1082
 
                if (true)
1083
 
                {
1084
 
                        ;
1085
 
                        ;
1086
 
                }
1087
 
                if (true)
1088
 
                        ;
 
1131
                        var compilationUnit = new CSharpParser ().Parse (data);
 
1132
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
 
1133
                        
 
1134
                        Assert.AreEqual (@"class Test
 
1135
{
 
1136
        Test TestMethod ()
 
1137
        {
 
1138
                if (true)
 
1139
                {
 
1140
                        ;
 
1141
                        ;
 
1142
                }
 
1143
                if (true)
 
1144
                        ;
 
1145
        }
 
1146
}", data.Document.Text);
 
1147
                }
 
1148
                
 
1149
                [Test()]
 
1150
                public void TestIfAlignment ()
 
1151
                {
 
1152
                        TextEditorData data = new TextEditorData ();
 
1153
                        data.Document.FileName = "a.cs";
 
1154
                        data.Document.Text = @"class Test {
 
1155
        Test TestMethod ()
 
1156
        {
 
1157
if (a)
 
1158
if (b) {
 
1159
}
 
1160
        }
 
1161
}";
 
1162
                        
 
1163
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
 
1164
                        policy.AlignEmbeddedIfStatements = true;
 
1165
                        policy.ClassBraceStyle = BraceStyle.EndOfLine;
 
1166
                        var compilationUnit = new CSharpParser ().Parse (data);
 
1167
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
 
1168
                        Assert.AreEqual (@"class Test {
 
1169
        Test TestMethod ()
 
1170
        {
 
1171
                if (a)
 
1172
                if (b) {
 
1173
                }
 
1174
        }
 
1175
}", data.Document.Text);
 
1176
                        policy.AlignEmbeddedIfStatements = false;
 
1177
                        compilationUnit = new CSharpParser ().Parse (data);
 
1178
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
 
1179
                        Assert.AreEqual (@"class Test {
 
1180
        Test TestMethod ()
 
1181
        {
 
1182
                if (a)
 
1183
                        if (b) {
 
1184
                        }
 
1185
        }
 
1186
}", data.Document.Text);
 
1187
                }
 
1188
                
 
1189
                
 
1190
                [Test()]
 
1191
                public void TestIfForcementAdd ()
 
1192
                {
 
1193
                        TextEditorData data = new TextEditorData ();
 
1194
                        data.Document.FileName = "a.cs";
 
1195
                        data.Document.Text = @"class Test
 
1196
{
 
1197
        void TestMethod ()
 
1198
        {
 
1199
                if (true)
 
1200
                        Call ();
 
1201
        }
 
1202
}";
 
1203
                        
 
1204
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
 
1205
                        
 
1206
                        policy.StatementBraceStyle = BraceStyle.EndOfLine;
 
1207
                        policy.IfElseBraceForcement = BraceForcement.AddBraces;
 
1208
                        var compilationUnit = new CSharpParser ().Parse (data);
 
1209
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
 
1210
                        Assert.AreEqual (@"class Test
 
1211
{
 
1212
        void TestMethod ()
 
1213
        {
 
1214
                if (true) {
 
1215
                        Call ();
 
1216
                }
 
1217
        }
 
1218
}", data.Document.Text);
 
1219
                }
 
1220
                
 
1221
                static void TestErrors (CSharpParser parser)
 
1222
                {
 
1223
                        foreach (var error in parser.ErrorReportPrinter.Errors) {
 
1224
                                Console.WriteLine (error.Message);
 
1225
                        }
 
1226
                        Assert.AreEqual (0, parser.ErrorReportPrinter.ErrorsCount);
 
1227
                }
 
1228
                
 
1229
                [Test()]
 
1230
                public void TestIfForcementWithComment ()
 
1231
                {
 
1232
                        TextEditorData data = new TextEditorData ();
 
1233
                        data.Document.FileName = "a.cs";
 
1234
                        data.Document.Text = @"class Test
 
1235
{
 
1236
        void TestMethod ()
 
1237
        {
 
1238
                if (true) // TestComment
 
1239
                        Call ();
 
1240
        }
 
1241
}";
 
1242
                        
 
1243
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
 
1244
                        
 
1245
                        policy.StatementBraceStyle = BraceStyle.EndOfLine;
 
1246
                        policy.IfElseBraceForcement = BraceForcement.AddBraces;
 
1247
                        CSharpParser parser = new CSharpParser ();
 
1248
                        var compilationUnit = parser.Parse (data);
 
1249
                        TestErrors (parser);
 
1250
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
 
1251
                        Assert.AreEqual (@"class Test
 
1252
{
 
1253
        void TestMethod ()
 
1254
        {
 
1255
                if (true) {
 
1256
                        // TestComment
 
1257
                        Call ();
 
1258
                }
 
1259
        }
 
1260
}", data.Document.Text);
 
1261
                }
 
1262
                
 
1263
                [Test()]
 
1264
                public void TestIfElseForcementAdd ()
 
1265
                {
 
1266
                        TextEditorData data = new TextEditorData ();
 
1267
                        data.Document.FileName = "a.cs";
 
1268
                        data.Document.Text = @"class Test
 
1269
{
 
1270
        void TestMethod ()
 
1271
        {
 
1272
                if (true)
 
1273
                        Call ();
 
1274
                else
 
1275
                        Call2 ();
 
1276
        }
 
1277
}";
 
1278
                        
 
1279
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
 
1280
                        
 
1281
                        policy.StatementBraceStyle = BraceStyle.EndOfLine;
 
1282
                        policy.IfElseBraceForcement = BraceForcement.AddBraces;
 
1283
                        var compilationUnit = new CSharpParser ().Parse (data);
 
1284
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
 
1285
                        Assert.AreEqual (@"class Test
 
1286
{
 
1287
        void TestMethod ()
 
1288
        {
 
1289
                if (true) {
 
1290
                        Call ();
 
1291
                } else {
 
1292
                        Call2 ();
 
1293
                }
 
1294
        }
 
1295
}", data.Document.Text);
 
1296
                }
 
1297
                
 
1298
                [Test()]
 
1299
                public void TestIfElseIFForcementAdd ()
 
1300
                {
 
1301
                        TextEditorData data = new TextEditorData ();
 
1302
                        data.Document.FileName = "a.cs";
 
1303
                        data.Document.Text = @"class Test
 
1304
{
 
1305
        void TestMethod ()
 
1306
        {
 
1307
                if (true)
 
1308
                        Call ();
 
1309
                else if (false)
 
1310
                        Call2 ();
 
1311
        }
 
1312
}";
 
1313
                        
 
1314
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
 
1315
                        
 
1316
                        policy.StatementBraceStyle = BraceStyle.EndOfLine;
 
1317
                        policy.IfElseBraceForcement = BraceForcement.AddBraces;
 
1318
                        var compilationUnit = new CSharpParser ().Parse (data);
 
1319
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
 
1320
                        Assert.AreEqual (@"class Test
 
1321
{
 
1322
        void TestMethod ()
 
1323
        {
 
1324
                if (true) {
 
1325
                        Call ();
 
1326
                } else if (false) {
 
1327
                        Call2 ();
 
1328
                }
1089
1329
        }
1090
1330
}", data.Document.Text);
1091
1331
                }
1109
1349
                        
1110
1350
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
1111
1351
                        policy.PlaceElseOnNewLine = true;
1112
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
1113
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
1114
 
                        
1115
 
                        Console.WriteLine (data.Document.Text);
 
1352
                        var compilationUnit = new CSharpParser ().Parse (data);
 
1353
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
1116
1354
                        
1117
1355
                        Assert.AreEqual (@"class Test
1118
1356
{
1147
1385
                        
1148
1386
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
1149
1387
                        policy.PlaceElseIfOnNewLine = true;
1150
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
1151
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
1388
                        var compilationUnit = new CSharpParser ().Parse (data);
 
1389
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
1152
1390
                        
1153
1391
                        Assert.AreEqual (@"class Test
1154
1392
{
1184
1422
                        
1185
1423
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
1186
1424
                        policy.PlaceElseOnNewLine = false;
1187
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
1188
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
1189
 
                        
1190
 
                        Console.WriteLine (data.Document.Text);
 
1425
                        var compilationUnit = new CSharpParser ().Parse (data);
 
1426
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
1191
1427
                        
1192
1428
                        Assert.AreEqual (@"class Test
1193
1429
{
1202
1438
}", data.Document.Text);
1203
1439
                }
1204
1440
                
 
1441
                [Test()]
 
1442
                public void TestSimpleIfElseComment ()
 
1443
                {
 
1444
                        TextEditorData data = new TextEditorData ();
 
1445
                        data.Document.FileName = "a.cs";
 
1446
                        data.Document.Text = @"class Test
 
1447
{
 
1448
        void TestMethod ()
 
1449
        {
 
1450
                if (true) Call (); else Call ();
 
1451
        }
 
1452
}";
 
1453
                        
 
1454
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
 
1455
                        
 
1456
                        policy.StatementBraceStyle = BraceStyle.EndOfLine;
 
1457
                        policy.PlaceElseIfOnNewLine = false; // for simple statements it must be new line.
 
1458
                        var compilationUnit = new CSharpParser ().Parse (data);
 
1459
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
 
1460
                        Assert.AreEqual (@"class Test
 
1461
{
 
1462
        void TestMethod ()
 
1463
        {
 
1464
                if (true)
 
1465
                        Call ();
 
1466
                else
 
1467
                        Call ();
 
1468
        }
 
1469
}", data.Document.Text);
 
1470
                }
1205
1471
                
1206
1472
                [Test()]
1207
1473
                public void TestWhileForcementRemove ()
1228
1494
                        
1229
1495
                        policy.StatementBraceStyle = BraceStyle.NextLine;
1230
1496
                        policy.WhileBraceForcement = BraceForcement.RemoveBraces;
1231
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
1232
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
1233
 
                        
1234
 
                        Console.WriteLine (data.Document.Text);
 
1497
                        var compilationUnit = new CSharpParser ().Parse (data);
 
1498
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
1235
1499
                        
1236
1500
                        Assert.AreEqual (@"class Test
1237
1501
{
1266
1530
                        
1267
1531
                        policy.StatementBraceStyle = BraceStyle.NextLineShifted;
1268
1532
                        policy.FixedBraceForcement = BraceForcement.AddBraces;
1269
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
1270
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
1271
 
                        Console.WriteLine (data.Document.Text);
 
1533
                        var compilationUnit = new CSharpParser ().Parse (data);
 
1534
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
1272
1535
                        Assert.AreEqual (@"class Test
1273
1536
{
1274
1537
        Test TestMethod ()
1297
1560
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
1298
1561
                        
1299
1562
                        policy.StatementBraceStyle = BraceStyle.EndOfLineWithoutSpace;
1300
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
1301
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
1563
                        var compilationUnit = new CSharpParser ().Parse (data);
 
1564
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
1302
1565
                        Assert.AreEqual (@"class Test
1303
1566
{
1304
1567
        Test TestMethod ()
1326
1589
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
1327
1590
                        
1328
1591
                        policy.StatementBraceStyle = BraceStyle.EndOfLineWithoutSpace;
1329
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
1330
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
1592
                        var compilationUnit = new CSharpParser ().Parse (data);
 
1593
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
1331
1594
                        Assert.AreEqual (@"class Test
1332
1595
{
1333
1596
        Test TestMethod ()
1355
1618
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
1356
1619
                        
1357
1620
                        policy.StatementBraceStyle = BraceStyle.EndOfLineWithoutSpace;
1358
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
1359
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
1621
                        var compilationUnit = new CSharpParser ().Parse (data);
 
1622
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
1360
1623
                        Assert.AreEqual (@"class Test
1361
1624
{
1362
1625
        Test TestMethod ()
1387
1650
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
1388
1651
                        
1389
1652
                        policy.StatementBraceStyle = BraceStyle.EndOfLine;
1390
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
1391
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
1653
                        var compilationUnit = new CSharpParser ().Parse (data);
 
1654
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
1392
1655
                        Assert.AreEqual (@"class Test
1393
1656
{
1394
1657
        Test TestMethod ()
1419
1682
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
1420
1683
                        
1421
1684
                        policy.StatementBraceStyle = BraceStyle.EndOfLine;
1422
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
1423
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
1685
                        var compilationUnit = new CSharpParser ().Parse (data);
 
1686
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
1424
1687
                        Assert.AreEqual (@"class Test
1425
1688
{
1426
1689
        Test TestMethod ()
1451
1714
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
1452
1715
                        
1453
1716
                        policy.StatementBraceStyle = BraceStyle.EndOfLine;
1454
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
1455
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
1717
                        var compilationUnit = new CSharpParser ().Parse (data);
 
1718
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
1456
1719
                        Assert.AreEqual (@"class Test
1457
1720
{
1458
1721
        Test TestMethod ()
1483
1746
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
1484
1747
                        
1485
1748
                        policy.StatementBraceStyle = BraceStyle.EndOfLine;
1486
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
1487
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
1749
                        var compilationUnit = new CSharpParser ().Parse (data);
 
1750
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
1488
1751
                        Assert.AreEqual (@"class Test
1489
1752
{
1490
1753
        Test TestMethod ()
1515
1778
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
1516
1779
                        
1517
1780
                        policy.StatementBraceStyle = BraceStyle.EndOfLine;
1518
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
1519
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
1781
                        var compilationUnit = new CSharpParser ().Parse (data);
 
1782
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
1520
1783
                        Assert.AreEqual (@"class Test
1521
1784
{
1522
1785
        Test TestMethod ()
1546
1809
                        policy.IndentSwitchBody = true;
1547
1810
                        policy.IndentCaseBody = true;
1548
1811
                        policy.IndentBreakStatements = true;
1549
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
1550
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
1812
                        var compilationUnit = new CSharpParser ().Parse (data);
 
1813
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
1551
1814
                        Assert.AreEqual (@"class Test
1552
1815
{
1553
1816
        Test TestMethod ()
1555
1818
                switch (a) {
1556
1819
                        case 1:
1557
1820
                        case 2:
1558
 
                                DoSomething();
 
1821
                                DoSomething ();
1559
1822
                                break;
1560
1823
                        default:
1561
1824
                                Foo ();
1583
1846
                        policy.IndentSwitchBody = false;
1584
1847
                        policy.IndentCaseBody = false;
1585
1848
                        policy.IndentBreakStatements = false;
1586
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
1587
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
1849
                        var compilationUnit = new CSharpParser ().Parse (data);
 
1850
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
1588
1851
                        Assert.AreEqual (@"class Test
1589
1852
{
1590
1853
        Test TestMethod ()
1592
1855
                switch (a) {
1593
1856
                case 1:
1594
1857
                case 2:
1595
 
                DoSomething();
 
1858
                DoSomething ();
1596
1859
                break;
1597
1860
                default:
1598
1861
                Foo ();
1618
1881
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
1619
1882
                        
1620
1883
                        policy.StatementBraceStyle = BraceStyle.EndOfLine;
1621
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
1622
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
1884
                        var compilationUnit = new CSharpParser ().Parse (data);
 
1885
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
1623
1886
                        
1624
 
                        Console.WriteLine (data.Document.Text);
1625
1887
                        Assert.AreEqual (@"class Test
1626
1888
{
1627
1889
        Test TestMethod ()
1655
1917
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
1656
1918
                        
1657
1919
                        policy.PlaceCatchOnNewLine = true;
1658
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
1659
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
1920
                        var compilationUnit = new CSharpParser ().Parse (data);
 
1921
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
1660
1922
                        
1661
 
                        Console.WriteLine (data.Document.Text);
1662
1923
                        Assert.AreEqual (@"class Test
1663
1924
{
1664
1925
        Test TestMethod ()
1693
1954
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
1694
1955
                        
1695
1956
                        policy.PlaceFinallyOnNewLine = true;
1696
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
1697
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
1957
                        var compilationUnit = new CSharpParser ().Parse (data);
 
1958
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
1698
1959
                        
1699
 
                        Console.WriteLine (data.Document.Text);
1700
1960
                        Assert.AreEqual (@"class Test
1701
1961
{
1702
1962
        Test TestMethod ()
1729
1989
                        CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
1730
1990
                        
1731
1991
                        policy.PlaceWhileOnNewLine = true;
1732
 
                        CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data);
1733
 
                        compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null);
 
1992
                        var compilationUnit = new CSharpParser ().Parse (data);
 
1993
                        compilationUnit.AcceptVisitor (new AstFormattingVisitor (policy, data), null);
1734
1994
                        
1735
 
                        Console.WriteLine (data.Document.Text);
1736
1995
                        Assert.AreEqual (@"class Test
1737
1996
{
1738
1997
        Test TestMethod ()
1746
2005
                }
1747
2006
                
1748
2007
        }
1749
 
}*/
 
2008
}