1 //
2 // Copyright (c) 2010-2025 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.Core;
10 using Antmicro.Renode.Peripherals.CPU;
11 using Antmicro.Renode.Peripherals.Miscellaneous;
12 using Antmicro.Renode.PlatformDescription;
13 using Antmicro.Renode.PlatformDescription.Syntax;
14 using Antmicro.Renode.Utilities;
15 using Moq;
16 using NUnit.Framework;
17 using Antmicro.Renode.UnitTests.Mocks;
18 using static Antmicro.Renode.Tests.UnitTests.Mocks.MockPeripheralWithEnumAttribute;
19 using System.Security.Policy;
20 
21 namespace Antmicro.Renode.UnitTests.PlatformDescription
22 {
23     [TestFixture]
24     public class MergeAndCreationTests
25     {
26         [Test]
ShouldUpdateRegistrationPoint()27         public void ShouldUpdateRegistrationPoint()
28         {
29             var source = @"
30 register1: Antmicro.Renode.UnitTests.Mocks.NullRegister @ sysbus <0, 100>
31 register2: Antmicro.Renode.UnitTests.Mocks.NullRegister @ sysbus new Antmicro.Renode.Peripherals.Bus.BusRangeRegistration { range: <100, +100> }
32 cpu: Antmicro.Renode.UnitTests.Mocks.MockCPU @ register1
33 cpu: @register2";
34 
35             ProcessSource(source);
36             ICPU peripheral;
37             Assert.IsTrue(machine.TryGetByName("sysbus.register2.cpu", out peripheral));
38             Assert.IsFalse(machine.TryGetByName("sysbus.register1.cpu", out peripheral));
39         }
40 
41         [Test]
ShouldCancelRegistration()42         public void ShouldCancelRegistration()
43         {
44             var source = @"
45 register: Antmicro.Renode.UnitTests.Mocks.NullRegister @ sysbus <0, 100>
46 cpu: Antmicro.Renode.UnitTests.Mocks.MockCPU @ register
47 cpu: @none";
48 
49             ProcessSource(source);
50             ICPU peripheral;
51             Assert.IsFalse(machine.TryGetByName("sysbus.register.cpu", out peripheral));
52         }
53 
54         [Test]
ShouldHandleRegistrationInReverseOrder()55         public void ShouldHandleRegistrationInReverseOrder()
56         {
57             var source = @"
58 cpu: Antmicro.Renode.UnitTests.Mocks.MockCPU @ register
59 register: Antmicro.Renode.UnitTests.Mocks.NullRegister @ sysbus <0, 100>
60 ";
61 
62             ProcessSource(source);
63             ICPU peripheral;
64             Assert.IsTrue(machine.TryGetByName("sysbus.register.cpu", out peripheral));
65         }
66 
67         [Test]
ShouldHandleAlias()68         public void ShouldHandleAlias()
69         {
70             var source = @"
71 cpu: Antmicro.Renode.UnitTests.Mocks.MockCPU @ sysbus as ""otherName""";
72 
73             ProcessSource(source);
74             ICPU peripheral;
75             Assert.IsTrue(machine.TryGetByName("sysbus.otherName", out peripheral));
76             Assert.IsFalse(machine.TryGetByName("sysbus.cpu", out peripheral));
77         }
78 
79         [Test]
ShouldUpdateProperty()80         public void ShouldUpdateProperty()
81         {
82             var source = @"
83 cpu: Antmicro.Renode.UnitTests.Mocks.MockCPU @ sysbus
84     Placeholder: ""one""
85     EnumValue: TwoStateEnum.Two
86 
87 cpu:
88     Placeholder: ""two""";
89 
90             ProcessSource(source);
91             MockCPU mock;
92             Assert.IsTrue(machine.TryGetByName("sysbus.cpu", out mock));
93             Assert.AreEqual("two", mock.Placeholder);
94             Assert.AreEqual(TwoStateEnum.Two, mock.EnumValue);
95         }
96 
97         [Test]
ShouldHandleEscapedOuoteInString()98         public void ShouldHandleEscapedOuoteInString()
99         {
100             var source = @"
101 cpu: Antmicro.Renode.UnitTests.Mocks.MockCPU @ sysbus
102     Placeholder: ""one with \""escaped\"" quote\""""";
103 
104             ProcessSource(source);
105             MockCPU mock;
106             Assert.IsTrue(machine.TryGetByName("sysbus.cpu", out mock));
107             Assert.AreEqual("one with \"escaped\" quote\"", mock.Placeholder);
108         }
109 
110         [Test]
ShouldHandleMultilineQuotedStringAsValue()111         public void ShouldHandleMultilineQuotedStringAsValue()
112         {
113             var source = @"
114 cpu: Antmicro.Renode.UnitTests.Mocks.MockCPU @ sysbus
115     Placeholder: '''this is
116 multiline
117 string'''";
118 
119             ProcessSource(source);
120             MockCPU mock;
121             Assert.IsTrue(machine.TryGetByName("sysbus.cpu", out mock));
122             Assert.AreEqual("this is\nmultiline\nstring", mock.Placeholder);
123         }
124 
125         [Test]
ShouldHandleMultipleMultilineQuotedStrings()126         public void ShouldHandleMultipleMultilineQuotedStrings()
127         {
128             var source = @"
129 cpu: Antmicro.Renode.UnitTests.Mocks.MockCPU @ sysbus
130     Placeholder: '''this is a
131 multiline
132 string'''
133 cpu2: Antmicro.Renode.UnitTests.Mocks.MockCPU @ sysbus
134     Placeholder: '''this is another
135 multilineeee
136 stringgggg'''";
137 
138             ProcessSource(source);
139             MockCPU mock1;
140             MockCPU mock2;
141 
142             Assert.IsTrue(machine.TryGetByName("sysbus.cpu", out mock1));
143             Assert.IsTrue(machine.TryGetByName("sysbus.cpu2", out mock2));
144 
145             Assert.AreEqual("this is a\nmultiline\nstring", mock1.Placeholder);
146             Assert.AreEqual("this is another\nmultilineeee\nstringgggg", mock2.Placeholder);
147         }
148 
149         [Test]
ShouldFailOnUnclosedMultipleMultilineQuotedStrings()150         public void ShouldFailOnUnclosedMultipleMultilineQuotedStrings()
151         {
152             var source = @"
153 cpu: Antmicro.Renode.UnitTests.Mocks.MockCPU @ sysbus
154     Placeholder: '''this is
155 multiline
156 string'''
157 cpu2: Antmicro.Renode.UnitTests.Mocks.MockCPU @ sysbus
158     Placeholder: '''this is
159 multiline
160 string'''
161 cpu3: Antmicro.Renode.UnitTests.Mocks.MockCPU @ sysbus
162     Placeholder: '''this is
163 multiline
164 string";
165             var exception = Assert.Throws<ParsingException>(() => ProcessSource(source));
166             Assert.AreEqual(ParsingError.SyntaxError, exception.Error);
167             var position = exception.Message.Split(new string[] { Environment.NewLine }, StringSplitOptions.None)[1];
168             Assert.AreEqual("At 11:17:", position);
169         }
170 
171         [Test]
ShouldFailOnUnclosedMultilineQuotedStringBetweenQuotedStrings()172         public void ShouldFailOnUnclosedMultilineQuotedStringBetweenQuotedStrings()
173         {
174             var source = @"
175 cpu: Antmicro.Renode.UnitTests.Mocks.MockCPU @ sysbus
176     Placeholder: '''this is
177 multiline
178 string'''
179 cpu2: Antmicro.Renode.UnitTests.Mocks.MockCPU @ sysbus
180     Placeholder: '''this is
181 multiline
182 string
183 cpu3: Antmicro.Renode.UnitTests.Mocks.MockCPU @ sysbus
184     Placeholder: '''this is
185 multiline'''
186 string";
187             var exception = Assert.Throws<ParsingException>(() => ProcessSource(source));
188             Assert.AreEqual(ParsingError.SyntaxError, exception.Error);
189             var position = exception.Message.Split(new string[] { Environment.NewLine }, StringSplitOptions.None)[1];
190             Assert.AreEqual("At 12:9:", position);
191         }
192 
193         [Test, Ignore("Ignored")]
ShouldHandleEscapedMultilineStringQuoteInSingleLineQuotedString()194         public void ShouldHandleEscapedMultilineStringQuoteInSingleLineQuotedString()
195         {
196             var source = @"
197 cpu: Antmicro.Renode.UnitTests.Mocks.MockCPU @ sysbus
198     Placeholder: ""one with \''' escaped quote""";
199 
200             ProcessSource(source);
201             MockCPU mock;
202             Assert.IsTrue(machine.TryGetByName("sysbus.cpu", out mock));
203             Assert.AreEqual("one with ''' escaped quote", mock.Placeholder);
204         }
205 
206         [Test, Ignore("Ignored")]
ShouldHandleMultipleEscapeCharsInMultilineString()207         public void ShouldHandleMultipleEscapeCharsInMultilineString()
208         {
209             var source = @"
210 cpu: Antmicro.Renode.UnitTests.Mocks.MockCPU @ sysbus
211     Placeholder: '''one with escaped quote\\'''";
212 
213             ProcessSource(source);
214             MockCPU mock;
215             Assert.IsTrue(machine.TryGetByName("sysbus.cpu", out mock));
216             Assert.AreEqual("one with escaped quote\\", mock.Placeholder);
217         }
218 
219 
220         [Test]
ShouldHandleMultilineQuotedStringInOneLine()221         public void ShouldHandleMultilineQuotedStringInOneLine()
222         {
223             var source = @"
224 cpu: Antmicro.Renode.UnitTests.Mocks.MockCPU @ sysbus
225     Placeholder: '''this is single line'''";
226 
227             ProcessSource(source);
228             MockCPU mock;
229             Assert.IsTrue(machine.TryGetByName("sysbus.cpu", out mock));
230             Assert.AreEqual("this is single line", mock.Placeholder);
231         }
232 
233         [Test]
ShouldFailOnMultilineQuotedStringInUsing()234         public void ShouldFailOnMultilineQuotedStringInUsing()
235         {
236             var source = @"
237 using '''this is
238 multiline
239 string '''";
240 
241             var exception = Assert.Throws<ParsingException>(() => ProcessSource(source));
242             Assert.AreEqual(ParsingError.SyntaxError, exception.Error);
243         }
244 
245         [Test]
ShouldHandleEscapedQuoteInMultilineString()246         public void ShouldHandleEscapedQuoteInMultilineString()
247         {
248             var source = @"
249 cpu: Antmicro.Renode.UnitTests.Mocks.MockCPU @ sysbus
250     Placeholder: '''this is \''' single line'''";
251 
252             ProcessSource(source);
253             MockCPU mock;
254             Assert.IsTrue(machine.TryGetByName("sysbus.cpu", out mock));
255             Assert.AreEqual("this is ''' single line", mock.Placeholder);
256         }
257 
258         [Test]
ShouldHandleEscapedUnescapedSingleQuoteCharInMultilineString()259         public void ShouldHandleEscapedUnescapedSingleQuoteCharInMultilineString()
260         {
261             var source = @"
262 cpu: Antmicro.Renode.UnitTests.Mocks.MockCPU @ sysbus
263     Placeholder: ''' this is string with ' and '' '''";
264 
265             ProcessSource(source);
266             MockCPU mock;
267             Assert.IsTrue(machine.TryGetByName("sysbus.cpu", out mock));
268             Assert.AreEqual(" this is string with ' and '' ", mock.Placeholder);
269         }
270 
271         [Test]
ShouldFailOnAnyStringAfterClosedMultilineString()272         public void ShouldFailOnAnyStringAfterClosedMultilineString()
273         {
274             var source = @"
275 cpu: Antmicro.Renode.UnitTests.Mocks.MockCPU @ sysbus
276     Placeholder: '''this is
277 not a single line ''' xx";
278 
279             var exception = Assert.Throws<ParsingException>(() => ProcessSource(source));
280             Assert.AreEqual(ParsingError.SyntaxError, exception.Error);
281             var position = exception.Message.Split(new string[] { Environment.NewLine }, StringSplitOptions.None)[1];
282             Assert.AreEqual("At 4:23:", position);
283         }
284 
285         [Test]
ShouldFailOnMultipleMultilineStringSignsInOneLine()286         public void ShouldFailOnMultipleMultilineStringSignsInOneLine()
287         {
288             var source = @"
289 cpu: Antmicro.Renode.UnitTests.Mocks.MockCPU @ sysbus
290     Placeholder: '''this is \''' ''' ''' '''
291 not a single line '''";
292 
293             var exception = Assert.Throws<ParsingException>(() => ProcessSource(source));
294             Assert.AreEqual(ParsingError.SyntaxError, exception.Error);
295             var position = exception.Message.Split(new string[] { Environment.NewLine }, StringSplitOptions.None)[1];
296             Assert.AreEqual("At 4:18:", position);
297         }
298 
299         [Test]
ShouldHandleMultipleEscapedMultilineStringSignsInOneLine()300         public void ShouldHandleMultipleEscapedMultilineStringSignsInOneLine()
301         {
302             var source = @"
303 cpu: Antmicro.Renode.UnitTests.Mocks.MockCPU @ sysbus
304     Placeholder: '''this is \''' \''' \''' \'''
305 not a single line '''";
306 
307             ProcessSource(source);
308             MockCPU mock;
309             Assert.IsTrue(machine.TryGetByName("sysbus.cpu", out mock));
310             Assert.AreEqual("this is ''' ''' ''' '''\nnot a single line ", mock.Placeholder);
311         }
312 
313         [Test]
ShouldFailOnUnclosedMultilineString()314         public void ShouldFailOnUnclosedMultilineString()
315         {
316             var source = @"
317 cpu: Antmicro.Renode.UnitTests.Mocks.MockCPU @ sysbus
318     Placeholder: '''this is ";
319 
320             var exception = Assert.Throws<ParsingException>(() => ProcessSource(source));
321             Assert.AreEqual(ParsingError.SyntaxError, exception.Error);
322             var position = exception.Message.Split(new string[] { Environment.NewLine }, StringSplitOptions.None)[1];
323             Assert.AreEqual("At 3:17:", position);
324         }
325 
326         [Test]
ShouldHandleEscapedMultilineStringSignInNewLine()327         public void ShouldHandleEscapedMultilineStringSignInNewLine()
328         {
329             var source = @"
330 cpu: Antmicro.Renode.UnitTests.Mocks.MockCPU @ sysbus
331     Placeholder: '''this is
332 \'''
333 not a single line '''";
334 
335             ProcessSource(source);
336             MockCPU mock;
337             Assert.IsTrue(machine.TryGetByName("sysbus.cpu", out mock));
338             Assert.AreEqual("this is \n\'''\nnot a single line ", mock.Placeholder);
339         }
340 
341         [Test]
ShouldHandleEscapedMultilineStringSignAtTheEndOfALine()342         public void ShouldHandleEscapedMultilineStringSignAtTheEndOfALine()
343         {
344             var source = @"
345 cpu: Antmicro.Renode.UnitTests.Mocks.MockCPU @ sysbus
346     Placeholder: '''this is \'''
347 not a single line '''";
348 
349             ProcessSource(source);
350             MockCPU mock;
351             Assert.IsTrue(machine.TryGetByName("sysbus.cpu", out mock));
352             Assert.AreEqual("this is \'''\nnot a single line ", mock.Placeholder);
353         }
354 
355         [Test, Ignore("Ignored")]
ShouldHandleMultipleBackslashesAsEscapingCharacters()356         public void ShouldHandleMultipleBackslashesAsEscapingCharacters()
357         {
358             var source = @"
359 cpu: Antmicro.Renode.UnitTests.Mocks.MockCPU @ sysbus
360     Placeholder: '''this is \\\'''
361 not a single line '''";
362 
363             ProcessSource(source);
364             MockCPU mock;
365             Assert.IsTrue(machine.TryGetByName("sysbus.cpu", out mock));
366             Assert.AreEqual(@"this is \\\'''
367 not a single line ", mock.Placeholder);
368         }
369 
370         [Test]
ShouldHandleNoneInProperty()371         public void ShouldHandleNoneInProperty()
372         {
373             var source = @"
374 cpu: Antmicro.Renode.UnitTests.Mocks.MockCPU @ sysbus
375     EnumValue: TwoStateEnum.Two
376 
377 cpu:
378     EnumValue: none";
379 
380             ProcessSource(source);
381             MockCPU mock;
382             Assert.IsTrue(machine.TryGetByName("sysbus.cpu", out mock));
383             Assert.AreEqual(TwoStateEnum.One, mock.EnumValue);
384         }
385 
386         [Test]
ShouldHandleEmptyNumericalValue()387         public void ShouldHandleEmptyNumericalValue()
388         {
389             var source = @"
390 mockPeripheral: Antmicro.Renode.Tests.UnitTests.Mocks.MockPeripheralWithNumericalAttrubute @ sysbus  <0, 1>
391     mockInt: empty";
392 
393             ProcessSource(source);
394             Tests.UnitTests.Mocks.MockPeripheralWithNumericalAttrubute mockPeripheral;
395             Assert.IsTrue(machine.TryGetByName("sysbus.mockPeripheral", out mockPeripheral));
396             Assert.AreEqual(default(int), mockPeripheral.MockInt);
397         }
398 
399         [Test]
ShouldHandleEmptyStringValue()400         public void ShouldHandleEmptyStringValue()
401         {
402             var source = @"
403 mockPeripheral: Antmicro.Renode.Tests.UnitTests.Mocks.MockPeripheralWithStringAttribute @ sysbus  <0, 1>
404     mockString: empty";
405 
406             ProcessSource(source);
407             Tests.UnitTests.Mocks.MockPeripheralWithStringAttribute mockPeripheral;
408             Assert.IsTrue(machine.TryGetByName("sysbus.mockPeripheral", out mockPeripheral));
409             Assert.AreEqual(default(string), mockPeripheral.MockString);
410         }
411 
412         [Test]
ShouldHandleEmptyEnumValue()413         public void ShouldHandleEmptyEnumValue()
414         {
415             var source = @"
416 cpu: Antmicro.Renode.UnitTests.Mocks.MockCPU @ sysbus
417     EnumValue: empty";
418 
419             ProcessSource(source);
420             MockCPU mock;
421             Assert.IsTrue(machine.TryGetByName("sysbus.cpu", out mock));
422             Assert.AreEqual(default(TwoStateEnum), mock.EnumValue);
423         }
424 
425         [Test]
ShouldHandleEmptyRangeValue()426         public void ShouldHandleEmptyRangeValue()
427         {
428             var source = @"
429 mockPeripheral: Antmicro.Renode.Tests.UnitTests.Mocks.MockPeripheralWithRangeAttribute @ sysbus  <0, 1>
430     mockRange: empty";
431 
432             ProcessSource(source);
433             Tests.UnitTests.Mocks.MockPeripheralWithRangeAttribute mockPeripheral;
434             Assert.IsTrue(machine.TryGetByName("sysbus.mockPeripheral", out mockPeripheral));
435             Assert.AreEqual(default(Core.Range), mockPeripheral.MockRange);
436         }
437 
438         [Test]
ShouldHandleEmptyObjectValue()439         public void ShouldHandleEmptyObjectValue()
440         {
441             var source = @"
442 mockPeripheral: Antmicro.Renode.Tests.UnitTests.Mocks.MockPeripheralWithObjectAttribute @ sysbus  <0, 1>
443     mockObject: empty";
444 
445             ProcessSource(source);
446             Tests.UnitTests.Mocks.MockPeripheralWithObjectAttribute mockPeripheral;
447             Assert.IsTrue(machine.TryGetByName("sysbus.mockPeripheral", out mockPeripheral));
448             Assert.AreEqual(default(Object), mockPeripheral.MockObject);
449         }
450 
451         [Test]
ShouldHandleEmptyBoolValue()452         public void ShouldHandleEmptyBoolValue()
453         {
454             var source = @"
455 mockPeripheral: Antmicro.Renode.Tests.UnitTests.Mocks.MockPeripheralWithBoolAttribute @ sysbus  <0, 1>
456     mockBool: empty";
457 
458             ProcessSource(source);
459             Tests.UnitTests.Mocks.MockPeripheralWithBoolAttribute mockPeripheral;
460             Assert.IsTrue(machine.TryGetByName("sysbus.mockPeripheral", out mockPeripheral));
461             Assert.AreEqual(default(bool), mockPeripheral.MockBool);
462         }
463 
464         [Test]
ShouldHandleEmptyReferenceAttribute()465         public void ShouldHandleEmptyReferenceAttribute()
466         {
467             var source = @"
468 mockPeripheral: Antmicro.Renode.Tests.UnitTests.Mocks.MockPeripheralUsingReferenceAttribute @ sysbus <0, 1>
469     mockReference: empty";
470 
471             ProcessSource(source);
472             Tests.UnitTests.Mocks.MockPeripheralUsingReferenceAttribute mockPeripheral;
473             Assert.IsTrue(machine.TryGetByName("sysbus.mockPeripheral", out mockPeripheral));
474             Assert.AreEqual(default(Antmicro.Renode.Peripherals.IPeripheral), mockPeripheral.MockReference);
475         }
476 
477         [Test]
ShouldFailOnEmptyKeywordAsType()478         public void ShouldFailOnEmptyKeywordAsType()
479         {
480             var source = @"
481 mockPeripheral: empty @ sysbus <0, 1>
482     value: 0";
483             var exception = Assert.Throws<ParsingException>(() => ProcessSource(source));
484             Assert.AreEqual(ParsingError.SyntaxError, exception.Error);
485         }
486 
487         [Test]
ShouldFailOnEmptyKeywordAsRegistrationDestination()488         public void ShouldFailOnEmptyKeywordAsRegistrationDestination()
489         {
490             var source = @"
491 mockPeripheral:  Antmicro.Renode.UnitTests.Mocks.EmptyPeripheral @ empty <0, 1>
492     value: 0";
493             var exception = Assert.Throws<ParsingException>(() => ProcessSource(source));
494             Assert.AreEqual(ParsingError.SyntaxError, exception.Error);
495         }
496 
497         [Test]
ShouldFailOnEmptyKeywordAsParameterName()498         public void ShouldFailOnEmptyKeywordAsParameterName()
499         {
500             var source = @"
501 mockPeripheral:  Antmicro.Renode.UnitTests.Mocks.EmptyPeripheral @ sysbus <0, 1>
502     empty: 0";
503             var exception = Assert.Throws<ParsingException>(() => ProcessSource(source));
504             Assert.AreEqual(ParsingError.SyntaxError, exception.Error);
505         }
506 
507         [Test]
ShouldFailOnEmptyKeywordAsUsingParameter()508         public void ShouldFailOnEmptyKeywordAsUsingParameter()
509         {
510             var source = @"using empty";
511             var exception = Assert.Throws<ParsingException>(() => ProcessSource(source));
512             Assert.AreEqual(ParsingError.SyntaxError, exception.Error);
513         }
514 
515         [Test]
ShouldHandleNoneInCtorParam()516         public void ShouldHandleNoneInCtorParam()
517         {
518             var source = @"
519 peripheral: Antmicro.Renode.UnitTests.Mocks.EmptyPeripheral @ sysbus <0, 1>
520     value: 1
521 
522 peripheral:
523     value: none";
524 
525             ProcessSource(source);
526             EmptyPeripheral peripheral;
527             Assert.IsTrue(machine.TryGetByName("sysbus.peripheral", out peripheral));
528             Assert.AreEqual(1, peripheral.Counter);
529         }
530 
531         [Test]
ShouldUpdateSingleInterrupt()532         public void ShouldUpdateSingleInterrupt()
533         {
534             var source = @"
535 sender: Antmicro.Renode.UnitTests.Mocks.MockIrqSender @ sysbus <0, 1>
536     [Irq] -> receiver@[0]
537 receiver: Antmicro.Renode.UnitTests.Mocks.MockReceiver @ sysbus <1, 2>
538 sender:
539     Irq -> receiver@1";
540 
541             ProcessSource(source);
542             MockIrqSender sender;
543             Assert.IsTrue(machine.TryGetByName("sysbus.sender", out sender));
544             Assert.AreEqual(1, sender.Irq.Endpoints[0].Number);
545         }
546 
547         [Test]
ShouldHandleManyMultiplexedMultiDestinationInterrupts()548         public void ShouldHandleManyMultiplexedMultiDestinationInterrupts()
549         {
550             var source = @"
551 sender: Antmicro.Renode.UnitTests.Mocks.MockGPIOByNumberConnectorPeripheral @ sysbus <3, 4>
552     gpios: 2
553     [0, Irq] -> receiver@[1-2] | receiver2@[3-4] | receiver3@[5-6]
554 receiver: Antmicro.Renode.UnitTests.Mocks.MockReceiver @ sysbus <0, 1>
555 receiver2: Antmicro.Renode.UnitTests.Mocks.MockReceiver @ sysbus <1, 2>
556 receiver3: Antmicro.Renode.UnitTests.Mocks.MockReceiver @ sysbus <2, 3>";
557 
558             ProcessSource(source);
559             MockGPIOByNumberConnectorPeripheral sender;
560             MockReceiver receiver, receiver2, receiver3;
561             Assert.IsTrue(machine.TryGetByName("sysbus.sender", out sender));
562             Assert.IsTrue(machine.TryGetByName("sysbus.receiver", out receiver));
563             Assert.IsTrue(machine.TryGetByName("sysbus.receiver2", out receiver2));
564             Assert.IsTrue(machine.TryGetByName("sysbus.receiver3", out receiver3));
565 
566             Assert.AreEqual(3, sender.Irq.Endpoints.Count);
567             Assert.AreEqual(2, sender.Irq.Endpoints[0].Number);
568             Assert.AreEqual(4, sender.Irq.Endpoints[1].Number);
569             Assert.AreEqual(6, sender.Irq.Endpoints[2].Number);
570 
571             Assert.AreEqual(receiver, sender.Irq.Endpoints[0].Receiver);
572             Assert.AreEqual(receiver2, sender.Irq.Endpoints[1].Receiver);
573             Assert.AreEqual(receiver3, sender.Irq.Endpoints[2].Receiver);
574         }
575 
576         [Test]
ShouldCancelIrqConnection()577         public void ShouldCancelIrqConnection()
578         {
579             var source = @"
580 sender: Antmicro.Renode.UnitTests.Mocks.MockIrqSender @ sysbus <0, 1> { [Irq] -> receiver@[0] }
581 receiver: Antmicro.Renode.UnitTests.Mocks.MockReceiver @ sysbus <1, 2>
582 sender:
583     Irq -> none";
584 
585             ProcessSource(source);
586             MockIrqSender sender;
587             Assert.IsTrue(machine.TryGetByName("sysbus.sender", out sender));
588             Assert.IsFalse(sender.Irq.IsConnected);
589         }
590 
591         [Test]
ShouldUpdateDefaultIrq()592         public void ShouldUpdateDefaultIrq()
593         {
594             var source = @"
595 sender: Antmicro.Renode.UnitTests.Mocks.MockIrqSender @ sysbus <0, 1>
596     [Irq] -> receiver@[0]
597 receiver: Antmicro.Renode.UnitTests.Mocks.MockReceiver @ sysbus <1, 2>
598 sender:
599     -> receiver@2";
600 
601             ProcessSource(source);
602             MockIrqSender sender;
603             Assert.IsTrue(machine.TryGetByName("sysbus.sender", out sender));
604             Assert.AreEqual(2, sender.Irq.Endpoints[0].Number);
605         }
606 
607         [Test]
ShouldUpdateMultiInterrupts()608         public void ShouldUpdateMultiInterrupts()
609         {
610             var a = @"
611 sender: Antmicro.Renode.UnitTests.Mocks.MockGPIOByNumberConnectorPeripheral @ sysbus <0, 1>
612     gpios: 64
613     [0-2, 3-5, Irq, OtherIrq] -> receiver@[0-7] | receiver@[8-15]
614     6 -> receiver2@7
615 receiver: Antmicro.Renode.UnitTests.Mocks.MockReceiver @ sysbus<1, 2>
616 receiver2: Antmicro.Renode.UnitTests.Mocks.MockReceiver @ sysbus<2, 3>";
617 
618             var source = @"
619 using ""A""
620 
621 sender:
622     [Irq, 3-4] -> receiver2@[0-2]
623     6 -> receiver@16
624     [7-8] -> receiver@[17-18]
625 ";
626 
627             ProcessSource(source, a);
628             MockGPIOByNumberConnectorPeripheral sender;
629             MockReceiver receiver1, receiver2;
630             Assert.IsTrue(machine.TryGetByName("sysbus.sender", out sender));
631             Assert.IsTrue(machine.TryGetByName("sysbus.receiver", out receiver1));
632             Assert.IsTrue(machine.TryGetByName("sysbus.receiver2", out receiver2));
633 
634             Assert.AreEqual(0, sender.Irq.Endpoints[0].Number);
635             Assert.AreEqual(receiver2, sender.Irq.Endpoints[0].Receiver);
636             Assert.AreEqual(7, sender.OtherIrq.Endpoints[0].Number);
637             Assert.AreEqual(receiver1, sender.OtherIrq.Endpoints[0].Receiver);
638             Assert.AreEqual(0, sender.Connections[0].Endpoints[0].Number);
639             Assert.AreEqual(receiver1, sender.Connections[0].Endpoints[0].Receiver);
640             Assert.AreEqual(1, sender.Connections[1].Endpoints[0].Number);
641             Assert.AreEqual(receiver1, sender.Connections[1].Endpoints[0].Receiver);
642             Assert.AreEqual(2, sender.Connections[2].Endpoints[0].Number);
643             Assert.AreEqual(receiver1, sender.Connections[2].Endpoints[0].Receiver);
644             Assert.AreEqual(1, sender.Connections[3].Endpoints[0].Number);
645             Assert.AreEqual(receiver2, sender.Connections[3].Endpoints[0].Receiver);
646             Assert.AreEqual(2, sender.Connections[4].Endpoints[0].Number);
647             Assert.AreEqual(receiver2, sender.Connections[4].Endpoints[0].Receiver);
648             Assert.AreEqual(5, sender.Connections[5].Endpoints[0].Number);
649             Assert.AreEqual(receiver1, sender.Connections[5].Endpoints[0].Receiver);
650             Assert.AreEqual(16, sender.Connections[6].Endpoints[0].Number);
651             Assert.AreEqual(receiver1, sender.Connections[6].Endpoints[0].Receiver);
652             Assert.AreEqual(17, sender.Connections[7].Endpoints[0].Number);
653             Assert.AreEqual(receiver1, sender.Connections[7].Endpoints[0].Receiver);
654             Assert.AreEqual(18, sender.Connections[8].Endpoints[0].Number);
655             Assert.AreEqual(receiver1, sender.Connections[8].Endpoints[0].Receiver);
656         }
657 
658         [Test]
ShouldCombineIfInterruptUsedSecondTimeInEntryAsDestination()659         public void ShouldCombineIfInterruptUsedSecondTimeInEntryAsDestination()
660         {
661             var source = @"
662 receiver: Antmicro.Renode.UnitTests.Mocks.MockReceiver @ sysbus
663 sender: Antmicro.Renode.UnitTests.Mocks.MockIrqSenderWithTwoInterrupts @ sysbus
664     Irq -> receiver@0
665     AnotherIrq -> receiver@0";
666 
667             ProcessSource(source);
668             Assert.IsTrue(machine.TryGetByName("sysbus.sender", out MockIrqSenderWithTwoInterrupts sender));
669             Assert.IsTrue(machine.TryGetByName("sysbus.receiver", out MockReceiver receiver));
670 
671             Assert.AreEqual(0, sender.Irq.Endpoints[0].Number);
672             Assert.AreEqual(1, sender.AnotherIrq.Endpoints[0].Number);
673             Assert.IsInstanceOf(typeof(CombinedInput), sender.Irq.Endpoints[0].Receiver);
674             var combiner = (CombinedInput)sender.Irq.Endpoints[0].Receiver;
675             Assert.AreEqual(0, combiner.OutputLine.Endpoints[0].Number);
676             Assert.AreEqual(receiver, combiner.OutputLine.Endpoints[0].Receiver);
677             Assert.AreEqual(combiner, sender.AnotherIrq.Endpoints[0].Receiver);
678         }
679 
680         [Test]
ShouldFailOnUsingAlreadyRegisteredPeripheralsName()681         public void ShouldFailOnUsingAlreadyRegisteredPeripheralsName()
682         {
683             var source = @"
684 peripheral: Antmicro.Renode.UnitTests.Mocks.MockCPU";
685 
686             var peripheral = new EmptyPeripheral();
687             machine.SystemBus.Register(peripheral, new Antmicro.Renode.Peripherals.Bus.BusRangeRegistration(0.To(1)));
688             machine.SetLocalName(peripheral, "peripheral");
689 
690             var exception = Assert.Throws<ParsingException>(() => ProcessSource(source));
691             Assert.AreEqual(ParsingError.VariableAlreadyDeclared, exception.Error);
692         }
693 
694         [Test]
ShouldTakeAlreadyRegisteredPeripheralsAsVariables()695         public void ShouldTakeAlreadyRegisteredPeripheralsAsVariables()
696         {
697             var source = @"
698 newCpu: Antmicro.Renode.UnitTests.Mocks.MockCPU @ sysbus 2
699     OtherCpu: cpu";
700 
701             var cpu = new MockCPU(machine);
702             machine.SystemBus.Register(cpu, new CPURegistrationPoint(1));
703             machine.SetLocalName(cpu, "cpu");
704 
705             ProcessSource(source);
706             MockCPU otherMockCpu;
707             Assert.IsTrue(machine.TryGetByName("sysbus.newCpu", out otherMockCpu));
708             Assert.AreEqual(cpu, otherMockCpu.OtherCpu);
709         }
710 
711         [Test]
ShouldNotDetectCycleInPerCoreRegistration()712         public void  ShouldNotDetectCycleInPerCoreRegistration()
713         {
714             var source = @"
715 core1_nvic: IRQControllers.NVIC @ sysbus new Bus.BusPointRegistration {
716     address: 0xE000E000;
717     cpu: cpu1
718 }
719 
720 core2_nvic: IRQControllers.NVIC @ sysbus new Bus.BusPointRegistration {
721     address: 0xE000E000;
722     cpu: cpu2
723 }
724 
725 cpu1: CPU.CortexM @ sysbus
726     cpuType: ""cortex-m0""
727     nvic: core1_nvic
728 
729 cpu2: CPU.CortexM @ sysbus
730     cpuType: ""cortex-m0""
731     nvic: core2_nvic";
732 
733             ProcessSource(source);
734         }
735 
736         [Test]
ShouldNotDetectCycleInSignalConnection()737         public void  ShouldNotDetectCycleInSignalConnection()
738         {
739             var source = @"
740 clint: IRQControllers.CoreLevelInterruptor @ {
741         sysbus new Bus.BusPointRegistration { address: 0x002000000; cpu: cpu_rv }
742     }
743     [0,1] -> cpu_rv@[3,7]
744     frequency: 10000000
745 
746 cpu_rv: CPU.RiscV32 @ sysbus
747     cpuType: ""rv32ima""
748     timeProvider: clint";
749 
750             ProcessSource(source);
751         }
752 
753         [Test]
ShouldReplaceInit()754         public void ShouldReplaceInit()
755         {
756             var source = @"
757 peri: Antmicro.Renode.UnitTests.Mocks.EmptyPeripheral @ sysbus <0, 1>
758     init:
759         Increment
760 
761 peri:
762     init:
763         Increment
764         Increment";
765 
766             ProcessSource(source);
767             initHandlerMock.Verify(x => x.Execute(It.IsAny<IInitable>(), new[] { "Increment", "Increment" }, It.IsAny<Action<string>>()));
768         }
769 
770         [Test]
ShouldAddInit()771         public void ShouldAddInit()
772         {
773             var source = @"
774 peri: Antmicro.Renode.UnitTests.Mocks.EmptyPeripheral
775     init:
776         Increment
777 
778 peri:
779     init add:
780         Increment
781         Increment";
782 
783 
784             ProcessSource(source);
785             initHandlerMock.Verify(x => x.Execute(It.IsAny<IInitable>(), new[] { "Increment", "Increment", "Increment" }, It.IsAny<Action<string>>()));
786         }
787 
788         [Test]
ShouldUpdateSysbusInit()789         public void ShouldUpdateSysbusInit()
790         {
791             var source = @"
792 sysbus:
793     init:
794         WriteByte 0 1";
795 
796             ProcessSource(source);
797             initHandlerMock.Verify(x => x.Execute(It.IsAny<IInitable>(), new[] { "WriteByte 0 1" }, It.IsAny<Action<string>>()));
798         }
799 
800         [Test]
ShouldFailOnNotValidatedInit()801         public void ShouldFailOnNotValidatedInit()
802         {
803             var a = @"
804 peri: Antmicro.Renode.UnitTests.Mocks.EmptyPeripheral
805     init:
806         Increment
807         Increment";
808 
809             var source = @"
810 using ""A""
811 
812 peri:
813     init:
814         Increment";
815 
816             var errorMessage = "Invalid init section";
817             initHandlerMock.Setup(x => x.Validate(It.IsAny<IInitable>(), out errorMessage)).Returns(false);
818             var exception = Assert.Throws<ParsingException>(() => ProcessSource(source, a));
819             Assert.AreEqual(ParsingError.InitSectionValidationError, exception.Error);
820         }
821 
822         [Test]
ShouldFindCyclicDependency()823         public void ShouldFindCyclicDependency()
824         {
825             var source = @"
826 peri1: Antmicro.Renode.UnitTests.Mocks.MockPeripheralWithDependency
827     other: new Antmicro.Renode.UnitTests.Mocks.MockPeripheralWithDependency
828         other: peri2
829 
830 peri3: Antmicro.Renode.UnitTests.Mocks.MockPeripheralWithDependency
831     other: peri4
832 
833 peri4: Antmicro.Renode.UnitTests.Mocks.MockPeripheralWithDependency
834     other: peri1
835 
836 peri2: Antmicro.Renode.UnitTests.Mocks.MockPeripheralWithDependency
837     other: peri3
838 ";
839 
840             var exception = Assert.Throws<ParsingException>(() => ProcessSource(source));
841             Assert.AreEqual(ParsingError.CreationOrderCycle, exception.Error);
842         }
843 
844         [Test]
ShouldFindCyclicReferenceToItself()845         public void ShouldFindCyclicReferenceToItself()
846         {
847             var source = @"
848 peri: Antmicro.Renode.UnitTests.Mocks.MockPeripheralWithDependency
849     other: peri";
850 
851             var exception = Assert.Throws<ParsingException>(() => ProcessSource(source));
852             Assert.AreEqual(ParsingError.CreationOrderCycle, exception.Error);
853         }
854 
855         [Test]
ShouldFindCyclicReferenceBetweenFiles()856         public void ShouldFindCyclicReferenceBetweenFiles()
857         {
858             var a = @"
859 peri1: Antmicro.Renode.UnitTests.Mocks.MockPeripheralWithDependency
860     other: peri3
861 peri3: Antmicro.Renode.UnitTests.Mocks.MockPeripheralWithDependency
862 ";
863 
864             var source = @"
865 using ""A""
866 peri2: Antmicro.Renode.UnitTests.Mocks.MockPeripheralWithDependency
867     other: peri1
868 
869 peri3:
870     other: peri2";
871 
872             var exception = Assert.Throws<ParsingException>(() => ProcessSource(source, a));
873             Assert.AreEqual(ParsingError.CreationOrderCycle, exception.Error);
874         }
875 
876         [Test]
ShouldSetPropertyOfInlineObject()877         public void ShouldSetPropertyOfInlineObject()
878         {
879             var source = @"
880 cpu: Antmicro.Renode.UnitTests.Mocks.MockCPU @ sysbus
881     OtherCpu: new Antmicro.Renode.UnitTests.Mocks.MockCPU
882         OtherCpu: new Antmicro.Renode.UnitTests.Mocks.MockCPU
883             Placeholder: ""something""";
884 
885             ProcessSource(source);
886             MockCPU cpu;
887             Assert.IsTrue(machine.TryGetByName("sysbus.cpu", out cpu));
888             Assert.AreEqual("something", ((cpu.OtherCpu as MockCPU).OtherCpu as MockCPU).Placeholder);
889         }
890 
891         [Test]
ShouldRegisterPeripheralWithManyRegistrationPoints()892         public void ShouldRegisterPeripheralWithManyRegistrationPoints()
893         {
894             var source = @"
895 peripheral: Antmicro.Renode.UnitTests.Mocks.EmptyPeripheral @{
896     sysbus <0x100, +0x10>;
897     sysbus <0x200, +0x20>} as ""alias""
898 ";
899             ProcessSource(source);
900             EmptyPeripheral peripheral;
901             Assert.IsTrue(machine.TryGetByName("sysbus.alias", out peripheral));
902             var ranges = machine.GetPeripheralRegistrationPoints(machine.SystemBus, peripheral).OfType<Antmicro.Renode.Peripherals.Bus.BusRangeRegistration>().Select(x => x.Range).ToArray();
903             Assert.AreEqual(0x100.By(0x10), ranges[0]);
904             Assert.AreEqual(0x200.By(0x20), ranges[1]);
905             Assert.AreEqual(2, ranges.Length);
906         }
907 
908         [Test]
ShouldFailOnNonExistingReferenceInCtorAttribute()909         public void ShouldFailOnNonExistingReferenceInCtorAttribute()
910         {
911             var source = @"
912 peripheral: Antmicro.Renode.UnitTests.Mocks.MockPeripheralWithDependency
913     other: nonExististing";
914 
915             var exception = Assert.Throws<ParsingException>(() => ProcessSource(source));
916             Assert.AreEqual(ParsingError.MissingReference, exception.Error);
917         }
918 
919         [Test]
ShouldProcessEntryDependantOnSysbus()920         public void ShouldProcessEntryDependantOnSysbus()
921         {
922             var source = @"
923 peripheral: Antmicro.Renode.UnitTests.Mocks.MockPeripheralWithDependency
924     other: sysbus";
925 
926             ProcessSource(source);
927         }
928 
929         [Test]
ShouldProcessEntryDependantOnSysbusWithUpdateEntry()930         public void ShouldProcessEntryDependantOnSysbusWithUpdateEntry()
931         {
932             var source = @"
933 sysbus:
934     init:
935         Method
936 
937 peripheral: Antmicro.Renode.UnitTests.Mocks.MockPeripheralWithDependency
938     other: sysbus";
939 
940             ProcessSource(source);
941         }
942 
943         [Test]
ShouldCatchExceptionOnEntryConstruction()944         public void ShouldCatchExceptionOnEntryConstruction()
945         {
946             var source = @"
947 peripheral: Antmicro.Renode.UnitTests.Mocks.MockPeripheralWithDependency
948     throwException: true";
949 
950             var exception = Assert.Throws<ParsingException>(() => ProcessSource(source));
951             Assert.AreEqual(ParsingError.ConstructionException, exception.Error);
952         }
953 
954         [Test]
ShouldCatchExceptionOnObjectValueConstruction()955         public void ShouldCatchExceptionOnObjectValueConstruction()
956         {
957             var source = @"
958 peripheral: Antmicro.Renode.UnitTests.Mocks.MockPeripheralWithDependency
959     other: new Antmicro.Renode.UnitTests.Mocks.MockPeripheralWithDependency
960         throwException: true";
961 
962             var exception = Assert.Throws<ParsingException>(() => ProcessSource(source));
963             Assert.AreEqual(ParsingError.ConstructionException, exception.Error);
964         }
965 
966         [Test]
ShouldCatchExceptionOnPropertySetting()967         public void ShouldCatchExceptionOnPropertySetting()
968         {
969             var source = @"
970 peripheral: Antmicro.Renode.UnitTests.Mocks.EmptyPeripheral
971     ThrowingProperty: 1";
972 
973             var exception = Assert.Throws<ParsingException>(() => ProcessSource(source));
974             Assert.AreEqual(ParsingError.PropertySettingException, exception.Error);
975         }
976 
977         [Test]
ShouldCatchExceptionOnRegistration()978         public void ShouldCatchExceptionOnRegistration()
979         {
980             var source = @"
981 peripheral: Antmicro.Renode.UnitTests.Mocks.EmptyPeripheral @ {
982     sysbus <0x100, +0x100>;
983     sysbus <0x150, +0x100>
984 }";
985 
986             var exception = Assert.Throws<ParsingException>(() => ProcessSource(source));
987             Assert.AreEqual(ParsingError.RegistrationException, exception.Error);
988         }
989 
990         [Test]
ShouldHandleNameConflict()991         public void ShouldHandleNameConflict()
992         {
993             var source = @"
994 p1: Antmicro.Renode.UnitTests.Mocks.EmptyPeripheral @ sysbus <0x100, +0x50>
995 p2: Antmicro.Renode.UnitTests.Mocks.EmptyPeripheral @ sysbus <0x200, +0x50> as ""p1""
996 ";
997 
998             var exception = Assert.Throws<ParsingException>(() => ProcessSource(source));
999             Assert.AreEqual(ParsingError.NameSettingException, exception.Error);
1000         }
1001 
1002         [Test]
ShouldProcessRepeatedRegistration()1003         public void ShouldProcessRepeatedRegistration()
1004         {
1005             var source = @"
1006 mockRegister1: Antmicro.Renode.UnitTests.Mocks.MockRegister @ sysbus 0x0
1007 cpu: Antmicro.Renode.UnitTests.Mocks.MockCPU @ {
1008     mockRegister1;
1009     mockRegister2
1010 }
1011 mockRegister2: Antmicro.Renode.UnitTests.Mocks.MockRegister @ sysbus 0x100
1012 ";
1013             ProcessSource(source);
1014 
1015             ICPU peripheral;
1016             Assert.IsTrue(machine.TryGetByName("sysbus.mockRegister1.cpu", out peripheral));
1017             Assert.IsTrue(machine.TryGetByName("sysbus.mockRegister2.cpu", out peripheral));
1018         }
1019 
1020         [Test]
ShouldProcessValidEnum()1021         public void ShouldProcessValidEnum()
1022         {
1023             var source = @"
1024 mockPeripheral: Antmicro.Renode.Tests.UnitTests.Mocks.MockPeripheralWithEnumAttribute @ sysbus <0, 1>
1025     mockEnum: MockEnum.ValidValue
1026 ";
1027 
1028             ProcessSource(source);
1029             var result = machine.TryGetByName("sysbus.mockPeripheral", out Tests.UnitTests.Mocks.MockPeripheralWithEnumAttribute mockPeripheral);
1030             Assert.IsTrue(result);
1031             Assert.AreEqual(MockEnum.ValidValue, mockPeripheral.MockEnumValue);
1032         }
1033 
1034         [Test]
ShouldFailOnInvalidEnum()1035         public void ShouldFailOnInvalidEnum()
1036         {
1037             var source = @"
1038 peripheral: Antmicro.Renode.Tests.UnitTests.Mocks.MockPeripheralWithEnumAttribute
1039     mockEnum: MockEnum.InvalidValue
1040 ";
1041             var exception = Assert.Throws<ParsingException>(() => ProcessSource(source));
1042             Assert.AreEqual(ParsingError.NoCtor, exception.Error);
1043         }
1044 
1045         [Test]
ShouldProcessValidIntAsEnum()1046         public void ShouldProcessValidIntAsEnum()
1047         {
1048             var source = @"
1049 peripheral: Antmicro.Renode.Tests.UnitTests.Mocks.MockPeripheralWithEnumAttribute @ sysbus <0, 1>
1050     mockEnum: 1
1051 ";
1052             ProcessSource(source);
1053             Assert.IsTrue(machine.TryGetByName("sysbus.peripheral", out Tests.UnitTests.Mocks.MockPeripheralWithEnumAttribute mockPeripheral));
1054             Assert.AreEqual(MockEnum.ValidValue, mockPeripheral.MockEnumValue);
1055         }
1056 
1057         [Test]
ShouldFailOnInvalidIntToEnumCast()1058         public void ShouldFailOnInvalidIntToEnumCast()
1059         {
1060             var source = @"
1061 peripheral: Antmicro.Renode.Tests.UnitTests.Mocks.MockPeripheralWithEnumAttribute
1062     mockEnum: 2
1063 ";
1064             var exception = Assert.Throws<ParsingException>(() => ProcessSource(source));
1065             Assert.AreEqual(ParsingError.NoCtor, exception.Error);
1066         }
1067 
1068         [Test]
ShouldFailOnInvalidIntToEnumWithAttributeCast()1069         public void ShouldFailOnInvalidIntToEnumWithAttributeCast()
1070         {
1071             var source = @"
1072 peripheral: Antmicro.Renode.Tests.UnitTests.Mocks.MockPeripheralWithEnumAttribute @ sysbus <0, 1>
1073     mockEnumWithAttribute: MockEnumWithAttribute.InvalidValue
1074 ";
1075             //ProcessSource(source);
1076             var exception = Assert.Throws<ParsingException>(() => ProcessSource(source));
1077             Assert.AreEqual(ParsingError.NoCtor, exception.Error);
1078         }
1079 
1080         [Test]
ShouldProcessCastOfAnyIntToEnumWithAttribute()1081         public void ShouldProcessCastOfAnyIntToEnumWithAttribute()
1082         {
1083             var source = @"
1084 peripheral: Antmicro.Renode.Tests.UnitTests.Mocks.MockPeripheralWithEnumAttribute @ sysbus <0, 1>
1085     mockEnumWithAttribute: 2
1086 ";
1087             ProcessSource(source);
1088             Assert.IsTrue(machine.TryGetByName("sysbus.peripheral", out Tests.UnitTests.Mocks.MockPeripheralWithEnumAttribute mockPeripheral));
1089             Assert.AreEqual((MockEnumWithAttribute)2, mockPeripheral.MockEnumWithAttributeValue);
1090         }
1091 
1092         [Test]
ShouldFailOnAssignmentOfMachineTypeAttribute()1093         public void ShouldFailOnAssignmentOfMachineTypeAttribute()
1094         {
1095             var source = @"
1096 peripheral: Antmicro.Renode.Tests.UnitTests.Mocks.MachineTestPeripheral @ sysbus <0, 1>
1097     mach: empty
1098     machine: empty
1099 ";
1100             var exception = Assert.Throws<ParsingException>(() => ProcessSource(source));
1101             Assert.AreEqual(ParsingError.NoCtor, exception.Error);
1102         }
1103 
1104         [Test]
ShouldNotFailOnAssignmentToAttributeWithMachineParameterNameThatIsNotMachine()1105         public void ShouldNotFailOnAssignmentToAttributeWithMachineParameterNameThatIsNotMachine()
1106         {
1107             var source = @"
1108 peripheral: Antmicro.Renode.Tests.UnitTests.Mocks.MachineTestPeripheral @ sysbus <0, 1>
1109     machine: empty
1110 ";
1111             Assert.DoesNotThrow(() => ProcessSource(source));
1112         }
1113 
1114         [Test]
ShouldAcceptPreviousRegistrationPoint()1115         public void ShouldAcceptPreviousRegistrationPoint()
1116         {
1117             var source = @"
1118 mock: @ sysbus
1119 mock: Antmicro.Renode.UnitTests.Mocks.MockCPU";
1120 
1121             Assert.DoesNotThrow(() => ProcessSource(source));
1122         }
1123 
1124         [Test]
ShouldRejectPreviousIncompatibleRegistrationPoint()1125         public void ShouldRejectPreviousIncompatibleRegistrationPoint()
1126         {
1127             var source = @"
1128 mock: @ sysbus <0, 1>
1129 mock: Antmicro.Renode.UnitTests.Mocks.MockCPU";
1130 
1131             var exception = Assert.Throws<ParsingException>(() => ProcessSource(source));
1132             Assert.AreEqual(ParsingError.NoCtorForRegistrationPoint, exception.Error);
1133         }
1134 
1135         [OneTimeSetUp]
Init()1136         public void Init()
1137         {
1138             if(!Misc.TryGetRootDirectory(out var rootDir))
1139             {
1140                 throw new ArgumentException("Couldn't get root directory.");
1141             }
1142             TypeManager.Instance.Scan(rootDir);
1143         }
1144 
1145         [SetUp]
SetUp()1146         public void SetUp()
1147         {
1148             machine = new Machine();
1149             EmulationManager.Instance.CurrentEmulation.AddMachine(machine, "machine");
1150             initHandlerMock = new Mock<IInitHandler>();
1151             string nullMessage = null;
1152             initHandlerMock.Setup(x => x.Validate(It.IsAny<IInitable>(), out nullMessage)).Returns(true);
1153         }
1154 
1155         [TearDown]
TearDown()1156         public void TearDown()
1157         {
1158             var currentEmulation = EmulationManager.Instance.CurrentEmulation;
1159             currentEmulation.RemoveMachine(machine);
1160         }
1161 
ProcessSource(params string[] sources)1162         private void ProcessSource(params string[] sources)
1163         {
1164             var letters = Enumerable.Range(0, sources.Length - 1).Select(x => (char)('A' + x)).ToArray();
1165             var usingResolver = new FakeUsingResolver();
1166             for(var i = 1; i < sources.Length; i++)
1167             {
1168                 usingResolver.With(letters[i - 1].ToString(), sources[i]);
1169             }
1170             var creationDriver = new CreationDriver(machine, usingResolver, initHandlerMock.Object);
1171             creationDriver.ProcessDescription(sources[0]);
1172         }
1173 
1174         private Mock<IInitHandler> initHandlerMock;
1175         private Machine machine;
1176     }
1177 }
1178