1 //
2 // Copyright (c) 2010-2018 Antmicro
3 //
4 // This file is licensed under the MIT License.
5 // Full license text is available in 'licenses/MIT.txt'.
6 //
7 using System;
8 using System.Linq;
9 using Antmicro.Renode.PlatformDescription;
10 using NUnit.Framework;
11 
12 namespace Antmicro.Renode.UnitTests.PlatformDescription
13 {
14     [TestFixture]
15     public class PreLexerTests
16     {
17         [Test]
ShouldProcessEmptyFile()18         public void ShouldProcessEmptyFile()
19         {
20             var result = PreLexer.Process(string.Empty);
21             CollectionAssert.AreEquivalent(string.Empty, result.First());
22         }
23 
24         [Test]
ShouldProcessSimpleFile()25         public void ShouldProcessSimpleFile()
26         {
27             var source = @"first line
28 second line
29     first indented
30     second indented
31 third line";
32             var result = PreLexer.Process(source);
33 
34             var expectedResult = SplitUsingNewline(@"first line;
35 second line{
36     first indented;
37     second indented};
38 third line");
39 
40             CollectionAssert.AreEquivalent(expectedResult, result);
41         }
42 
43         [Test]
ShouldProcessDoubleDedent()44         public void ShouldProcessDoubleDedent()
45         {
46             var source = @"first line
47 second line
48     first indented
49     second indented
50 
51 third line";
52             var result = PreLexer.Process(source);
53 
54             var expectedResult = SplitUsingNewline(@"first line;
55 second line{
56     first indented;
57     second indented};
58 
59 third line");
60 
61             CollectionAssert.AreEquivalent(expectedResult, result);
62         }
63 
64         [Test]
ShouldProcessDoubleDedentAtTheEndOfFile()65         public void ShouldProcessDoubleDedentAtTheEndOfFile()
66         {
67             var source = @"first line
68 second line
69     first indented";
70             var result = PreLexer.Process(source);
71 
72             var expectedResult = SplitUsingNewline(@"first line;
73 second line{
74     first indented}");
75 
76             CollectionAssert.AreEquivalent(expectedResult, result);
77         }
78 
79         [Test]
ShouldProcessTwoLinesWithNoIndent()80         public void ShouldProcessTwoLinesWithNoIndent()
81         {
82             var source = @"
83 line1
84 line2";
85             var result = PreLexer.Process(source);
86 
87             var expectedResult = SplitUsingNewline(@"
88 line1;
89 line2");
90             CollectionAssert.AreEquivalent(expectedResult, result);
91         }
92 
93         [Test]
ShouldProcessTwoLinesWithNoIndentAndSeparation()94         public void ShouldProcessTwoLinesWithNoIndentAndSeparation()
95         {
96             var source = @"
97 line1
98 
99 line2";
100            var result = PreLexer.Process(source);
101 
102             var expectedResult = SplitUsingNewline(@"
103 line1;
104 
105 line2");
106             CollectionAssert.AreEquivalent(expectedResult, result);
107         }
108 
109         [Test]
ShouldHandleEmptyLinesAtTheEndOfSource()110         public void ShouldHandleEmptyLinesAtTheEndOfSource()
111         {
112             var source = @"
113 line1
114 line2
115 
116 ";
117             var result = PreLexer.Process(source);
118 
119             var expectedResult = SplitUsingNewline(@"
120 line1;
121 line2
122 
123 ");
124             CollectionAssert.AreEquivalent(expectedResult, result);
125         }
126 
127         [Test]
ShouldNotProcessIndentInBraces()128         public void ShouldNotProcessIndentInBraces()
129         {
130 var source = @"
131 line1 {
132     line2 }";
133 
134             var result = PreLexer.Process(source);
135 
136             var expectedResult = SplitUsingNewline(@"
137 line1 {
138     line2 }");
139 
140             CollectionAssert.AreEqual(expectedResult, result);
141         }
142 
143         [Test]
ShouldHandleCorrectLineComments()144         public void ShouldHandleCorrectLineComments()
145         {
146             var source = @"
147 line1 { // something
148     line2 }";
149 
150             var result = PreLexer.Process(source);
151 
152             var expectedResult = SplitUsingNewline(@"
153 line1 {
154     line2 }");
155 
156             CollectionAssert.AreEqual(expectedResult, result);
157         }
158 
159         [Test]
ShouldHandleUncorrectLineComments()160         public void ShouldHandleUncorrectLineComments()
161         {
162             var source = @"
163 line1 {// something
164     line2 }";
165 
166             var result = PreLexer.Process(source);
167 
168             var expectedResult = SplitUsingNewline(@"
169 line1 {// something
170     line2 }");
171 
172             CollectionAssert.AreEqual(expectedResult, result);
173         }
174 
175         [Test]
ShouldHandleBeginningLineComment()176         public void ShouldHandleBeginningLineComment()
177         {
178             var source = @"
179 // something
180 line1 {
181     line2 }";
182 
183             var result = PreLexer.Process(source);
184 
185             var expectedResult = SplitUsingNewline(@"
186 
187 line1 {
188     line2 }");
189 
190             CollectionAssert.AreEqual(expectedResult, result);
191         }
192 
193         [Test]
ShouldHandleLineCommentsAndStrings()194         public void ShouldHandleLineCommentsAndStrings()
195         {
196             var source = @"
197 line1 ""something with //"" ""another // pseudo comment"" { // and here goes real comment
198     line2 }";
199 
200             var result = PreLexer.Process(source);
201 
202             var expectedResult = SplitUsingNewline(@"
203 line1 ""something with //"" ""another // pseudo comment"" {
204     line2 }");
205 
206             CollectionAssert.AreEqual(expectedResult, result);
207         }
208 
209         [Test]
ShouldFailOnUnterminatedString()210         public void ShouldFailOnUnterminatedString()
211         {
212             var source = @"
213 line1 ""i'm unterminated";
214 
215             var result = PreLexer.Process(source);
216             var exception = Assert.Throws<ParsingException>(() => result.ToArray());
217             Assert.AreEqual(ParsingError.SyntaxError, exception.Error);
218         }
219 
220         [Test]
ShouldHandleMultilineCommentsInOneLine()221         public void ShouldHandleMultilineCommentsInOneLine()
222         {
223             var source = @"
224 line1 used as a ruler1234            123456789                1234
225 line 2/* first comment*/ ""string with /*"" /* second comment */ something";
226 
227             var result = PreLexer.Process(source);
228 
229             var expectedResult = SplitUsingNewline(@"
230 line1 used as a ruler1234            123456789                1234;
231 line 2                   ""string with /*""                      something");
232 
233             CollectionAssert.AreEqual(expectedResult, result);
234         }
235 
236         [Test]
ShouldHandleMultilineComments()237         public void ShouldHandleMultilineComments()
238         {
239             var source = @"
240 line1/* here we begin
241     here it goes
242 more
243 more
244     here we finish*/
245 line2";
246 
247             var result = PreLexer.Process(source);
248 
249             var expectedResult = SplitUsingNewline(@"
250 line1;
251 
252 
253 
254 
255 line2");
256 
257             CollectionAssert.AreEqual(expectedResult, result);
258         }
259 
260         [Test]
ShouldHandleMultilineCommentsWithinBraces()261         public void ShouldHandleMultilineCommentsWithinBraces()
262         {
263             var source = @"
264 line1 { /* here we begin
265     here it goes
266 here the comment ends*/ x: 5 }
267 line2";
268 
269             var result = PreLexer.Process(source);
270 
271             var expectedResult = SplitUsingNewline(@"
272 line1 {
273 
274                         x: 5 };
275 line2");
276 
277             CollectionAssert.AreEqual(expectedResult, result);
278         }
279 
280         [Test]
ShouldFailIfTheMultilineCommentFinishesBeforeEndOfLine()281         public void ShouldFailIfTheMultilineCommentFinishesBeforeEndOfLine()
282         {
283             var source = @"
284 line1 /* here we begin
285     here it goes
286 here the comment ends*/ x: 5
287 line2";
288 
289             var result = PreLexer.Process(source);
290             var exception = Assert.Throws<ParsingException>(() => result.ToArray());
291             Assert.AreEqual(ParsingError.SyntaxError, exception.Error);
292         }
293 
294         [Test]
ShouldProcessBraceInString()295         public void ShouldProcessBraceInString()
296         {
297             var source = @"
298 line1 ""{ \"" {""
299 line2";
300 
301             var result = PreLexer.Process(source);
302 
303             var expectedResult = SplitUsingNewline(@"
304 line1 ""{ \"" {"";
305 line2");
306 
307             CollectionAssert.AreEqual(expectedResult, result);
308         }
309 
310         [Test]
311         public void ShouldHandleTextOnTheFirstLine()
312         {
313             var source = @"onlyLine";
314 
315             var result = PreLexer.Process(source).ToArray();
316 
317             var expectedResult = SplitUsingNewline(@"onlyLine");
318 
319             CollectionAssert.AreEqual(expectedResult, result);
320         }
321 
322         [Test]
323         public void ShouldHandleInitialIndent()
324         {
325             var source = @"
326     first line
327     second line
328         first indented
329         second indented
330     third line";
331             var result = PreLexer.Process(source);
332 
333             var exception = Assert.Throws<ParsingException>(() => result.ToArray());
334             Assert.AreEqual(ParsingError.WrongIndent, exception.Error);
335         }
336 
337         [Test]
338         public void ShouldFailOnSingleLineMultilineComment()
339         {
340             var source = @"
341 first line
342     /*something*/ second line";
343 
344             var result = PreLexer.Process(source);
345 
346             var exception = Assert.Throws<ParsingException>(() => result.ToArray());
347             Assert.AreEqual(ParsingError.SyntaxError, exception.Error);
348         }
349 
350         private static string[] SplitUsingNewline(string source)
351         {
352             return source.Replace("\r", string.Empty).Split(new[] { '\n' }, StringSplitOptions.None);
353         }
354     }
355 }
356