Skip to content

Commit e734a8d

Browse files
SergeiPavlovSergeiPavlov
committed
Move ICache defaults to CacheBase class; revert changes in tests; Tests for FastConcurrentLruCache
1 parent 7ff1f20 commit e734a8d

16 files changed

+470
-216
lines changed

‎Orm/Xtensive.Orm.Tests.Core/Caching/FastConcurrentLruCacheTest.cs‎

Lines changed: 283 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,283 @@
1+
using System;
2+
using System.Threading;
3+
using System.Threading.Tasks;
4+
using NUnit.Framework;
5+
using Xtensive.Caching;
6+
using Xtensive.Conversion;
7+
using Xtensive.Core;
8+
using Xtensive.Orm.Tests;
9+
10+
11+
namespace Xtensive.Orm.Tests.Core.Caching
12+
{
13+
[TestFixture]
14+
public class FastConcurrentLruCacheTest
15+
{
16+
private FastConcurrentLruCache<string, TestClass> globalCache;
17+
private Random random = RandomManager.CreateRandom((int)DateTime.Now.Ticks);
18+
19+
class BadTestClass:
20+
IIdentified<String>,
21+
IHasSize
22+
{
23+
object IIdentified.Identifier
24+
{
25+
get { return Identifier; }
26+
}
27+
28+
public string Identifier
29+
{
30+
get { return null; }
31+
}
32+
33+
public long Size
34+
{
35+
get { return 1; }
36+
}
37+
}
38+
39+
[Test]
40+
public void ConstructorsTest()
41+
{
42+
var cache = new LruCache<string, TestClass, TestClass>(
43+
1000,
44+
value => value.Text);
45+
46+
var cache1 = new LruCache<string, TestClass, TestClass>(
47+
1000,
48+
(value) => value.Text,
49+
new Biconverter<TestClass, TestClass>(value => value, value => value));
50+
51+
52+
TestClass item = new TestClass("1");
53+
cache.Add(item);
54+
cache1.Add(item);
55+
Assert.AreEqual(1, cache.Size);
56+
Assert.AreEqual(1, cache1.Count);
57+
58+
for (int i=0;i<100000;i++) {
59+
TestClass test = new TestClass(""+i);
60+
cache1.Add(test);
61+
}
62+
}
63+
64+
[Test]
65+
public void ConstructorDenyTest()
66+
{
67+
Assert.Throws<ArgumentOutOfRangeException>(() => {
68+
var cache =
69+
new LruCache<string, TestClass, TestClass>(
70+
-1,
71+
value => value.Text
72+
);
73+
});
74+
}
75+
76+
[Test]
77+
public void AddRemoveTest()
78+
{
79+
var cache = new LruCache<string, TestClass, TestClass>(
80+
100,
81+
value => value.Text);
82+
83+
TestClass item = new TestClass("1");
84+
cache.Add(item);
85+
Assert.AreEqual(1, cache.Count);
86+
item = new TestClass("2");
87+
cache.Add(item);
88+
Assert.AreEqual(2, cache.Count);
89+
Assert.AreEqual(item, cache[item.Text, false]);
90+
ICache<string, TestClass> icache = cache;
91+
Assert.AreEqual(item, icache[item.Text, false]);
92+
Assert.AreEqual(null, icache["3", false]);
93+
cache.Remove(item);
94+
Assert.AreEqual(1, cache.Count);
95+
cache.Clear();
96+
Assert.AreEqual(0, cache.Count);
97+
}
98+
99+
[Test]
100+
public void AddDenyTest1()
101+
{
102+
var cache = new LruCache<string, TestClass, TestClass>(
103+
100,
104+
value => value.Text);
105+
Assert.Throws<ArgumentNullException>(() => cache.Add(null));
106+
}
107+
108+
[Test]
109+
public void AddDenyTest3()
110+
{
111+
var cache =
112+
new LruCache<string, BadTestClass, BadTestClass>(
113+
100,
114+
value => value.Identifier);
115+
Assert.Throws<ArgumentNullException>(() => cache.Add(new BadTestClass()));
116+
}
117+
118+
[Test]
119+
public void RemoveDenyTest1()
120+
{
121+
var cache =
122+
new LruCache<string, TestClass, TestClass>(
123+
100,
124+
value => value.Text);
125+
Assert.Throws<ArgumentNullException>(() => cache.Remove(null));
126+
}
127+
128+
[Test]
129+
public void RemoveDenyTest2()
130+
{
131+
var cache =
132+
new LruCache<string, TestClass, TestClass>(
133+
100,
134+
value => value.Text);
135+
Assert.Throws<ArgumentNullException>(() => cache.RemoveKey(null));
136+
}
137+
138+
[Test]
139+
public void RemoveDenyTest3()
140+
{
141+
var cache =
142+
new LruCache<string, BadTestClass, BadTestClass>(
143+
100,
144+
value => value.Identifier);
145+
BadTestClass test1 = new BadTestClass();
146+
Assert.Throws<ArgumentNullException>(() => cache.Remove(test1));
147+
}
148+
149+
[Test]
150+
public void IEnumerableTest()
151+
{
152+
var cache =
153+
new LruCache<string, TestClass, TestClass>(
154+
10000,
155+
value => value.Text);
156+
for (int i = 0; i < 100; i++)
157+
{
158+
cache.Add(new TestClass("item " + i));
159+
}
160+
Assert.AreEqual(100, cache.Count);
161+
162+
int itemsCount = 0;
163+
foreach (TestClass testClass in cache)
164+
{
165+
Assert.IsTrue(testClass.Text.StartsWith("item"));
166+
itemsCount++;
167+
}
168+
Assert.AreEqual(100, itemsCount);
169+
}
170+
171+
private static bool canFinish = true;
172+
173+
[Test]
174+
public void SynchronizationTest()
175+
{
176+
globalCache =
177+
new FastConcurrentLruCache<string, TestClass>(
178+
1000,
179+
value => value.Text);
180+
181+
using (new ThreadPoolThreadsIncreaser(20, 20)) {
182+
var addThreads = new Task[10];
183+
var removeThreads = new Task[10];
184+
var cancellationTokenSource = new CancellationTokenSource();
185+
186+
for (int i = 0; i < 10; i++) {
187+
addThreads[i] = new Task(() => AddItem(cancellationTokenSource.Token), cancellationTokenSource.Token);
188+
removeThreads[i] = new Task(() => RemoveItem(cancellationTokenSource.Token), cancellationTokenSource.Token);
189+
}
190+
191+
try {
192+
for (int i = 0; i < 10; i++) {
193+
addThreads[i].Start();
194+
}
195+
Thread.Sleep(10);
196+
197+
for (int i = 0; i < 10; i++) {
198+
removeThreads[i].Start();
199+
}
200+
Thread.Sleep(200);
201+
}
202+
finally {
203+
cancellationTokenSource.Cancel();
204+
Thread.Sleep(20);
205+
}
206+
}
207+
208+
Assert.IsTrue(globalCache.Count >= 0);
209+
globalCache = null;
210+
}
211+
212+
private void AddItem(CancellationToken cancellationToken)
213+
{
214+
int count = random.Next(100000);
215+
int counter = 0;
216+
bool whileCondition = (counter++) < 10 || !cancellationToken.IsCancellationRequested;
217+
while (!cancellationToken.IsCancellationRequested) {
218+
globalCache.Add(new TestClass("item " + count));
219+
count++;
220+
}
221+
cancellationToken.ThrowIfCancellationRequested();
222+
}
223+
224+
private void RemoveItem(CancellationToken cancellationToken)
225+
{
226+
int counter = 0;
227+
while (!cancellationToken.IsCancellationRequested) {
228+
TestClass test = null;
229+
foreach (TestClass testClass in globalCache) {
230+
test = testClass;
231+
break;
232+
}
233+
if (test!=null)
234+
globalCache.Remove(test);
235+
}
236+
cancellationToken.ThrowIfCancellationRequested();
237+
}
238+
239+
private class ThreadPoolThreadsIncreaser : Disposable
240+
{
241+
private int previousWorkingThreadsCount;
242+
private int previousIOThreadsCount;
243+
244+
private static Func<int> A;
245+
private static Func<int> B;
246+
247+
private void Increase(int workingThreadsCount, int ioThreadsCount)
248+
{
249+
int minWorkingThreads;
250+
int minIOTheads;
251+
ThreadPool.GetMinThreads(out minWorkingThreads, out minIOTheads);
252+
previousWorkingThreadsCount = minWorkingThreads;
253+
previousIOThreadsCount = minIOTheads;
254+
255+
ThreadPool.SetMinThreads(workingThreadsCount, ioThreadsCount);
256+
}
257+
258+
private static void Decrease(bool disposing, Func<int> workingThreadsCountAcccessor, Func<int> ioThreadsCountAcccessor)
259+
{
260+
ThreadPool.SetMinThreads(workingThreadsCountAcccessor(), ioThreadsCountAcccessor());
261+
}
262+
263+
private int Aa()
264+
{
265+
return previousWorkingThreadsCount;
266+
}
267+
268+
private int Bb()
269+
{
270+
return previousIOThreadsCount;
271+
}
272+
273+
274+
public ThreadPoolThreadsIncreaser(int workingThreadsCount, int ioThreadsCount)
275+
: base((disposing)=>Decrease(disposing, A, B))
276+
{
277+
Increase(workingThreadsCount, ioThreadsCount);
278+
A = Aa;
279+
B = Bb;
280+
}
281+
}
282+
}
283+
}

‎Orm/Xtensive.Orm.Tests.Core/Caching/InfiniteCacheTest.cs‎

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -54,13 +54,13 @@ public TestItem(string key, string value)
5454
[TestFixture]
5555
public class InfiniteCacheTest
5656
{
57-
private ICache<string, TestItem> globalCache;
57+
private InfiniteCache<string, TestItem> globalCache;
5858
private Random random = RandomManager.CreateRandom((int)DateTime.Now.Ticks);
5959

6060
[Test]
6161
public void ConstructorsTest()
6262
{
63-
ICache<string, TestItem> cache = new InfiniteCache<string, TestItem>(value => value.Key);
63+
var cache = new InfiniteCache<string, TestItem>(value => value.Key);
6464

6565
Assert.IsNotNull(cache.KeyExtractor);
6666

@@ -85,7 +85,7 @@ public void ConstructorDenyTest2()
8585
[Test]
8686
public void AddRemoveTest()
8787
{
88-
ICache<string, TestItem> cache = new InfiniteCache<string, TestItem>(value => value.Key);
88+
var cache = new InfiniteCache<string, TestItem>(value => value.Key);
8989

9090
TestItem item = new TestItem("1");
9191
cache.Add(item);
@@ -116,28 +116,28 @@ public void AddRemoveTest()
116116
[Test]
117117
public void AddDenyTest()
118118
{
119-
ICache<string, TestItem> cache = new InfiniteCache<string, TestItem>(value => value.Key);
119+
var cache = new InfiniteCache<string, TestItem>(value => value.Key);
120120
Assert.Throws<ArgumentNullException>(() => cache.Add(null));
121121
}
122122

123123
[Test]
124124
public void RemoveDenyTest()
125125
{
126-
ICache<string, TestItem> cache = new InfiniteCache<string, TestItem>(value => value.Key);
126+
var cache = new InfiniteCache<string, TestItem>(value => value.Key);
127127
Assert.Throws<ArgumentNullException>(() => cache.Remove((TestItem)null));
128128
}
129129

130130
[Test]
131131
public void RemoveDenyTest1()
132132
{
133-
ICache<string, TestItem> cache = new InfiniteCache<string, TestItem>(value => value.Key);
133+
var cache = new InfiniteCache<string, TestItem>(value => value.Key);
134134
Assert.Throws<ArgumentNullException>(() => cache.Remove((TestItem)null));
135135
}
136136

137137
[Test]
138138
public void IEnumerableTest()
139139
{
140-
ICache<string, TestItem> cache = new InfiniteCache<string, TestItem>(value => value.Key);
140+
var cache = new InfiniteCache<string, TestItem>(value => value.Key);
141141

142142
for (int i = 0; i < 100; i++)
143143
cache.Add(new TestItem("item " + i));

‎Orm/Xtensive.Orm.Tests.Core/Caching/LruCacheTest.cs‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -65,7 +65,7 @@ public bool IsRough
6565
[TestFixture]
6666
public class LruCacheTest
6767
{
68-
private ICache<string, TestClass> globalCache;
68+
private LruCache<string, TestClass, TestClass> globalCache;
6969
private Random random = RandomManager.CreateRandom((int)DateTime.Now.Ticks);
7070

7171
class BadTestClass:
@@ -128,7 +128,7 @@ public void ConstructorDenyTest()
128128
[Test]
129129
public void AddRemoveTest()
130130
{
131-
ICache<string, TestClass> cache = new LruCache<string, TestClass, TestClass>(
131+
var cache = new LruCache<string, TestClass, TestClass>(
132132
100,
133133
value => value.Text);
134134

@@ -170,7 +170,7 @@ public void AddDenyTest3()
170170
[Test]
171171
public void RemoveDenyTest1()
172172
{
173-
ICache<string, TestClass> cache =
173+
var cache =
174174
new LruCache<string, TestClass, TestClass>(
175175
100,
176176
value => value.Text);
@@ -190,7 +190,7 @@ public void RemoveDenyTest2()
190190
[Test]
191191
public void RemoveDenyTest3()
192192
{
193-
ICache<string, BadTestClass> cache =
193+
var cache =
194194
new LruCache<string, BadTestClass, BadTestClass>(
195195
100,
196196
value => value.Identifier);

0 commit comments

Comments
 (0)