1 //
2 // Copyright (c) 2010-2019 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 NUnit.Framework;
9 using Antmicro.Renode.Utilities.Collections;
10 namespace Antmicro.Renode.Utilities
11 {
12     [TestFixture]
13     public class SimpleCacheTests
14     {
15         [SetUp]
Init()16         public void Init()
17         {
18             obj1 = new object();
19             obj2 = new object();
20         }
21 
22         [Test]
ShouldNotMissCache()23         public void ShouldNotMissCache()
24         {
25             var result = cache.Get(obj1, Generator1);
26             var beforeMisses = cache.CacheMisses;
27             var beforeHits = cache.CacheHits;
28             var resultAfter = cache.Get(obj1, Generator1);
29             var afterMisses = cache.CacheMisses;
30             var afterHits = cache.CacheHits;
31             Assert.AreEqual(beforeMisses, afterMisses);
32             Assert.AreEqual(beforeHits + 1, afterHits);
33             Assert.AreEqual(result, resultAfter);
34         }
35 
36         [Test]
ShouldNotMissCacheWithTwoParameters()37         public void ShouldNotMissCacheWithTwoParameters()
38         {
39             var result = cache.Get(obj1, obj2, Generator3);
40             var beforeMisses = cache.CacheMisses;
41             var beforeHits = cache.CacheHits;
42             var resultAfter = cache.Get(obj1, obj2, Generator3);
43             var afterMisses = cache.CacheMisses;
44             var afterHits = cache.CacheHits;
45             Assert.AreEqual(beforeHits + 1, afterHits);
46             Assert.AreEqual(beforeMisses, afterMisses);
47             Assert.AreEqual(result, resultAfter);
48         }
49 
50         [Test]
ShouldNotMixParametersAndGenerators()51         public void ShouldNotMixParametersAndGenerators() //in one test to make sure none of those duplicate in the cache
52         {
53             var misses1 = cache.CacheMisses;
54             var hits1 = cache.CacheHits;
55             cache.Get(obj2, Generator1);
56             var misses2 = cache.CacheMisses;
57             var hits2 = cache.CacheHits;
58             Assert.AreEqual(misses1 + 1, misses2);
59             Assert.AreEqual(hits1, hits2);
60             cache.Get(obj2, Generator2);
61             var misses3 = cache.CacheMisses;
62             var hits3 = cache.CacheHits;
63             Assert.AreEqual(hits2, hits3);
64             Assert.AreEqual(misses2 + 1, misses3);
65             cache.Get(obj1, Generator2);
66             var misses4 = cache.CacheMisses;
67             var hits4 = cache.CacheHits;
68             Assert.AreEqual(hits3, hits4);
69             Assert.AreEqual(misses3 + 1, misses4);
70             cache.Get(obj1, obj2, Generator3);
71             var misses5 = cache.CacheMisses;
72             var hits5 = cache.CacheHits;
73             Assert.AreEqual(misses4 + 1, misses5);
74             Assert.AreEqual(hits4, hits5);
75             cache.Get(obj1, obj2, Generator4);
76             var misses6 = cache.CacheMisses;
77             var hits6 = cache.CacheHits;
78             Assert.AreEqual(hits5, hits6);
79             Assert.AreEqual(misses5 + 1, misses6);
80         }
81 
82         [Test]
ShouldHandleNullsAsParameter()83         public void ShouldHandleNullsAsParameter()
84         {
85             int? val = null;
86             var result = "";
87             var resultAfter = "";
88             var cacheMisses = 0UL;
89             var cacheMissesAfter = 0UL;
90             var cacheHits = 0UL;
91             var cacheHitsAfter = 0UL;
92 
93             Assert.DoesNotThrow(() =>
94             {
95                 result = cache.Get(val, NullParameterGenerator);
96                 cacheMisses = cache.CacheMisses;
97                 cacheHits = cache.CacheHits;
98                 resultAfter = cache.Get(val, NullParameterGenerator);
99                 cacheMissesAfter = cache.CacheMisses;
100                 cacheHitsAfter = cache.CacheHits;
101             });
102 
103             Assert.AreEqual(result, resultAfter);
104             Assert.AreEqual(cacheMisses, cacheMissesAfter);
105             Assert.AreEqual(cacheHits + 1, cacheHitsAfter);
106         }
107 
108         [Test]
ShouldHandleNullsAsParameters()109         public void ShouldHandleNullsAsParameters()
110         {
111             int? val = null;
112             int? val2 = null;
113             var result = "";
114             var resultAfter = "";
115             var cacheMisses = 0UL;
116             var cacheMissesAfter = 0UL;
117             var cacheHits = 0UL;
118             var cacheHitsAfter = 0UL;
119 
120             Assert.DoesNotThrow(() =>
121             {
122                 result = cache.Get(val, val2, NullParametersGenerator);
123                 cacheMisses = cache.CacheMisses;
124                 cacheHits = cache.CacheHits;
125                 resultAfter = cache.Get(val, val2, NullParametersGenerator);
126                 cacheMissesAfter = cache.CacheMisses;
127                 cacheHitsAfter = cache.CacheHits;
128             });
129 
130             Assert.AreEqual(result, resultAfter);
131             Assert.AreEqual(cacheMisses, cacheMissesAfter);
132             Assert.AreEqual(cacheHits + 1, cacheHitsAfter);
133         }
134 
135         [Test]
ShouldHandleNullableAsParameter()136         public void ShouldHandleNullableAsParameter()
137         {
138             int? val = null;
139             var result = "";
140             var resultAfter = "";
141             var cacheMisses = 0UL;
142             var cacheMissesAfter = 0UL;
143             var cacheHits = 0UL;
144             var cacheHitsAfter = 0UL;
145 
146             Assert.DoesNotThrow(() =>
147             {
148                 result = cache.Get(val, NullParameterGenerator);
149                 cacheMisses = cache.CacheMisses;
150                 cacheHits = cache.CacheHits;
151             });
152 
153             val = 0;
154 
155             Assert.DoesNotThrow(() =>
156             {
157                 resultAfter = cache.Get(val, NullParameterGenerator);
158                 cacheMissesAfter = cache.CacheMisses;
159                 cacheHitsAfter = cache.CacheHits;
160             });
161 
162             Assert.AreNotEqual(result, resultAfter);
163             Assert.AreEqual(cacheMisses + 1, cacheMissesAfter);
164             Assert.AreEqual(cacheHits, cacheHitsAfter);
165         }
166 
167         [Test]
ShouldHandleNullableAsParameters()168         public void ShouldHandleNullableAsParameters()
169         {
170             int? val = null;
171             int? val2 = null;
172             var result = "";
173             var resultAfter = "";
174             var resultAfter2 = "";
175             var cacheMisses = 0UL;
176             var cacheMissesAfter = 0UL;
177             var cacheMissesAfter2 = 0UL;
178             var cacheHits = 0UL;
179             var cacheHitsAfter = 0UL;
180             var cacheHitsAfter2 = 0UL;
181 
182             Assert.DoesNotThrow(() =>
183             {
184                 result = cache.Get(val, val2, NullParametersGenerator);
185                 cacheMisses = cache.CacheMisses;
186                 cacheHits = cache.CacheHits;
187                 val = 0;
188                 resultAfter = cache.Get(val, val2, NullParametersGenerator);
189                 cacheMissesAfter = cache.CacheMisses;
190                 cacheHitsAfter = cache.CacheHits;
191             });
192 
193             Assert.AreNotEqual(result, resultAfter);
194             Assert.AreEqual(cacheMisses + 1, cacheMissesAfter);
195             Assert.AreEqual(cacheHits, cacheHitsAfter);
196 
197             Assert.DoesNotThrow(() =>
198             {
199                 val = null;
200                 val2 = 0;
201                 resultAfter2 = cache.Get(val, val2, NullParametersGenerator);
202                 cacheMissesAfter2 = cache.CacheMisses;
203                 cacheHitsAfter2 = cache.CacheHits;
204             });
205 
206             Assert.AreNotEqual(resultAfter, resultAfter2);
207             Assert.AreEqual(cacheMissesAfter + 1, cacheMissesAfter2);
208             Assert.AreEqual(cacheHitsAfter, cacheHitsAfter2);
209         }
210 
211         [Test]
ShouldNotHandleNullAsAGenerator()212         public void ShouldNotHandleNullAsAGenerator()
213         {
214             Assert.Throws<ArgumentNullException>(() => cache.Get(obj1, (Func<object, string>)null));
215             Assert.Throws<ArgumentNullException>(() => cache.Get(obj1, obj2, (Func<object, object, string>)null));
216         }
217 
218         [Test]
ShouldNotMixOrderOfParameteres()219         public void ShouldNotMixOrderOfParameteres()
220         {
221             var result = cache.Get(obj1, obj2, Generator3);
222             var misses = cache.CacheMisses;
223             var hits = cache.CacheHits;
224             var resultAfter = cache.Get(obj2, obj1, Generator3);
225             var afterMisses = cache.CacheMisses;
226             var afterHits = cache.CacheHits;
227             Assert.AreNotEqual(misses, afterMisses);
228             Assert.AreEqual(hits, afterHits);
229             Assert.AreNotEqual(result, resultAfter);
230         }
231 
232         [Test]
ShouldClearCache()233         public void ShouldClearCache()
234         {
235             cache.Get(obj1, Generator1);
236             cache.Get(obj2, Generator1);
237             cache.Get(obj1, Generator2);
238             cache.Get(obj2, Generator2);
239             Assert.AreEqual(4, cache.CacheSize);
240             cache.ClearCache();
241             Assert.AreEqual(0, cache.CacheSize);
242         }
243 
244         [TearDown]
Cleanup()245         public void Cleanup()
246         {
247             cache.ClearCache();
248         }
249 
NullParameterGenerator(int? val)250         private string NullParameterGenerator(int? val)
251         {
252             return val.HasValue.ToString() + "abcde".GetHashCode();
253         }
254 
NullParametersGenerator(int? val, int? val2)255         private string NullParametersGenerator(int? val, int? val2)
256         {
257             return val.HasValue.ToString() + val.HasValue.ToString() + "abcde".GetHashCode();
258         }
259 
Generator1(object obj)260         private string Generator1(object obj)
261         {
262             return obj.ToString();
263         }
264 
Generator2(object obj)265         private string Generator2(object obj)
266         {
267             return obj.GetHashCode() + " this is unit test";
268         }
269 
Generator3(object obj, object obj_1)270         private string Generator3(object obj, object obj_1)
271         {
272             return obj.GetHashCode().ToString() + obj_1;
273         }
274 
Generator4(object obj, object obj_1)275         private string Generator4(object obj, object obj_1)
276         {
277             return obj.GetHashCode().ToString() + obj_1 + " this is another test";
278         }
279 
280         private SimpleCache cache = new SimpleCache();
281         private object obj1;
282         private object obj2;
283     }
284 }
285