← Back to branch summary

~halega/+junk/sharpdevelop

« back to all changes in this revision

Viewing changes to src/Libraries/NRefactory/Test/Lexer/CSharp/PreprocessingTests.cs

  • Committer: sk
  • Date: 2011-09-10 05:17:57 UTC
  • Revision ID: halega@halega.com-20110910051757-qfouz1llya9m6boy
4.1.0.7915 Release Candidate 1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/Libraries/NRefactory/Test/Lexer/CSharp/PreprocessingTests.cs
 
1
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
 
2
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
3
 
 
4
using System;
 
5
using System.Collections.Generic;
 
6
using System.IO;
 
7
using NUnit.Framework;
 
8
using ICSharpCode.NRefactory.Parser;
 
9
using ICSharpCode.NRefactory.Parser.CSharp;
 
10
using ICSharpCode.NRefactory.PrettyPrinter;
 
11
 
 
12
namespace ICSharpCode.NRefactory.Tests.Lexer.CSharp
 
13
{
 
14
        [TestFixture]
 
15
        public class PreprocessingTests
 
16
        {
 
17
                ILexer GenerateLexer(string text)
 
18
                {
 
19
                        ILexer lexer = ParserFactory.CreateLexer(SupportedLanguage.CSharp, new StringReader(text));
 
20
                        lexer.EvaluateConditionalCompilation = true;
 
21
                        lexer.ConditionalCompilationSymbols["TEST"] = null;
 
22
                        return lexer;
 
23
                }
 
24
                
 
25
                int[] GetTokenKinds(string text)
 
26
                {
 
27
                        List<int> list = new List<int>();
 
28
                        ILexer lexer = GenerateLexer(text);
 
29
                        Token token;
 
30
                        while ((token = lexer.NextToken()) != null) {
 
31
                                list.Add(token.Kind);
 
32
                                if (token.Kind == Tokens.EOF)
 
33
                                        break;
 
34
                        }
 
35
                        Assert.AreEqual("", lexer.Errors.ErrorOutput);
 
36
                        return list.ToArray();
 
37
                }
 
38
                
 
39
                [Test]
 
40
                public void TestEmptyIfdef()
 
41
                {
 
42
                        Assert.AreEqual(new int[] { Tokens.Int, Tokens.EOF }, GetTokenKinds("#if true\n#endif\nint"));
 
43
                        Assert.AreEqual(new int[] { Tokens.Int, Tokens.EOF }, GetTokenKinds("#if false\n#endif\nint"));
 
44
                }
 
45
                
 
46
                [Test]
 
47
                public void TestBooleanPrimitives()
 
48
                {
 
49
                        Assert.AreEqual(new int[] { Tokens.True, Tokens.EOF }, GetTokenKinds("#if true \n true \n #else \n false \n #endif"));
 
50
                        Assert.AreEqual(new int[] { Tokens.False, Tokens.EOF }, GetTokenKinds("#if false \n true \n #else \n false \n #endif"));
 
51
                }
 
52
                
 
53
                [Test]
 
54
                public void TestDefinedSymbols()
 
55
                {
 
56
                        Assert.AreEqual(new int[] { Tokens.True, Tokens.EOF }, GetTokenKinds("#if TEST \n true \n #else \n false \n #endif"));
 
57
                        Assert.AreEqual(new int[] { Tokens.False, Tokens.EOF }, GetTokenKinds("#if DEBUG \n true \n #else \n false \n #endif"));
 
58
                }
 
59
                
 
60
                [Test]
 
61
                public void TestDefineUndefineSymbol()
 
62
                {
 
63
                        Assert.AreEqual(new int[] { Tokens.False, Tokens.EOF }, GetTokenKinds("#undef TEST \n #if TEST \n true \n #else \n false \n #endif"));
 
64
                        Assert.AreEqual(new int[] { Tokens.True, Tokens.EOF }, GetTokenKinds("#define DEBUG \n #if DEBUG \n true \n #else \n false \n #endif"));
 
65
                        Assert.AreEqual(new int[] { Tokens.True, Tokens.EOF }, GetTokenKinds("#define DEBUG // comment \n #if DEBUG \n true \n #else \n false \n #endif"));
 
66
                }
 
67
                
 
68
                [Test]
 
69
                public void TestNestedIfDef()
 
70
                {
 
71
                        string program = @"
 
72
                                #if A
 
73
                                        public
 
74
                                        #if B
 
75
                                                abstract
 
76
                                        #elif C
 
77
                                                virtual
 
78
                                        #endif
 
79
                                        void
 
80
                                #elif B
 
81
                                        protected
 
82
                                        #if C // this is a comment
 
83
                                                sealed
 
84
                                        #endif
 
85
                                        string
 
86
                                #else
 
87
                                        class
 
88
                                #endif
 
89
                        ";
 
90
                        Assert.AreEqual(new int[] { Tokens.Class, Tokens.EOF }, GetTokenKinds(program));
 
91
                        Assert.AreEqual(new int[] { Tokens.Public, Tokens.Void, Tokens.EOF }, GetTokenKinds("#define A\n" + program));
 
92
                        Assert.AreEqual(new int[] { Tokens.Public, Tokens.Abstract, Tokens.Void, Tokens.EOF },
 
93
                                        GetTokenKinds("#define A\n#define B\n" + program));
 
94
                        Assert.AreEqual(new int[] { Tokens.Public, Tokens.Virtual, Tokens.Void, Tokens.EOF },
 
95
                                        GetTokenKinds("#define A\n#define C\n" + program));
 
96
                        Assert.AreEqual(new int[] { Tokens.Public, Tokens.Abstract, Tokens.Void, Tokens.EOF },
 
97
                                        GetTokenKinds("#define A\n#define B\n#define C\n" + program));
 
98
                        Assert.AreEqual(new int[] { Tokens.Protected, Tokens.String, Tokens.EOF },
 
99
                                        GetTokenKinds("#define B\n" + program));
 
100
                        Assert.AreEqual(new int[] { Tokens.Protected, Tokens.Sealed, Tokens.String, Tokens.EOF },
 
101
                                        GetTokenKinds("#define B\n#define C\n" + program));
 
102
                }
 
103
                
 
104
                [Test]
 
105
                public void TestDefineInIfDef()
 
106
                {
 
107
                        string program = @"
 
108
                                #if !A
 
109
                                        #define B
 
110
                                        class
 
111
                                #else
 
112
                                        int
 
113
                                #endif
 
114
                                #if B
 
115
                                        struct
 
116
                                #endif
 
117
                        ";
 
118
                        Assert.AreEqual(new int[] { Tokens.Class, Tokens.Struct, Tokens.EOF }, GetTokenKinds(program));
 
119
                        Assert.AreEqual(new int[] { Tokens.Int, Tokens.EOF }, GetTokenKinds("#define A\n" + program));
 
120
                }
 
121
                
 
122
                [Test]
 
123
                public void TestMultilineCommentStartInIfDef()
 
124
                {
 
125
                        string program = @"
 
126
                        #if X
 
127
                                struct
 
128
                                /*
 
129
                        #else
 
130
                                /* */ class
 
131
                        #endif
 
132
                        ";
 
133
                        Assert.AreEqual(new int[] { Tokens.Class, Tokens.EOF }, GetTokenKinds(program));
 
134
                        Assert.AreEqual(new int[] { Tokens.Struct, Tokens.Class, Tokens.EOF }, GetTokenKinds("#define X\n" + program));
 
135
                }
 
136
                
 
137
                [Test]
 
138
                public void Region()
 
139
                {
 
140
                        string program = @"
 
141
        #region Region Title
 
142
        ;
 
143
        #endregion
 
144
        ,";
 
145
                        Assert.AreEqual(new int[] { Tokens.Semicolon, Tokens.Comma, Tokens.EOF }, GetTokenKinds(program));
 
146
                        ILexer lexer = GenerateLexer(program);
 
147
                        while (lexer.NextToken().Kind != Tokens.EOF);
 
148
                        List<ISpecial> specials = lexer.SpecialTracker.RetrieveSpecials();
 
149
                        
 
150
                        Assert.IsTrue(specials[0] is BlankLine);
 
151
                        Assert.AreEqual(new Location(1, 1), specials[0].StartPosition);
 
152
                        Assert.AreEqual(new Location(1, 1), specials[0].EndPosition);
 
153
                        
 
154
                        Assert.AreEqual("#region", (specials[1] as PreprocessingDirective).Cmd);
 
155
                        Assert.AreEqual("Region Title", (specials[1] as PreprocessingDirective).Arg);
 
156
                        Assert.AreEqual(new Location(2, 2), specials[1].StartPosition);
 
157
                        Assert.AreEqual(new Location(22, 2), specials[1].EndPosition);
 
158
                        
 
159
                        Assert.AreEqual("#endregion", (specials[2] as PreprocessingDirective).Cmd);
 
160
                        Assert.AreEqual(new Location(2, 4), specials[2].StartPosition);
 
161
                        Assert.AreEqual(new Location(12, 4), specials[2].EndPosition);
 
162
                }
 
163
        }
 
164
}