1 //
2 // Copyright (c) 2010-2024 Antmicro
3 // Copyright (c) 2011-2015 Realtime Embedded
4 //
5 // This file is licensed under the MIT License.
6 // Full license text is available in 'licenses/MIT.txt'.
7 //
8 
9 using Antmicro.Renode.Core.Extensions;
10 using Antmicro.Renode.Peripherals.Bus;
11 using NUnit.Framework;
12 using Moq;
13 
14 namespace Antmicro.Renode.UnitTests
15 {
16     [TestFixture]
17     public class ReadExtensionsTest
18     {
19         [SetUp]
SetUp()20         public void SetUp()
21         {
22             var bytePeriMock = new Mock<IBytePeripheral>();
23             bytePeriMock.Setup(x => x.ReadByte(0)).Returns(0x12);
24             bytePeriMock.Setup(x => x.ReadByte(1)).Returns(0x34);
25             bytePeriMock.Setup(x => x.ReadByte(2)).Returns(0x56);
26             bytePeriMock.Setup(x => x.ReadByte(3)).Returns(0x78);
27             bytePeriMock.Setup(x => x.ReadByte(4)).Returns(0x90);
28             bytePeriMock.Setup(x => x.ReadByte(5)).Returns(0xAA);
29             bytePeriMock.Setup(x => x.ReadByte(6)).Returns(0xBB);
30             bytePeriMock.Setup(x => x.ReadByte(7)).Returns(0xCC);
31             bytePeripheral = bytePeriMock.Object;
32 
33             var wordPeriMock = new Mock<IWordPeripheral>();
34             wordPeriMock.Setup(x => x.ReadWord(0)).Returns(0x3412);
35             wordPeriMock.Setup(x => x.ReadWord(2)).Returns(0x7856);
36             wordPeriMock.Setup(x => x.ReadWord(4)).Returns(0xAA90);
37             wordPeriMock.Setup(x => x.ReadWord(6)).Returns(0xCCBB);
38             wordPeripheral = wordPeriMock.Object;
39 
40             var dwordPeriMock = new Mock<IDoubleWordPeripheral>();
41             dwordPeriMock.Setup(x => x.ReadDoubleWord(0)).Returns(0x78563412);
42             dwordPeriMock.Setup(x => x.ReadDoubleWord(4)).Returns(0xCCBBAA90);
43             dwordPeripheral = dwordPeriMock.Object;
44 
45             var qwordPeriMock = new Mock<IQuadWordPeripheral>();
46             qwordPeriMock.Setup(x => x.ReadQuadWord(0)).Returns(0x7856341221436587);
47             qwordPeripheral = qwordPeriMock.Object;
48         }
49 
50         [Test]
ShouldReadByteUsingWord()51         public void ShouldReadByteUsingWord()
52         {
53             Assert.AreEqual(0x12, wordPeripheral.ReadByteUsingWord(0));
54             Assert.AreEqual(0x34, wordPeripheral.ReadByteUsingWord(1));
55             Assert.AreEqual(0x56, wordPeripheral.ReadByteUsingWord(2));
56             Assert.AreEqual(0x78, wordPeripheral.ReadByteUsingWord(3));
57         }
58 
59         [Test]
ShouldReadByteUsingWordBigEndian()60         public void ShouldReadByteUsingWordBigEndian()
61         {
62             Assert.AreEqual(0x34, wordPeripheral.ReadByteUsingWordBigEndian(0));
63             Assert.AreEqual(0x12, wordPeripheral.ReadByteUsingWordBigEndian(1));
64             Assert.AreEqual(0x78, wordPeripheral.ReadByteUsingWordBigEndian(2));
65             Assert.AreEqual(0x56, wordPeripheral.ReadByteUsingWordBigEndian(3));
66         }
67 
68         [Test]
ShouldReadByteUsingDoubleWord()69         public void ShouldReadByteUsingDoubleWord()
70         {
71             Assert.AreEqual(0x12, dwordPeripheral.ReadByteUsingDoubleWord(0));
72             Assert.AreEqual(0x34, dwordPeripheral.ReadByteUsingDoubleWord(1));
73             Assert.AreEqual(0x56, dwordPeripheral.ReadByteUsingDoubleWord(2));
74             Assert.AreEqual(0x78, dwordPeripheral.ReadByteUsingDoubleWord(3));
75         }
76 
77         [Test]
ShouldReadByteUsingDoubleWordBigEndian()78         public void ShouldReadByteUsingDoubleWordBigEndian()
79         {
80             Assert.AreEqual(0x78, dwordPeripheral.ReadByteUsingDoubleWordBigEndian(0));
81             Assert.AreEqual(0x56, dwordPeripheral.ReadByteUsingDoubleWordBigEndian(1));
82             Assert.AreEqual(0x34, dwordPeripheral.ReadByteUsingDoubleWordBigEndian(2));
83             Assert.AreEqual(0x12, dwordPeripheral.ReadByteUsingDoubleWordBigEndian(3));
84         }
85 
86         [Test]
ShouldReadByteUsingQuadWord()87         public void ShouldReadByteUsingQuadWord()
88         {
89             Assert.AreEqual(0x87, qwordPeripheral.ReadByteUsingQuadWord(0));
90             Assert.AreEqual(0x65, qwordPeripheral.ReadByteUsingQuadWord(1));
91             Assert.AreEqual(0x43, qwordPeripheral.ReadByteUsingQuadWord(2));
92             Assert.AreEqual(0x21, qwordPeripheral.ReadByteUsingQuadWord(3));
93             Assert.AreEqual(0x12, qwordPeripheral.ReadByteUsingQuadWord(4));
94             Assert.AreEqual(0x34, qwordPeripheral.ReadByteUsingQuadWord(5));
95             Assert.AreEqual(0x56, qwordPeripheral.ReadByteUsingQuadWord(6));
96             Assert.AreEqual(0x78, qwordPeripheral.ReadByteUsingQuadWord(7));
97         }
98 
99         [Test]
ShouldReadByteUsingQuadWordBigEndian()100         public void ShouldReadByteUsingQuadWordBigEndian()
101         {
102             Assert.AreEqual(0x78, qwordPeripheral.ReadByteUsingQuadWordBigEndian(0));
103             Assert.AreEqual(0x56, qwordPeripheral.ReadByteUsingQuadWordBigEndian(1));
104             Assert.AreEqual(0x34, qwordPeripheral.ReadByteUsingQuadWordBigEndian(2));
105             Assert.AreEqual(0x12, qwordPeripheral.ReadByteUsingQuadWordBigEndian(3));
106             Assert.AreEqual(0x21, qwordPeripheral.ReadByteUsingQuadWordBigEndian(4));
107             Assert.AreEqual(0x43, qwordPeripheral.ReadByteUsingQuadWordBigEndian(5));
108             Assert.AreEqual(0x65, qwordPeripheral.ReadByteUsingQuadWordBigEndian(6));
109             Assert.AreEqual(0x87, qwordPeripheral.ReadByteUsingQuadWordBigEndian(7));
110         }
111 
112         [Test]
ShouldReadWordUsingByte()113         public void ShouldReadWordUsingByte()
114         {
115             Assert.AreEqual(0x3412, bytePeripheral.ReadWordUsingByte(0));
116             Assert.AreEqual(0x7856, bytePeripheral.ReadWordUsingByte(2));
117         }
118 
119         [Test]
ShouldReadWordUsingByteBigEndian()120         public void ShouldReadWordUsingByteBigEndian()
121         {
122             Assert.AreEqual(0x1234, bytePeripheral.ReadWordUsingByteBigEndian(0));
123             Assert.AreEqual(0x5678, bytePeripheral.ReadWordUsingByteBigEndian(2));
124         }
125 
126         [Test]
ShouldReadWordUsingByteNotAligned()127         public void ShouldReadWordUsingByteNotAligned()
128         {
129             Assert.AreEqual(0x5634, bytePeripheral.ReadWordUsingByte(1));
130             Assert.AreEqual(0x9078, bytePeripheral.ReadWordUsingByte(3));
131         }
132 
133         [Test]
ShouldReadWordUsingByteNotAlignedBigEndian()134         public void ShouldReadWordUsingByteNotAlignedBigEndian()
135         {
136             Assert.AreEqual(0x3456, bytePeripheral.ReadWordUsingByteBigEndian(1));
137             Assert.AreEqual(0x7890, bytePeripheral.ReadWordUsingByteBigEndian(3));
138         }
139 
140         [Test]
ShouldReadWordUsingDoubleWord()141         public void ShouldReadWordUsingDoubleWord()
142         {
143             Assert.AreEqual(0x3412, dwordPeripheral.ReadWordUsingDoubleWord(0));
144             Assert.AreEqual(0x7856, dwordPeripheral.ReadWordUsingDoubleWord(2));
145         }
146 
147         [Test]
ShouldReadWordUsingDoubleWordBigEndian()148         public void ShouldReadWordUsingDoubleWordBigEndian()
149         {
150             Assert.AreEqual(0x5678, dwordPeripheral.ReadWordUsingDoubleWordBigEndian(0));
151             Assert.AreEqual(0x1234, dwordPeripheral.ReadWordUsingDoubleWordBigEndian(2));
152         }
153 
154         [Test]
ShouldReadWordUsingQuadWord()155         public void ShouldReadWordUsingQuadWord()
156         {
157             Assert.AreEqual(0x6587, qwordPeripheral.ReadWordUsingQuadWord(0));
158             Assert.AreEqual(0x2143, qwordPeripheral.ReadWordUsingQuadWord(2));
159             Assert.AreEqual(0x3412, qwordPeripheral.ReadWordUsingQuadWord(4));
160             Assert.AreEqual(0x7856, qwordPeripheral.ReadWordUsingQuadWord(6));
161         }
162 
163         [Test]
ShouldReadWordUsingQuadWordBigEndian()164         public void ShouldReadWordUsingQuadWordBigEndian()
165         {
166             Assert.AreEqual(0x5678, qwordPeripheral.ReadWordUsingQuadWordBigEndian(0));
167             Assert.AreEqual(0x1234, qwordPeripheral.ReadWordUsingQuadWordBigEndian(2));
168             Assert.AreEqual(0x4321, qwordPeripheral.ReadWordUsingQuadWordBigEndian(4));
169             Assert.AreEqual(0x8765, qwordPeripheral.ReadWordUsingQuadWordBigEndian(6));
170         }
171 
172 
173         [Test]
ShouldReadDoubleWordUsingByte()174         public void ShouldReadDoubleWordUsingByte()
175         {
176             Assert.AreEqual(0x78563412, bytePeripheral.ReadDoubleWordUsingByte(0));
177         }
178 
179         [Test]
ShouldReadDoubleWordUsingByteBigEndian()180         public void ShouldReadDoubleWordUsingByteBigEndian()
181         {
182             Assert.AreEqual(0x12345678, bytePeripheral.ReadDoubleWordUsingByteBigEndian(0));
183         }
184 
185         [Test]
ShouldReadDoubleWordUsingByteNotAligned()186         public void ShouldReadDoubleWordUsingByteNotAligned()
187         {
188             Assert.AreEqual(0x90785634, bytePeripheral.ReadDoubleWordUsingByte(1));
189         }
190 
191         [Test]
ShouldReadDoubleWordUsingByteNotAlignedBigEndian()192         public void ShouldReadDoubleWordUsingByteNotAlignedBigEndian()
193         {
194             Assert.AreEqual(0x34567890, bytePeripheral.ReadDoubleWordUsingByteBigEndian(1));
195         }
196 
197         [Test]
ShouldReadDoubleWordUsingWord()198         public void ShouldReadDoubleWordUsingWord()
199         {
200             Assert.AreEqual(0x78563412, wordPeripheral.ReadDoubleWordUsingWord(0));
201         }
202 
203         [Test]
ShouldReadDoubleWordUsingWordBigEndian()204         public void ShouldReadDoubleWordUsingWordBigEndian()
205         {
206             Assert.AreEqual(0x12345678, wordPeripheral.ReadDoubleWordUsingWordBigEndian(0));
207         }
208 
209         [Test]
ShouldReadDoubleWordUsingQuadWord()210         public void ShouldReadDoubleWordUsingQuadWord()
211         {
212             Assert.AreEqual(0x21436587, qwordPeripheral.ReadDoubleWordUsingQuadWord(0));
213             Assert.AreEqual(0x78563412, qwordPeripheral.ReadDoubleWordUsingQuadWord(4));
214         }
215 
216         [Test]
ShouldReadDoubleWordUsingQuadWordBigEndian()217         public void ShouldReadDoubleWordUsingQuadWordBigEndian()
218         {
219             Assert.AreEqual(0x12345678, qwordPeripheral.ReadDoubleWordUsingQuadWordBigEndian(0));
220             Assert.AreEqual(0x87654321, qwordPeripheral.ReadDoubleWordUsingQuadWordBigEndian(4));
221         }
222 
223         [Test]
ShouldReadQuadWordUsingByte()224         public void ShouldReadQuadWordUsingByte()
225         {
226             Assert.AreEqual(0xccbbaa9078563412, bytePeripheral.ReadQuadWordUsingByte(0));
227         }
228 
229         [Test]
ShouldReadQuadWordUsingByteBigEndian()230         public void ShouldReadQuadWordUsingByteBigEndian()
231         {
232             Assert.AreEqual(0x1234567890aabbcc, bytePeripheral.ReadQuadWordUsingByteBigEndian(0));
233         }
234 
235         [Test]
ShouldReadQuadWordUsingByteNotAligned()236         public void ShouldReadQuadWordUsingByteNotAligned()
237         {
238             Assert.AreEqual(0xccbbaa90785634, bytePeripheral.ReadQuadWordUsingByte(1));
239         }
240 
241         [Test]
ShouldReadQuadWordUsingByteNotAlignedBigEndian()242         public void ShouldReadQuadWordUsingByteNotAlignedBigEndian()
243         {
244             Assert.AreEqual(0x34567890aabbcc00, bytePeripheral.ReadQuadWordUsingByteBigEndian(1));
245         }
246 
247         [Test]
ShouldReadQuadWordUsingWord()248         public void ShouldReadQuadWordUsingWord()
249         {
250             Assert.AreEqual(0xccbbaa9078563412, wordPeripheral.ReadQuadWordUsingWord(0));
251         }
252 
253         [Test]
ShouldReadQuadWordUsingWordBigEndian()254         public void ShouldReadQuadWordUsingWordBigEndian()
255         {
256             Assert.AreEqual(0x1234567890aabbcc, wordPeripheral.ReadQuadWordUsingWordBigEndian(0));
257         }
258 
259         [Test]
ShouldReadQuadWordUsingDoubleWord()260         public void ShouldReadQuadWordUsingDoubleWord()
261         {
262             Assert.AreEqual(0xccbbaa9078563412, dwordPeripheral.ReadQuadWordUsingDoubleWord(0));
263         }
264 
265         [Test]
ShouldReadQuadWordUsingDoubleWordBigEndian()266         public void ShouldReadQuadWordUsingDoubleWordBigEndian()
267         {
268             Assert.AreEqual(0x1234567890aabbcc, dwordPeripheral.ReadQuadWordUsingDoubleWordBigEndian(0));
269         }
270 
271         private IBytePeripheral bytePeripheral;
272         private IWordPeripheral wordPeripheral;
273         private IDoubleWordPeripheral dwordPeripheral;
274         private IQuadWordPeripheral qwordPeripheral;
275     }
276 }
277 
278