1 // Copyright (C) 2024 Antmicro
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 //     http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 //
15 // SPDX-License-Identifier: Apache-2.0
16 
17 using System;
18 using NUnit.Framework;
19 using Antmicro.Renode.Peripherals.Bus;
20 using System.Collections.Generic;
21 
22 
23 namespace Antmicro.Renode.PeripheralsTests
24 {
25     [TestFixture]
26     public class SystemRDLMem1PeripheralTest
27     {
28         public struct TestCase {
29             public bool FLAG1 { get; set; }
30             public bool FLAG2 { get; set; }
31             public byte VALUE1 { get; set; }
32             public uint VALUE2 { get; set; }
33             public uint Memory { get; set; }
34         }
35 
36         static public List<TestCase> testCases = new List<TestCase> {
37             new TestCase {
38                 FLAG1 = false,
39                 FLAG2 = false,
40                 VALUE1 = 0x0,
41                 VALUE2 = 0x0,
42                 Memory = 0x0000_0000,
43             },
44             new TestCase {
45                 FLAG1 = true,
46                 FLAG2 = false,
47                 VALUE1 = 0x0,
48                 VALUE2 = 0x400,
49                 Memory = 0x0001_0001,
50             },
51             new TestCase {
52                 FLAG1 = true,
53                 FLAG2 = true,
54                 VALUE1 = 0xf,
55                 VALUE2 = 0x216400,
56                 Memory = 0x0859_003f,
57             },
58             new TestCase {
59                 FLAG1 = true,
60                 FLAG2 = true,
61                 VALUE1 = 0xf,
62                 VALUE2 = 0x859,
63                 Memory = 0x0002_167f,
64             },
65             new TestCase {
66                 FLAG1 = false,
67                 FLAG2 = true,
68                 VALUE1 = 0xf,
69                 VALUE2 = 0x1ff_ffff,
70                 Memory = 0xffff_fffe,
71             },
72         };
73 
74         [OneTimeSetUp]
Setup()75         public void Setup()
76         {
77             peripheral = new Peripherals.Mocks.Mem1Peripheral();
78         }
79 
80         [Test]
TestSize()81         public void TestSize()
82         {
83             Assert.AreEqual(16, peripheral.Mem1.Size);
84         }
85 
86         [Test]
TestBounds()87         public void TestBounds()
88         {
89             var _ = peripheral.Mem1[mem1ElementCount - 1];
90             try
91             {
92                 _ = peripheral.Mem1[mem1ElementCount];
93             }
94             catch(IndexOutOfRangeException)
95             {
96                 return;
97             }
98             Assert.Fail("Out-of-bounds memory access succeeded");
99         }
100 
101         [Test, TestCaseSource(nameof(testCases))]
TestRead(TestCase testCase)102         public void TestRead(TestCase testCase)
103         {
104             for(long i = 0; i < peripheral.Mem1.Size / 4; ++i)
105             {
106                 (peripheral as IDoubleWordPeripheral)
107                     .WriteDoubleWord(mem1Offset + i * 4, testCase.Memory);
108             }
109 
110             for(long i = 0; i < peripheral.Mem1.Size / mem1ElementCount; ++i)
111             {
112                 Assert.AreEqual(testCase.FLAG1, peripheral.Mem1[i].FLAG1);
113                 Assert.AreEqual(testCase.FLAG2, peripheral.Mem1[i].FLAG2);
114                 Assert.AreEqual(testCase.VALUE1, peripheral.Mem1[i].VALUE1);
115                 Assert.AreEqual(testCase.VALUE2, peripheral.Mem1[i].VALUE2);
116             }
117         }
118 
119         [Test, TestCaseSource(nameof(testCases))]
TestWrite(TestCase testCase)120         public void TestWrite(TestCase testCase)
121         {
122             for(long i = 0; i < peripheral.Mem1.Size / mem1ElementCount; ++i)
123             {
124                 peripheral.Mem1[i].FLAG1 = testCase.FLAG1;
125                 peripheral.Mem1[i].FLAG2 = testCase.FLAG2;
126                 peripheral.Mem1[i].VALUE1 = testCase.VALUE1;
127                 peripheral.Mem1[i].VALUE2 = testCase.VALUE2;
128             }
129 
130             for(long i = 0; i < peripheral.Mem1.Size / 4; ++i)
131             {
132                 var word = (peripheral as IDoubleWordPeripheral)
133                     .ReadDoubleWord(mem1Offset + i * 4);
134                 Assert.AreEqual(testCase.Memory & mem1RegMask, word & mem1RegMask);
135             }
136         }
137 
138         private Peripherals.Mocks.Mem1Peripheral peripheral;
139         long mem1Offset = 0x10;
140         long mem1ElementCount = 4;
141         long mem1RegMask = 0x3fff_ffff;
142     }
143 }
144